@sveltejs/adapter-auto

import adapter from '@sveltejs/adapter-auto';

const adapter = require('@sveltejs/adapter-auto').default;

// svelte.config.js
import adapter from '@sveltejs/adapter-auto';

/** @type {import('@sveltejs/kit').Config} */
const config = {
  kit: {
    adapter: adapter()
  }
};

export default config;

/**
 * Creates a SvelteKit adapter that automatically detects the deployment environment
 * @returns {Adapter} SvelteKit adapter with auto-detection capabilities
 */
export default function(): Adapter;

/**
 * SvelteKit Adapter interface - returned by the default export function
 */
interface Adapter {
  /** The name of the adapter, using for logging. Will typically correspond to the package name. */
  name: string;
  /** This function is called after SvelteKit has built your app. */
  adapt(builder: Builder): MaybePromise<void>;
  /** Checks called during dev and build to determine whether specific features will work in production with this adapter. */
  supports?: {
    /** Test support for `read` from `$app/server`. */
    read?(details: { config: any; route: { id: string } }): boolean;
  };
  /** Creates an `Emulator`, which allows the adapter to influence the environment during dev, build and prerendering. */
  emulate?(): MaybePromise<Emulator>;
}

/**
 * SvelteKit Builder interface (from @sveltejs/kit)
 * This object is passed to the `adapt` function of adapters.
 * It contains various methods and properties that are useful for adapting the app.
 */
interface Builder {
  /** Print messages to the console. `log.info` and `log.minor` are silent unless Vite's `logLevel` is `info`. */
  log: Logger;
  /** Remove `dir` and all its contents. */
  rimraf(dir: string): void;
  /** Create `dir` and any required parent directories. */
  mkdirp(dir: string): void;

  /** The fully resolved Svelte config. */
  config: ValidatedConfig;
  /** Information about prerendered pages and assets, if any. */
  prerendered: Prerendered;
  /** An array of all routes (including prerendered) */
  routes: RouteDefinition[];

  /** Find all the assets imported by server files belonging to `routes` */
  findServerAssets(routes: RouteDefinition[]): string[];
  /** Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps. */
  generateFallback(dest: string): Promise<void>;
  /** Generate a module exposing build-time environment variables as `$env/dynamic/public`. */
  generateEnvModule(): void;
  /** Generate a server-side manifest to initialise the SvelteKit server with. */
  generateManifest(opts: { relativePath: string; routes?: RouteDefinition[] }): string;

  /** Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`. */
  getBuildDirectory(name: string): string;
  /** Get the fully resolved path to the directory containing client-side assets, including the contents of your `static` directory. */
  getClientDirectory(): string;
  /** Get the fully resolved path to the directory containing server-side code. */
  getServerDirectory(): string;
  /** Get the application path including any configured `base` path, e.g. `my-base-path/_app`. */
  getAppPath(): string;

  /** Write client assets to `dest`. */
  writeClient(dest: string): string[];
  /** Write prerendered files to `dest`. */
  writePrerendered(dest: string): string[];
  /** Write server-side code to `dest`. */
  writeServer(dest: string): string[];
  /** Copy a file or directory. */
  copy(
    from: string,
    to: string,
    opts?: {
      filter?(basename: string): boolean;
      replace?: Record<string, string>;
    }
  ): string[];

  /** Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals. */
  compress(directory: string): Promise<void>;
}

/**
 * Logger interface used by Builder.log
 */
interface Logger {
  (msg: string): void;
  success(msg: string): void;
  error(msg: string): void;
  warn(msg: string): void;
  minor(msg: string): void;
  info(msg: string): void;
}

/**
 * A collection of functions that influence the environment during dev, build and prerendering
 */
interface Emulator {
  /** A function that is called with the current route `config` and `prerender` option and returns an `App.Platform` object */
  platform?(details: { config: any; prerender: PrerenderOption }): MaybePromise<App.Platform>;
}

/** Helper type for values that may or may not be wrapped in a Promise */
type MaybePromise<T> = T | Promise<T>;

/** Configuration interfaces and other supporting types are imported from @sveltejs/kit */
interface ValidatedConfig extends Record<string, any> {}
interface Prerendered extends Record<string, any> {}
interface RouteDefinition extends Record<string, any> {}
type PrerenderOption = boolean | 'auto'