effortless-aws 0.0.2 → 0.1.0

package/dist/index.d.ts

@@ -86,170 +86,115 @@ 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 & {});
 
-/** HTTP methods supported by API Gateway */
-type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-/**
- * 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
+ * Query parameters for TableClient.query()
  */
-type HttpResponse = {
-    /** HTTP status code (e.g., 200, 404, 500) */
-    status: number;
-    /** Response body (will be JSON serialized) */
-    body?: unknown;
-    /** Response headers */
-    headers?: Record<string, string>;
+type QueryParams = {
+    /** Partition key name and value */
+    pk: {
+        name: string;
+        value: unknown;
+    };
+    /** Optional sort key condition */
+    sk?: {
+        name: string;
+        condition: "=" | "begins_with" | "<" | ">" | "<=" | ">=";
+        value: unknown;
+    };
+    /** Maximum number of items to return */
+    limit?: number;
+    /** Sort order (true = ascending, false = descending) */
+    scanIndexForward?: boolean;
 };
+/** Extract keys of T whose values are arrays */
+type ArrayKeys<T> = {
+    [K in keyof T]: T[K] extends unknown[] ? K : never;
+}[keyof T];
 /**
- * Configuration options extracted from DefineHttpOptions (without onRequest callback)
+ * Update actions for TableClient.update()
+ *
+ * @typeParam T - Type of the table items
  */
-type HttpConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
-    /** HTTP method for the route */
-    method: HttpMethod;
-    /** Route path (e.g., "/api/users", "/api/users/{id}") */
-    path: string;
-    /** Lambda memory in MB (default: 256) */
-    memory?: number;
-    /** Lambda timeout in seconds (default: 30) */
-    timeout?: number;
-    /** Additional IAM permissions for the Lambda */
-    permissions?: Permission[];
+type UpdateActions<T> = {
+    /** Set attribute values (overwrites existing) */
+    set?: Partial<T>;
+    /** Append elements to list attributes (creates the list if it doesn't exist) */
+    append?: Pick<Partial<T>, ArrayKeys<T>>;
+    /** Remove attributes from the item */
+    remove?: (keyof T)[];
 };
 /**
- * Handler function type for HTTP endpoints
+ * Typed DynamoDB table client injected via deps.
  *
- * @typeParam C - Type of the context/dependencies (from context function)
+ * @typeParam T - Type of the table items
  */
-type HttpHandlerFn<C = undefined> = C extends undefined ? (args: {
-    req: HttpRequest;
-}) => Promise<HttpResponse> : (args: {
-    req: HttpRequest;
-    ctx: C;
-}) => Promise<HttpResponse>;
+type TableClient<T = Record<string, unknown>> = {
+    /** Put a full item into the table */
+    put(item: T): Promise<void>;
+    /** Get an item by its key attributes */
+    get(key: Partial<T>): Promise<T | undefined>;
+    /** Delete an item by its key attributes */
+    delete(key: Partial<T>): Promise<void>;
+    /** Update specific attributes without reading the full item */
+    update(key: Partial<T>, actions: UpdateActions<T>): Promise<void>;
+    /** Query by partition key with optional sort key condition */
+    query(params: QueryParams): Promise<T[]>;
+    /** The underlying DynamoDB table name */
+    tableName: string;
+};
+
+type AnyParamRef = ParamRef<any>;
 /**
- * Options for defining an HTTP endpoint
- *
- * @typeParam C - Type of the context/dependencies returned by context function
- *
- * @example Without context
- * ```typescript
- * export const getUsers = defineHttp({
- *   method: "GET",
- *   path: "/api/users",
- *   onRequest: async ({ req }) => ({
- *     status: 200,
- *     body: { users: [] }
- *   })
- * });
- * ```
+ * Reference to an SSM Parameter Store parameter.
  *
- * @example With context (e.g., Effect runtime)
- * ```typescript
- * export const createOrder = defineHttp<typeof orderRuntime>({
- *   method: "POST",
- *   path: "/api/orders",
- *   context: () => ManagedRuntime.make(
- *     Layer.mergeAll(ConfigLive, DbClientLive)
- *   ),
- *   onRequest: async ({ req, ctx }) => {
- *     const result = await ctx.runPromise(createOrderEffect(req.body));
- *     return { status: 201, body: result };
- *   }
- * });
- * ```
+ * @typeParam T - The resolved type after optional transform (default: string)
  */
-type DefineHttpOptions<C = undefined> = HttpConfig & {
-    /**
-     * Factory function to create context/dependencies for the request handler.
-     * Called once on cold start, result is cached and reused across invocations.
-     */
-    context?: () => C;
-    /** HTTP request handler function */
-    onRequest: HttpHandlerFn<C>;
+type ParamRef<T = string> = {
+    readonly __brand: "effortless-param";
+    readonly key: string;
+    readonly transform?: (raw: string) => T;
 };
 /**
- * Internal handler object created by defineHttp
- * @internal
+ * Maps a params declaration to resolved value types.
+ *
+ * @typeParam P - Record of param names to ParamRef instances
  */
-type HttpHandler<C = undefined> = {
-    readonly __brand: "effortless-http";
-    readonly config: HttpConfig;
-    readonly context?: () => C;
-    readonly onRequest: HttpHandlerFn<C>;
+type ResolveParams<P> = {
+    [K in keyof P]: P[K] extends ParamRef<infer T> ? T : never;
 };
 /**
- * Define an HTTP endpoint that creates an API Gateway route + Lambda function
+ * Declare an SSM Parameter Store parameter.
  *
- * @typeParam C - Type of the context/dependencies (inferred from context function)
- * @param options - Configuration, optional context factory, and request handler
- * @returns Handler object used by the deployment system
+ * The key is combined with project and stage at deploy time to form the full
+ * SSM path: `/${project}/${stage}/${key}`.
  *
- * @example Basic GET endpoint
- * ```typescript
- * export const hello = defineHttp({
- *   method: "GET",
- *   path: "/hello",
- *   onRequest: async ({ req }) => ({
- *     status: 200,
- *     body: { message: "Hello World!" }
- *   })
- * });
- * ```
+ * @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 POST endpoint with body parsing
+ * @example Simple string parameter
  * ```typescript
- * export const createUser = defineHttp({
- *   method: "POST",
- *   path: "/users",
- *   memory: 512,
- *   timeout: 30,
- *   onRequest: async ({ req }) => {
- *     const { name, email } = req.body as { name: string; email: string };
- *     // ... create user
- *     return { status: 201, body: { id: "123", name, email } };
- *   }
- * });
+ * params: {
+ *   dbUrl: param("database-url"),
+ * }
  * ```
  *
- * @example With Effect runtime context
+ * @example With transform (e.g., TOML parsing)
  * ```typescript
- * export const processPayment = defineHttp<typeof paymentRuntime>({
- *   method: "POST",
- *   path: "/payments",
- *   context: () => ManagedRuntime.make(
- *     Layer.mergeAll(ConfigLive, StripeClientLive)
- *   ),
- *   onRequest: async ({ req, ctx }) => {
- *     const result = await ctx.runPromise(
- *       processPaymentEffect(req.body)
- *     );
- *     return { status: 200, body: result };
- *   }
- * });
+ * import TOML from "smol-toml";
+ *
+ * params: {
+ *   config: param("app-config", TOML.parse),
+ * }
  * ```
  */
-declare const defineHttp: <C = undefined>(options: DefineHttpOptions<C>) => HttpHandler<C>;
+declare const param: <T = string>(key: string, transform?: (raw: string) => T) => ParamRef<T>;
 
+type AnyTableHandler$1 = TableHandler<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;
+};
 /** DynamoDB attribute types for keys */
 type KeyType = "string" | "number" | "binary";
 /**
@@ -322,99 +267,127 @@ type FailedRecord<T = Record<string, unknown>> = {
     /** The error that occurred */
     error: unknown;
 };
+/**
+ * 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$1<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
+    params: ResolveParams<P & {}>;
+}) => C | Promise<C>;
 /**
  * Callback function type for processing a single DynamoDB stream record
- *
- * @typeParam T - Type of the table items
- * @typeParam C - Type of the context/dependencies (from context function)
- * @typeParam R - Return type (can be void or a value to accumulate)
  */
-type TableRecordFn<T = Record<string, unknown>, C = undefined, R = void> = C extends undefined ? (args: {
-    record: TableRecord<T>;
-}) => Promise<R> : (args: {
+type TableRecordFn<T = Record<string, unknown>, C = undefined, R = void, D = undefined, P = undefined> = (args: {
     record: TableRecord<T>;
+    table: TableClient<T>;
+} & ([C] extends [undefined] ? {} : {
     ctx: C;
-}) => Promise<R>;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+})) => Promise<R>;
 /**
  * Callback function type for processing accumulated batch results
- *
- * @typeParam T - Type of the table items
- * @typeParam C - Type of the context/dependencies
- * @typeParam R - Type of results accumulated from onRecord
  */
-type TableBatchCompleteFn<T = Record<string, unknown>, C = undefined, R = void> = C extends undefined ? (args: {
-    results: R[];
-    failures: FailedRecord<T>[];
-}) => Promise<void> : (args: {
+type TableBatchCompleteFn<T = Record<string, unknown>, C = undefined, R = void, D = undefined, P = undefined> = (args: {
     results: R[];
     failures: FailedRecord<T>[];
+    table: TableClient<T>;
+} & ([C] extends [undefined] ? {} : {
     ctx: C;
-}) => Promise<void>;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+})) => Promise<void>;
 /**
- * Options for defining a DynamoDB table with optional stream handler
- *
- * @typeParam T - Type of the table items for type-safe record access
- * @typeParam C - Type of the context/dependencies returned by context function
- *
- * @example Without context
- * ```typescript
- * export const users = defineTable<User>({
- *   pk: { name: "id", type: "string" },
- *   onRecord: async ({ record }) => {
- *     console.log(record.new?.name);
- *   }
- * });
- * ```
- *
- * @example With context (e.g., Effect runtime)
- * ```typescript
- * export const orders = defineTable<Order, ManagedRuntime<...>>({
- *   pk: { name: "id", type: "string" },
- *   context: () => ManagedRuntime.make(
- *     Layer.mergeAll(ConfigLive, DbClientLive)
- *   ),
- *   onRecord: async ({ record, ctx }) => {
- *     await ctx.runPromise(processOrder(record));
- *   }
- * });
- * ```
+ * Callback function type for processing all records in a batch at once
  */
-type DefineTableOptions<T = Record<string, unknown>, C = undefined, R = void> = TableConfig & {
+type TableBatchFn<T = Record<string, unknown>, C = undefined, D = undefined, P = undefined> = (args: {
+    records: TableRecord<T>[];
+    table: TableClient<T>;
+} & ([C] extends [undefined] ? {} : {
+    ctx: C;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+})) => Promise<void>;
+/** Base options shared by all defineTable variants */
+type DefineTableBase<T = Record<string, unknown>, C = undefined, D = undefined, P = undefined> = TableConfig & {
+    /**
+     * Decode/validate function for stream record items (new/old images).
+     * Called with the unmarshalled DynamoDB item; should return typed data or throw on validation failure.
+     * When provided, T is inferred from the return type — no need to specify generic parameters.
+     */
+    schema?: (input: unknown) => T;
     /**
-     * Factory function to create context/dependencies for onRecord callback.
+     * Error handler called when onRecord, onBatch, or onBatchComplete throws.
+     * Receives the error. If not provided, defaults to `console.error`.
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * Factory function to create context/dependencies for callbacks.
      * 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.
      */
-    context?: () => C;
-    /** Stream record callback. If omitted, only the table is created (no Lambda) */
-    onRecord?: TableRecordFn<T, C, R>;
+    deps?: D;
     /**
-     * Callback invoked after all records in the batch are processed.
-     * Receives accumulated results from onRecord and list of failures.
+     * 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.
      */
-    onBatchComplete?: TableBatchCompleteFn<T, C, R>;
+    params?: P;
 };
+/** Per-record processing: onRecord with optional onBatchComplete */
+type DefineTableWithOnRecord<T = Record<string, unknown>, C = undefined, R = void, D = undefined, P = undefined> = DefineTableBase<T, C, D, P> & {
+    onRecord: TableRecordFn<T, C, R, D, P>;
+    onBatchComplete?: TableBatchCompleteFn<T, C, R, D, P>;
+    onBatch?: never;
+};
+/** Batch processing: onBatch processes all records at once */
+type DefineTableWithOnBatch<T = Record<string, unknown>, C = undefined, D = undefined, P = undefined> = DefineTableBase<T, C, D, P> & {
+    onBatch: TableBatchFn<T, C, D, P>;
+    onRecord?: never;
+    onBatchComplete?: never;
+};
+/** Resource-only: no handler, just creates the table */
+type DefineTableResourceOnly<T = Record<string, unknown>, C = undefined, D = undefined, P = undefined> = DefineTableBase<T, C, D, P> & {
+    onRecord?: never;
+    onBatch?: never;
+    onBatchComplete?: never;
+};
+type DefineTableOptions<T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined> = DefineTableWithOnRecord<T, C, R, D, P> | DefineTableWithOnBatch<T, C, D, P> | DefineTableResourceOnly<T, C, D, P>;
 /**
  * Internal handler object created by defineTable
  * @internal
  */
-type TableHandler<T = Record<string, unknown>, C = undefined, R = void> = {
+type TableHandler<T = Record<string, unknown>, C = undefined, R = void, D = undefined, P = undefined> = {
     readonly __brand: "effortless-table";
     readonly config: TableConfig;
-    readonly context?: () => C;
-    readonly onRecord?: TableRecordFn<T, C, R>;
-    readonly onBatchComplete?: TableBatchCompleteFn<T, C, R>;
+    readonly schema?: (input: unknown) => T;
+    readonly onError?: (error: unknown) => void;
+    readonly context?: (...args: any[]) => C | Promise<C>;
+    readonly deps?: D;
+    readonly params?: P;
+    readonly onRecord?: TableRecordFn<T, C, R, D, P>;
+    readonly onBatchComplete?: TableBatchCompleteFn<T, C, R, D, P>;
+    readonly onBatch?: TableBatchFn<T, C, D, P>;
 };
 /**
  * Define a DynamoDB table with optional stream handler
  *
  * Creates:
  * - DynamoDB table with specified key schema
- * - (If onRecord provided) DynamoDB Stream + Lambda + Event Source Mapping
- *
- * @typeParam T - Type of the table items for type-safe record access
- * @typeParam C - Type of the context/dependencies (inferred from context function)
- * @param options - Table configuration, optional context factory, and optional onRecord callback
- * @returns Handler object used by the deployment system
+ * - (If onRecord or onBatch provided) DynamoDB Stream + Lambda + Event Source Mapping
  *
  * @example Table with stream handler (typed)
  * ```typescript
@@ -432,19 +405,6 @@ type TableHandler<T = Record<string, unknown>, C = undefined, R = void> = {
  * });
  * ```
  *
- * @example With Effect runtime context
- * ```typescript
- * export const expenses = defineTable<Expense, typeof expenseRuntime>({
- *   pk: { name: "pk", type: "string" },
- *   context: () => ManagedRuntime.make(
- *     Layer.mergeAll(ConfigLive, DynamoDBClient.Default())
- *   ),
- *   onRecord: async ({ record, ctx }) => {
- *     await ctx.runPromise(processExpense(record));
- *   }
- * });
- * ```
- *
  * @example Table only (no Lambda)
  * ```typescript
  * export const users = defineTable({
@@ -453,6 +413,191 @@ type TableHandler<T = Record<string, unknown>, C = undefined, R = void> = {
  * });
  * ```
  */
-declare const defineTable: <T = Record<string, unknown>, C = undefined, R = void>(options: DefineTableOptions<T, C, R>) => TableHandler<T, C, R>;
+declare const defineTable: <T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined>(options: DefineTableOptions<T, C, R, D, P>) => TableHandler<T, C, R, D, P>;
+
+type AnyTableHandler = TableHandler<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";
+/**
+ * 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 (will be JSON serialized) */
+    body?: unknown;
+    /** Response headers */
+    headers?: Record<string, string>;
+};
+/**
+ * Configuration options extracted from DefineHttpOptions (without onRequest callback)
+ */
+type HttpConfig = {
+    /** Handler name. Defaults to export name if not specified */
+    name?: string;
+    /** HTTP method for the route */
+    method: HttpMethod;
+    /** Route path (e.g., "/api/users", "/api/users/{id}") */
+    path: string;
+    /** Lambda memory in MB (default: 256) */
+    memory?: number;
+    /** Lambda timeout in seconds (default: 30) */
+    timeout?: number;
+    /** Additional IAM permissions for the Lambda */
+    permissions?: Permission[];
+};
+/**
+ * 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> = (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>;
+})) => 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> = 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;
+    /** HTTP request handler function */
+    onRequest: HttpHandlerFn<T, C, D, P>;
+};
+/**
+ * Internal handler object created by defineHttp
+ * @internal
+ */
+type HttpHandler<T = undefined, C = undefined, D = undefined, P = 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 onRequest: HttpHandlerFn<T, C, D, P>;
+};
+/**
+ * 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>(options: DefineHttpOptions<T, C, D, P>) => HttpHandler<T, C, D, P>;
 
-export { type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type FailedRecord, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type StreamView, type TableBatchCompleteFn, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, defineConfig, defineHttp, defineTable };
+export { type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type FailedRecord, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type ParamRef, type QueryParams, type ResolveDeps, type ResolveParams, type StreamView, type TableBatchCompleteFn, type TableBatchFn, type TableClient, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, defineConfig, defineHttp, defineTable, param };