@orpc/openapi 0.0.0-next.93e7a4c → 0.0.0-next.9723092

package/dist/src/fetch/openapi-handler.d.ts

@@ -1,28 +0,0 @@
-import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
-import type { PublicInputBuilderSimple } from './input-builder-simple';
-import { type Context, type Router, type WithSignal } from '@orpc/server';
-import { type Hooks } from '@orpc/shared';
-import { type PublicInputBuilderFull } from './input-builder-full';
-import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
-import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
-import { type SchemaCoercer } from './schema-coercer';
-export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputBuilderSimple;
-    inputBuilderFull?: PublicInputBuilderFull;
-    schemaCoercers?: SchemaCoercer[];
-};
-export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputBuilderSimple;
-    private readonly inputBuilderFull;
-    private readonly compositeSchemaCoercer;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    condition(request: Request): boolean;
-    fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
-    private convertToORPCError;
-}
-//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -1,13 +0,0 @@
-export declare class OpenAPIPayloadCodec {
-    encode(payload: unknown, accept?: string): {
-        body: FormData | Blob | string | undefined;
-        headers?: Headers;
-    };
-    private encodeAsJSON;
-    private encodeAsFormData;
-    private encodeAsURLSearchParams;
-    serialize(payload: unknown): unknown;
-    decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
-}
-export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;
-//# sourceMappingURL=openapi-payload-codec.d.ts.map

package/dist/src/fetch/openapi-procedure-matcher.d.ts

@@ -1,19 +0,0 @@
-import type { Router as BaseHono, Params } from 'hono/router';
-import { type ANY_PROCEDURE, type ANY_ROUTER } from '@orpc/server';
-export type Hono = BaseHono<[string, string[]]>;
-export declare class OpenAPIProcedureMatcher {
-    private readonly hono;
-    private readonly router;
-    private pendingRouters;
-    constructor(hono: Hono, router: ANY_ROUTER);
-    match(method: string, pathname: string): Promise<{
-        path: string[];
-        procedure: ANY_PROCEDURE;
-        params: Params;
-    } | undefined>;
-    private add;
-    private handlePendingRouters;
-    private convertOpenAPIPathToRouterPath;
-}
-export type PublicOpenAPIProcedureMatcher = Pick<OpenAPIProcedureMatcher, keyof OpenAPIProcedureMatcher>;
-//# sourceMappingURL=openapi-procedure-matcher.d.ts.map

package/dist/src/fetch/schema-coercer.d.ts

@@ -1,10 +0,0 @@
-import type { Schema } from '@orpc/contract';
-export interface SchemaCoercer {
-    coerce: (schema: Schema, value: unknown) => unknown;
-}
-export declare class CompositeSchemaCoercer implements SchemaCoercer {
-    private readonly coercers;
-    constructor(coercers: SchemaCoercer[]);
-    coerce(schema: Schema, value: unknown): unknown;
-}
-//# sourceMappingURL=schema-coercer.d.ts.map

package/dist/src/generator.d.ts

@@ -1,26 +0,0 @@
-import type { PublicOpenAPIPayloadCodec } from './fetch';
-import { type ContractRouter } from '@orpc/contract';
-import { type ANY_ROUTER } from '@orpc/server';
-import { type OpenAPIObject } from 'openapi3-ts/oas31';
-export interface GenerateOpenAPIOptions {
-    /**
-     * Throw error when you missing define tag definition on OpenAPI root tags
-     *
-     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
-     * Because OpenAPI root tags is missing 'bar' tag
-     *
-     * @default false
-     */
-    throwOnMissingTagDefinition?: boolean;
-    /**
-     * Weather ignore procedures that has no path defined.
-     *
-     * @default false
-     */
-    ignoreUndefinedPathProcedures?: boolean;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-}
-export declare function generateOpenAPI(opts: {
-    router: ContractRouter | ANY_ROUTER;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
-//# sourceMappingURL=generator.d.ts.map

package/dist/src/zod-to-json-schema.d.ts

@@ -1,43 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
-export declare const UNSUPPORTED_JSON_SCHEMA: {
-    not: {};
-};
-export declare const UNDEFINED_JSON_SCHEMA: {
-    const: string;
-};
-export interface ZodToJsonSchemaOptions {
-    /**
-     * Max depth of lazy type, if it exceeds.
-     *
-     * Used `{}` when reach max depth
-     *
-     * @default 5
-     */
-    maxLazyDepth?: number;
-    /**
-     * The length used to track the depth of lazy type
-     *
-     * @internal
-     */
-    lazyDepth?: number;
-    /**
-     * The expected json schema for input or output zod schema
-     *
-     * @default input
-     */
-    mode?: 'input' | 'output';
-    /**
-     * Track if current level schema is handled custom json schema to prevent recursive
-     *
-     * @internal
-     */
-    isHandledCustomJSONSchema?: boolean;
-}
-export declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
-export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
-    schema: JSONSchema | undefined;
-    matches: JSONSchema[];
-};
-//# sourceMappingURL=zod-to-json-schema.d.ts.map