@sapporta/rest-core 3.52.1 → 3.52.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sapporta/rest-core",
-  "version": "3.52.1",
+  "version": "3.52.2",
   "private": false,
   "description": "Sapporta-maintained ts-rest core fork for Zod 4 contracts and inference",
   "keywords": [
@@ -14,7 +14,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/sapporta/sapporta-rest.git",
+    "url": "https://github.com/jasim/sapporta-rest.git",
     "directory": "libs/ts-rest/core"
   },
   "license": "MIT",
@@ -29,5 +29,15 @@
   },
   "devDependencies": {
     "zod": "^4.0.0"
-  }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
 }

package/src/lib/client.d.ts

@@ -0,0 +1,107 @@
+import { AppRoute, AppRouteMutation, AppRouter } from './dsl';
+import { AreAllPropertiesOptional, Prettify } from './type-utils';
+import { ClientInferRequest, ClientInferResponses, PartialClientInferRequest } from './infer-types';
+type RecursiveProxyObj<T extends AppRouter, TClientArgs extends ClientArgs> = {
+    [TKey in keyof T]: T[TKey] extends AppRoute ? AppRouteFunction<T[TKey], TClientArgs> : T[TKey] extends AppRouter ? RecursiveProxyObj<T[TKey], TClientArgs> : never;
+};
+/**
+ * @deprecated Only safe to use on the client-side. Use `ServerInferResponses`/`ClientInferResponses` instead.
+ */
+export type ApiResponseForRoute<T extends AppRoute> = ClientInferResponses<T>;
+/**
+ * @deprecated Only safe to use on the client-side. Use `ServerInferResponses`/`ClientInferResponses` instead.
+ */
+export declare function getRouteResponses<T extends AppRouter>(router: T): ClientInferResponses<T>;
+/**
+ * Returned from a mutation or query call
+ */
+export type AppRouteFunction<TRoute extends AppRoute, TClientArgs extends ClientArgs, TArgs = PartialClientInferRequest<TRoute, TClientArgs>> = AreAllPropertiesOptional<TArgs> extends true ? (args?: Prettify<TArgs>) => Promise<Prettify<ClientInferResponses<TRoute>>> : (args: Prettify<TArgs>) => Promise<Prettify<ClientInferResponses<TRoute>>>;
+export type FetchOptions = typeof globalThis extends {
+    Request: infer T extends typeof Request;
+} ? Omit<NonNullable<ConstructorParameters<T>[1]>, 'method' | 'headers' | 'body'> : never;
+export interface OverridableClientArgs {
+    baseUrl: string;
+    credentials?: FetchOptions['credentials'];
+    jsonQuery?: boolean;
+    validateResponse?: boolean;
+}
+export interface ClientArgs extends OverridableClientArgs {
+    baseHeaders?: Record<string, string | ((options: FetchApiOptions) => string)>;
+    api?: ApiFetcher;
+}
+export type ApiFetcherArgs<TFetchOptions extends FetchOptions = FetchOptions> = {
+    route: AppRoute;
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+    body: FormData | URLSearchParams | string | null | undefined;
+    rawBody: unknown;
+    rawQuery: unknown;
+    contentType: AppRouteMutation['contentType'];
+    fetchOptions?: FetchOptions;
+    validateResponse?: boolean;
+    /**
+     * @deprecated Use `fetchOptions.credentials` instead
+     */
+    credentials?: TFetchOptions['credentials'];
+    /**
+     * @deprecated Use `fetchOptions.signal` instead
+     */
+    signal?: TFetchOptions['signal'];
+    /**
+     * @deprecated Use `fetchOptions.cache` instead
+     */
+    cache?: 'cache' extends keyof TFetchOptions ? TFetchOptions['cache'] : never;
+    /**
+     * @deprecated Use `fetchOptions.next` instead
+     */
+    next?: 'next' extends keyof TFetchOptions ? TFetchOptions['next'] : never;
+};
+export type ApiFetcher = (args: ApiFetcherArgs) => Promise<{
+    status: number;
+    body: unknown;
+    headers: Headers;
+}>;
+/**
+ * Default fetch api implementation:
+ *
+ * Can be used as a reference for implementing your own fetcher,
+ * or used in the "api" field of ClientArgs to allow you to hook
+ * into the request to run custom logic
+ */
+export declare const tsRestFetchApi: ApiFetcher;
+export type FetchApiOptions = {
+    path: string;
+    clientArgs: ClientArgs;
+    route: AppRoute;
+    query: unknown;
+    body: unknown;
+    extraInputArgs: Record<string, unknown>;
+    headers: Record<string, string | undefined>;
+    fetchOptions?: FetchOptions;
+};
+export declare const fetchApi: (options: FetchApiOptions) => Promise<{
+    status: number;
+    body: unknown;
+    headers: Headers;
+}>;
+export declare const evaluateFetchApiArgs: <TAppRoute extends AppRoute>(route: TAppRoute, clientArgs: InitClientArgs, inputArgs?: ClientInferRequest<AppRouteMutation, ClientArgs>) => FetchApiOptions;
+/**
+ * @hidden
+ */
+export declare const getCompleteUrl: (query: unknown, baseUrl: string, params: Record<string, string>, route: AppRoute, jsonQuery: boolean) => string;
+export declare const getRouteQuery: <TAppRoute extends AppRoute>(route: TAppRoute, clientArgs: InitClientArgs) => (inputArgs?: ClientInferRequest<AppRouteMutation, ClientArgs>) => Promise<{
+    status: number;
+    body: unknown;
+    headers: Headers;
+}>;
+export type InitClientReturn<T extends AppRouter, TClientArgs extends ClientArgs> = RecursiveProxyObj<T, TClientArgs>;
+export type InitClientArgs = ClientArgs & {
+    /**
+     * Ensures that the responses from the server match those defined in the
+     * contract.
+     */
+    throwOnUnknownStatus?: boolean;
+};
+export declare const initClient: <T extends AppRouter, TClientArgs extends InitClientArgs>(router: T, args: TClientArgs) => RecursiveProxyObj<T, TClientArgs>;
+export {};

package/src/lib/dsl.d.ts

@@ -0,0 +1,222 @@
+import { StandardSchemaV1 } from './standard-schema';
+import { LowercaseKeys, Merge, Opaque, Prettify, SchemaInputOrType, SchemaOutputOrType, WithoutUnknown } from './type-utils';
+type MixedSchemaError<A, B> = Opaque<{
+    a: A;
+    b: B;
+}, 'MixedSchemaError'>;
+/**
+ * The path with colon-prefixed parameters
+ * e.g. "/posts/:id".
+ */
+type Path = string;
+declare const NullSymbol: unique symbol;
+export declare const ContractNoBody: unique symbol;
+export type ContractPlainType<T> = Opaque<T, 'ContractPlainType'>;
+export type ContractNullType = Opaque<typeof NullSymbol, 'ContractNullType'>;
+export type ContractNoBodyType = typeof ContractNoBody;
+export type ContractAnyType = StandardSchemaV1<any> | ContractPlainType<unknown> | ContractNullType | null;
+export type ContractOtherResponse<T extends ContractAnyType> = Opaque<{
+    contentType: string;
+    body: T;
+}, 'ContractOtherResponse'>;
+export type AppRouteResponse = ContractAnyType | ContractNoBodyType | ContractOtherResponse<ContractAnyType>;
+type AppRouteCommon = {
+    path: Path;
+    pathParams?: ContractAnyType;
+    query?: ContractAnyType;
+    headers?: Record<string, ContractAnyType>;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    responses: Record<number, AppRouteResponse>;
+    strictStatusCodes?: boolean;
+    metadata?: unknown;
+    /**
+     * @deprecated Use `validateResponse` on the client options
+     */
+    validateResponseOnClient?: boolean;
+};
+/**
+ * A query endpoint. In REST terms, one using GET.
+ */
+export type AppRouteQuery = AppRouteCommon & {
+    method: 'GET';
+};
+/**
+ * A mutation endpoint. In REST terms, one using POST, PUT,
+ * PATCH, or DELETE.
+ */
+export type AppRouteMutation = AppRouteCommon & {
+    method: 'POST' | 'DELETE' | 'PUT' | 'PATCH';
+    contentType?: 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded';
+    body: ContractAnyType | ContractNoBodyType;
+};
+/**
+ * A mutation endpoint. In REST terms, one using POST, PUT,
+ * PATCH, or DELETE.
+ */
+export type AppRouteDeleteNoBody = AppRouteCommon & {
+    method: 'DELETE';
+};
+type ValidatedHeaders<T extends AppRoute, TOptions extends RouterOptions, TOptionsApplied = ApplyOptions<T, TOptions>> = 'headers' extends keyof TOptionsApplied ? TOptionsApplied['headers'] extends MixedSchemaError<infer A, infer B> ? {
+    _error: 'Cannot mix plain object types with StandardSchemaV1 objects for headers';
+    a: A;
+    b: B;
+} : T : T;
+/**
+ * Recursively process a router, allowing for you to define nested routers.
+ *
+ * The main purpose of this is to convert all path strings into string constants so we can infer the path
+ */
+type RecursivelyProcessAppRouter<T extends AppRouter, TOptions extends RouterOptions> = {
+    [K in keyof T]: T[K] extends AppRoute ? ValidatedHeaders<T[K], TOptions> : T[K] extends AppRouter ? RecursivelyProcessAppRouter<T[K], TOptions> : T[K];
+};
+type RecursivelyApplyOptions<TRouter extends AppRouter, TOptions extends RouterOptions> = {
+    [TRouterKey in keyof TRouter]: TRouter[TRouterKey] extends AppRoute ? Prettify<ApplyOptions<TRouter[TRouterKey], TOptions>> : TRouter[TRouterKey] extends AppRouter ? RecursivelyApplyOptions<TRouter[TRouterKey], TOptions> : TRouter[TRouterKey];
+};
+/**
+ * Merge headers together
+ */
+export type MergeHeaders<A extends AppRouteCommon['headers'], B extends AppRouteCommon['headers']> = [A, B] extends [undefined, undefined] ? unknown : A extends undefined ? B : B extends undefined ? A : A extends Record<string, ContractAnyType> ? B extends Record<string, ContractAnyType> ? MergeObjectBasedHeaders<A, B> : unknown : unknown;
+/**
+ * Headers are typed as a Record<string, ContractAnyType>
+ *
+ * We need to be able to merge together base headers and route headers, this smushes them together taking precedence to route headers
+ */
+type MergeObjectBasedHeaders<T extends Record<string, ContractAnyType>, U extends Record<string, ContractAnyType>> = {
+    [K in keyof T | keyof U]: K extends keyof U ? U[K] : K extends keyof T ? T[K] : never;
+} extends infer M ? {
+    [K in keyof M as M[K] extends null ? never : K]: M[K];
+} : never;
+type IsEmptyObject<T> = keyof T extends never ? {} extends T ? true : false : false;
+/**
+ * For a given app route, infer the headers input type
+ */
+export type InferHeadersInput<T extends AppRoute, THeaders = T['headers']> = unknown extends THeaders ? undefined : IsEmptyObject<THeaders> extends true ? {} : THeaders extends Record<string, ContractAnyType> ? LowercaseKeys<UnknownOrUndefinedObjectValuesToOptionalKeys<{
+    [K in keyof THeaders]: THeaders[K] extends ContractAnyType ? SchemaInputOrType<THeaders[K]> : never;
+}>> : undefined;
+/**
+ * { foo: string | undefined } => { foo?: string | undefined }
+ * { foo: unknown } => { foo?: unknown }
+ *
+ * @internal
+ */
+export type UnknownOrUndefinedObjectValuesToOptionalKeys<T> = {
+    [K in keyof T as undefined extends T[K] ? K : unknown extends T[K] ? K : never]?: T[K];
+} & {
+    [K in keyof T as undefined extends T[K] ? never : unknown extends T[K] ? never : K]: T[K];
+};
+/**
+ * For a given app route, infer the headers output type
+ */
+export type InferHeadersOutput<T extends AppRoute, THeaders = T['headers']> = unknown extends THeaders ? '1' : IsEmptyObject<THeaders> extends true ? {} : THeaders extends Record<string, ContractAnyType> ? {
+    [K in keyof THeaders]: THeaders[K] extends ContractAnyType ? LowercaseKeys<SchemaOutputOrType<THeaders[K]>> : never;
+} : '3';
+type ApplyOptions<TRoute extends AppRoute, TOptions extends RouterOptions> = Omit<TRoute, 'headers' | 'path' | 'responses'> & WithoutUnknown<{
+    path: TOptions['pathPrefix'] extends string ? `${TOptions['pathPrefix']}${TRoute['path']}` : TRoute['path'];
+    headers: MergeHeaders<UnknownToUndefined<TOptions['baseHeaders']>, UnknownToUndefined<TRoute['headers']>>;
+    strictStatusCodes: TRoute['strictStatusCodes'] extends boolean ? TRoute['strictStatusCodes'] : TOptions['strictStatusCodes'] extends boolean ? TOptions['strictStatusCodes'] : unknown;
+    responses: 'commonResponses' extends keyof TOptions ? Prettify<Merge<TOptions['commonResponses'], TRoute['responses']>> : TRoute['responses'];
+    metadata: 'metadata' extends keyof TOptions ? Prettify<Merge<TOptions['metadata'], TRoute['metadata']>> : TRoute['metadata'];
+}>;
+/**
+ * This was needed as **for some reason** headers above end up being `unknown`, our
+ * `MergeHeadersWithLegacySupport` function expends undefined, so we need to normalize it
+ *
+ * Can be moved in V4 when the legacy polyfill is removed
+ */
+export type UnknownToUndefined<T> = unknown extends T ? T extends unknown ? undefined : T : T;
+/**
+ * A union of all possible endpoint types.
+ */
+export type AppRoute = AppRouteQuery | AppRouteMutation | AppRouteDeleteNoBody;
+export type AppRouteStrictStatusCodes = Omit<AppRoute, 'strictStatusCodes'> & {
+    strictStatusCodes: true;
+};
+/**
+ * A router (or contract) in @ts-rest is a collection of more routers or
+ * individual routes
+ */
+export type AppRouter = {
+    [key: string]: AppRouter | AppRoute;
+};
+export type FlattenAppRouter<T extends AppRouter | AppRoute> = T extends AppRoute ? T : {
+    [TKey in keyof T]: T[TKey] extends AppRoute ? T[TKey] : T[TKey] extends AppRouter ? FlattenAppRouter<T[TKey]> : never;
+}[keyof T];
+export type RouterOptions<TPrefix extends string = string> = {
+    baseHeaders?: Record<string, ContractAnyType>;
+    strictStatusCodes?: boolean;
+    pathPrefix?: TPrefix;
+    commonResponses?: Record<number, AppRouteResponse>;
+    metadata?: unknown;
+    /**
+     * @deprecated Use `validateResponse` on the client options
+     */
+    validateResponseOnClient?: boolean;
+};
+/**
+ * Differentiate between a route and a router
+ *
+ * @param obj
+ * @returns
+ */
+export declare const isAppRoute: (obj: AppRoute | AppRouter) => obj is AppRoute;
+export declare const isAppRouteQuery: (route: AppRoute) => route is AppRouteQuery;
+export declare const isAppRouteMutation: (route: AppRoute) => route is AppRouteMutation;
+type NarrowObject<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * The instantiated ts-rest client
+ */
+type ContractInstance = {
+    /**
+     * A collection of routes or routers
+     */
+    router: <TRouter extends AppRouter, TPrefix extends string, TOptions extends RouterOptions<TPrefix> = {}>(endpoints: RecursivelyProcessAppRouter<TRouter, TOptions>, options?: TOptions) => RecursivelyApplyOptions<TRouter, TOptions>;
+    /**
+     * A single query route, should exist within
+     * a {@link AppRouter}
+     */
+    query: <T extends AppRouteQuery>(query: NarrowObject<T>) => T;
+    /**
+     * A single mutation route, should exist within
+     * a {@link AppRouter}
+     */
+    mutation: <T extends AppRouteMutation>(mutation: NarrowObject<T>) => T;
+    responses: <TResponses extends Record<number, AppRouteResponse>>(responses: TResponses) => TResponses;
+    /**
+     * @deprecated Please use type() instead.
+     */
+    response: <T>() => T extends null ? ContractNullType : ContractPlainType<T>;
+    /**
+     * @deprecated Please use type() instead.
+     */
+    body: <T>() => T extends null ? ContractNullType : ContractPlainType<T>;
+    /**
+     * Exists to allow storing a Type in the contract (at compile time only)
+     */
+    type: <T>() => T extends null ? ContractNullType : ContractPlainType<T>;
+    /**
+     * Define a custom response type
+     */
+    otherResponse: <T extends ContractAnyType>({ contentType, body, }: {
+        contentType: string;
+        body: T;
+    }) => ContractOtherResponse<T>;
+    /** Use to indicate that a route takes no body or responds with no body */
+    noBody: () => ContractNoBodyType;
+};
+/**
+ *
+ * @deprecated Please use {@link initContract} instead.
+ */
+export declare const initTsRest: () => ContractInstance;
+export declare const ContractPlainTypeRuntimeSymbol: any;
+/**
+ * Instantiate a ts-rest client, primarily to access `router`, `response`, and `body`
+ *
+ * @returns {ContractInstance}
+ */
+export declare const initContract: () => ContractInstance;
+export {};

package/src/lib/infer-types.d.ts

@@ -0,0 +1,78 @@
+import { AppRoute, AppRouteMutation, AppRouter, AppRouteStrictStatusCodes, ContractAnyType, ContractNoBodyType, ContractOtherResponse, InferHeadersInput, InferHeadersOutput } from './dsl';
+import { HTTPStatusCode } from './status-codes';
+import { And, Extends, LowercaseKeys, Merge, Not, OptionalIfAllOptional, Or, PartialByLooseKeys, Prettify, Without, SchemaOutputOrType, SchemaInputOrType } from './type-utils';
+import { ApiFetcher, ClientArgs, OverridableClientArgs, FetchOptions } from './client';
+import { ParamsFromUrl } from './paths';
+type ExtractExtraParametersFromClientArgs<TClientArgs extends Pick<ClientArgs, 'api'>> = TClientArgs['api'] extends ApiFetcher ? Omit<Parameters<TClientArgs['api']>[0], keyof Parameters<ApiFetcher>[0]> : {};
+/**
+ * Extract the path params from the path in the contract
+ */
+type PathParamsFromUrl<T extends AppRoute> = ParamsFromUrl<T['path']> extends infer U ? U : never;
+/**
+ * Merge `PathParamsFromUrl<T>` with pathParams schema if it exists
+ */
+type PathParamsWithCustomValidators<T extends AppRoute, TClientOrServer extends 'client' | 'server' = 'server'> = 'pathParams' extends keyof T ? Merge<PathParamsFromUrl<T>, TClientOrServer extends 'server' ? SchemaOutputOrType<T['pathParams']> : SchemaInputOrType<T['pathParams']>> : PathParamsFromUrl<T>;
+export type ResolveResponseType<T extends ContractAnyType | ContractNoBodyType | ContractOtherResponse<ContractAnyType>> = T extends ContractOtherResponse<infer U> ? U : T;
+export type InferResponseDefinedStatusCodes<T extends AppRoute, TStatus extends HTTPStatusCode = HTTPStatusCode> = {
+    [K in keyof T['responses'] & TStatus]: K;
+}[keyof T['responses'] & TStatus];
+export type InferResponseUndefinedStatusCodes<T extends AppRoute, TStatus extends HTTPStatusCode = HTTPStatusCode> = Exclude<TStatus, InferResponseDefinedStatusCodes<T, TStatus>>;
+type AppRouteResponses<T extends AppRoute, TStatus extends HTTPStatusCode, TClientOrServer extends 'client' | 'server', TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default'> = {
+    [K in keyof T['responses'] & TStatus]: {
+        status: K;
+        body: TClientOrServer extends 'server' ? SchemaInputOrType<ResolveResponseType<T['responses'][K]>> : SchemaOutputOrType<ResolveResponseType<T['responses'][K]>>;
+    } & (TClientOrServer extends 'client' ? {
+        headers: Headers;
+    } : {});
+}[keyof T['responses'] & TStatus] | (Or<Extends<TStrictStatusCodes, 'force'>, And<Extends<T, AppRouteStrictStatusCodes>, Not<Extends<TStrictStatusCodes, 'ignore'>>>> extends true ? never : Exclude<TStatus, keyof T['responses']> extends never ? never : {
+    status: Exclude<TStatus, keyof T['responses']>;
+    body: unknown;
+} & (TClientOrServer extends 'client' ? {
+    headers: Headers;
+} : {}));
+export type ServerInferResponses<T extends AppRoute | AppRouter, TStatus extends HTTPStatusCode = HTTPStatusCode, TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default'> = T extends AppRoute ? Prettify<AppRouteResponses<T, TStatus, 'server', TStrictStatusCodes>> : T extends AppRouter ? {
+    [TKey in keyof T]: ServerInferResponses<T[TKey], TStatus, TStrictStatusCodes>;
+} : never;
+export type ClientInferResponses<T extends AppRoute | AppRouter, TStatus extends HTTPStatusCode = HTTPStatusCode, TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default'> = T extends AppRoute ? Prettify<AppRouteResponses<T, TStatus, 'client', TStrictStatusCodes>> : T extends AppRouter ? {
+    [TKey in keyof T]: ClientInferResponses<T[TKey], TStatus, TStrictStatusCodes>;
+} : never;
+export type ServerInferResponseBody<T extends AppRoute, TStatus extends keyof T['responses'] = keyof T['responses']> = Prettify<AppRouteResponses<T, TStatus & HTTPStatusCode, 'server'>['body']>;
+export type ClientInferResponseBody<T extends AppRoute, TStatus extends keyof T['responses'] = keyof T['responses']> = Prettify<AppRouteResponses<T, TStatus & HTTPStatusCode, 'client'>['body']>;
+type BodyWithoutFileIfMultiPart<T extends AppRouteMutation> = T['contentType'] extends 'multipart/form-data' ? Without<SchemaOutputOrType<T['body']>, File | File[]> : SchemaOutputOrType<T['body']>;
+export type ServerInferRequest<T extends AppRoute | AppRouter, TServerHeaders = never> = T extends AppRoute ? Prettify<Without<{
+    params: [keyof PathParamsWithCustomValidators<T>] extends [never] ? never : Prettify<PathParamsWithCustomValidators<T>>;
+    body: T extends AppRouteMutation ? BodyWithoutFileIfMultiPart<T> : never;
+    query: 'query' extends keyof T ? SchemaOutputOrType<T['query']> : never;
+    headers: 'headers' extends keyof T ? Prettify<InferHeadersOutput<T> & ([TServerHeaders] extends [never] ? {} : Omit<TServerHeaders, keyof LowercaseKeys<InferHeadersOutput<T>>>)> : TServerHeaders;
+}, never>> : T extends AppRouter ? {
+    [TKey in keyof T]: ServerInferRequest<T[TKey], TServerHeaders>;
+} : never;
+type ClientInferRequestBase<T extends AppRoute, TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {}, THeaders = 'headers' extends keyof T ? Prettify<PartialByLooseKeys<LowercaseKeys<InferHeadersInput<T>>, keyof LowercaseKeys<TClientArgs['baseHeaders']>>> : never, TFetchOptions extends FetchOptions = FetchOptions> = Prettify<Without<{
+    params: [keyof PathParamsWithCustomValidators<T, 'client'>] extends [
+        never
+    ] ? never : Prettify<PathParamsWithCustomValidators<T, 'client'>>;
+    body: T extends AppRouteMutation ? T['body'] extends null ? never : T['contentType'] extends 'multipart/form-data' ? FormData | SchemaInputOrType<T['body']> : T['contentType'] extends 'application/x-www-form-urlencoded' ? string | SchemaInputOrType<T['body']> : SchemaInputOrType<T['body']> : never;
+    query: 'query' extends keyof T ? T['query'] extends null ? never : SchemaInputOrType<T['query']> : never;
+    headers: THeaders;
+    extraHeaders?: [THeaders] extends [never] ? Record<string, string> : {
+        [K in keyof RequiredKeys<InferHeadersInput<T>>]?: never;
+    } & Record<string, string>;
+    fetchOptions?: FetchOptions;
+    overrideClientOptions?: Partial<OverridableClientArgs>;
+    /**
+     * @deprecated Use `fetchOptions.cache` instead
+     */
+    cache?: 'cache' extends keyof TFetchOptions ? TFetchOptions['cache'] : never;
+    /**
+     * @deprecated Use `fetchOptions.next` instead
+     */
+    next?: 'next' extends keyof TFetchOptions ? TFetchOptions['next'] : never;
+} & ExtractExtraParametersFromClientArgs<TClientArgs>, never>>;
+type RequiredKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+export type ClientInferRequest<T extends AppRoute | AppRouter, TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {}> = T extends AppRoute ? ClientInferRequestBase<T, TClientArgs> : T extends AppRouter ? {
+    [TKey in keyof T]: ClientInferRequest<T[TKey]>;
+} : never;
+export type PartialClientInferRequest<TRoute extends AppRoute, TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {}> = OptionalIfAllOptional<ClientInferRequest<TRoute, TClientArgs>>;
+export {};

package/src/lib/paths.d.ts

@@ -0,0 +1,30 @@
+type ResolveOptionalPathParam<T extends string> = T extends `${infer PathParam}?` ? {
+    [key in PathParam]?: string | undefined;
+} : {
+    [key in T]: string;
+};
+/**
+ * @params T - The URL e.g. /posts/:id
+ * @params TAcc - Accumulator object
+ */
+type RecursivelyExtractPathParams<T extends string> = T extends '' ? Record<never, never> : T extends `${infer Left}/:${infer PathParam}/${infer Right}` ? ResolveOptionalPathParam<PathParam> & RecursivelyExtractPathParams<Left> & RecursivelyExtractPathParams<Right> : T extends `:${infer PathParam}/${infer Right}` ? ResolveOptionalPathParam<PathParam> & RecursivelyExtractPathParams<Right> : T extends `${infer Left}/:${infer PathParam}` ? ResolveOptionalPathParam<PathParam> & RecursivelyExtractPathParams<Left> : T extends `:${infer PathParam}` ? ResolveOptionalPathParam<PathParam> : Record<never, never>;
+/**
+ * Extract path params from path function
+ *
+ * `{ id: string, commentId: string }`
+ *
+ * @params T - The URL e.g. /posts/:id
+ */
+export type ParamsFromUrl<T extends string> = RecursivelyExtractPathParams<T> extends infer U ? {
+    [key in keyof U]: U[key];
+} : never;
+/**
+ * @param path - The URL e.g. /posts/:id
+ * @param params - The params e.g. `{ id: string }`
+ * @returns - The URL with the params e.g. /posts/123
+ */
+export declare const insertParamsIntoPath: <T extends string>({ path, params, }: {
+    path: T;
+    params: ParamsFromUrl<T>;
+}) => string;
+export {};

package/src/lib/query.d.ts

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param query - Any JSON object
+ * @param json - Use JSON.stringify to encode the query values
+ * @returns - The query url segment, using explode array syntax, and deep object syntax
+ */
+export declare const convertQueryParamsToUrlString: (query: unknown, json?: boolean) => string;
+export declare const encodeQueryParamsJson: (query: unknown) => string;
+export declare const encodeQueryParams: (query: unknown) => string;
+/**
+ *
+ * @param query - A server-side query object where values have been encoded as JSON strings
+ * @returns - The same object with the JSON strings decoded. Objects that were encoded using toJSON such as Dates will remain as strings
+ */
+export declare const parseJsonQueryObject: (query: Record<string, string>) => {
+    [k: string]: any;
+};

package/src/lib/response-error.d.ts

@@ -0,0 +1,20 @@
+import { AppRoute, AppRouter, AppRouteResponse } from './dsl';
+import { ResolveResponseType, ServerInferResponses } from './infer-types';
+import { HTTPStatusCode } from './status-codes';
+import { CommonAndEqual, SchemaInputOrType } from './type-utils';
+export declare class TsRestResponseError<T extends AppRoute | AppRouter> extends Error {
+    statusCode: HTTPStatusCode;
+    body: any;
+    constructor(route: T, response: T extends AppRouter ? ServerCommonResponses<T> : ServerInferResponses<T>);
+}
+type FlattenAppRouter<T extends AppRouter | AppRoute> = T extends AppRoute ? T : {
+    [TKey in keyof T]: T[TKey] extends AppRoute ? T[TKey] : T[TKey] extends AppRouter ? FlattenAppRouter<T[TKey]> : never;
+}[keyof T];
+type AppRouterCommonResponses<T extends AppRouter> = CommonAndEqual<FlattenAppRouter<T>['responses']>;
+type ServerCommonResponses<T extends AppRouter, TResponses = AppRouterCommonResponses<T>> = {
+    [K in keyof TResponses]: {
+        status: K;
+        body: TResponses[K] extends AppRouteResponse ? SchemaInputOrType<ResolveResponseType<TResponses[K]>> : never;
+    };
+}[keyof TResponses];
+export {};

package/src/lib/response-validation-error.d.ts

@@ -0,0 +1,14 @@
+import { AppRoute } from './dsl';
+import { StandardSchemaError } from './validation-error';
+export declare class TsRestResponseValidationError extends Error {
+    appRoute: AppRoute;
+    cause: StandardSchemaError;
+    constructor(appRoute: AppRoute, cause: StandardSchemaError);
+}
+export declare class TsRestRequestValidationError extends Error {
+    pathParams: StandardSchemaError | null;
+    headers: StandardSchemaError | null;
+    query: StandardSchemaError | null;
+    body: StandardSchemaError | null;
+    constructor(pathParams: StandardSchemaError | null, headers: StandardSchemaError | null, query: StandardSchemaError | null, body: StandardSchemaError | null);
+}

package/src/lib/server.d.ts

@@ -0,0 +1,18 @@
+import { HTTPStatusCode } from './status-codes';
+import { AppRoute, ContractAnyType, ContractNoBody, ContractNoBodyType, ContractOtherResponse } from './dsl';
+export declare const isAppRouteResponse: (value: unknown) => value is {
+    status: HTTPStatusCode;
+    body?: any;
+};
+export declare const isAppRouteOtherResponse: (response: ContractAnyType | ContractNoBodyType | ContractOtherResponse<ContractAnyType>) => response is ContractOtherResponse<ContractAnyType>;
+export declare const isAppRouteNoBody: (response: ContractAnyType | ContractNoBodyType | ContractOtherResponse<ContractAnyType>) => response is typeof ContractNoBody;
+export declare const validateResponse: ({ appRoute, response, }: {
+    appRoute: AppRoute;
+    response: {
+        status: number;
+        body?: unknown;
+    };
+}) => {
+    status: number;
+    body?: unknown;
+};

package/src/lib/standard-schema-utils.d.ts

@@ -0,0 +1,68 @@
+import { ZodError } from 'zod';
+import { StandardSchemaV1 } from './standard-schema';
+import { StandardSchemaError } from './validation-error';
+import { ContractAnyType } from './dsl';
+/**
+ * Type guard to check if the schema is a standard schema.
+ *
+ * @param schema - unknown
+ * @returns boolean
+ */
+export declare const isStandardSchema: (schema: unknown) => schema is StandardSchemaV1<unknown, unknown>;
+/**
+ * Takes in an unknown object and returns either a standard schema or null
+ *
+ * @param schema - unknown
+ * @returns StandardSchemaV1<unknown, unknown> | null
+ */
+export declare const parseAsStandardSchema: (schema: unknown) => StandardSchemaV1<unknown, unknown> | null;
+/**
+ * Since 3.53.0 we've moved to headers using an object with schemas inside it, rather than a top level schema.
+ *
+ * This makes it easier to merge schemas together.
+ *
+ * @param data - Data to validate e.g. headers
+ * @param schemaObject - Schema object to validate against e.g. { 'x-foo': v.string() }
+ * @returns
+ */
+export declare const validateMultiSchemaObject: (data: unknown, schemaObject: Record<string, ContractAnyType> | undefined) => {
+    value?: unknown;
+    error?: StandardSchemaError | ZodError;
+    schemasUsed: Array<StandardSchemaV1<unknown, unknown>>;
+};
+/**
+ * Combines two standard schemas into a single standard schema.
+ *
+ * The combined schema will run the validation of both schemas and return the result of the first schema that
+ * succeeds.
+ *
+ * If either schema fails, the combined schema will return the issues from both schemas.
+ *
+ * @param a - StandardSchemaV1<unknown, unknown>
+ * @param b - StandardSchemaV1<unknown, unknown>
+ * @returns StandardSchemaV1<unknown, unknown>
+ */
+export declare const combineStandardSchemas: (a: StandardSchemaV1<unknown, unknown>, b: StandardSchemaV1<unknown, unknown>) => StandardSchemaV1<unknown, unknown>;
+/**
+ * Merges two header schemas together, these can either be legacy zod objects or objects containing standard schemas.
+ */
+export declare const mergeHeaderSchemasForRoute: (baseSchema: unknown, routeSchema: unknown) => unknown;
+/**
+ * Similar to validateAgainstStandardSchema, but it takes an unknown schema, it will not validate if no schema provided and will check the schema is
+ * valid before validating the data.
+ *
+ * This is super handy for validating request bodies, headers, etc. as it passes through the data if no schema is provided.
+ */
+export declare const validateIfSchema: (data: unknown, schema: unknown, { passThroughExtraKeys, }?: {
+    passThroughExtraKeys?: boolean | undefined;
+}) => {
+    value?: unknown;
+    error?: StandardSchemaError;
+    schemasUsed: Array<StandardSchemaV1<unknown, unknown>>;
+};
+export declare const validateAgainstStandardSchema: (data: unknown, schema: StandardSchemaV1<unknown, unknown>, { passThroughExtraKeys, }?: {
+    passThroughExtraKeys?: boolean | undefined;
+}) => {
+    value?: unknown;
+    error?: StandardSchemaError | ZodError;
+};