@orpc/openapi 0.0.0-next.f99e554 → 0.0.0-next.fe39bf3

package/dist/src/adapters/fetch/bracket-notation.d.ts

@@ -1,84 +0,0 @@
-/**
- * Serialize an object or array into a list of [key, value] pairs.
- * The key will express by using bracket-notation.
- *
- * Notice: This way cannot express the empty object or array.
- *
- * @example
- * ```ts
- * const payload = {
- *  name: 'John Doe',
- *  pets: ['dog', 'cat'],
- * }
- *
- * const entities = serialize(payload)
- *
- * expect(entities).toEqual([
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- * ])
- * ```
- */
-export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
-/**
- * Deserialize a list of [key, value] pairs into an object or array.
- * The key is expressed by using bracket-notation.
- *
- * @example
- * ```ts
- * const entities = [
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- *  ['name[dogs][]', 'hello'],
- *  ['name[dogs][]', 'kitty'],
- * ]
- *
- * const payload = deserialize(entities)
- *
- * expect(payload).toEqual({
- *  name: 'John Doe',
- *  pets: { 0: 'dog', 1: 'cat' },
- *  dogs: ['hello', 'kitty'],
- * })
- * ```
- */
-export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
-/**
- * Escape the `[`, `]`, and `\` chars in a path segment.
- *
- * @example
- * ```ts
- * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
- * ```
- */
-export declare function escapeSegment(segment: string): string;
-/**
- * Convert an array of path segments into a path string using bracket-notation.
- *
- * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
- *
- * @example
- * ```ts
- * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
- * ```
- */
-export declare function stringifyPath(path: readonly [string, ...string[]]): string;
-/**
- * Convert a path string using bracket-notation into an array of path segments.
- *
- * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
- * It only treats a pair `[${string}]` as a path segment.
- * If missing or escape it will bypass and treat as normal string.
- *
- * @example
- * ```ts
- * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
- * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
- * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
- * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
- * ```
- */
-export declare function parsePath(path: string): [string, ...string[]];
-//# sourceMappingURL=bracket-notation.d.ts.map

package/dist/src/adapters/fetch/input-structure-compact.d.ts

@@ -1,6 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureCompact {
-    build(params: Params, payload: unknown): unknown;
-}
-export type PublicInputStructureCompact = Pick<InputStructureCompact, keyof InputStructureCompact>;
-//# sourceMappingURL=input-structure-compact.d.ts.map

package/dist/src/adapters/fetch/input-structure-detailed.d.ts

@@ -1,11 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureDetailed {
-    build(params: Params, query: unknown, headers: unknown, body: unknown): {
-        params: Params;
-        query: unknown;
-        headers: unknown;
-        body: unknown;
-    };
-}
-export type PublicInputStructureDetailed = Pick<InputStructureDetailed, keyof InputStructureDetailed>;
-//# sourceMappingURL=input-structure-detailed.d.ts.map

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

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from './openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-server.d.ts.map

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

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from './openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-serverless.d.ts.map

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

@@ -1,15 +0,0 @@
-import type { PublicJSONSerializer } from '../../json-serializer';
-export declare class OpenAPIPayloadCodec {
-    private readonly jsonSerializer;
-    constructor(jsonSerializer: PublicJSONSerializer);
-    encode(payload: unknown, accept: string | undefined): {
-        body: FormData | Blob | string | undefined;
-        headers?: Headers;
-    };
-    private encodeAsJSON;
-    private encodeAsFormData;
-    private encodeAsURLSearchParams;
-    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/adapters/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/adapters/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/adapters/node/openapi-handler-server.d.ts

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-server.d.ts.map

package/dist/src/adapters/node/openapi-handler-serverless.d.ts

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-serverless.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -1,5 +0,0 @@
-export declare class JSONSerializer {
-    serialize(payload: unknown): unknown;
-}
-export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
-//# sourceMappingURL=json-serializer.d.ts.map