adorn-api 1.0.3 → 1.0.5

package/dist/core/reply/reply.d.ts

@@ -1,102 +0,0 @@
-import type { Reply, ReplyHeaders } from '../../contracts/reply.js';
-/**
- * Initialization options for creating Reply objects.
- *
- * These options allow customization of response headers and content type.
- */
-export type ReplyInit = {
-    /** Custom response headers */
-    headers?: ReplyHeaders;
-    /** Content type header (convenience property) */
-    contentType?: string;
-};
-/**
- * Creates a typed HTTP response with body content.
- *
- * This function creates a Reply object with status code, body, and optional headers.
- * It's the primary way to create successful responses with content in Adorn API.
- *
- * @template TBody - Type of the response body
- * @template TStatus - HTTP status code (must be a number literal)
- * @param status - HTTP status code
- * @param body - Response body content
- * @param init - Optional initialization options (headers, contentType)
- * @returns Typed Reply object
- *
- * @example
- * ```typescript
- * // Simple JSON response
- * return reply(200, { message: 'Success', data: user });
- *
- * // Response with custom headers
- * return reply(201, createdUser, {
- *   headers: { 'Location': `/users/${createdUser.id}` },
- *   contentType: 'application/json'
- * });
- *
- * // Error response
- * return reply(404, { error: 'User not found', code: 'USER_NOT_FOUND' });
- * ```
- *
- * @example
- * ```typescript
- * // In a controller
- * @Get('/users/:id')
- * async getUser(id: string) {
- *   const user = await userService.findById(id);
- *   if (!user) {
- *     return reply(404, { error: 'User not found' });
- *   }
- *   return reply(200, user);
- * }
- * ```
- *
- * @see Reply for the return type structure
- * @see noContent for responses without body
- */
-export declare function reply<TBody, const TStatus extends number>(status: TStatus, body: TBody, init?: ReplyInit): Reply<TBody, TStatus>;
-/**
- * Creates a typed HTTP response without body content.
- *
- * This function creates a Reply object for responses that don't include a body,
- * such as 204 No Content responses. It's commonly used for successful DELETE operations
- * or other operations where no response body is needed.
- *
- * @template TStatus - HTTP status code (default: 204, must be a number literal)
- * @param status - Optional HTTP status code (default: 204)
- * @param init - Optional initialization options (headers, contentType)
- * @returns Typed Reply object without body
- *
- * @example
- * ```typescript
- * // Standard 204 No Content response
- * return noContent();
- *
- * // Custom no-content status with headers
- * return noContent(202, {
- *   headers: { 'X-Request-Processed': 'true' }
- * });
- * ```
- *
- * @example
- * ```typescript
- * // In a DELETE controller
- * @Delete('/users/:id')
- * async deleteUser(id: string) {
- *   await userService.delete(id);
- *   return noContent(); // 204 No Content
- * }
- *
- * // Custom accepted response
- * @Post('/users/bulk-delete')
- * async bulkDeleteUser(ids: string[]) {
- *   await userService.bulkDelete(ids);
- *   return noContent(202); // 202 Accepted
- * }
- * ```
- *
- * @see Reply for the return type structure
- * @see reply for responses with body content
- */
-export declare function noContent<const TStatus extends number = 204>(status?: TStatus, init?: ReplyInit): Reply<undefined, TStatus>;
-//# sourceMappingURL=reply.d.ts.map

package/dist/core/reply/reply.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reply.d.ts","sourceRoot":"","sources":["../../../src/core/reply/reply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,SAAS,MAAM,EACvD,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,KAAK,EACX,IAAI,GAAE,SAAc,GACnB,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAQvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,OAAO,SAAS,MAAM,GAAG,GAAG,EAC1D,MAAM,CAAC,EAAE,OAAO,EAChB,IAAI,GAAE,SAAc,GACnB,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAO3B"}

package/dist/core/reply/reply.js

@@ -1,105 +0,0 @@
-/**
- * Creates a typed HTTP response with body content.
- *
- * This function creates a Reply object with status code, body, and optional headers.
- * It's the primary way to create successful responses with content in Adorn API.
- *
- * @template TBody - Type of the response body
- * @template TStatus - HTTP status code (must be a number literal)
- * @param status - HTTP status code
- * @param body - Response body content
- * @param init - Optional initialization options (headers, contentType)
- * @returns Typed Reply object
- *
- * @example
- * ```typescript
- * // Simple JSON response
- * return reply(200, { message: 'Success', data: user });
- *
- * // Response with custom headers
- * return reply(201, createdUser, {
- *   headers: { 'Location': `/users/${createdUser.id}` },
- *   contentType: 'application/json'
- * });
- *
- * // Error response
- * return reply(404, { error: 'User not found', code: 'USER_NOT_FOUND' });
- * ```
- *
- * @example
- * ```typescript
- * // In a controller
- * @Get('/users/:id')
- * async getUser(id: string) {
- *   const user = await userService.findById(id);
- *   if (!user) {
- *     return reply(404, { error: 'User not found' });
- *   }
- *   return reply(200, user);
- * }
- * ```
- *
- * @see Reply for the return type structure
- * @see noContent for responses without body
- */
-export function reply(status, body, init = {}) {
-    return {
-        __adornReply: true,
-        status,
-        ...(body !== undefined ? { body } : {}),
-        ...(init.headers !== undefined ? { headers: init.headers } : {}),
-        ...(init.contentType !== undefined ? { contentType: init.contentType } : {}),
-    };
-}
-/**
- * Creates a typed HTTP response without body content.
- *
- * This function creates a Reply object for responses that don't include a body,
- * such as 204 No Content responses. It's commonly used for successful DELETE operations
- * or other operations where no response body is needed.
- *
- * @template TStatus - HTTP status code (default: 204, must be a number literal)
- * @param status - Optional HTTP status code (default: 204)
- * @param init - Optional initialization options (headers, contentType)
- * @returns Typed Reply object without body
- *
- * @example
- * ```typescript
- * // Standard 204 No Content response
- * return noContent();
- *
- * // Custom no-content status with headers
- * return noContent(202, {
- *   headers: { 'X-Request-Processed': 'true' }
- * });
- * ```
- *
- * @example
- * ```typescript
- * // In a DELETE controller
- * @Delete('/users/:id')
- * async deleteUser(id: string) {
- *   await userService.delete(id);
- *   return noContent(); // 204 No Content
- * }
- *
- * // Custom accepted response
- * @Post('/users/bulk-delete')
- * async bulkDeleteUser(ids: string[]) {
- *   await userService.bulkDelete(ids);
- *   return noContent(202); // 202 Accepted
- * }
- * ```
- *
- * @see Reply for the return type structure
- * @see reply for responses with body content
- */
-export function noContent(status, init = {}) {
-    return {
-        __adornReply: true,
-        status: (status ?? 204),
-        ...(init.headers !== undefined ? { headers: init.headers } : {}),
-        ...(init.contentType !== undefined ? { contentType: init.contentType } : {}),
-    };
-}
-//# sourceMappingURL=reply.js.map

package/dist/core/reply/reply.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reply.js","sourceRoot":"","sources":["../../../src/core/reply/reply.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,UAAU,KAAK,CACnB,MAAe,EACf,IAAW,EACX,OAAkB,EAAE;IAEpB,OAAO;QACL,YAAY,EAAE,IAAI;QAClB,MAAM;QACN,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChE,GAAG,CAAC,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC7E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,SAAS,CACvB,MAAgB,EAChB,OAAkB,EAAE;IAEpB,OAAO;QACL,YAAY,EAAE,IAAI;QAClB,MAAM,EAAE,CAAC,MAAM,IAAK,GAAe,CAAC;QACpC,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChE,GAAG,CAAC,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC7E,CAAC;AACJ,CAAC"}

package/dist/core/reply/typed.d.ts

@@ -1,161 +0,0 @@
-import type { ResponsesSpec } from '../../contracts/responses.js';
-import type { Reply, ReplyHeaderValue } from '../../contracts/reply.js';
-import type { Schema, Infer } from '../../validation/native/schema.js';
-import type { ReplyInit } from './reply.js';
-import type { AllowedStatus, BodySchemaFor, HeadersDefFor, StatusesNoBody, StatusesWithBody } from '../../contracts/response-types.js';
-type HeaderValueFromSpec<H> = H extends {
-    schema: infer S extends Schema<unknown>;
-} ? (Exclude<Infer<S>, undefined> extends ReplyHeaderValue ? Exclude<Infer<S>, undefined> : ReplyHeaderValue) : ReplyHeaderValue;
-type HeaderValues<H> = H extends Record<string, unknown> ? string extends keyof H ? Record<string, HeaderValueFromSpec<H[string]>> : {
-    [K in keyof H]?: HeaderValueFromSpec<H[K]>;
-} : never;
-type InitFor<R extends ResponsesSpec, S extends number> = Omit<ReplyInit, 'headers'> & {
-    headers?: HeaderValues<HeadersDefFor<R, S>>;
-};
-/**
- * Creates a typed reply builder function based on route responses specification.
- *
- * This function generates a reply builder that is type-safe based on the
- * ResponsesSpec provided. It ensures that only valid status codes and
- * body types can be used, providing excellent TypeScript support.
- *
- * @template R - Responses specification for the route
- * @param _responses - Responses specification object
- * @returns Typed reply builder with `reply` and `noContent` methods
- *
- * @example
- * ```typescript
- * // Define route with responses
- * const userRoute = defineRoute('/users/:id', {
- *   responses: {
- *     200: {
- *       description: 'User found',
- *       content: {
- *         'application/json': {
- *           schema: Schema.Object({
- *             id: Schema.String().format('uuid'),
- *             name: Schema.String(),
- *             email: Schema.String().format('email')
- *           })
- *         }
- *       }
- *     },
- *     404: {
- *       description: 'User not found',
- *       content: {
- *         'application/json': {
- *           schema: Schema.Object({
- *             error: Schema.String(),
- *             code: Schema.String()
- *           })
- *         }
- *       }
- *     }
- *   }
- * });
- *
- * // Use the typed reply function
- * const reply = userRoute.reply;
- *
- * // Type-safe responses
- * reply(200, { id: '123', name: 'John', email: 'john@example.com' }); // ✅ Valid
- * reply(404, { error: 'Not found', code: 'USER_NOT_FOUND' }); // ✅ Valid
- * reply(200, { error: 'Wrong' }); // ❌ Type error - wrong body type
- * reply(500, { error: 'Server error' }); // ❌ Type error - 500 not in responses
- * ```
- *
- * @example
- * ```typescript
- * // In a controller with route definition
- * const route = routeFor('/users')({
- *   responses: {
- *     201: {
- *       description: 'User created',
- *       content: {
- *         'application/json': {
- *           schema: userSchema
- *         }
- *       }
- *     },
- *     400: {
- *       description: 'Bad request',
- *       content: {
- *         'application/json': {
- *           schema: errorSchema
- *         }
- *       }
- *     }
- *   }
- * });
- *
- * class UserController {
- *   @Post('/users')
- *   async createUser(@Body() userData: CreateUserDto) {
- *     const createdUser = await userService.create(userData);
- *     return route.reply(201, createdUser); // Type-safe!
- *   }
- * }
- * ```
- *
- * @see ResponsesSpec for response specification format
- * @see defineRoute for creating route definitions
- */
-export declare function makeReply<const R extends ResponsesSpec>(_responses: R): {
-    /**
-     * Creates a typed response with body content.
-     *
-     * Only allowed for statuses that have a body schema in `responses`.
-     * Body is type-checked against that schema for complete type safety.
-     *
-     * @template S - Status code that must be in responses and allow body
-     * @param status - HTTP status code
-     * @param body - Response body (type-checked against schema)
-     * @param init - Optional initialization options
-     * @returns Typed Reply object
-     *
-     * @example
-     * ```typescript
-     * // With route definition
-     * const reply = makeReply({
-     *   200: {
-     *     content: {
-     *       'application/json': {
-     *         schema: Schema.Object({ name: Schema.String() })
-     *       }
-     *     }
-     *   }
-     * });
-     *
-     * reply.reply(200, { name: 'John' }); // ✅ Valid
-     * reply.reply(200, { age: 30 }); // ❌ Type error - missing name, wrong property
-     * ```
-     */
-    reply<const S extends AllowedStatus<R> & StatusesWithBody<R>>(status: S, body: Infer<BodySchemaFor<R, S>>, init?: InitFor<R, S>): Reply<Infer<BodySchemaFor<R, S>>, S>;
-    /**
-     * Creates a typed response without body content.
-     *
-     * For no-content responses (204 etc) or when you want an empty body.
-     * Only allowed for status codes that don't require a body in the responses spec.
-     *
-     * @template S - Status code that must be in responses and not require body
-     * @param status - Optional HTTP status code (uses default from responses if omitted)
-     * @param init - Optional initialization options
-     * @returns Typed Reply object without body
-     *
-     * @example
-     * ```typescript
-     * // With route definition
-     * const reply = makeReply({
-     *   204: { description: 'No content' },
-     *   202: { description: 'Accepted' }
-     * });
-     *
-     * reply.noContent(); // ✅ Uses 204 by default
-     * reply.noContent(202); // ✅ Explicit 202 status
-     * reply.noContent(200); // ❌ Type error - 200 not in no-content responses
-     * ```
-     */
-    noContent<const S extends AllowedStatus<R> & (StatusesNoBody<R> | number)>(status?: S, init?: InitFor<R, S>): Reply<undefined, S>;
-};
-export {};
-//# sourceMappingURL=typed.d.ts.map

package/dist/core/reply/typed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typed.d.ts","sourceRoot":"","sources":["../../../src/core/reply/typed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,gBAAgB,EACjB,MAAM,mCAAmC,CAAC;AAE3C,KAAK,mBAAmB,CAAC,CAAC,IACxB,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,OAAO,CAAC,CAAA;CAAE,GACjD,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAC,GACzG,gBAAgB,CAAC;AAEvB,KAAK,YAAY,CAAC,CAAC,IACjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,SAAS,MAAM,CAAC,GACpB,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAC9C;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAChD,KAAK,CAAC;AAEZ,KAAK,OAAO,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,MAAM,IACpD,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,UAAU,EAAE,CAAC;IAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBACS,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,UAClD,CAAC,QACH,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SACzB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAIvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;oBACa,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,WAC9D,CAAC,SACH,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;EAKzB"}

package/dist/core/reply/typed.js

@@ -1,154 +0,0 @@
-import { reply as baseReply, noContent as baseNoContent } from './reply.js';
-/**
- * Creates a typed reply builder function based on route responses specification.
- *
- * This function generates a reply builder that is type-safe based on the
- * ResponsesSpec provided. It ensures that only valid status codes and
- * body types can be used, providing excellent TypeScript support.
- *
- * @template R - Responses specification for the route
- * @param _responses - Responses specification object
- * @returns Typed reply builder with `reply` and `noContent` methods
- *
- * @example
- * ```typescript
- * // Define route with responses
- * const userRoute = defineRoute('/users/:id', {
- *   responses: {
- *     200: {
- *       description: 'User found',
- *       content: {
- *         'application/json': {
- *           schema: Schema.Object({
- *             id: Schema.String().format('uuid'),
- *             name: Schema.String(),
- *             email: Schema.String().format('email')
- *           })
- *         }
- *       }
- *     },
- *     404: {
- *       description: 'User not found',
- *       content: {
- *         'application/json': {
- *           schema: Schema.Object({
- *             error: Schema.String(),
- *             code: Schema.String()
- *           })
- *         }
- *       }
- *     }
- *   }
- * });
- *
- * // Use the typed reply function
- * const reply = userRoute.reply;
- *
- * // Type-safe responses
- * reply(200, { id: '123', name: 'John', email: 'john@example.com' }); // ✅ Valid
- * reply(404, { error: 'Not found', code: 'USER_NOT_FOUND' }); // ✅ Valid
- * reply(200, { error: 'Wrong' }); // ❌ Type error - wrong body type
- * reply(500, { error: 'Server error' }); // ❌ Type error - 500 not in responses
- * ```
- *
- * @example
- * ```typescript
- * // In a controller with route definition
- * const route = routeFor('/users')({
- *   responses: {
- *     201: {
- *       description: 'User created',
- *       content: {
- *         'application/json': {
- *           schema: userSchema
- *         }
- *       }
- *     },
- *     400: {
- *       description: 'Bad request',
- *       content: {
- *         'application/json': {
- *           schema: errorSchema
- *         }
- *       }
- *     }
- *   }
- * });
- *
- * class UserController {
- *   @Post('/users')
- *   async createUser(@Body() userData: CreateUserDto) {
- *     const createdUser = await userService.create(userData);
- *     return route.reply(201, createdUser); // Type-safe!
- *   }
- * }
- * ```
- *
- * @see ResponsesSpec for response specification format
- * @see defineRoute for creating route definitions
- */
-export function makeReply(_responses) {
-    return {
-        /**
-         * Creates a typed response with body content.
-         *
-         * Only allowed for statuses that have a body schema in `responses`.
-         * Body is type-checked against that schema for complete type safety.
-         *
-         * @template S - Status code that must be in responses and allow body
-         * @param status - HTTP status code
-         * @param body - Response body (type-checked against schema)
-         * @param init - Optional initialization options
-         * @returns Typed Reply object
-         *
-         * @example
-         * ```typescript
-         * // With route definition
-         * const reply = makeReply({
-         *   200: {
-         *     content: {
-         *       'application/json': {
-         *         schema: Schema.Object({ name: Schema.String() })
-         *       }
-         *     }
-         *   }
-         * });
-         *
-         * reply.reply(200, { name: 'John' }); // ✅ Valid
-         * reply.reply(200, { age: 30 }); // ❌ Type error - missing name, wrong property
-         * ```
-         */
-        reply(status, body, init) {
-            return baseReply(status, body, init);
-        },
-        /**
-         * Creates a typed response without body content.
-         *
-         * For no-content responses (204 etc) or when you want an empty body.
-         * Only allowed for status codes that don't require a body in the responses spec.
-         *
-         * @template S - Status code that must be in responses and not require body
-         * @param status - Optional HTTP status code (uses default from responses if omitted)
-         * @param init - Optional initialization options
-         * @returns Typed Reply object without body
-         *
-         * @example
-         * ```typescript
-         * // With route definition
-         * const reply = makeReply({
-         *   204: { description: 'No content' },
-         *   202: { description: 'Accepted' }
-         * });
-         *
-         * reply.noContent(); // ✅ Uses 204 by default
-         * reply.noContent(202); // ✅ Explicit 202 status
-         * reply.noContent(200); // ❌ Type error - 200 not in no-content responses
-         * ```
-         */
-        noContent(status, init) {
-            const replyInit = (init ?? {});
-            return baseNoContent(status, replyInit);
-        },
-    };
-}
-//# sourceMappingURL=typed.js.map

package/dist/core/reply/typed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typed.js","sourceRoot":"","sources":["../../../src/core/reply/typed.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,YAAY,CAAC;AAwB5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,MAAM,UAAU,SAAS,CAAgC,UAAa;IACpE,OAAO;QACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BG;QACH,KAAK,CACH,MAAS,EACT,IAAgC,EAChC,IAAoB;YAEpB,OAAO,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;WAuBG;QACH,SAAS,CACP,MAAU,EACV,IAAoB;YAEpB,MAAM,SAAS,GAAG,CAAC,IAAI,IAAI,EAAE,CAAc,CAAC;YAC5C,OAAO,aAAa,CAAC,MAAM,EAAE,SAAS,CAAwB,CAAC;QACjE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/core/responses/helpers.d.ts

@@ -1,10 +0,0 @@
-import type { Schema } from '../../validation/native/schema.js';
-export declare function header<S extends Schema<unknown>>(schema: S, opts?: {
-    required?: boolean;
-    description?: string;
-}): {
-    schema: S;
-    required?: boolean;
-    description?: string;
-};
-//# sourceMappingURL=helpers.d.ts.map

package/dist/core/responses/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/core/responses/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAEhE,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,OAAO,CAAC,EAC9C,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAMzD"}

package/dist/core/responses/helpers.js

@@ -1,8 +0,0 @@
-export function header(schema, opts) {
-    return {
-        schema,
-        ...(opts?.required !== undefined ? { required: opts.required } : {}),
-        ...(opts?.description !== undefined ? { description: opts.description } : {}),
-    };
-}
-//# sourceMappingURL=helpers.js.map

package/dist/core/responses/helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/core/responses/helpers.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,MAAM,CACpB,MAAS,EACT,IAAmD;IAEnD,OAAO;QACL,MAAM;QACN,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpE,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9E,CAAC;AACJ,CAAC"}

package/dist/core/responses/index.d.ts

@@ -1,4 +0,0 @@
-export * from './normalize.js';
-export * from './pickStatus.js';
-export * from './helpers.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/responses/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/responses/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/core/responses/index.js

@@ -1,4 +0,0 @@
-export * from './normalize.js';
-export * from './pickStatus.js';
-export * from './helpers.js';
-//# sourceMappingURL=index.js.map

package/dist/core/responses/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/responses/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/core/responses/normalize.d.ts

@@ -1,3 +0,0 @@
-import type { ResponseSpec, ResponsesSpec } from '../../contracts/responses.js';
-export declare function normalizeResponses(input?: ResponsesSpec): Record<string, ResponseSpec>;
-//# sourceMappingURL=normalize.d.ts.map

package/dist/core/responses/normalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/core/responses/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAQhF,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CA+BtF"}

package/dist/core/responses/normalize.js

@@ -1,33 +0,0 @@
-function isSchema(value) {
-    const candidate = value;
-    return typeof candidate?.parse === 'function';
-}
-export function normalizeResponses(input) {
-    if (!input)
-        return {};
-    const out = {};
-    for (const [status, spec] of Object.entries(input)) {
-        if (isSchema(spec)) {
-            out[status] = {
-                content: {
-                    'application/json': {
-                        schema: spec,
-                    },
-                },
-            };
-            continue;
-        }
-        const normalized = { ...spec };
-        if (normalized.schema && !normalized.content) {
-            normalized.content = {
-                'application/json': {
-                    schema: normalized.schema,
-                },
-            };
-            delete normalized.schema;
-        }
-        out[status] = normalized;
-    }
-    return out;
-}
-//# sourceMappingURL=normalize.js.map

package/dist/core/responses/normalize.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../../../src/core/responses/normalize.ts"],"names":[],"mappings":"AAGA,SAAS,QAAQ,CAAC,KAAc;IAC9B,MAAM,SAAS,GAAG,KAAwB,CAAC;IAC3C,OAAO,OAAO,SAAS,EAAE,KAAK,KAAK,UAAU,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAqB;IACtD,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IAEtB,MAAM,GAAG,GAAiC,EAAE,CAAC;IAE7C,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,MAAM,CAAC,GAAG;gBACZ,OAAO,EAAE;oBACP,kBAAkB,EAAE;wBAClB,MAAM,EAAE,IAAI;qBACb;iBACF;aACF,CAAC;YACF,SAAS;QACX,CAAC;QAED,MAAM,UAAU,GAAiB,EAAE,GAAG,IAAI,EAAE,CAAC;QAC7C,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YAC7C,UAAU,CAAC,OAAO,GAAG;gBACnB,kBAAkB,EAAE;oBAClB,MAAM,EAAE,UAAU,CAAC,MAAM;iBAC1B;aACF,CAAC;YACF,OAAO,UAAU,CAAC,MAAM,CAAC;QAC3B,CAAC;QAED,GAAG,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/core/responses/pickStatus.d.ts

@@ -1,3 +0,0 @@
-import type { ResponsesSpec } from '../../contracts/responses.js';
-export declare function pickSuccessStatus(method: string, responses?: ResponsesSpec, explicit?: number): number;
-//# sourceMappingURL=pickStatus.d.ts.map

package/dist/core/responses/pickStatus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pickStatus.d.ts","sourceRoot":"","sources":["../../../src/core/responses/pickStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAwBtG"}

package/dist/core/responses/pickStatus.js

@@ -1,27 +0,0 @@
-import { normalizeResponses } from './normalize.js';
-export function pickSuccessStatus(method, responses, explicit) {
-    if (typeof explicit === 'number')
-        return explicit;
-    const m = method.toUpperCase();
-    if (responses) {
-        const normalized = normalizeResponses(responses);
-        const codes = Object.keys(normalized)
-            .filter((k) => /^\d+$/.test(k))
-            .map((k) => Number(k))
-            .filter((n) => n >= 200 && n < 300)
-            .sort((a, b) => a - b);
-        if (codes.length) {
-            if (m === 'POST' && codes.includes(201))
-                return 201;
-            if (codes.includes(200))
-                return 200;
-            return codes[0];
-        }
-    }
-    if (m === 'POST')
-        return 201;
-    if (m === 'DELETE')
-        return 204;
-    return 200;
-}
-//# sourceMappingURL=pickStatus.js.map