ts-typed-api 0.1.0 → 0.1.2

package/dist/router/router.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerRouteHandlers = exports.makeRouteHandlerCreator = exports.createRouteHandler = void 0;
-const zod_1 = require("zod");
-// Type-safe route handler creation function, now generic over TDef
-// This function is called within a context where TDef is known (e.g. specific handlers file)
-function createRouteHandler(domain, routeKey, handler) {
-    // The returned object includes enough type information (domain, routeKey)
-    // for registerRouteHandlers to correctly associate it with TDef.
-    // The phantom type TDef is carried by the function's generic signature.
-    return { domain, routeKey, handler };
-}
-exports.createRouteHandler = createRouteHandler;
-// Factory function to create a route handler creator for a specific API definition
-function makeRouteHandlerCreator() {
-    return function createHandler(domain, routeKey, handler) {
-        // We call the original createRouteHandler, but TDef is fixed here by the factory's closure.
-        // TDomain and TRouteKey are inferred from the arguments to createHandler.
-        return createRouteHandler(domain, routeKey, handler);
-    };
-}
-exports.makeRouteHandlerCreator = makeRouteHandlerCreator;
-// Register route handlers with Express, now generic over TDef
-function registerRouteHandlers(app, apiDefinition, // Pass the actual API definition object
-routeHandlers // Use the generic handler type
-) {
-    routeHandlers.forEach((specificHandlerIterationItem) => {
-        const { domain, routeKey, handler } = specificHandlerIterationItem; // Use 'as any' for simplicity in destructuring union
-        const currentDomain = domain;
-        const currentRouteKey = routeKey;
-        // Use the passed apiDefinition object
-        const routeDefinition = apiDefinition[currentDomain][currentRouteKey];
-        if (!routeDefinition) {
-            console.error(`Route definition not found for domain "${String(currentDomain)}" and routeKey "${String(currentRouteKey)}"`);
-            return;
-        }
-        const { path, method } = routeDefinition;
-        const expressMiddleware = async (expressReq, expressRes) => {
-            try {
-                // Ensure TDef is correctly used for type inference if this section needs it.
-                // Currently, parsedParams,Query,Body are based on runtime routeDefinition.
-                const parsedParams = ('params' in routeDefinition && routeDefinition.params)
-                    ? routeDefinition.params.parse(expressReq.params)
-                    : expressReq.params;
-                const parsedQuery = ('query' in routeDefinition && routeDefinition.query)
-                    ? routeDefinition.query.parse(expressReq.query)
-                    : expressReq.query;
-                const parsedBody = (method === 'POST' || method === 'PUT') && ('body' in routeDefinition && routeDefinition.body)
-                    ? routeDefinition.body.parse(expressReq.body)
-                    : expressReq.body;
-                // Construct TypedRequest using TDef, currentDomain, currentRouteKey
-                const finalTypedReq = {
-                    ...expressReq,
-                    params: parsedParams,
-                    query: parsedQuery,
-                    body: parsedBody,
-                };
-                // Augment expressRes with the .respond method, using TDef
-                const typedExpressRes = expressRes;
-                typedExpressRes.respond = (status, dataForResponse) => {
-                    // Use the passed apiDefinition object
-                    const routeSchemaForHandler = apiDefinition[currentDomain][currentRouteKey];
-                    const responseSchemaForStatus = routeSchemaForHandler.responses[status];
-                    if (!responseSchemaForStatus) {
-                        console.error(`No response schema defined for status ${status} in route ${String(currentDomain)}/${String(currentRouteKey)}`);
-                        typedExpressRes.status(500).json({
-                            // data: null, // data field might not be part of error schema for 500 if not using unified
-                            error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
-                        });
-                        return;
-                    }
-                    let responseBodyToValidate; // This will be the object { data: ..., error: ... }
-                    if (status === 422) {
-                        // For 422, dataForResponse is expected to be the UnifiedError array or null
-                        // The schema for 422 is errorUnifiedResponseSchema, expecting { error: UnifiedError }
-                        responseBodyToValidate = {
-                            data: null,
-                            error: dataForResponse // dataForResponse should be UnifiedError for 422
-                        };
-                    }
-                    else {
-                        // For other statuses, dataForResponse is the actual data payload for the 'data' field
-                        // The schema is createSuccessUnifiedResponseSchema, expecting { data: ActualData }
-                        responseBodyToValidate = {
-                            data: dataForResponse,
-                            error: null // error is null for success
-                        };
-                    }
-                    // Validate the constructed responseBodyToValidate against the full schema for that status
-                    const validationResult = responseSchemaForStatus.safeParse(responseBodyToValidate);
-                    if (validationResult.success) {
-                        typedExpressRes.status(status).json(validationResult.data);
-                    }
-                    else {
-                        console.error(`FATAL: Constructed response body failed Zod validation for status ${status} in route ${String(currentDomain)}/${String(currentRouteKey)}. This indicates an issue with respond logic or schemas.`, validationResult.error.errors);
-                        console.error("Response body was:", responseBodyToValidate);
-                        typedExpressRes.status(500).json({
-                            // data: null,
-                            error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
-                        });
-                    }
-                };
-                const specificHandlerFn = handler;
-                await specificHandlerFn(finalTypedReq, typedExpressRes);
-            }
-            catch (error) {
-                if (error instanceof zod_1.z.ZodError) {
-                    const mappedErrors = error.errors.map(err => {
-                        let errorType = 'general';
-                        const pathZero = String(err.path[0]); // Ensure pathZero is a string
-                        if (pathZero === 'params')
-                            errorType = 'param'; // Corrected: 'params' from path maps to 'param' type
-                        else if (pathZero === 'query')
-                            errorType = 'query';
-                        else if (pathZero === 'body')
-                            errorType = 'body';
-                        return {
-                            field: err.path.join('.') || 'request',
-                            message: err.message,
-                            type: errorType,
-                        };
-                    });
-                    const errorResponseBody = { data: null, error: mappedErrors };
-                    const schema422 = routeDefinition.responses[422];
-                    if (schema422) {
-                        const validationResult = schema422.safeParse(errorResponseBody);
-                        if (validationResult.success) {
-                            expressRes.status(422).json(validationResult.data);
-                        }
-                        else {
-                            console.error("FATAL: Constructed 422 error response failed its own schema validation.", validationResult.error.errors);
-                            expressRes.status(500).json({ error: [{ field: "general", type: "general", message: "Internal server error constructing validation error response." }] });
-                        }
-                    }
-                    else {
-                        console.error("Error: 422 schema not found for route, sending raw Zod errors.");
-                        expressRes.status(422).json({ error: mappedErrors }); // Fallback
-                    }
-                }
-                else if (error instanceof Error) {
-                    console.error(`Error in ${method} ${path}:`, error.message, error.stack);
-                    expressRes.status(500).json({ error: [{ field: "general", type: "general", message: 'Internal server error' }] });
-                }
-                else {
-                    console.error(`Unknown error in ${method} ${path}:`, error);
-                    expressRes.status(500).json({ error: [{ field: "general", type: "general", message: 'An unknown error occurred' }] });
-                }
-            }
-        };
-        switch (method.toUpperCase()) {
-            case 'GET':
-                app.get(path, expressMiddleware);
-                break;
-            case 'POST':
-                app.post(path, expressMiddleware);
-                break;
-            case 'PUT':
-                app.put(path, expressMiddleware);
-                break;
-            case 'DELETE':
-                app.delete(path, expressMiddleware);
-                break;
-            default:
-                console.warn(`Unsupported HTTP method: ${method} for path ${path}`);
-        }
-    });
-}
-exports.registerRouteHandlers = registerRouteHandlers;

package/dist/src/router/client.d.ts

@@ -1,151 +0,0 @@
-import { type ApiDefinitionSchema as BaseApiDefinitionSchema, type ApiClientParams, type ApiClientQuery, type ApiClientBody, type RouteSchema, type UnifiedError, type InferDataFromUnifiedResponse } from "./definition";
-import { type ZodTypeAny } from 'zod';
-/**
- * Options for an HTTP request made by an adapter.
- */
-export interface HttpRequestOptions {
-    method: RouteSchema['method'];
-    headers?: Record<string, string>;
-    body?: string | FormData;
-}
-/**
- * Represents an HTTP response from an adapter.
- * @template T The expected type of the JSON body.
- */
-export interface HttpResponse<T = any> {
-    status: number;
-    headers: Headers;
-    json(): Promise<T>;
-    text(): Promise<string>;
-    /**
-     * Gets the underlying raw response object from the adapter (e.g., Fetch API's Response object).
-     * The type of this object depends on the adapter implementation.
-     */
-    getRawResponse(): any;
-}
-/**
- * Interface for an HTTP client adapter.
- * Allows swapping out the underlying HTTP request mechanism (e.g., fetch, axios).
- */
-export interface HttpClientAdapter {
-    /**
-     * Makes an HTTP request.
-     * @template T The expected type of the JSON response body.
-     * @param url The URL to request.
-     * @param options The request options.
-     * @returns A promise that resolves to an HttpResponse.
-     */
-    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
-}
-/**
- * An HttpClientAdapter implementation that uses the native Fetch API.
- */
-export declare class FetchHttpClientAdapter implements HttpClientAdapter {
-    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
-}
-type GetRoute<TActualDef extends BaseApiDefinitionSchema, TDomain extends keyof TActualDef['endpoints'], K extends keyof TActualDef['endpoints'][TDomain]> = TActualDef['endpoints'][TDomain][K] extends infer Rte ? Rte extends RouteSchema ? Rte : never : never;
-type GetResponses<Rte extends RouteSchema> = Rte['responses'];
-/**
- * Discriminated union type for the result of callApi.
- * @template TDef The specific ApiDefinition structure being used.
- * @template TDomain The domain (controller) of the API.
- * @template TRouteKey The key of the route within the domain.
- */
-type ApiCallResultPayload<S_STATUS_NUM extends number, ActualSchema extends ZodTypeAny> = S_STATUS_NUM extends 422 ? {
-    status: S_STATUS_NUM;
-    error: UnifiedError;
-    rawResponse: any;
-    data?: undefined;
-} : S_STATUS_NUM extends 204 ? {
-    status: S_STATUS_NUM;
-    data: void;
-    rawResponse: any;
-    error?: undefined;
-} : {
-    status: S_STATUS_NUM;
-    data: InferDataFromUnifiedResponse<ActualSchema>;
-    rawResponse: any;
-    error?: undefined;
-};
-export type ApiCallResult<TActualDef extends BaseApiDefinitionSchema, TDomain extends keyof TActualDef['endpoints'], TRouteKey extends keyof TActualDef['endpoints'][TDomain], CurrentRoute extends RouteSchema = GetRoute<TActualDef, TDomain, TRouteKey>, ResponsesMap = GetResponses<CurrentRoute>> = ResponsesMap extends Record<any, ZodTypeAny> ? {
-    [S_STATUS_NUM in keyof ResponsesMap]: S_STATUS_NUM extends number ? ResponsesMap[S_STATUS_NUM] extends infer ActualSchema extends ZodTypeAny ? ApiCallResultPayload<S_STATUS_NUM, ActualSchema> : never : never;
-}[keyof ResponsesMap] : never;
-/**
- * Options for the callApi method.
- * @template TDef The specific ApiDefinition structure being used.
- * @template TDomainParam The domain (controller) of the API.
- * @template TRouteKeyParam The key of the route within the domain.
- */
-export type CallApiOptions<TActualDef extends BaseApiDefinitionSchema, // Made generic over TActualDef
-TDomainParam extends keyof TActualDef['endpoints'], TRouteKeyParam extends keyof TActualDef['endpoints'][TDomainParam]> = {
-    params?: ApiClientParams<TActualDef, TDomainParam, TRouteKeyParam>;
-    query?: ApiClientQuery<TActualDef, TDomainParam, TRouteKeyParam>;
-    body?: ApiClientBody<TActualDef, TDomainParam, TRouteKeyParam>;
-    headers?: Record<string, string>;
-};
-/**
- * A client for making API calls defined by an ApiDefinition.
- * It uses an HttpClientAdapter for making actual HTTP requests and supports persistent headers.
- */
-export declare class ApiClient<TActualDef extends BaseApiDefinitionSchema> {
-    private baseUrl;
-    private apiDefinitionObject;
-    private adapter;
-    private persistentHeaders;
-    /**
-     * Creates an instance of ApiClient.
-     * @param baseUrl The base URL for all API calls (e.g., 'http://localhost:3001').
-     * @param apiDefinitionObject The API definition object.
-     * @param adapter An instance of HttpClientAdapter to use for requests.
-     */
-    constructor(baseUrl: string, apiDefinitionObject: TActualDef, // Parameter uses TActualDef
-    adapter: HttpClientAdapter);
-    /**
-     * Sets a persistent header that will be included in all subsequent API calls.
-     * If the header already exists, its value will be updated.
-     * @param name The name of the header.
-     * @param value The value of the header.
-     */
-    setHeader(name: string, value: string): void;
-    /**
-     * Gets the value of a persistent header.
-     * @param name The name of the header.
-     * @returns The value of the header, or undefined if not set.
-     */
-    getHeader(name: string): string | undefined;
-    /**
-     * Removes a persistent header.
-     * @param name The name of the header to remove.
-     */
-    removeHeader(name: string): void;
-    /**
-     * Clears all persistent headers.
-     */
-    clearHeaders(): void;
-    /**
-     * Gets the full base URL including any prefix from the API definition.
-     * @returns The base URL with prefix applied.
-     */
-    private getBaseUrlWithPrefix;
-    /**
-     * Makes an API call to a specified domain and route.
-     * @template TDomain The domain (controller) of the API.
-     * @template TRouteKey The key of the route within the domain.
-     * @template TInferredHandlers A type inferred from the handlers object, ensuring all defined statuses are handled.
-     * @param domain The API domain (e.g., 'user').
-     * @param routeKey The API route key (e.g., 'getUsers').
-     * @param callData Optional parameters, query, body, and headers for the request.
-     * @param handlers An object where keys are status codes and values are handler functions for those statuses.
-     * @returns A promise that resolves to the return value of the executed handler.
-     * @throws Error if the route configuration is invalid, a network error occurs, an unhandled status code is received, or JSON parsing fails.
-     */
-    callApi<TDomain extends keyof TActualDef['endpoints'], TRouteKey extends keyof TActualDef['endpoints'][TDomain], TInferredHandlers extends {
-        [KStatus in ApiCallResult<TActualDef, TDomain, TRouteKey>['status']]: (payload: Extract<ApiCallResult<TActualDef, TDomain, TRouteKey>, {
-            status: KStatus;
-        }>) => any;
-    }>(domain: TDomain, routeKey: TRouteKey, callData: CallApiOptions<TActualDef, TDomain, TRouteKey> | undefined, // Uses TActualDef
-    handlers: TInferredHandlers): Promise<{
-        [SKey in keyof TInferredHandlers]: TInferredHandlers[SKey] extends (...args: any[]) => infer R ? R : never;
-    }[keyof TInferredHandlers]>;
-}
-export {};

package/dist/src/router/client.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClient = exports.FetchHttpClientAdapter = void 0;
-// --- Fetch Implementation of the Adapter ---
-/**
- * An HttpClientAdapter implementation that uses the native Fetch API.
- */
-class FetchHttpClientAdapter {
-    async request(url, options) {
-        const fetchOptions = {
-            method: options.method,
-            headers: options.headers,
-            // Note: `credentials` (e.g., 'include' for cookies) is not set by default.
-            // It can be configured by extending this adapter or by managing cookies via the 'Cookie' header.
-        };
-        if (options.body !== undefined) {
-            fetchOptions.body = options.body;
-        }
-        const nativeFetchResponse = await fetch(url, fetchOptions);
-        return {
-            status: nativeFetchResponse.status,
-            headers: nativeFetchResponse.headers,
-            json: () => nativeFetchResponse.json(),
-            text: () => nativeFetchResponse.text(),
-            getRawResponse: () => nativeFetchResponse,
-        };
-    }
-}
-exports.FetchHttpClientAdapter = FetchHttpClientAdapter;
-// --- API Client Class ---
-/**
- * A client for making API calls defined by an ApiDefinition.
- * It uses an HttpClientAdapter for making actual HTTP requests and supports persistent headers.
- */
-class ApiClient {
-    /**
-     * Creates an instance of ApiClient.
-     * @param baseUrl The base URL for all API calls (e.g., 'http://localhost:3001').
-     * @param apiDefinitionObject The API definition object.
-     * @param adapter An instance of HttpClientAdapter to use for requests.
-     */
-    constructor(baseUrl, apiDefinitionObject, // Parameter uses TActualDef
-    adapter) {
-        this.persistentHeaders = {};
-        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
-        this.apiDefinitionObject = apiDefinitionObject;
-        this.adapter = adapter;
-    }
-    /**
-     * Sets a persistent header that will be included in all subsequent API calls.
-     * If the header already exists, its value will be updated.
-     * @param name The name of the header.
-     * @param value The value of the header.
-     */
-    setHeader(name, value) {
-        this.persistentHeaders[name] = value;
-    }
-    /**
-     * Gets the value of a persistent header.
-     * @param name The name of the header.
-     * @returns The value of the header, or undefined if not set.
-     */
-    getHeader(name) {
-        return this.persistentHeaders[name];
-    }
-    /**
-     * Removes a persistent header.
-     * @param name The name of the header to remove.
-     */
-    removeHeader(name) {
-        delete this.persistentHeaders[name];
-    }
-    /**
-     * Clears all persistent headers.
-     */
-    clearHeaders() {
-        this.persistentHeaders = {};
-    }
-    /**
-     * Gets the full base URL including any prefix from the API definition.
-     * @returns The base URL with prefix applied.
-     */
-    getBaseUrlWithPrefix() {
-        const prefix = this.apiDefinitionObject.prefix;
-        if (prefix) {
-            const cleanPrefix = prefix.startsWith('/') ? prefix : `/${prefix}`;
-            return this.baseUrl + cleanPrefix.replace(/\/$/, '');
-        }
-        return this.baseUrl;
-    }
-    /**
-     * Makes an API call to a specified domain and route.
-     * @template TDomain The domain (controller) of the API.
-     * @template TRouteKey The key of the route within the domain.
-     * @template TInferredHandlers A type inferred from the handlers object, ensuring all defined statuses are handled.
-     * @param domain The API domain (e.g., 'user').
-     * @param routeKey The API route key (e.g., 'getUsers').
-     * @param callData Optional parameters, query, body, and headers for the request.
-     * @param handlers An object where keys are status codes and values are handler functions for those statuses.
-     * @returns A promise that resolves to the return value of the executed handler.
-     * @throws Error if the route configuration is invalid, a network error occurs, an unhandled status code is received, or JSON parsing fails.
-     */
-    async callApi(domain, routeKey, callData, // Uses TActualDef
-    handlers) {
-        const routeInfo = this.apiDefinitionObject.endpoints[domain][routeKey]; // Accessing from TActualDef instance
-        if (!routeInfo || typeof routeInfo.path !== 'string') {
-            throw new Error(`API route configuration ${String(domain)}.${String(routeKey)} not found or invalid.`);
-        }
-        let urlPath = routeInfo.path;
-        if (callData?.params) {
-            const params = callData.params;
-            for (const key in params) {
-                if (Object.prototype.hasOwnProperty.call(params, key) && params[key] !== undefined) {
-                    urlPath = urlPath.replace(`:${key}`, String(params[key]));
-                }
-            }
-        }
-        const url = new URL(this.getBaseUrlWithPrefix() + urlPath);
-        if (callData?.query) {
-            const queryParams = callData.query;
-            for (const key in queryParams) {
-                if (Object.prototype.hasOwnProperty.call(queryParams, key) && queryParams[key] !== undefined) {
-                    url.searchParams.append(key, String(queryParams[key]));
-                }
-            }
-        }
-        const requestHeaders = {
-            ...this.persistentHeaders,
-            'Content-Type': 'application/json', // Default, can be overridden by callData.headers or persistentHeaders
-            ...(callData?.headers || {}),
-        };
-        const adapterRequestOptions = {
-            method: routeInfo.method,
-            headers: requestHeaders,
-        };
-        if (routeInfo.method !== 'GET' && routeInfo.method !== 'HEAD' && callData?.body !== undefined) {
-            adapterRequestOptions.body = JSON.stringify(callData.body);
-        }
-        let adapterResponse;
-        try {
-            adapterResponse = await this.adapter.request(url.toString(), adapterRequestOptions);
-        }
-        catch (networkError) {
-            const errorMessage = networkError instanceof Error ? networkError.message : `Unknown network error calling API ${String(domain)}.${String(routeKey)}`;
-            console.error(`Network error for ${String(domain)}.${String(routeKey)}:`, networkError);
-            throw new Error(`Network error: ${errorMessage}`);
-        }
-        const runtimeStatus = adapterResponse.status;
-        const definedStatusCodes = Object.keys(routeInfo.responses).map(Number);
-        if (!definedStatusCodes.includes(runtimeStatus)) {
-            const responseText = await adapterResponse.text().catch(() => "Could not read response text.");
-            const errorMsg = `API ${String(domain)}.${String(routeKey)}: Received unhandled status code ${runtimeStatus}. Expected one of: ${definedStatusCodes.join(', ')}. Response: ${responseText}`;
-            console.error(errorMsg);
-            throw new Error(errorMsg);
-        }
-        const currentStatusLiteral = runtimeStatus;
-        // apiResultPayload now uses ApiCallResult with TActualDef
-        let apiResultPayload;
-        if (currentStatusLiteral === 204) {
-            apiResultPayload = {
-                status: 204,
-                data: undefined, // data is undefined for 204
-                rawResponse: adapterResponse.getRawResponse(),
-            };
-        }
-        else {
-            let responseBodyJson;
-            const contentType = adapterResponse.headers.get("content-type");
-            if (contentType && contentType.includes("application/json")) {
-                try {
-                    responseBodyJson = await adapterResponse.json();
-                }
-                catch (e) {
-                    const parseErrorMsg = `API ${String(domain)}.${String(routeKey)}: Failed to parse JSON for status ${currentStatusLiteral}. Error: ${e instanceof Error ? e.message : String(e)}`;
-                    console.error(parseErrorMsg, adapterResponse.getRawResponse());
-                    throw new Error(parseErrorMsg);
-                }
-            }
-            else if (runtimeStatus >= 400) { // Handle non-JSON error responses
-                const responseText = await adapterResponse.text().catch(() => "Could not read response text.");
-                if (currentStatusLiteral === 422) { // Try to conform to UnifiedError for 422
-                    responseBodyJson = {
-                        error: [{ field: 'general', type: 'general', message: `Non-JSON error response for 422: ${responseText}` }] // Adjusted: type to 'general'
-                    };
-                }
-                else { // For other non-JSON errors, data will likely be undefined. Log a warning.
-                    console.warn(`API ${String(domain)}.${String(routeKey)}: Received non-JSON response for status ${currentStatusLiteral}. Response: ${responseText}`);
-                    // responseBodyJson remains undefined or as is, data extraction below will handle it.
-                }
-            }
-            if (currentStatusLiteral === 422) {
-                const errorData = responseBodyJson?.error || [{ field: 'general', type: 'general', message: `HTTP error 422: ${await adapterResponse.text().catch(() => 'Unknown error text')}` }];
-                // Assign directly to apiResultPayload, relying on its type ApiCallResult<TActualDef, TDomain, TRouteKey>
-                // to correctly match the 422 variant.
-                apiResultPayload = {
-                    status: 422,
-                    error: errorData,
-                    rawResponse: adapterResponse.getRawResponse(),
-                }; // Force cast via unknown
-            }
-            else {
-                // Assuming responseBodyJson is an object like { data: <actual_payload> }
-                // as per backend contract for non-204/non-422 responses.
-                apiResultPayload = {
-                    status: currentStatusLiteral,
-                    data: responseBodyJson.data, // Extract the actual data from the wrapped response
-                    rawResponse: adapterResponse.getRawResponse(),
-                };
-            }
-        }
-        const handler = handlers[apiResultPayload.status];
-        return handler(apiResultPayload); // Reverting to `as any` as TS struggles with direct narrowing here
-    }
-}
-exports.ApiClient = ApiClient;

package/dist/src/router/definition.d.ts

@@ -1,121 +0,0 @@
-import { z, ZodTypeAny, ZodType } from 'zod';
-export declare class TsTypeMarker<T> {
-    readonly _isTsTypeMarker = true;
-    readonly _type: T;
-    constructor();
-}
-export declare function CustomResponse<T>(): TsTypeMarker<T>;
-type InputSchemaOrMarker = ZodTypeAny | TsTypeMarker<any>;
-declare const unifiedErrorSchema: z.ZodNullable<z.ZodArray<z.ZodObject<{
-    field: z.ZodString;
-    type: z.ZodEnum<["body", "query", "param", "general"]>;
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    field: string;
-    type: "body" | "query" | "param" | "general";
-    message: string;
-}, {
-    field: string;
-    type: "body" | "query" | "param" | "general";
-    message: string;
-}>, "many">>;
-export type UnifiedError = z.infer<typeof unifiedErrorSchema>;
-declare const errorUnifiedResponseSchema: z.ZodObject<{
-    error: z.ZodEffects<z.ZodNullable<z.ZodArray<z.ZodObject<{
-        field: z.ZodString;
-        type: z.ZodEnum<["body", "query", "param", "general"]>;
-        message: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }, {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }>, "many">>, {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }[], {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }[] | null>;
-}, "strip", z.ZodTypeAny, {
-    error: {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }[];
-}, {
-    error: {
-        field: string;
-        type: "body" | "query" | "param" | "general";
-        message: string;
-    }[] | null;
-}>;
-export declare const HttpSuccessCodes: readonly [200, 201, 202, 204];
-export declare const HttpClientErrorCodes: readonly [400, 401, 403, 404, 409];
-export declare const HttpServerErrorCodes: readonly [500];
-export type HttpSuccessStatusCode = typeof HttpSuccessCodes[number];
-export type HttpClientErrorStatusCode = typeof HttpClientErrorCodes[number];
-export type HttpServerErrorStatusCode = typeof HttpServerErrorCodes[number];
-export type AllowedInputStatusCode = HttpSuccessStatusCode | HttpClientErrorStatusCode | HttpServerErrorStatusCode;
-export type AllowedResponseStatusCode = AllowedInputStatusCode | 422;
-type CreateResponsesReturnType<InputSchemas extends Partial<Record<AllowedInputStatusCode, InputSchemaOrMarker>>> = {
-    [KStatus in keyof InputSchemas]: InputSchemas[KStatus] extends TsTypeMarker<infer T> ? z.ZodObject<{
-        data: ZodType<T, z.ZodTypeDef, T>;
-    }> : InputSchemas[KStatus] extends ZodTypeAny ? z.ZodObject<{
-        data: InputSchemas[KStatus];
-    }> : never;
-} & {
-    422: typeof errorUnifiedResponseSchema;
-};
-export declare function createResponses<TInputMap extends Partial<Record<AllowedInputStatusCode, InputSchemaOrMarker>>>(schemas: TInputMap): CreateResponsesReturnType<TInputMap>;
-export interface RouteSchema {
-    path: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
-    params?: ZodTypeAny;
-    query?: ZodTypeAny;
-    body?: ZodTypeAny;
-    responses: Record<number, ZodTypeAny>;
-}
-export type ApiDefinitionSchema = {
-    prefix?: string;
-    endpoints: Record<string, Record<string, RouteSchema>>;
-};
-export declare function createApiDefinition<T extends ApiDefinitionSchema>(definition: T): T;
-export type ApiRouteKey<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints']> = keyof TDef['endpoints'][TDomain];
-export type ApiRoute<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName];
-export type InferDataFromUnifiedResponse<S extends ZodTypeAny> = S extends z.ZodVoid ? void : z.infer<S> extends {
-    data: infer D;
-} ? D extends null ? null : D extends (infer ActualD | null) ? ActualD extends void ? void : ActualD : D : never;
-export type ApiResponse<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    responses: infer R;
-} ? R extends {
-    200: infer R200 extends ZodTypeAny;
-} ? InferDataFromUnifiedResponse<R200> : R extends {
-    201: infer R201 extends ZodTypeAny;
-} ? InferDataFromUnifiedResponse<R201> : R extends {
-    204: infer R204 extends ZodTypeAny;
-} ? InferDataFromUnifiedResponse<R204> : any : any;
-export type ApiBody<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    body: infer B extends z.ZodTypeAny;
-} ? z.infer<B> : Record<string, any>;
-export type ApiParams<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    params: infer P extends z.ZodTypeAny;
-} ? z.infer<P> : Record<string, any>;
-export type ApiQuery<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    query: infer Q extends z.ZodTypeAny;
-} ? z.infer<Q> : Record<string, any>;
-export type ApiClientBody<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    body: infer B extends ZodTypeAny;
-} ? z.input<B> : undefined;
-export type ApiClientParams<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    params: infer P extends ZodTypeAny;
-} ? z.input<P> : undefined;
-export type ApiClientQuery<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends ApiRouteKey<TDef, TDomain>> = TDef['endpoints'][TDomain][TRouteName] extends {
-    query: infer Q extends ZodTypeAny;
-} ? z.input<Q> : undefined;
-export {};