effortless-aws 0.7.0 → 0.7.2

package/dist/index.d.ts

@@ -88,6 +88,117 @@ type EffortlessConfig = {
  */
 declare const defineConfig: (config: EffortlessConfig) => EffortlessConfig;
 
+type AwsService = "dynamodb" | "s3" | "sqs" | "sns" | "ses" | "ssm" | "lambda" | "events" | "secretsmanager" | "cognito-idp" | "logs";
+type Permission = `${AwsService}:${string}` | (string & {});
+/** Logging verbosity level for Lambda handlers */
+type LogLevel = "error" | "info" | "debug";
+/**
+ * Common Lambda configuration shared by all handler types.
+ */
+type LambdaConfig = {
+    /** Handler name. Defaults to export name if not specified */
+    name?: string;
+    /** Lambda memory in MB (default: 256) */
+    memory?: number;
+    /** Lambda timeout in seconds (default: 30) */
+    timeout?: number;
+    /** Logging verbosity: "error" (errors only), "info" (+ execution summary), "debug" (+ input/output). Default: "info" */
+    logLevel?: LogLevel;
+};
+/**
+ * Lambda configuration with additional IAM permissions.
+ * Used by handler types that support custom permissions (http, table, fifo-queue).
+ */
+type LambdaWithPermissions = LambdaConfig & {
+    /** Additional IAM permissions for the Lambda */
+    permissions?: Permission[];
+};
+type AnyParamRef = ParamRef<any>;
+/**
+ * Reference to an SSM Parameter Store parameter.
+ *
+ * @typeParam T - The resolved type after optional transform (default: string)
+ */
+type ParamRef<T = string> = {
+    readonly __brand: "effortless-param";
+    readonly key: string;
+    readonly transform?: (raw: string) => T;
+};
+/**
+ * Maps a params declaration to resolved value types.
+ *
+ * @typeParam P - Record of param names to ParamRef instances
+ */
+type ResolveParams<P> = {
+    [K in keyof P]: P[K] extends ParamRef<infer T> ? T : never;
+};
+/**
+ * Declare an SSM Parameter Store parameter.
+ *
+ * The key is combined with project and stage at deploy time to form the full
+ * SSM path: `/${project}/${stage}/${key}`.
+ *
+ * @param key - Parameter key (e.g., "database-url")
+ * @param transform - Optional function to transform the raw string value
+ * @returns A ParamRef used by the deployment and runtime systems
+ *
+ * @example Simple string parameter
+ * ```typescript
+ * params: {
+ *   dbUrl: param("database-url"),
+ * }
+ * ```
+ *
+ * @example With transform (e.g., TOML parsing)
+ * ```typescript
+ * import TOML from "smol-toml";
+ *
+ * params: {
+ *   config: param("app-config", TOML.parse),
+ * }
+ * ```
+ */
+declare function param(key: string): ParamRef<string>;
+declare function param<T>(key: string, transform: (raw: string) => T): ParamRef<T>;
+/**
+ * Type-only schema helper for handlers.
+ *
+ * Use this instead of explicit generic parameters like `defineTable<Order>(...)`.
+ * It enables TypeScript to infer all generic types from the options object,
+ * avoiding the partial-inference problem where specifying one generic
+ * forces all others to their defaults.
+ *
+ * At runtime this is a no-op identity function — it simply returns the input unchanged.
+ * The type narrowing happens entirely at the TypeScript level.
+ *
+ * @example Resource-only table
+ * ```typescript
+ * type User = { id: string; email: string };
+ *
+ * // Before (breaks inference for context, deps, params):
+ * export const users = defineTable<User>({ pk: { name: "id", type: "string" } });
+ *
+ * // After (all generics inferred correctly):
+ * export const users = defineTable({
+ *   pk: { name: "id", type: "string" },
+ *   schema: typed<User>(),
+ * });
+ * ```
+ *
+ * @example Table with stream handler
+ * ```typescript
+ * export const orders = defineTable({
+ *   pk: { name: "id", type: "string" },
+ *   schema: typed<Order>(),
+ *   context: async () => ({ db: createClient() }),
+ *   onRecord: async ({ record, ctx }) => {
+ *     // record.new is Order, ctx is { db: Client } — all inferred
+ *   },
+ * });
+ * ```
+ */
+declare function typed<T>(): (input: unknown) => T;
+
 /**
  * Query parameters for TableClient.query()
  */
@@ -374,87 +485,286 @@ type TableHandler<T = Record<string, unknown>, C = undefined, R = void, D = unde
  */
 declare const defineTable: <T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$2> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineTableOptions<T, C, R, D, P, S>) => TableHandler<T, C, R, D, P, S>;
 
+type AnyTableHandler$1 = TableHandler<any, any, any, any, any, any>;
+/** Maps a deps declaration to resolved runtime client types */
+type ResolveDeps$1<D> = {
+    [K in keyof D]: D[K] extends TableHandler<infer T, any, any, any, any> ? TableClient<T> : never;
+};
+/** HTTP methods supported by API Gateway */
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/** Short content-type aliases for common response formats */
+type ContentType = "json" | "html" | "text" | "css" | "js" | "xml" | "csv" | "svg";
 /**
- * Configuration for a Lambda-served static site (API Gateway + Lambda)
+ * Incoming HTTP request object passed to the handler
  */
-type AppConfig = LambdaConfig & {
-    /** Base URL path the site is served under (e.g., "/app") */
-    path?: string;
-    /** Directory containing the static site files, relative to project root */
-    dir: string;
-    /** Default file for directory requests (default: "index.html") */
-    index?: string;
-    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
-    spa?: boolean;
-    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
-    build?: string;
+type HttpRequest = {
+    /** HTTP method (GET, POST, etc.) */
+    method: string;
+    /** Request path (e.g., "/users/123") */
+    path: string;
+    /** Request headers */
+    headers: Record<string, string | undefined>;
+    /** Query string parameters */
+    query: Record<string, string | undefined>;
+    /** Path parameters extracted from route (e.g., {id} -> params.id) */
+    params: Record<string, string | undefined>;
+    /** Parsed request body (JSON parsed if Content-Type is application/json) */
+    body: unknown;
+    /** Raw unparsed request body */
+    rawBody?: string;
 };
 /**
- * Internal handler object created by defineApp
- * @internal
+ * HTTP response returned from the handler
  */
-type AppHandler = {
-    readonly __brand: "effortless-app";
-    readonly config: AppConfig;
+type HttpResponse = {
+    /** HTTP status code (e.g., 200, 404, 500) */
+    status: number;
+    /** Response body — JSON-serialized by default, or sent as string when contentType is set */
+    body?: unknown;
+    /**
+     * Short content-type alias. Resolves to full MIME type automatically:
+     * - `"json"` → `application/json` (default if omitted)
+     * - `"html"` → `text/html; charset=utf-8`
+     * - `"text"` → `text/plain; charset=utf-8`
+     * - `"css"` → `text/css; charset=utf-8`
+     * - `"js"` → `application/javascript; charset=utf-8`
+     * - `"xml"` → `application/xml; charset=utf-8`
+     * - `"csv"` → `text/csv; charset=utf-8`
+     * - `"svg"` → `image/svg+xml; charset=utf-8`
+     */
+    contentType?: ContentType;
+    /** Response headers (use for custom content-types not covered by contentType) */
+    headers?: Record<string, string>;
 };
 /**
- * Deploy a static site via Lambda + API Gateway.
- * Files are bundled into the Lambda ZIP and served with auto-detected content types.
- *
- * For CDN-backed sites (S3 + CloudFront), use {@link defineStaticSite} instead.
- *
- * @param options - Site configuration: path, directory, optional SPA mode
- * @returns Handler object used by the deployment system
- *
- * @example Basic static site
- * ```typescript
- * export const app = defineApp({
- *   path: "/app",
- *   dir: "src/webapp",
- * });
- * ```
+ * Configuration options extracted from DefineHttpOptions (without onRequest callback)
  */
-declare const defineApp: (options: AppConfig) => AppHandler;
-
+type HttpConfig = LambdaWithPermissions & {
+    /** HTTP method for the route */
+    method: HttpMethod;
+    /** Route path (e.g., "/api/users", "/api/users/{id}") */
+    path: string;
+};
 /**
- * Configuration for a static site handler (S3 + CloudFront)
+ * Handler function type for HTTP endpoints
+ *
+ * @typeParam T - Type of the validated request body (from schema function)
+ * @typeParam C - Type of the context/dependencies (from context function)
+ * @typeParam D - Type of the deps (from deps declaration)
+ * @typeParam P - Type of the params (from params declaration)
  */
-type StaticSiteConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
-    /** Directory containing the static site files, relative to project root */
-    dir: string;
-    /** Default file for directory requests (default: "index.html") */
-    index?: string;
-    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
-    spa?: boolean;
-    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
-    build?: string;
-};
+type HttpHandlerFn<T = undefined, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = (args: {
+    req: HttpRequest;
+} & ([T] extends [undefined] ? {} : {
+    data: T;
+}) & ([C] extends [undefined] ? {} : {
+    ctx: C;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+}) & ([S] extends [undefined] ? {} : {
+    readStatic: (path: string) => string;
+})) => Promise<HttpResponse>;
 /**
- * Internal handler object created by defineStaticSite
- * @internal
+ * Context factory type — conditional on whether params are declared.
+ * Without params: `() => C | Promise<C>`
+ * With params: `(args: { params: ResolveParams<P> }) => C | Promise<C>`
  */
-type StaticSiteHandler = {
-    readonly __brand: "effortless-static-site";
-    readonly config: StaticSiteConfig;
-};
+type ContextFactory$1<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
+    params: ResolveParams<P & {}>;
+}) => C | Promise<C>;
 /**
- * Deploy a static site via S3 + CloudFront CDN.
- *
- * @param options - Static site configuration: directory, optional SPA mode, build command
- * @returns Handler object used by the deployment system
- *
- * @example Documentation site
- * ```typescript
- * export const docs = defineStaticSite({
- *   dir: "dist",
- *   build: "npx astro build",
- * });
- * ```
+ * Options for defining an HTTP endpoint
  *
- * @example SPA with client-side routing
- * ```typescript
+ * @typeParam T - Type of the validated request body (inferred from schema function)
+ * @typeParam C - Type of the context/dependencies returned by context function
+ * @typeParam D - Type of the deps (from deps declaration)
+ * @typeParam P - Type of the params (from params declaration)
+ */
+type DefineHttpOptions<T = undefined, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = HttpConfig & {
+    /**
+     * Decode/validate function for the request body.
+     * Called with the parsed body; should return typed data or throw on validation failure.
+     * When provided, the handler receives validated `data` and invalid requests get a 400 response.
+     *
+     * Works with any validation library:
+     * - Effect: `S.decodeUnknownSync(MySchema)`
+     * - Zod: `(body) => myZodSchema.parse(body)`
+     */
+    schema?: (input: unknown) => T;
+    /**
+     * Error handler called when schema validation or onRequest throws.
+     * Receives the error and request, returns an HttpResponse.
+     * If not provided, defaults to 400 for validation errors and 500 for handler errors.
+     */
+    onError?: (error: unknown, req: HttpRequest) => HttpResponse;
+    /**
+     * Factory function to create context/dependencies for the request handler.
+     * Called once on cold start, result is cached and reused across invocations.
+     * When params are declared, receives resolved params as argument.
+     * Supports both sync and async return values.
+     */
+    context?: ContextFactory$1<C, P>;
+    /**
+     * Dependencies on other handlers (tables, queues, etc.).
+     * Typed clients are injected into the handler via the `deps` argument.
+     */
+    deps?: D;
+    /**
+     * SSM Parameter Store parameters.
+     * Declare with `param()` helper. Values are fetched and cached at cold start.
+     * Typed values are injected into the handler via the `params` argument.
+     */
+    params?: P;
+    /**
+     * Static file glob patterns to bundle into the Lambda ZIP.
+     * Files are accessible at runtime via the `readStatic` callback argument.
+     */
+    static?: S;
+    /** HTTP request handler function */
+    onRequest: HttpHandlerFn<T, C, D, P, S>;
+};
+/**
+ * Internal handler object created by defineHttp
+ * @internal
+ */
+type HttpHandler<T = undefined, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = {
+    readonly __brand: "effortless-http";
+    readonly config: HttpConfig;
+    readonly schema?: (input: unknown) => T;
+    readonly onError?: (error: unknown, req: HttpRequest) => HttpResponse;
+    readonly context?: (...args: any[]) => C | Promise<C>;
+    readonly deps?: D;
+    readonly params?: P;
+    readonly static?: string[];
+    readonly onRequest: HttpHandlerFn<T, C, D, P, S>;
+};
+/**
+ * Define an HTTP endpoint that creates an API Gateway route + Lambda function
+ *
+ * @typeParam T - Type of the validated request body (inferred from schema function)
+ * @typeParam C - Type of the context/dependencies (inferred from context function)
+ * @typeParam D - Type of the deps (from deps declaration)
+ * @typeParam P - Type of the params (from params declaration)
+ * @param options - Configuration, optional schema, optional context factory, and request handler
+ * @returns Handler object used by the deployment system
+ *
+ * @example Basic GET endpoint
+ * ```typescript
+ * export const hello = defineHttp({
+ *   method: "GET",
+ *   path: "/hello",
+ *   onRequest: async ({ req }) => ({
+ *     status: 200,
+ *     body: { message: "Hello World!" }
+ *   })
+ * });
+ * ```
+ *
+ * @example With SSM parameters
+ * ```typescript
+ * import { param } from "effortless-aws";
+ *
+ * export const api = defineHttp({
+ *   method: "GET",
+ *   path: "/orders",
+ *   params: {
+ *     dbUrl: param("database-url"),
+ *   },
+ *   context: async ({ params }) => ({
+ *     pool: createPool(params.dbUrl),
+ *   }),
+ *   onRequest: async ({ req, ctx, params }) => ({
+ *     status: 200,
+ *     body: { dbUrl: params.dbUrl }
+ *   })
+ * });
+ * ```
+ */
+declare const defineHttp: <T = undefined, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineHttpOptions<T, C, D, P, S>) => HttpHandler<T, C, D, P, S>;
+
+/**
+ * Configuration for a Lambda-served static site (API Gateway + Lambda)
+ */
+type AppConfig = LambdaConfig & {
+    /** Base URL path the site is served under (e.g., "/app") */
+    path?: string;
+    /** Directory containing the static site files, relative to project root */
+    dir: string;
+    /** Default file for directory requests (default: "index.html") */
+    index?: string;
+    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
+    spa?: boolean;
+    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
+    build?: string;
+};
+/**
+ * Internal handler object created by defineApp
+ * @internal
+ */
+type AppHandler = {
+    readonly __brand: "effortless-app";
+    readonly config: AppConfig;
+};
+/**
+ * Deploy a static site via Lambda + API Gateway.
+ * Files are bundled into the Lambda ZIP and served with auto-detected content types.
+ *
+ * For CDN-backed sites (S3 + CloudFront), use {@link defineStaticSite} instead.
+ *
+ * @param options - Site configuration: path, directory, optional SPA mode
+ * @returns Handler object used by the deployment system
+ *
+ * @example Basic static site
+ * ```typescript
+ * export const app = defineApp({
+ *   path: "/app",
+ *   dir: "src/webapp",
+ * });
+ * ```
+ */
+declare const defineApp: (options: AppConfig) => AppHandler;
+
+/**
+ * Configuration for a static site handler (S3 + CloudFront)
+ */
+type StaticSiteConfig = {
+    /** Handler name. Defaults to export name if not specified */
+    name?: string;
+    /** Directory containing the static site files, relative to project root */
+    dir: string;
+    /** Default file for directory requests (default: "index.html") */
+    index?: string;
+    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
+    spa?: boolean;
+    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
+    build?: string;
+};
+/**
+ * Internal handler object created by defineStaticSite
+ * @internal
+ */
+type StaticSiteHandler = {
+    readonly __brand: "effortless-static-site";
+    readonly config: StaticSiteConfig;
+};
+/**
+ * Deploy a static site via S3 + CloudFront CDN.
+ *
+ * @param options - Static site configuration: directory, optional SPA mode, build command
+ * @returns Handler object used by the deployment system
+ *
+ * @example Documentation site
+ * ```typescript
+ * export const docs = defineStaticSite({
+ *   dir: "dist",
+ *   build: "npx astro build",
+ * });
+ * ```
+ *
+ * @example SPA with client-side routing
+ * ```typescript
  * export const app = defineStaticSite({
  *   dir: "dist",
  *   spa: true,
@@ -464,9 +774,9 @@ type StaticSiteHandler = {
  */
 declare const defineStaticSite: (options: StaticSiteConfig) => StaticSiteHandler;
 
-type AnyTableHandler$1 = TableHandler<any, any, any, any, any, any>;
+type AnyTableHandler = TableHandler<any, any, any, any, any, any>;
 /** Maps a deps declaration to resolved runtime client types */
-type ResolveDeps$1<D> = {
+type ResolveDeps<D> = {
     [K in keyof D]: D[K] extends TableHandler<infer T, any, any, any, any> ? TableClient<T> : never;
 };
 /**
@@ -519,7 +829,7 @@ type FifoQueueConfig = LambdaWithPermissions & {
  * Without params: `() => C | Promise<C>`
  * With params: `(args: { params: ResolveParams<P> }) => C | Promise<C>`
  */
-type ContextFactory$1<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
+type ContextFactory<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
     params: ResolveParams<P & {}>;
 }) => C | Promise<C>;
 /**
@@ -531,7 +841,7 @@ type FifoQueueMessageFn<T = unknown, C = undefined, D = undefined, P = undefined
 } & ([C] extends [undefined] ? {} : {
     ctx: C;
 }) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps$1<D>;
+    deps: ResolveDeps<D>;
 }) & ([P] extends [undefined] ? {} : {
     params: ResolveParams<P>;
 }) & ([S] extends [undefined] ? {} : {
@@ -546,7 +856,7 @@ type FifoQueueBatchFn<T = unknown, C = undefined, D = undefined, P = undefined,
 } & ([C] extends [undefined] ? {} : {
     ctx: C;
 }) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps$1<D>;
+    deps: ResolveDeps<D>;
 }) & ([P] extends [undefined] ? {} : {
     params: ResolveParams<P>;
 }) & ([S] extends [undefined] ? {} : {
@@ -569,7 +879,7 @@ type DefineFifoQueueBase<T = unknown, C = undefined, D = undefined, P = undefine
      * Called once on cold start, result is cached and reused across invocations.
      * When params are declared, receives resolved params as argument.
      */
-    context?: ContextFactory$1<C, P>;
+    context?: ContextFactory<C, P>;
     /**
      * Dependencies on other handlers (tables, queues, etc.).
      * Typed clients are injected into the handler via the `deps` argument.
@@ -596,7 +906,7 @@ type DefineFifoQueueWithOnBatch<T = unknown, C = undefined, D = undefined, P = u
     onBatch: FifoQueueBatchFn<T, C, D, P, S>;
     onMessage?: never;
 };
-type DefineFifoQueueOptions<T = unknown, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = DefineFifoQueueWithOnMessage<T, C, D, P, S> | DefineFifoQueueWithOnBatch<T, C, D, P, S>;
+type DefineFifoQueueOptions<T = unknown, C = undefined, D extends Record<string, AnyTableHandler> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = DefineFifoQueueWithOnMessage<T, C, D, P, S> | DefineFifoQueueWithOnBatch<T, C, D, P, S>;
 /**
  * Internal handler object created by defineFifoQueue
  * @internal
@@ -643,316 +953,6 @@ type FifoQueueHandler<T = unknown, C = undefined, D = undefined, P = undefined,
  * });
  * ```
  */
-declare const defineFifoQueue: <T = unknown, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineFifoQueueOptions<T, C, D, P, S>) => FifoQueueHandler<T, C, D, P, S>;
-
-type AwsService = "dynamodb" | "s3" | "sqs" | "sns" | "ses" | "ssm" | "lambda" | "events" | "secretsmanager" | "cognito-idp" | "logs";
-type Permission = `${AwsService}:${string}` | (string & {});
-/** Logging verbosity level for Lambda handlers */
-type LogLevel = "error" | "info" | "debug";
-/**
- * Common Lambda configuration shared by all handler types.
- */
-type LambdaConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
-    /** Lambda memory in MB (default: 256) */
-    memory?: number;
-    /** Lambda timeout in seconds (default: 30) */
-    timeout?: number;
-    /** Logging verbosity: "error" (errors only), "info" (+ execution summary), "debug" (+ input/output). Default: "info" */
-    logLevel?: LogLevel;
-};
-/**
- * Lambda configuration with additional IAM permissions.
- * Used by handler types that support custom permissions (http, table, fifo-queue).
- */
-type LambdaWithPermissions = LambdaConfig & {
-    /** Additional IAM permissions for the Lambda */
-    permissions?: Permission[];
-};
-type AnyParamRef = ParamRef<any>;
-/**
- * Reference to an SSM Parameter Store parameter.
- *
- * @typeParam T - The resolved type after optional transform (default: string)
- */
-type ParamRef<T = string> = {
-    readonly __brand: "effortless-param";
-    readonly key: string;
-    readonly transform?: (raw: string) => T;
-};
-/**
- * Maps a params declaration to resolved value types.
- *
- * @typeParam P - Record of param names to ParamRef instances
- */
-type ResolveParams<P> = {
-    [K in keyof P]: P[K] extends ParamRef<infer T> ? T : never;
-};
-/**
- * Declare an SSM Parameter Store parameter.
- *
- * The key is combined with project and stage at deploy time to form the full
- * SSM path: `/${project}/${stage}/${key}`.
- *
- * @param key - Parameter key (e.g., "database-url")
- * @param transform - Optional function to transform the raw string value
- * @returns A ParamRef used by the deployment and runtime systems
- *
- * @example Simple string parameter
- * ```typescript
- * params: {
- *   dbUrl: param("database-url"),
- * }
- * ```
- *
- * @example With transform (e.g., TOML parsing)
- * ```typescript
- * import TOML from "smol-toml";
- *
- * params: {
- *   config: param("app-config", TOML.parse),
- * }
- * ```
- */
-declare function param(key: string): ParamRef<string>;
-declare function param<T>(key: string, transform: (raw: string) => T): ParamRef<T>;
-/**
- * Type-only schema helper for handlers.
- *
- * Use this instead of explicit generic parameters like `defineTable<Order>(...)`.
- * It enables TypeScript to infer all generic types from the options object,
- * avoiding the partial-inference problem where specifying one generic
- * forces all others to their defaults.
- *
- * At runtime this is a no-op identity function — it simply returns the input unchanged.
- * The type narrowing happens entirely at the TypeScript level.
- *
- * @example Resource-only table
- * ```typescript
- * type User = { id: string; email: string };
- *
- * // Before (breaks inference for context, deps, params):
- * export const users = defineTable<User>({ pk: { name: "id", type: "string" } });
- *
- * // After (all generics inferred correctly):
- * export const users = defineTable({
- *   pk: { name: "id", type: "string" },
- *   schema: typed<User>(),
- * });
- * ```
- *
- * @example Table with stream handler
- * ```typescript
- * export const orders = defineTable({
- *   pk: { name: "id", type: "string" },
- *   schema: typed<Order>(),
- *   context: async () => ({ db: createClient() }),
- *   onRecord: async ({ record, ctx }) => {
- *     // record.new is Order, ctx is { db: Client } — all inferred
- *   },
- * });
- * ```
- */
-declare function typed<T>(): (input: unknown) => T;
-
-type AnyTableHandler = TableHandler<any, any, any, any, any, any>;
-/** Maps a deps declaration to resolved runtime client types */
-type ResolveDeps<D> = {
-    [K in keyof D]: D[K] extends TableHandler<infer T, any, any, any, any> ? TableClient<T> : never;
-};
-/** HTTP methods supported by API Gateway */
-type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-/** Short content-type aliases for common response formats */
-type ContentType = "json" | "html" | "text" | "css" | "js" | "xml" | "csv" | "svg";
-/**
- * Incoming HTTP request object passed to the handler
- */
-type HttpRequest = {
-    /** HTTP method (GET, POST, etc.) */
-    method: string;
-    /** Request path (e.g., "/users/123") */
-    path: string;
-    /** Request headers */
-    headers: Record<string, string | undefined>;
-    /** Query string parameters */
-    query: Record<string, string | undefined>;
-    /** Path parameters extracted from route (e.g., {id} -> params.id) */
-    params: Record<string, string | undefined>;
-    /** Parsed request body (JSON parsed if Content-Type is application/json) */
-    body: unknown;
-    /** Raw unparsed request body */
-    rawBody?: string;
-};
-/**
- * HTTP response returned from the handler
- */
-type HttpResponse = {
-    /** HTTP status code (e.g., 200, 404, 500) */
-    status: number;
-    /** Response body — JSON-serialized by default, or sent as string when contentType is set */
-    body?: unknown;
-    /**
-     * Short content-type alias. Resolves to full MIME type automatically:
-     * - `"json"` → `application/json` (default if omitted)
-     * - `"html"` → `text/html; charset=utf-8`
-     * - `"text"` → `text/plain; charset=utf-8`
-     * - `"css"` → `text/css; charset=utf-8`
-     * - `"js"` → `application/javascript; charset=utf-8`
-     * - `"xml"` → `application/xml; charset=utf-8`
-     * - `"csv"` → `text/csv; charset=utf-8`
-     * - `"svg"` → `image/svg+xml; charset=utf-8`
-     */
-    contentType?: ContentType;
-    /** Response headers (use for custom content-types not covered by contentType) */
-    headers?: Record<string, string>;
-};
-/**
- * Configuration options extracted from DefineHttpOptions (without onRequest callback)
- */
-type HttpConfig = LambdaWithPermissions & {
-    /** HTTP method for the route */
-    method: HttpMethod;
-    /** Route path (e.g., "/api/users", "/api/users/{id}") */
-    path: string;
-};
-/**
- * Handler function type for HTTP endpoints
- *
- * @typeParam T - Type of the validated request body (from schema function)
- * @typeParam C - Type of the context/dependencies (from context function)
- * @typeParam D - Type of the deps (from deps declaration)
- * @typeParam P - Type of the params (from params declaration)
- */
-type HttpHandlerFn<T = undefined, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = (args: {
-    req: HttpRequest;
-} & ([T] extends [undefined] ? {} : {
-    data: T;
-}) & ([C] extends [undefined] ? {} : {
-    ctx: C;
-}) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps<D>;
-}) & ([P] extends [undefined] ? {} : {
-    params: ResolveParams<P>;
-}) & ([S] extends [undefined] ? {} : {
-    readStatic: (path: string) => string;
-})) => Promise<HttpResponse>;
-/**
- * Context factory type — conditional on whether params are declared.
- * Without params: `() => C | Promise<C>`
- * With params: `(args: { params: ResolveParams<P> }) => C | Promise<C>`
- */
-type ContextFactory<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
-    params: ResolveParams<P & {}>;
-}) => C | Promise<C>;
-/**
- * Options for defining an HTTP endpoint
- *
- * @typeParam T - Type of the validated request body (inferred from schema function)
- * @typeParam C - Type of the context/dependencies returned by context function
- * @typeParam D - Type of the deps (from deps declaration)
- * @typeParam P - Type of the params (from params declaration)
- */
-type DefineHttpOptions<T = undefined, C = undefined, D extends Record<string, AnyTableHandler> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = HttpConfig & {
-    /**
-     * Decode/validate function for the request body.
-     * Called with the parsed body; should return typed data or throw on validation failure.
-     * When provided, the handler receives validated `data` and invalid requests get a 400 response.
-     *
-     * Works with any validation library:
-     * - Effect: `S.decodeUnknownSync(MySchema)`
-     * - Zod: `(body) => myZodSchema.parse(body)`
-     */
-    schema?: (input: unknown) => T;
-    /**
-     * Error handler called when schema validation or onRequest throws.
-     * Receives the error and request, returns an HttpResponse.
-     * If not provided, defaults to 400 for validation errors and 500 for handler errors.
-     */
-    onError?: (error: unknown, req: HttpRequest) => HttpResponse;
-    /**
-     * Factory function to create context/dependencies for the request handler.
-     * Called once on cold start, result is cached and reused across invocations.
-     * When params are declared, receives resolved params as argument.
-     * Supports both sync and async return values.
-     */
-    context?: ContextFactory<C, P>;
-    /**
-     * Dependencies on other handlers (tables, queues, etc.).
-     * Typed clients are injected into the handler via the `deps` argument.
-     */
-    deps?: D;
-    /**
-     * SSM Parameter Store parameters.
-     * Declare with `param()` helper. Values are fetched and cached at cold start.
-     * Typed values are injected into the handler via the `params` argument.
-     */
-    params?: P;
-    /**
-     * Static file glob patterns to bundle into the Lambda ZIP.
-     * Files are accessible at runtime via the `readStatic` callback argument.
-     */
-    static?: S;
-    /** HTTP request handler function */
-    onRequest: HttpHandlerFn<T, C, D, P, S>;
-};
-/**
- * Internal handler object created by defineHttp
- * @internal
- */
-type HttpHandler<T = undefined, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = {
-    readonly __brand: "effortless-http";
-    readonly config: HttpConfig;
-    readonly schema?: (input: unknown) => T;
-    readonly onError?: (error: unknown, req: HttpRequest) => HttpResponse;
-    readonly context?: (...args: any[]) => C | Promise<C>;
-    readonly deps?: D;
-    readonly params?: P;
-    readonly static?: string[];
-    readonly onRequest: HttpHandlerFn<T, C, D, P, S>;
-};
-/**
- * Define an HTTP endpoint that creates an API Gateway route + Lambda function
- *
- * @typeParam T - Type of the validated request body (inferred from schema function)
- * @typeParam C - Type of the context/dependencies (inferred from context function)
- * @typeParam D - Type of the deps (from deps declaration)
- * @typeParam P - Type of the params (from params declaration)
- * @param options - Configuration, optional schema, optional context factory, and request handler
- * @returns Handler object used by the deployment system
- *
- * @example Basic GET endpoint
- * ```typescript
- * export const hello = defineHttp({
- *   method: "GET",
- *   path: "/hello",
- *   onRequest: async ({ req }) => ({
- *     status: 200,
- *     body: { message: "Hello World!" }
- *   })
- * });
- * ```
- *
- * @example With SSM parameters
- * ```typescript
- * import { param } from "effortless-aws";
- *
- * export const api = defineHttp({
- *   method: "GET",
- *   path: "/orders",
- *   params: {
- *     dbUrl: param("database-url"),
- *   },
- *   context: async ({ params }) => ({
- *     pool: createPool(params.dbUrl),
- *   }),
- *   onRequest: async ({ req, ctx, params }) => ({
- *     status: 200,
- *     body: { dbUrl: params.dbUrl }
- *   })
- * });
- * ```
- */
-declare const defineHttp: <T = undefined, C = undefined, D extends Record<string, AnyTableHandler> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineHttpOptions<T, C, D, P, S>) => HttpHandler<T, C, D, P, S>;
+declare const defineFifoQueue: <T = unknown, C = undefined, D extends Record<string, AnyTableHandler> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineFifoQueueOptions<T, C, D, P, S>) => FifoQueueHandler<T, C, D, P, S>;
 
-export { type AppConfig, type AppHandler, type ContentType, type DefineFifoQueueOptions, type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type FailedRecord, type FifoQueueBatchFn, type FifoQueueConfig, type FifoQueueHandler, type FifoQueueMessage, type FifoQueueMessageFn, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type LambdaConfig, type LambdaWithPermissions, type LogLevel, type ParamRef, type QueryParams, type ResolveDeps, type ResolveParams, type StaticSiteConfig, type StaticSiteHandler, type StreamView, type TableBatchCompleteFn, type TableBatchFn, type TableClient, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, defineApp, defineConfig, defineFifoQueue, defineHttp, defineStaticSite, defineTable, param, typed };
+export { type AppConfig, type AppHandler, type ContentType, type DefineFifoQueueOptions, type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type FailedRecord, type FifoQueueBatchFn, type FifoQueueConfig, type FifoQueueHandler, type FifoQueueMessage, type FifoQueueMessageFn, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type LambdaConfig, type LambdaWithPermissions, type LogLevel, type ParamRef, type QueryParams, type ResolveDeps$1 as ResolveDeps, type ResolveParams, type StaticSiteConfig, type StaticSiteHandler, type StreamView, type TableBatchCompleteFn, type TableBatchFn, type TableClient, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, defineApp, defineConfig, defineFifoQueue, defineHttp, defineStaticSite, defineTable, param, typed };