@faasjs/core 8.0.0-beta.10

package/dist/index.d.ts

@@ -0,0 +1,814 @@
+import * as z from "zod";
+import { ZodTypeAny, output } from "zod";
+import { Logger } from "@faasjs/node-utils";
+import { IncomingMessage, Server as Server$1, ServerResponse } from "node:http";
+import knex, { Knex as Knex$1, Knex as OriginKnex } from "knex";
+
+//#region src/utils.d.ts
+/**
+ * Assigns a name to a given function handler, which will be displayed in logs and error messages.
+ *
+ * @template T - The type of the function handler.
+ * @param {string} name - The name to assign to the function handler.
+ * @param {T} handler - The function handler to which the name will be assigned.
+ * @returns {T} - The original function handler with the assigned name.
+ *
+ * @example
+ * ```ts
+ * import { nameFunc } from '@faasjs/core'
+ *
+ * const handler = nameFunc('myHandler', () => {
+ *  return 'Hello World'
+ * })
+ *
+ * console.log(handler.name) // => 'myHandler'
+ * ```
+ */
+declare function nameFunc<T extends (...args: any[]) => any>(name: string, handler: T): T;
+//#endregion
+//#region src/func.d.ts
+type Handler<TEvent = any, TContext = any, TResult = any> = (data: InvokeData<TEvent, TContext>) => Promise<TResult>;
+type Next = () => Promise<void>;
+type ExportedHandler<TEvent = any, TContext = any, TResult = any> = (event?: TEvent, context?: TContext, callback?: (...args: any) => any) => Promise<TResult>;
+type Plugin = {
+  [key: string]: any;
+  readonly type: string;
+  readonly name: string;
+  onMount?: (data: MountData, next: Next) => Promise<void>;
+  onInvoke?: (data: InvokeData, next: Next) => Promise<void>;
+};
+type Config = {
+  [key: string]: any;
+  plugins?: {
+    [key: string]: {
+      [key: string]: any;
+      type?: string;
+      config?: {
+        [key: string]: any;
+      };
+    };
+  };
+};
+type MountData = {
+  [key: string]: any;
+  config: Config;
+  event: any;
+  context: any;
+};
+type InvokeData<TEvent = any, TContext = any, TResult = any> = {
+  [key: string]: any;
+  event: TEvent;
+  context: TContext;
+  callback: any;
+  response: any;
+  logger: Logger;
+  handler?: Handler<TEvent, TContext, TResult>;
+  config: Config;
+};
+type LifeCycleKey = 'onMount' | 'onInvoke';
+type FuncConfig<TEvent = any, TContext = any, TResult = any> = {
+  plugins?: Plugin[];
+  handler?: Handler<TEvent, TContext, TResult>;
+};
+/**
+ * Get the event type of a func.
+ *
+ * @example
+ * ```ts
+ * import { defineApi } from '@faasjs/core'
+ * import type { FuncEventType } from '@faasjs/core'
+ *
+ * const func = defineApi<undefined, { counter: number }>({
+ *   async handler() {
+ *     return null
+ *   },
+ * })
+ *
+ * FuncEventType<typeof func> // => { counter: number }
+ * ```
+ */
+type FuncEventType<T extends Func<any, any, any>> = T extends Func<infer P, any, any> ? P : any;
+/**
+ * Get the return type of a func.
+ *
+ * @example
+ * ```ts
+ * import { defineApi } from '@faasjs/core'
+ * import type { FuncReturnType } from '@faasjs/core'
+ *
+ * const func = defineApi<undefined, any, any, number>({
+ *   async handler() {
+ *     return 1
+ *   },
+ * })
+ *
+ * FuncReturnType<typeof func> // => number
+ * ```
+ */
+type FuncReturnType<T extends Func<any, any, any>> = T extends Func<any, any, infer R> ? R : any;
+type NormalizePluginType<TType extends string> = TType extends `npm:${infer Name}` ? Name : TType extends `@faasjs/${infer Name}` ? Name : TType;
+type UnionToIntersection<T> = (T extends unknown ? (arg: T) => void : never) extends ((arg: infer TResult) => void) ? TResult : never;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Plugin event augmentation map.
+ *
+ * Extend this interface in plugin packages to describe which event fields are
+ * injected when the plugin is enabled through `faas.yaml`.
+ */
+interface FaasPluginEventMap {}
+type ResolvePluginEvent<TType extends string> = NormalizePluginType<TType> extends keyof FaasPluginEventMap ? FaasPluginEventMap[NormalizePluginType<TType>] : Record<never, never>;
+/**
+ * Infer event type from plugin type names.
+ *
+ * @example
+ * ```ts
+ * type Event = InferPluginEvent<['http']>
+ * ```
+ */
+type InferPluginEvent<TPlugins extends readonly string[]> = Simplify<Record<string, any> & UnionToIntersection<ResolvePluginEvent<TPlugins[number]>>>;
+declare function parseFuncFilenameFromStack(stack?: string): string | undefined;
+declare class Func<TEvent = any, TContext = any, TResult = any> {
+  [key: string]: any;
+  plugins: Plugin[];
+  handler?: Handler<TEvent, TContext, TResult>;
+  config: Config;
+  mounted: boolean;
+  filename?: string;
+  private cachedFunctions;
+  /**
+   * Create a cloud function.
+   */
+  constructor(config: FuncConfig<TEvent, TContext>);
+  private getCachedFunctions;
+  private compose;
+  /**
+   * First time mount the function.
+   */
+  mount(data?: {
+    event: TEvent;
+    context: TContext;
+    config?: Config;
+    logger?: Logger;
+  }): Promise<void>;
+  /**
+   * Invoke the function.
+   */
+  invoke(data: InvokeData<TEvent, TContext, TResult>): Promise<void>;
+  /**
+   * Export the function.
+   */
+  export(): {
+    handler: ExportedHandler<TEvent, TContext, TResult>;
+  };
+}
+type UseifyPlugin<T> = T & {
+  mount: (data?: MountData) => Promise<T>;
+};
+declare function usePlugin<T extends Plugin>(plugin: T & {
+  mount?: (data?: MountData) => Promise<T>;
+}): UseifyPlugin<T>;
+/**
+ * Create a cloud function.
+ */
+declare function useFunc<TEvent = any, TContext = any, TResult = any>(handler: () => Handler<TEvent, TContext, TResult>): Func<TEvent, TContext, TResult>;
+//#endregion
+//#region src/knex/plugin.d.ts
+/**
+ * Origin [knex](https://knexjs.org/) instance.
+ */
+declare const originKnex: typeof knex;
+type KnexConfig = {
+  name?: string;
+  config?: OriginKnex.Config;
+};
+declare function initPostgresTypeParsers(): Promise<void>;
+declare class Knex implements Plugin {
+  readonly type = "knex";
+  readonly name: string;
+  config: OriginKnex.Config;
+  adapter: OriginKnex;
+  query: OriginKnex;
+  logger: Logger;
+  constructor(config?: KnexConfig);
+  onMount(data: MountData, next: Next): Promise<void>;
+  onInvoke(data: InvokeData<any, any, any>, next: Next): Promise<void>;
+  raw<TResult = any>(sql: string, bindings?: OriginKnex.RawBinding[] | OriginKnex.ValueDict): Promise<OriginKnex.Raw<TResult>>;
+  /**
+   * Wraps a transaction, returning a promise that resolves to the return value of the callback.
+   *
+   * - Support 'commit' and 'rollback' event.
+   */
+  transaction<TResult = any>(scope: (trx: OriginKnex.Transaction<any, any>) => Promise<TResult>, config?: OriginKnex.TransactionConfig, options?: {
+    trx?: OriginKnex.Transaction;
+  }): Promise<TResult>;
+  schema(): OriginKnex.SchemaBuilder;
+  quit(): Promise<void>;
+}
+declare function useKnex(config?: KnexConfig): UseifyPlugin<Knex>;
+declare function query<TName extends OriginKnex.TableNames>(table: TName): OriginKnex.QueryBuilder<OriginKnex.TableType<TName>, {
+  _base: OriginKnex.ResolveTableType<OriginKnex.TableType<TName>, 'base'>;
+  _hasSelection: false;
+  _keys: never;
+  _aliases: {};
+  _single: false;
+  _intersectProps: {};
+  _unionProps: never;
+}[]>;
+declare function query<TName extends {} = any, TResult = any[]>(table: string): OriginKnex.QueryBuilder<TName, TResult>;
+declare function transaction<TResult = any>(scope: (trx: OriginKnex.Transaction<any, any>) => Promise<TResult>, config?: OriginKnex.TransactionConfig, options?: {
+  trx?: OriginKnex.Transaction;
+}): Promise<TResult>;
+declare function raw<TResult = any>(sql: string, bindings?: OriginKnex.RawBinding[] | OriginKnex.ValueDict): Promise<OriginKnex.Raw<TResult>>;
+//#endregion
+//#region src/http/session.d.ts
+type SessionOptions = {
+  key: string;
+  secret: string;
+  salt?: string;
+  signedSalt?: string;
+  keylen?: number;
+  iterations?: number;
+  digest?: string;
+  cipherName?: string;
+};
+type SessionContent = string | number | {
+  [key: string]: any;
+} | null | undefined;
+declare class Session<S extends Record<string, string> = any, C extends Record<string, string> = any> {
+  content: Record<string, string | number>;
+  readonly config: {
+    key: string;
+    secret: string;
+    salt: string;
+    signedSalt: string;
+    keylen: number;
+    iterations: number;
+    digest: string;
+    cipherName: string;
+  };
+  private readonly secret;
+  private readonly signedSecret;
+  private readonly cookie;
+  private changed?;
+  constructor(cookie: Cookie<C, S>, config: SessionOptions);
+  invoke(cookie?: string, logger?: Logger): void;
+  encode(text: SessionContent): string;
+  decode<TData = any>(text: string): TData | SessionContent;
+  read(key: string): string | number;
+  write(key: string, value?: string | number | null): Session<S, C>;
+  update(): Session<S, C>;
+}
+//#endregion
+//#region src/http/cookie.d.ts
+type CookieOptions = {
+  domain?: string;
+  path?: string;
+  expires?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+  session?: SessionOptions;
+  [key: string]: any;
+};
+declare class Cookie<C extends Record<string, string> = any, S extends Record<string, string> = any> {
+  session: Session<S, C>;
+  content: Record<string, string>;
+  readonly config: {
+    domain?: string;
+    path: string;
+    expires: number;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    session: SessionOptions;
+  };
+  logger: Logger | undefined;
+  private setCookie;
+  constructor(config: CookieOptions, logger?: Logger);
+  invoke(cookie: string | undefined, logger: Logger): Cookie<C, S>;
+  read(key: string): any;
+  write(key: string, value: string | null | undefined, opts?: {
+    domain?: string;
+    path?: string;
+    expires?: number | string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+  }): Cookie<C, S>;
+  headers(): {
+    'Set-Cookie'?: string[];
+  };
+}
+//#endregion
+//#region src/http/index.d.ts
+declare const ContentType: {
+  [key: string]: string;
+};
+type HttpConfig = {
+  [key: string]: any;
+  name?: string;
+  config?: {
+    [key: string]: any; /** POST as default */
+    method?: 'BEGIN' | 'GET' | 'POST' | 'DELETE' | 'HEAD' | 'PUT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'ANY';
+    timeout?: number; /** file relative path as default */
+    path?: string;
+    ignorePathPrefix?: string;
+    functionName?: string;
+    cookie?: CookieOptions;
+  };
+};
+type Response = {
+  statusCode?: number;
+  headers?: {
+    [key: string]: string;
+  };
+  body?: string | ReadableStream;
+  message?: string;
+};
+declare class HttpError extends Error {
+  readonly statusCode: number;
+  readonly message: string;
+  constructor({
+    statusCode,
+    message
+  }: {
+    statusCode?: number;
+    message: string;
+  });
+}
+declare class Http<TParams extends Record<string, any> = any, TCookie extends Record<string, string> = any, TSession extends Record<string, string> = any> implements Plugin {
+  readonly type = "http";
+  readonly name: string;
+  headers: {
+    [key: string]: string;
+  };
+  body: any;
+  params: TParams;
+  cookie: Cookie<TCookie, TSession>;
+  session: Session<TSession, TCookie>;
+  config: HttpConfig;
+  private response;
+  constructor(config?: HttpConfig);
+  onMount(data: MountData, next: Next): Promise<void>;
+  onInvoke(data: InvokeData, next: Next): Promise<void>;
+  private parseEventParams;
+  private buildResponse;
+  private finalizeBody;
+  /**
+   * set header
+   * @param key {string} key
+   * @param value {string} value
+   */
+  setHeader(key: string, value: string): Http<TParams, TCookie, TSession>;
+  /**
+   * set Content-Type
+   * @param type {string} 类型
+   * @param charset {string} 编码
+   */
+  setContentType(type: string, charset?: string): Http<TParams, TCookie, TSession>;
+  /**
+   * set status code
+   * @param code {number} 状态码
+   */
+  setStatusCode(code: number): Http<TParams, TCookie, TSession>;
+  /**
+   * set body
+   * @param body {*} 内容
+   */
+  setBody(body: string): Http<TParams, TCookie, TSession>;
+}
+declare function useHttp<TParams extends Record<string, any> = any, TCookie extends Record<string, string> = any, TSession extends Record<string, string> = any>(config?: HttpConfig): UseifyPlugin<Http<TParams, TCookie, TSession>>;
+declare module '@faasjs/core' {
+  interface FaasPluginEventMap {
+    http: {
+      headers?: Record<string, any>;
+      body?: any;
+      params?: Record<string, any>;
+      queryString?: Record<string, any>;
+      httpMethod?: string;
+      path?: string;
+      raw?: {
+        request?: unknown;
+        response?: unknown;
+      };
+    };
+  }
+}
+//#endregion
+//#region src/middleware/middleware.d.ts
+type MiddlewareEvent = {
+  body: any;
+  raw: {
+    request: IncomingMessage;
+    response: ServerResponse;
+  };
+};
+type MiddlewareContext = {
+  logger: Logger;
+};
+type Middleware = (request: IncomingMessage & {
+  body?: any;
+}, response: ServerResponse, context: MiddlewareContext) => void | Promise<void>;
+/**
+ * Apply a middleware function to handle incoming requests.
+ *
+ * @param handler - The middleware function to handle the request and response.
+ * @returns A function that processes the event and applies the middleware.
+ *
+ * @example
+ * ```typescript
+ * import { useMiddleware } from '@faasjs/core'
+ *
+ * export const func = useMiddleware((request, response, logger) => {
+ *   response.setHeader('X-Hello', 'World')
+ *   response.end('Hello, World!')
+ *   logger.info('Hello, World!')
+ * })
+ * ```
+ */
+declare function useMiddleware(handler: Middleware): Promise<Func<MiddlewareEvent, any, any>>;
+/**
+ * Apply an array of middleware functions to an event.
+ *
+ * @param {Middleware[]} handlers - An array of middleware functions to be applied.
+ * @returns {Promise<void>} A promise that resolves when all middleware functions have been applied.
+ *
+ * @example
+ * ```typescript
+ * import { useMiddlewares } from '@faasjs/core'
+ *
+ * export const func = useMiddlewares([
+ *   (request, response) => {
+ *     if (request.url === '/hi') return
+ *     response.end('Hello, World!')
+ *   },
+ *   (request, response) => {
+ *     if (request.url === '/hello') return
+ *     response.end('Hi, World!')
+ *   }
+ * ])
+ * ```
+ */
+declare function useMiddlewares(handlers: Middleware[]): Promise<Func<MiddlewareEvent, any, any>>;
+//#endregion
+//#region src/middleware/static.d.ts
+type StaticHandlerOptions = {
+  root: string;
+  /**
+   * Not found handler.
+   *
+   * If set to `true`, the middleware will respond with a default 404 status code.
+   * If set to a string as a fallback path, the middleware will respond with the file at that path.
+   * If set to a function, the middleware will call the function with the request, response, and logger.
+   * If set to `false`, the middleware will do nothing.
+   *
+   * @default false
+   */
+  notFound?: Middleware | boolean | string;
+  /**
+   * Cache static files.
+   * If set to `true`, the middleware will cache static files.
+   * If set to a string, the middleware will cache static files with the specified key.
+   * If set to `false`, the middleware will not cache static files.
+   *
+   * @default true
+   */
+  cache?: boolean | string;
+  /**
+   * Strip prefix from the URL.
+   *
+   * @example
+   * ```typescript
+   * import { useMiddleware, staticHandler } from '@faasjs/core'
+   *
+   * export const func = useMiddleware(staticHandler({ root: __dirname + '/public', stripPrefix: '/public' })) // /public/index.html -> /index.html
+   * ```
+   */
+  stripPrefix?: string | RegExp;
+};
+/**
+ * Middleware to handle static file requests.
+ *
+ * @param {StaticHandlerOptions} options - Options for the static handler.
+ * @returns {Middleware} The middleware function.
+ *
+ * The middleware resolves the requested URL to a file path within the specified root directory.
+ * If the file exists, it reads the file content and sends it in the response.
+ * If the file does not exist, it does nothing.
+ *
+ * @example
+ * ```typescript
+ * import { useMiddleware, staticHandler } from '@faasjs/core'
+ *
+ * export const func = useMiddleware(staticHandler({ root: __dirname + '/public' }))
+ * ```
+ */
+declare function staticHandler(options: StaticHandlerOptions): Middleware;
+//#endregion
+//#region src/cron/index.d.ts
+type CronJobContext = {
+  now: Date;
+  logger: Logger;
+  job: CronJob;
+};
+type CronJobHandler = (context: CronJobContext) => void | Promise<void>;
+type CronJobErrorHandler = (error: Error, context: CronJobContext) => void | Promise<void>;
+type CronJobOptions = {
+  /**
+   * Name of the cron job, used in logs.
+   *
+   * @default random name
+   */
+  name?: string;
+  /**
+   * Cron expression in 5-field format:
+   * minute hour dayOfMonth month dayOfWeek
+   *
+   * Supported syntax per field: wildcard (`*`), step (every n units), and fixed number.
+   */
+  expression: string;
+  /**
+   * Job handler.
+   */
+  handler: CronJobHandler;
+  /**
+   * Called when handler throws.
+   */
+  onError?: CronJobErrorHandler;
+  /**
+   * Custom logger for this cron job.
+   */
+  logger?: Logger;
+};
+/**
+ * Simple cron job scheduler with 5-field cron expression support.
+ */
+declare class CronJob {
+  readonly name: string;
+  readonly expression: string;
+  readonly handler: CronJobHandler;
+  private readonly onError;
+  private readonly logger;
+  private readonly matchers;
+  private timer;
+  private started;
+  private lastTickMinute;
+  constructor(options: CronJobOptions);
+  start(): void;
+  stop(): void;
+  get isStarted(): boolean;
+  private scheduleNext;
+  private tick;
+  private execute;
+  private handleError;
+}
+/**
+ * Create and register a cron job.
+ *
+ * Registered jobs are managed by `Server` lifecycle automatically.
+ */
+declare function createCronJob(options: CronJobOptions): CronJob;
+declare function removeCronJob(cronJob: CronJob): boolean;
+declare function listCronJobs(): CronJob[];
+//#endregion
+//#region src/server/index.d.ts
+type ServerHandlerOptions = {
+  requestedAt?: number;
+  filepath?: string;
+};
+declare function getAll(): Server[];
+declare function closeAll(): Promise<void>;
+/**
+ * Options for configuring the server.
+ */
+/**
+ * Configuration options for the server.
+ */
+type ServerOptions = {
+  /**
+   * The port on which the server will listen. Defaults to `3000` if not provided.
+   *
+   * @default 3000
+   */
+  port?: number;
+  /**
+   * Callback function that is invoked when the server starts.
+   *
+   * This function is executed asynchronously and will not interrupt the server
+   * if an error occurs during its execution.
+   *
+   * @param context - An object containing the logger instance.
+   *
+   * @example
+   * ```typescript
+   * const server = new Server(process.cwd(), {
+   *   onStart: async ({ logger }) => {
+   *     logger.info('Server started');
+   *   }
+   * });
+   * ```
+   */
+  onStart?: (context: {
+    logger: Logger;
+  }) => Promise<void>;
+  /**
+   * Callback function that is invoked when an error occurs.
+   *
+   * This function is executed asynchronously and allows handling of errors
+   * that occur during server operation.
+   *
+   * @param error - The error that occurred.
+   * @param context - An object containing the logger instance.
+   *
+   * @example
+   * ```typescript
+   * const server = new Server(process.cwd(), {
+   *   onError: async (error, { logger }) => {
+   *     logger.error(error);
+   *   }
+   * });
+   * ```
+   */
+  onError?: (error: Error, context: {
+    logger: Logger;
+  }) => Promise<void>;
+  /**
+   * Callback function that is invoked when the server is closed.
+   *
+   * This function is executed asynchronously and can be used to perform
+   * cleanup tasks or log server shutdown events.
+   *
+   * @param context - An object containing the logger instance.
+   *
+   * @example
+   * ```typescript
+   * const server = new Server(process.cwd(), {
+   *   onClose: async ({ logger }) => {
+   *     logger.info('Server closed');
+   *   }
+   * });
+   * ```
+   */
+  onClose?: (context: {
+    logger: Logger;
+  }) => Promise<void>;
+  /**
+   * Callback function that is invoked before handling each request.
+   *
+   * This function is executed asynchronously before the main request handling logic.
+   * It can be used for request preprocessing, authentication, logging, etc.
+   *
+   * @param req - The incoming HTTP request object.
+   * @param res - The server response object.
+   *
+   * @example
+   * ```typescript
+   * const server = new Server(process.cwd(), {
+   *   beforeHandle: async (req, res) => {
+   *     console.log(`Processing ${req.method} request to ${req.url}`)
+   *
+   *     if (req.method !== 'POST')
+   *       res.writeHead(405, { 'Allow': 'POST' }) // If you write response, it will finish the request
+   *   }
+   * });
+   * ```
+   */
+  beforeHandle?: Middleware;
+  /**
+   * Whether to mount cron job lifecycle with this server instance.
+   *
+   * When enabled, `server.listen()` mounts registered cron jobs and
+   * `server.close()` unmounts them.
+   *
+   * @default true
+   */
+  cronJob?: boolean;
+};
+/**
+ * FaasJS Server.
+ *
+ * @param {string} root The root path of the server.
+ * @param {ServerOptions} opts The options of the server.
+ * @returns {Server}
+ * @example
+ * ```ts
+ * import { Server } from '@faasjs/core'
+ *
+ * const server = new Server(process.cwd(), {
+ *   port: 8080,
+ * })
+ *
+ * server.listen()
+ * ```
+ */
+declare class Server {
+  readonly root: string;
+  readonly logger: Logger;
+  readonly options: ServerOptions;
+  protected closed: boolean;
+  private activeRequests;
+  private cachedFuncs;
+  private onError;
+  private server;
+  private sockets;
+  constructor(root: string, opts?: ServerOptions);
+  handle(req: IncomingMessage, res: ServerResponse<IncomingMessage>, options?: ServerHandlerOptions): Promise<void>;
+  private readRequestBody;
+  private runBeforeHandle;
+  private getOrLoadHandler;
+  private invokeHandler;
+  private buildResponseHeaders;
+  private pipeToResponse;
+  /**
+   * Start server.
+   * @returns {Server}
+   */
+  listen(): Server$1;
+  /**
+   * Close server.
+   */
+  close(): Promise<void>;
+  /**
+   * Middleware function to handle incoming HTTP requests.
+   *
+   * @param req - The incoming HTTP request object.
+   * @param res - The server response object.
+   * @param next - A callback function to pass control to the next middleware.
+   * @returns A promise that resolves when the middleware processing is complete.
+   */
+  middleware(req: IncomingMessage, res: ServerResponse<IncomingMessage>, next: () => void): Promise<void>;
+  private getFilePath;
+  private handleOptionRequest;
+}
+//#endregion
+//#region src/knex/pglite.d.ts
+type MountedKnexAdapter = {
+  adapter: Knex$1;
+  query: Knex$1;
+  config: Record<string, unknown>;
+};
+type MountFaasKnexOptions = {
+  /** key of `globalThis.FaasJS_Knex`, default is `knex` */name?: string; /** optional config metadata passed through to `@faasjs/core` */
+  config?: Record<string, unknown>;
+};
+/**
+ * Create a knex instance backed by `knex-pglite`.
+ * If connection is missing, it defaults to an in-memory database.
+ */
+declare function createPgliteKnex(config?: Partial<Knex$1.Config>, connection?: string): Promise<Knex$1>;
+/**
+ * Mount a knex adapter to `globalThis.FaasJS_Knex` for `@faasjs/core`.
+ */
+declare function mountFaasKnex(db: Knex$1, options?: MountFaasKnexOptions): void;
+/**
+ * Remove mounted knex adapter from `globalThis.FaasJS_Knex`.
+ */
+declare function unmountFaasKnex(name?: string): void;
+//#endregion
+//#region src/knex/schema.d.ts
+/**
+ * Migration helper for FaasJS knex plugin.
+ */
+declare class KnexSchema {
+  readonly knex: {
+    name: string;
+    adapter?: Knex$1;
+    config: Knex$1.Config;
+  };
+  constructor(knex: {
+    name: string;
+    adapter?: Knex$1;
+    config: Knex$1.Config;
+  });
+  private getAdapter;
+  private getMigratorConfig;
+  migrateLatest(): Promise<any>;
+  migrateRollback(): Promise<any>;
+  migrateStatus(): Promise<number>;
+  migrateCurrentVersion(): Promise<string>;
+  migrateMake(name: string): Promise<string>;
+}
+//#endregion
+//#region src/index.d.ts
+type ZodSchema = ZodTypeAny;
+type KnexQuery = Knex['query'];
+type DefineApiData<TSchema extends ZodSchema | undefined = undefined, TEvent = any, TContext = any, TResult = any> = InvokeData<TEvent, TContext, TResult> & {
+  params: TSchema extends ZodSchema ? output<NonNullable<TSchema>> : Record<string, never>;
+  knex: KnexQuery | undefined;
+};
+type DefineApiOptions<TSchema extends ZodSchema | undefined = undefined, TEvent = any, TContext = any, TResult = any> = {
+  schema?: TSchema;
+  handler: (data: DefineApiData<TSchema, TEvent, TContext, TResult>) => Promise<TResult>;
+};
+/**
+ * Create an HTTP API function with optional Zod validation.
+ *
+ * Plugins are always auto-loaded from `func.config.plugins`.
+ * Plugin module exports must be either a named class (normalized from
+ * plugin type) or a default class export.
+ *
+ * The `http` plugin is required.
+ */
+declare function defineApi<TSchema extends ZodSchema | undefined = undefined, TEvent = any, TContext = any, TResult = any>(options: DefineApiOptions<TSchema, TEvent, TContext, TResult>): Func<TEvent, TContext, TResult>;
+//#endregion
+export { Config, ContentType, Cookie, type CookieOptions, CronJob, type CronJobContext, type CronJobErrorHandler, type CronJobHandler, type CronJobOptions, DefineApiData, DefineApiOptions, ExportedHandler, FaasPluginEventMap, Func, FuncConfig, FuncEventType, FuncReturnType, Handler, Http, type HttpConfig, HttpError, InferPluginEvent, InvokeData, Knex, KnexConfig, KnexSchema, LifeCycleKey, type Middleware, type MiddlewareContext, type MiddlewareEvent, MountData, MountFaasKnexOptions, MountedKnexAdapter, Next, NormalizePluginType, type OriginKnex, Plugin, ResolvePluginEvent, type Response, Server, type ServerHandlerOptions, type ServerOptions, Session, type SessionContent, type SessionOptions, Simplify, type StaticHandlerOptions, UnionToIntersection, UseifyPlugin, closeAll, createCronJob, createPgliteKnex, defineApi, getAll, initPostgresTypeParsers, listCronJobs, mountFaasKnex, nameFunc, originKnex, parseFuncFilenameFromStack, query, raw, removeCronJob, staticHandler, transaction, unmountFaasKnex, useFunc, useHttp, useKnex, useMiddleware, useMiddlewares, usePlugin, z };