@orpc/openapi 0.0.0-next.f56d2b3 → 0.0.0-next.f81b4a2

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/index.d.ts

@@ -1,10 +0,0 @@
-export * from './bracket-notation';
-export * from './input-structure-compact';
-export * from './input-structure-detailed';
-export * from './openapi-handler';
-export * from './openapi-handler-server';
-export * from './openapi-handler-serverless';
-export * from './openapi-payload-codec';
-export * from './openapi-procedure-matcher';
-export * from './schema-coercer';
-//# sourceMappingURL=index.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-handler.d.ts

@@ -1,32 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
-import type { PublicInputStructureCompact } from './input-structure-compact';
-import { type Hooks } from '@orpc/shared';
-import { type PublicJSONSerializer } from '../../json-serializer';
-import { type PublicInputStructureDetailed } from './input-structure-detailed';
-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, FetchHandleResult, T, any> & {
-    jsonSerializer?: PublicJSONSerializer;
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputStructureCompact;
-    inputBuilderFull?: PublicInputStructureDetailed;
-    schemaCoercers?: SchemaCoercer[];
-};
-export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputStructureCompact;
-    private readonly inputStructureDetailed;
-    private readonly compositeSchemaCoercer;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
-    private decodeInput;
-    private encodeOutput;
-    private assertDetailedOutput;
-    private convertToORPCError;
-}
-//# sourceMappingURL=openapi-handler.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 { AnyProcedure, AnyRouter } from '@orpc/server';
-import type { Router as BaseHono, Params } from 'hono/router';
-export type Hono = BaseHono<[string, string[]]>;
-export declare class OpenAPIProcedureMatcher {
-    private readonly hono;
-    private readonly router;
-    private pendingRouters;
-    constructor(hono: Hono, router: AnyRouter);
-    match(method: string, pathname: string): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-        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/hono/index.d.ts

@@ -1,2 +0,0 @@
-export * from '../fetch';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -1,2 +0,0 @@
-export * from '../fetch';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +0,0 @@
-export * from './openapi-handler';
-export * from './openapi-handler-server';
-export * from './openapi-handler-serverless';
-export * from './types';
-//# sourceMappingURL=index.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/openapi-handler.d.ts

@@ -1,11 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
-import type { Hono } from '../fetch/openapi-procedure-matcher';
-import { type RequestHandler, type RequestHandleRest, type RequestHandleResult } from '@orpc/server/node';
-export declare class OpenAPIHandler<T extends Context> implements RequestHandler<T> {
-    private readonly openapiFetchHandler;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
-}
-//# sourceMappingURL=openapi-handler.d.ts.map

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

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

package/dist/src/index.d.ts

@@ -1,12 +0,0 @@
-/** unnoq */
-export * from './json-serializer';
-export * from './openapi';
-export * from './openapi-content-builder';
-export * from './openapi-generator';
-export * from './openapi-parameters-builder';
-export * from './openapi-path-parser';
-export * from './schema';
-export * from './schema-converter';
-export * from './schema-utils';
-export * from './utils';
-//# sourceMappingURL=index.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

package/dist/src/openapi-content-builder.d.ts

@@ -1,10 +0,0 @@
-import type { OpenAPI } from './openapi';
-import type { JSONSchema } from './schema';
-import type { PublicSchemaUtils } from './schema-utils';
-export declare class OpenAPIContentBuilder {
-    private readonly schemaUtils;
-    constructor(schemaUtils: PublicSchemaUtils);
-    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
-}
-export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
-//# sourceMappingURL=openapi-content-builder.d.ts.map

package/dist/src/openapi-error.d.ts

@@ -1,3 +0,0 @@
-export declare class OpenAPIError extends Error {
-}
-//# sourceMappingURL=openapi-error.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -1,67 +0,0 @@
-import type { AnyRouter } from '@orpc/server';
-import type { PublicOpenAPIInputStructureParser } from './openapi-input-structure-parser';
-import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
-import type { PublicOpenAPIPathParser } from './openapi-path-parser';
-import type { SchemaConverter } from './schema-converter';
-import { type ContractRouter } from '@orpc/contract';
-import { type PublicJSONSerializer } from './json-serializer';
-import { type OpenAPI } from './openapi';
-import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
-import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
-import { type PublicSchemaUtils } from './schema-utils';
-type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
-export interface OpenAPIGeneratorOptions {
-    contentBuilder?: PublicOpenAPIContentBuilder;
-    parametersBuilder?: PublicOpenAPIParametersBuilder;
-    schemaConverters?: SchemaConverter[];
-    schemaUtils?: PublicSchemaUtils;
-    jsonSerializer?: PublicJSONSerializer;
-    pathParser?: PublicOpenAPIPathParser;
-    inputStructureParser?: PublicOpenAPIInputStructureParser;
-    outputStructureParser?: PublicOpenAPIOutputStructureParser;
-    /**
-     * 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
-     */
-    considerMissingTagDefinitionAsError?: boolean;
-    /**
-     * Weather ignore procedures that has no path defined.
-     *
-     * @default false
-     */
-    ignoreUndefinedPathProcedures?: boolean;
-    /**
-     * What to do when we found an error with our router
-     *
-     * @default 'throw'
-     */
-    errorHandlerStrategy?: ErrorHandlerStrategy;
-    /**
-     * Strict error response
-     *
-     * @default true
-     */
-    strictErrorResponses?: boolean;
-}
-export declare class OpenAPIGenerator {
-    private readonly contentBuilder;
-    private readonly parametersBuilder;
-    private readonly schemaConverter;
-    private readonly schemaUtils;
-    private readonly jsonSerializer;
-    private readonly pathParser;
-    private readonly inputStructureParser;
-    private readonly outputStructureParser;
-    private readonly errorHandlerStrategy;
-    private readonly ignoreUndefinedPathProcedures;
-    private readonly considerMissingTagDefinitionAsError;
-    private readonly strictErrorResponses;
-    constructor(options?: OpenAPIGeneratorOptions);
-    generate(router: ContractRouter<any> | AnyRouter, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
-}
-export {};
-//# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-input-structure-parser.d.ts

@@ -1,22 +0,0 @@
-import type { AnyContractProcedure } from '@orpc/contract';
-import type { PublicOpenAPIPathParser } from './openapi-path-parser';
-import type { JSONSchema, ObjectSchema } from './schema';
-import type { SchemaConverter } from './schema-converter';
-import type { PublicSchemaUtils } from './schema-utils';
-export interface OpenAPIInputStructureParseResult {
-    paramsSchema: ObjectSchema | undefined;
-    querySchema: ObjectSchema | undefined;
-    headersSchema: ObjectSchema | undefined;
-    bodySchema: JSONSchema.JSONSchema | undefined;
-}
-export declare class OpenAPIInputStructureParser {
-    private readonly schemaConverter;
-    private readonly schemaUtils;
-    private readonly pathParser;
-    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
-    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
-    private parseDetailedSchema;
-    private parseCompactSchema;
-}
-export type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
-//# sourceMappingURL=openapi-input-structure-parser.d.ts.map

package/dist/src/openapi-output-structure-parser.d.ts

@@ -1,18 +0,0 @@
-import type { AnyContractProcedure } from '@orpc/contract';
-import type { JSONSchema, ObjectSchema } from './schema';
-import type { SchemaConverter } from './schema-converter';
-import type { PublicSchemaUtils } from './schema-utils';
-export interface OpenAPIOutputStructureParseResult {
-    headersSchema: ObjectSchema | undefined;
-    bodySchema: JSONSchema.JSONSchema | undefined;
-}
-export declare class OpenAPIOutputStructureParser {
-    private readonly schemaConverter;
-    private readonly schemaUtils;
-    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
-    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
-    private parseDetailedSchema;
-    private parseCompactSchema;
-}
-export type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
-//# sourceMappingURL=openapi-output-structure-parser.d.ts.map

package/dist/src/openapi-parameters-builder.d.ts

@@ -1,12 +0,0 @@
-import type { OpenAPI } from './openapi';
-import type { JSONSchema } from './schema';
-export declare class OpenAPIParametersBuilder {
-    build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
-        type: 'object';
-    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
-    buildHeadersObject(jsonSchema: JSONSchema.JSONSchema & {
-        type: 'object';
-    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.HeadersObject;
-}
-export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
-//# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/dist/src/openapi-path-parser.d.ts

@@ -1,8 +0,0 @@
-export declare class OpenAPIPathParser {
-    parseDynamicParams(path: string): {
-        name: string;
-        raw: string;
-    }[];
-}
-export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
-//# sourceMappingURL=openapi-path-parser.d.ts.map

package/dist/src/openapi.d.ts

@@ -1,3 +0,0 @@
-export { OpenApiBuilder } from 'openapi3-ts/oas31';
-export type * as OpenAPI from 'openapi3-ts/oas31';
-//# sourceMappingURL=openapi.d.ts.map

package/dist/src/schema-converter.d.ts

@@ -1,16 +0,0 @@
-import type { Schema } from '@orpc/contract';
-import type { JSONSchema } from './schema';
-export interface SchemaConvertOptions {
-    strategy: 'input' | 'output';
-}
-export interface SchemaConverter {
-    condition(schema: Schema, options: SchemaConvertOptions): boolean;
-    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
-}
-export declare class CompositeSchemaConverter implements SchemaConverter {
-    private readonly converters;
-    constructor(converters: SchemaConverter[]);
-    condition(): boolean;
-    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
-}
-//# sourceMappingURL=schema-converter.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -1,11 +0,0 @@
-import { type FileSchema, type JSONSchema, type ObjectSchema } from './schema';
-export declare class SchemaUtils {
-    isFileSchema(schema: JSONSchema.JSONSchema): schema is FileSchema;
-    isObjectSchema(schema: JSONSchema.JSONSchema): schema is ObjectSchema;
-    isAnySchema(schema: JSONSchema.JSONSchema): boolean;
-    isUndefinableSchema(schema: JSONSchema.JSONSchema): boolean;
-    separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
-    filterSchemaBranches(schema: JSONSchema.JSONSchema, check: (schema: JSONSchema.JSONSchema) => boolean, matches?: JSONSchema.JSONSchema[]): [matches: JSONSchema.JSONSchema[], rest: JSONSchema.JSONSchema | undefined];
-}
-export type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
-//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema.d.ts

@@ -1,12 +0,0 @@
-import * as JSONSchema from 'json-schema-typed/draft-2020-12';
-export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
-export { JSONSchema };
-export type ObjectSchema = JSONSchema.JSONSchema & {
-    type: 'object';
-} & object;
-export type FileSchema = JSONSchema.JSONSchema & {
-    type: 'string';
-    contentMediaType: string;
-} & object;
-export declare const NON_LOGIC_KEYWORDS: string[];
-//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -1,18 +0,0 @@
-import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
-import type { AnyProcedure, AnyRouter, Lazy } from '@orpc/server';
-export interface EachLeafOptions {
-    router: AnyContractRouter | AnyRouter;
-    path: string[];
-}
-export interface EachLeafCallbackOptions {
-    contract: AnyContractProcedure;
-    path: string[];
-}
-export interface EachContractLeafResultItem {
-    router: Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter> | AnyProcedure>;
-    path: string[];
-}
-export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
-export declare function forEachAllContractProcedure(router: AnyContractRouter | AnyRouter, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
-export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
-//# sourceMappingURL=utils.d.ts.map