@orpc/contract 0.0.0-next.fe39bf3 → 0.0.0-next.ff41b3a

package/dist/src/config.d.ts

@@ -1,10 +0,0 @@
-import type { HTTPMethod, InputStructure } from './route';
-export interface ContractConfig {
-    defaultMethod: HTTPMethod;
-    defaultSuccessStatus: number;
-    defaultSuccessDescription: string;
-    defaultInputStructure: InputStructure;
-    defaultOutputStructure: InputStructure;
-}
-export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
-//# sourceMappingURL=config.d.ts.map

package/dist/src/error.d.ts

@@ -1,27 +0,0 @@
-import type { ORPCError, ORPCErrorCode } from '@orpc/client';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Schema, SchemaOutput } from './schema';
-export interface ValidationErrorOptions extends ErrorOptions {
-    message: string;
-    issues: readonly StandardSchemaV1.Issue[];
-}
-export declare class ValidationError extends Error {
-    readonly issues: readonly StandardSchemaV1.Issue[];
-    constructor(options: ValidationErrorOptions);
-}
-export type ErrorMapItem<TDataSchema extends Schema> = {
-    status?: number;
-    message?: string;
-    description?: string;
-    data?: TDataSchema;
-};
-export type ErrorMap = {
-    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
-};
-export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
-export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
-export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
-    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
-}[keyof TErrorMap];
-export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
-//# sourceMappingURL=error.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -1,8 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Schema } from './schema';
-export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
-export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {
-    yields: Schema;
-    returns: Schema;
-};
-//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,15 +0,0 @@
-/** unnoq */
-export * from './builder';
-export * from './builder-variants';
-export * from './config';
-export * from './error';
-export * from './event-iterator';
-export * from './meta';
-export * from './procedure';
-export * from './procedure-client';
-export * from './route';
-export * from './router';
-export * from './router-client';
-export * from './schema';
-export { ORPCError } from '@orpc/client';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/meta.d.ts

@@ -1,3 +0,0 @@
-export type Meta = Record<string, any>;
-export declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
-//# sourceMappingURL=meta.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,5 +0,0 @@
-import type { Client, ClientContext } from '@orpc/client';
-import type { ErrorFromErrorMap, ErrorMap } from './error';
-import type { Schema, SchemaInput, SchemaOutput } from './schema';
-export type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-//# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,18 +0,0 @@
-import type { ErrorMap } from './error';
-import type { Meta } from './meta';
-import type { Route } from './route';
-import type { Schema } from './schema';
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    meta: TMeta;
-    route: Route;
-    inputSchema: TInputSchema;
-    outputSchema: TOutputSchema;
-    errorMap: TErrorMap;
-}
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
-}
-export type AnyContractProcedure = ContractProcedure<any, any, any, any>;
-export declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -1,79 +0,0 @@
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type InputStructure = 'compact' | 'detailed';
-export type OutputStructure = 'compact' | 'detailed';
-export interface Route {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    /**
-     * The status code of the response when the procedure is successful.
-     *
-     * @default 200
-     */
-    successStatus?: number;
-    /**
-     * The description of the response when the procedure is successful.
-     *
-     * @default 'OK'
-     */
-    successDescription?: string;
-    /**
-     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
-     *
-     * @option 'compact'
-     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
-     *
-     * @option 'detailed'
-     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
-     *
-     * Example:
-     * ```ts
-     * const input = {
-     *   params: { id: 1 },
-     *   query: { search: 'hello' },
-     *   headers: { 'Content-Type': 'application/json' },
-     *   body: { name: 'John' },
-     * }
-     * ```
-     *
-     * @default 'compact'
-     */
-    inputStructure?: InputStructure;
-    /**
-     * Determines how the response should be structured based on the output.
-     *
-     * @option 'compact'
-     * Includes only the body data, encoded directly in the response.
-     *
-     * @option 'detailed'
-     * Separates the output into `headers` and `body` fields.
-     * - `headers`: Custom headers to merge with the response headers.
-     * - `body`: The response data.
-     *
-     * Example:
-     * ```ts
-     * const output = {
-     *   headers: { 'x-custom-header': 'value' },
-     *   body: { message: 'Hello, world!' },
-     * };
-     * ```
-     *
-     * @default 'compact'
-     */
-    outputStructure?: OutputStructure;
-}
-export declare function mergeRoute(a: Route, b: Route): Route;
-export declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
-export declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
-export declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
-export declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
-export interface AdaptRouteOptions {
-    prefix?: HTTPPath;
-    tags?: readonly string[];
-}
-export declare function adaptRoute(route: Route, options: AdaptRouteOptions): Route;
-//# sourceMappingURL=route.d.ts.map

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

@@ -1,8 +0,0 @@
-import type { ClientContext } from '@orpc/client';
-import type { ContractProcedure } from './procedure';
-import type { ContractProcedureClient } from './procedure-client';
-import type { AnyContractRouter } from './router';
-export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
-};
-//# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,29 +0,0 @@
-import type { Meta } from './meta';
-import type { SchemaInput, SchemaOutput } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error';
-import { ContractProcedure } from './procedure';
-import { type HTTPPath } from './route';
-export type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
-    [k: string]: ContractRouter<TMeta>;
-};
-export type AnyContractRouter = ContractRouter<any>;
-export type AdaptedContractRouter<TContract extends AnyContractRouter, TErrorMap extends ErrorMap> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : TContract[K] extends AnyContractRouter ? AdaptedContractRouter<TContract[K], TErrorMap> : never;
-};
-export interface AdaptContractRouterOptions<TErrorMap extends ErrorMap> {
-    errorMap: TErrorMap;
-    prefix?: HTTPPath;
-    tags?: readonly string[];
-}
-export declare function adaptContractRouter<TRouter extends ContractRouter<any>, TErrorMap extends ErrorMap>(contract: TRouter, options: AdaptContractRouterOptions<TErrorMap>): AdaptedContractRouter<TRouter, TErrorMap>;
-export type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
-};
-export type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
-};
-export type ContractRouterToErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? ContractRouterToErrorMap<T[K]> : never;
-}[keyof T];
-export type ContractRouterToMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
-//# sourceMappingURL=router.d.ts.map

package/dist/src/schema.d.ts

@@ -1,8 +0,0 @@
-import type { IsEqual, Promisable } from '@orpc/shared';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type Schema = StandardSchemaV1 | undefined;
-export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
-export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
-export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
-export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
-//# sourceMappingURL=schema.d.ts.map