@temporary-name/server 1.9.3-alpha.021f5c8fe9793dff332b025dce560e804c45a7b1

package/dist/index.d.ts

@@ -0,0 +1,1324 @@
+import { AnySchema, ErrorMap, Meta, MergedErrorMap, Route, InferSchemaOutput, InferSchemaInput, EnhanceRouteOptions, AnyContractRouter, AnyContractProcedure, ContractProcedure, Schema, ContractRouter, ContractProcedureDef, InferContractRouterErrorMap, InferContractRouterMeta, ErrorFromErrorMap } from '@temporary-name/contract';
+export { ContractProcedure, ContractProcedureDef, ContractRouter, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InputStructure, MergedErrorMap, Meta, OutputStructure, Route, Schema, ValidationError, eventIterator, type, validateORPCError } from '@temporary-name/contract';
+import { IntersectPick, ClientContext, MaybeOptionalOptions, HTTPPath, ClientOptions, ClientPromiseResult } from '@temporary-name/shared';
+export { AsyncIteratorClass, ClientContext, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, HTTPMethod, HTTPPath, IntersectPick, ORPCError, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, safe, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import { C as Context, P as Procedure, M as Middleware, O as ORPCErrorConstructorMap, a as MergedInitialContext, b as MergedCurrentContext, c as MapInputMiddleware, d as CreateProcedureClientOptions, e as ProcedureClient, A as AnyMiddleware, L as Lazyable, f as AnyRouter, g as Lazy, h as AnyProcedure, i as ProcedureHandler, R as Router, I as InferRouterInitialContext } from './shared/server.BKSOrA6h.js';
+export { H as InferRouterCurrentContexts, G as InferRouterInitialContexts, J as InferRouterInputs, K as InferRouterOutputs, n as LAZY_SYMBOL, o as LazyMeta, v as MiddlewareNextFn, t as MiddlewareNextFnOptions, x as MiddlewareOptions, w as MiddlewareOutputFn, s as MiddlewareResult, k as ORPCErrorConstructorMapItem, j as ORPCErrorConstructorMapItemOptions, E as ProcedureClientInterceptorOptions, B as ProcedureDef, z as ProcedureHandlerOptions, l as createORPCErrorConstructorMap, F as createProcedureClient, r as getLazyMeta, q as isLazy, D as isProcedure, p as lazy, m as mergeCurrentContext, y as middlewareOutputFn, u as unlazy } from './shared/server.BKSOrA6h.js';
+import * as core from 'zod/v4/core';
+import { $ZodError, util } from 'zod/v4/core';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
+
+declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    /**
+     * Adds type-safe custom errors.
+     * The provided errors are spared-merged with any existing errors.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+     */
+    errors<U extends ErrorMap>(errors: U): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    /**
+     * Sets or updates the metadata.
+     * The provided metadata is spared-merged with any existing metadata.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
+     */
+    meta(meta: TMeta): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Sets or updates the route definition.
+     * The provided route is spared-merged with any existing route.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+     * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     */
+    route(route: Route): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): DecoratedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInput, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, UInput, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<InferSchemaOutput<TInputSchema>, UInput>): DecoratedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Make this procedure callable (works like a function while still being a procedure).
+     *
+     * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+     */
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+}
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    constructor(def: BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>);
+    /**
+     * Adds type-safe custom errors to the contract.
+     * The provided errors are spared-merged with any existing errors in the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+     */
+    errors<U extends ErrorMap>(errors: U): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta, TGateName>;
+    /**
+     * Sets or updates the metadata for the contract.
+     * The provided metadata is spared-merged with any existing metadata in the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
+     */
+    meta(meta: TMeta): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Sets or updates the route definition for the contract.
+     * The provided route is spared-merged with any existing route in the contract.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+     * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     */
+    route(route: Route): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Defines the input validation schema.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Input Validation Docs}
+     */
+    input<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, USchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Defines the output validation schema.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
+     */
+    output<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, USchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ProcedureBuilder<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    useGating<const TInferredGateName extends string>(gates: TInferredGateName[], isGateEnabled: (gate: TInferredGateName, ctx: TCurrentContext) => boolean): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, Context, TCurrentContext>, MergedCurrentContext<TCurrentContext, {
+        isGateEnabled: typeof isGateEnabled;
+    }>, TInputSchema, TOutputSchema, TErrorMap, TMeta, TInferredGateName>;
+    /**
+     * Defines the handler of the procedure.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+     */
+    handler<UFuncOutput>(handler: ProcedureHandler<TCurrentContext, InferSchemaOutput<TInputSchema>, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, Schema<UFuncOutput, UFuncOutput>, TErrorMap, TMeta>;
+}
+declare class BuilderWithMiddlewares<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName> {
+    /**
+     * Prefixes all procedures in the router.
+     * The provided prefix is post-appended to any existing router prefix.
+     *
+     * @note This option does not affect procedures that do not define a path in their route definition.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+     */
+    prefix(prefix: HTTPPath): BuilderWithMiddlewares<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Adds tags to all procedures in the router.
+     * This helpful when you want to group procedures together in the OpenAPI specification.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    tag(...tags: string[]): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    /**
+     * Applies all of the previously defined options to the specified router.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    router<U extends Router<ContractRouter<TMeta>, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>;
+    /**
+     * Create a lazy router
+     * And applies all of the previously defined options to the specified router.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    lazyRoute<U extends Router<ContractRouter<TMeta>, TCurrentContext>>(loader: () => Promise<{
+        default: U;
+    }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, TErrorMap>;
+}
+interface RouterBuilder<TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> extends Pick<BuilderWithMiddlewares<TInitialContext, TCurrentContext, any, any, TErrorMap, TMeta, any>, 'prefix' | 'tag' | 'router' | 'lazyRoute'> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': EnhanceRouterOptions<TErrorMap>;
+}
+
+interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta> {
+    /**
+     * Change the expected input type by providing a map function.
+     */
+    mapInput<UInput>(map: MapInputMiddleware<UInput, TInput>): DecoratedMiddleware<TInContext, TOutContext, UInput, TOutput, TErrorConstructorMap, TMeta>;
+    /**
+     * Concatenates two middlewares.
+     *
+     * @info Pass second argument to map the input.
+     * @see {@link https://orpc.unnoq.com/docs/middleware#concatenation Middleware Concatenation Docs}
+     */
+    concat<UOutContext extends IntersectPick<MergedCurrentContext<TInContext, TOutContext>, UOutContext>, UInput extends TInput, UInContext extends Context = MergedCurrentContext<TInContext, TOutContext>>(middleware: Middleware<UInContext | MergedCurrentContext<TInContext, TOutContext>, UOutContext, UInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<MergedInitialContext<TInContext, UInContext, MergedCurrentContext<TInContext, TOutContext>>, MergedCurrentContext<TOutContext, UOutContext>, UInput, TOutput, TErrorConstructorMap, TMeta>;
+    /**
+     * Concatenates two middlewares.
+     *
+     * @info Pass second argument to map the input.
+     * @see {@link https://orpc.unnoq.com/docs/middleware#concatenation Middleware Concatenation Docs}
+     */
+    concat<UOutContext extends IntersectPick<MergedCurrentContext<TInContext, TOutContext>, UOutContext>, UInput extends TInput, UMappedInput, UInContext extends Context = MergedCurrentContext<TInContext, TOutContext>>(middleware: Middleware<UInContext | MergedCurrentContext<TInContext, TOutContext>, UOutContext, UMappedInput, TOutput, TErrorConstructorMap, TMeta>, mapInput: MapInputMiddleware<UInput, UMappedInput>): DecoratedMiddleware<MergedInitialContext<TInContext, UInContext, MergedCurrentContext<TInContext, TOutContext>>, MergedCurrentContext<TOutContext, UOutContext>, UInput, TOutput, TErrorConstructorMap, TMeta>;
+}
+declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta>;
+
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    format(): core.$ZodFormattedError<T>;
+    format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    flatten(): core.$ZodFlattenedError<T>;
+    flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssue(issue: core.$ZodIssue): void;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssues(issues: core.$ZodIssue[]): void;
+    /** @deprecated Check `err.issues.length === 0` instead. */
+    isEmpty: boolean;
+}
+declare const ZodError: core.$constructor<ZodError>;
+
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+type ZodSafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: ZodError<T>;
+};
+
+type IsGateEnabled = (gate: string) => boolean;
+declare const gatingContext: AsyncLocalStorage<IsGateEnabled>;
+declare function isGateIssueRaw(issue: core.$ZodRawIssue): boolean;
+declare function isGateIssue(issue: core.$ZodIssue): boolean;
+interface $ZodGateDef<T extends core.SomeType = core.$ZodType> extends core.$ZodOptionalDef<T> {
+    gateName: string;
+}
+interface $ZodGateInternals<T extends core.SomeType = core.$ZodType> extends core.$ZodOptionalInternals<T> {
+    def: $ZodGateDef<T>;
+}
+interface $ZodGate<T extends core.SomeType = core.$ZodType> extends core.$ZodType {
+    _zod: $ZodGateInternals<T>;
+}
+declare const $ZodGate: core.$constructor<$ZodGate>;
+interface ZodGate<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<$ZodGateInternals<T>, K>, $ZodGate<T> {
+    unwrap(): T;
+}
+declare const ZodGate: core.$constructor<ZodGate>;
+declare function gate<T extends core.SomeType, K extends KrustyInternals>(innerType: T, gateName: K['gateNames']): ZodGate<T, K>;
+
+type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
+};
+interface ZodObject<
+/** @ts-expect-error Cast variance */
+out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodObjectInternals<Shape, Config>, K>, core.$ZodObject<Shape, Config> {
+    shape: Shape;
+    keyof(): ZodEnum<util.ToEnum<keyof Shape & string>, K>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+    catchall<T extends core.SomeType>(schema: T): ZodObject<Shape, core.$catchall<T>, K>;
+    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+    passthrough(): ZodObject<Shape, core.$loose, K>;
+    /** Consider `z.looseObject(A.shape)` instead */
+    loose(): ZodObject<Shape, core.$loose, K>;
+    /** Consider `z.strictObject(A.shape)` instead */
+    strict(): ZodObject<Shape, core.$strict, K>;
+    /** This is the default behavior. This method call is likely unnecessary. */
+    strip(): ZodObject<Shape, core.$strip, K>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config, K>;
+    safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodObject<util.Extend<Shape, U>, Config, K>;
+    /**
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+     */
+    merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U['shape']>, U['_zod']['config'], K>;
+    pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config, K>;
+    omit<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config, K>;
+    partial(): ZodObject<{
+        [k in keyof Shape]: ZodOptional<Shape[k], K>;
+    }, Config, K>;
+    partial<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k], K> : Shape[k];
+    }, Config, K>;
+    required(): ZodObject<{
+        [k in keyof Shape]: ZodNonOptional<Shape[k], K>;
+    }, Config, K>;
+    required<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k], K> : Shape[k];
+    }, Config, K>;
+}
+declare const ZodObject: core.$constructor<ZodObject>;
+declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>, K extends KrustyInternals = KrustyInternals>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T>, core.$strip, K>;
+declare function strictObject<T extends core.$ZodLooseShape, K extends KrustyInternals>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict, K>;
+declare function looseObject<T extends core.$ZodLooseShape, K extends KrustyInternals>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose, K>;
+
+interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[], K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUnionInternals<T>, K>, core.$ZodUnion<T> {
+    options: T;
+}
+declare const ZodUnion: core.$constructor<ZodUnion>;
+declare function union<const T extends readonly core.SomeType[], K extends KrustyInternals>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T, K>;
+interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string, K extends KrustyInternals = KrustyInternals> extends ZodUnion<Options, K>, core.$ZodDiscriminatedUnion<Options, Disc> {
+    _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
+    def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
+}
+declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
+declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string, K extends KrustyInternals = KrustyInternals>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc, K>;
+
+interface KrustyInternals<GateNames extends string = string> {
+    gateNames: GateNames;
+}
+interface _KrustyType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals, out KInternals extends KrustyInternals = KrustyInternals> extends KrustyType<any, any, Internals, KInternals> {
+}
+interface KrustyType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>, KInternals extends KrustyInternals = KrustyInternals> extends core.$ZodType<Output, Input, Internals> {
+    def: Internals['def'];
+    type: Internals['def']['type'];
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
+    clone(def?: Internals['def'], params?: {
+        parent: boolean;
+    }): this;
+    register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R['_schema'] ? undefined extends R['_meta'] ? [
+        core.$replace<R['_meta'], this>?
+    ] : [core.$replace<R['_meta'], this>] : ['Incompatible schema']): this;
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T>;
+    parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
+    safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
+    parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
+    safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
+    spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<this>>>;
+    encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
+    decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
+    encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
+    decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
+    safeEncode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.input<this>>;
+    safeDecode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
+    safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.input<this>>>;
+    safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
+    refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
+    superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>): this;
+    overwrite(fn: (x: core.output<this>) => core.output<this>): this;
+    gate(gateName: KInternals['gateNames']): ZodGate<this, KInternals>;
+    optional(): ZodOptional<this, KInternals>;
+    nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this, KInternals>;
+    nullable(): ZodNullable<this, KInternals>;
+    nullish(): ZodOptional<ZodNullable<this, KInternals>, KInternals>;
+    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this, KInternals>;
+    default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this, KInternals>;
+    prefault(def: () => core.input<this>): ZodPrefault<this, KInternals>;
+    prefault(def: core.input<this>): ZodPrefault<this, KInternals>;
+    array(): ZodArray<this, KInternals>;
+    or<T extends core.SomeType>(option: T): ZodUnion<[this, T], KInternals>;
+    and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T, KInternals>;
+    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>, KInternals>;
+    catch(def: core.output<this>): ZodCatch<this, KInternals>;
+    catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this, KInternals>;
+    pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.output<this>>): ZodPipe<this, T, KInternals>;
+    readonly(): ZodReadonly<this, KInternals>;
+    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+    describe(description: string): this;
+    description?: string;
+    /** Returns the metadata associated with this instance in `z.globalRegistry` */
+    meta(): core.$replace<core.GlobalMeta, this> | undefined;
+    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+    meta(data: core.$replace<core.GlobalMeta, this>): this;
+}
+declare const KrustyType: core.$constructor<KrustyType>;
+interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
+    includes(value: string, params?: core.$ZodCheckIncludesParams): this;
+    startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;
+    uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD' | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+}
+/** @internal */
+declare const _ZodString: core.$constructor<_ZodString>;
+interface ZodString<K extends KrustyInternals = KrustyInternals> extends _ZodString<core.$ZodStringInternals<string>, K> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | core.$ZodCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | core.$ZodCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | core.$ZodCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | core.$ZodCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | core.$ZodCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.cuid()` instead. */
+    cuid(params?: string | core.$ZodCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | core.$ZodCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | core.$ZodCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | core.$ZodCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | core.$ZodCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | core.$ZodCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | core.$ZodCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | core.$ZodCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | core.$ZodCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | core.$ZodCheckE164Params): this;
+    /** @deprecated Use `z.iso.datetime()` instead. */
+    datetime(params?: string | core.$ZodCheckISODateTimeParams): this;
+    /** @deprecated Use `z.iso.date()` instead. */
+    date(params?: string | core.$ZodCheckISODateParams): this;
+    /** @deprecated Use `z.iso.time()` instead. */
+    time(params?: string | core.$ZodCheckISOTimeParams): this;
+    /** @deprecated Use `z.iso.duration()` instead. */
+    duration(params?: string | core.$ZodCheckISODurationParams): this;
+}
+declare const ZodString: core.$constructor<ZodString>;
+declare function string(params?: string | core.$ZodStringParams): ZodString;
+declare function string<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;
+interface ZodStringFormat<Format extends string = string, K extends KrustyInternals = KrustyInternals> extends _ZodString<core.$ZodStringFormatInternals<Format>, K> {
+}
+declare const ZodStringFormat: core.$constructor<ZodStringFormat>;
+interface ZodEmail<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'email', K> {
+    _zod: core.$ZodEmailInternals;
+}
+declare const ZodEmail: core.$constructor<ZodEmail>;
+declare function email(params?: string | core.$ZodEmailParams): ZodEmail;
+interface ZodGUID<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'guid', K> {
+    _zod: core.$ZodGUIDInternals;
+}
+declare const ZodGUID: core.$constructor<ZodGUID>;
+declare function guid(params?: string | core.$ZodGUIDParams): ZodGUID;
+interface ZodUUID<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'uuid', K> {
+    _zod: core.$ZodUUIDInternals;
+}
+declare const ZodUUID: core.$constructor<ZodUUID>;
+declare function uuid(params?: string | core.$ZodUUIDParams): ZodUUID;
+declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID;
+declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID;
+declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID;
+interface ZodURL extends ZodStringFormat<'url'> {
+    _zod: core.$ZodURLInternals;
+}
+declare const ZodURL: core.$constructor<ZodURL>;
+declare function url(params?: string | core.$ZodURLParams): ZodURL;
+declare function httpUrl(params?: string | Omit<core.$ZodURLParams, 'protocol' | 'hostname'>): ZodURL;
+interface ZodEmoji extends ZodStringFormat<'emoji'> {
+    _zod: core.$ZodEmojiInternals;
+}
+declare const ZodEmoji: core.$constructor<ZodEmoji>;
+declare function emoji(params?: string | core.$ZodEmojiParams): ZodEmoji;
+interface ZodNanoID extends ZodStringFormat<'nanoid'> {
+    _zod: core.$ZodNanoIDInternals;
+}
+declare const ZodNanoID: core.$constructor<ZodNanoID>;
+declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodNanoID;
+interface ZodCUID extends ZodStringFormat<'cuid'> {
+    _zod: core.$ZodCUIDInternals;
+}
+declare const ZodCUID: core.$constructor<ZodCUID>;
+declare function cuid(params?: string | core.$ZodCUIDParams): ZodCUID;
+interface ZodCUID2 extends ZodStringFormat<'cuid2'> {
+    _zod: core.$ZodCUID2Internals;
+}
+declare const ZodCUID2: core.$constructor<ZodCUID2>;
+declare function cuid2(params?: string | core.$ZodCUID2Params): ZodCUID2;
+interface ZodULID extends ZodStringFormat<'ulid'> {
+    _zod: core.$ZodULIDInternals;
+}
+declare const ZodULID: core.$constructor<ZodULID>;
+declare function ulid(params?: string | core.$ZodULIDParams): ZodULID;
+interface ZodXID extends ZodStringFormat<'xid'> {
+    _zod: core.$ZodXIDInternals;
+}
+declare const ZodXID: core.$constructor<ZodXID>;
+declare function xid(params?: string | core.$ZodXIDParams): ZodXID;
+interface ZodKSUID extends ZodStringFormat<'ksuid'> {
+    _zod: core.$ZodKSUIDInternals;
+}
+declare const ZodKSUID: core.$constructor<ZodKSUID>;
+declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodKSUID;
+interface ZodIPv4 extends ZodStringFormat<'ipv4'> {
+    _zod: core.$ZodIPv4Internals;
+}
+declare const ZodIPv4: core.$constructor<ZodIPv4>;
+declare function ipv4(params?: string | core.$ZodIPv4Params): ZodIPv4;
+interface ZodIPv6 extends ZodStringFormat<'ipv6'> {
+    _zod: core.$ZodIPv6Internals;
+}
+declare const ZodIPv6: core.$constructor<ZodIPv6>;
+declare function ipv6(params?: string | core.$ZodIPv6Params): ZodIPv6;
+interface ZodCIDRv4 extends ZodStringFormat<'cidrv4'> {
+    _zod: core.$ZodCIDRv4Internals;
+}
+declare const ZodCIDRv4: core.$constructor<ZodCIDRv4>;
+declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4;
+interface ZodCIDRv6 extends ZodStringFormat<'cidrv6'> {
+    _zod: core.$ZodCIDRv6Internals;
+}
+declare const ZodCIDRv6: core.$constructor<ZodCIDRv6>;
+declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6;
+interface ZodBase64 extends ZodStringFormat<'base64'> {
+    _zod: core.$ZodBase64Internals;
+}
+declare const ZodBase64: core.$constructor<ZodBase64>;
+declare function base64(params?: string | core.$ZodBase64Params): ZodBase64;
+interface ZodBase64URL extends ZodStringFormat<'base64url'> {
+    _zod: core.$ZodBase64URLInternals;
+}
+declare const ZodBase64URL: core.$constructor<ZodBase64URL>;
+declare function base64url(params?: string | core.$ZodBase64URLParams): ZodBase64URL;
+interface ZodE164 extends ZodStringFormat<'e164'> {
+    _zod: core.$ZodE164Internals;
+}
+declare const ZodE164: core.$constructor<ZodE164>;
+declare function e164(params?: string | core.$ZodE164Params): ZodE164;
+interface ZodJWT extends ZodStringFormat<'jwt'> {
+    _zod: core.$ZodJWTInternals;
+}
+declare const ZodJWT: core.$constructor<ZodJWT>;
+declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
+interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, core.$ZodCustomStringFormat<Format> {
+    _zod: core.$ZodCustomStringFormatInternals<Format>;
+}
+declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
+declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
+declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<'hostname'>;
+declare function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<'hex'>;
+declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = 'hex'>(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
+interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<Internals, K> {
+    gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Identical to .min() */
+    gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Identical to .max() */
+    lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+    int(params?: string | core.$ZodCheckNumberFormatParams): this;
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+    safe(params?: string | core.$ZodCheckNumberFormatParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated Use `.multipleOf()` instead. */
+    step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+    finite(params?: unknown): this;
+    minValue: number | null;
+    maxValue: number | null;
+    /** @deprecated Check the `format` property instead.  */
+    isInt: boolean;
+    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+    isFinite: boolean;
+    format: string | null;
+}
+interface ZodNumber<K extends KrustyInternals = KrustyInternals> extends _ZodNumber<core.$ZodNumberInternals<number>, K> {
+}
+declare const ZodNumber: core.$constructor<ZodNumber>;
+declare function number(params?: string | core.$ZodNumberParams): ZodNumber;
+interface ZodNumberFormat extends ZodNumber {
+    _zod: core.$ZodNumberFormatInternals;
+}
+declare const ZodNumberFormat: core.$constructor<ZodNumberFormat>;
+interface ZodInt extends ZodNumberFormat {
+}
+declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;
+interface ZodFloat32 extends ZodNumberFormat {
+}
+declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;
+interface ZodFloat64 extends ZodNumberFormat {
+}
+declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;
+interface ZodInt32 extends ZodNumberFormat {
+}
+declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;
+interface ZodUInt32 extends ZodNumberFormat {
+}
+declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
+interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+}
+interface ZodBoolean<K extends KrustyInternals = KrustyInternals> extends _ZodBoolean<core.$ZodBooleanInternals<boolean>, K> {
+}
+declare const ZodBoolean: core.$constructor<ZodBoolean>;
+declare function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean;
+interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.gte()` */
+    min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.lte()` */
+    lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;
+    minValue: bigint | null;
+    maxValue: bigint | null;
+    format: string | null;
+}
+interface ZodBigInt<K extends KrustyInternals = KrustyInternals> extends _ZodBigInt<core.$ZodBigIntInternals<bigint>, K> {
+}
+declare const ZodBigInt: core.$constructor<ZodBigInt>;
+declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;
+interface ZodBigIntFormat extends ZodBigInt {
+    _zod: core.$ZodBigIntFormatInternals;
+}
+declare const ZodBigIntFormat: core.$constructor<ZodBigIntFormat>;
+declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
+declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
+interface ZodSymbol<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSymbolInternals, K> {
+}
+declare const ZodSymbol: core.$constructor<ZodSymbol>;
+declare function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol;
+interface ZodUndefined<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUndefinedInternals, K> {
+}
+declare const ZodUndefined: core.$constructor<ZodUndefined>;
+declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined;
+
+interface ZodNull<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNullInternals, K> {
+}
+declare const ZodNull: core.$constructor<ZodNull>;
+declare function _null(params?: string | core.$ZodNullParams): ZodNull;
+
+interface ZodAny<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodAnyInternals, K> {
+}
+declare const ZodAny: core.$constructor<ZodAny>;
+declare function any(): ZodAny;
+interface ZodUnknown<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUnknownInternals, K> {
+}
+declare const ZodUnknown: core.$constructor<ZodUnknown>;
+declare function unknown(): ZodUnknown;
+interface ZodNever<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNeverInternals, K> {
+}
+declare const ZodNever: core.$constructor<ZodNever>;
+declare function never(params?: string | core.$ZodNeverParams): ZodNever;
+interface ZodVoid<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodVoidInternals, K> {
+}
+declare const ZodVoid: core.$constructor<ZodVoid>;
+declare function _void(params?: string | core.$ZodVoidParams): ZodVoid;
+
+interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
+    max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
+    /** @deprecated Not recommended. */
+    minDate: Date | null;
+    /** @deprecated Not recommended. */
+    maxDate: Date | null;
+}
+interface ZodDate<K extends KrustyInternals = KrustyInternals> extends _ZodDate<core.$ZodDateInternals<Date>, K> {
+}
+declare const ZodDate: core.$constructor<ZodDate>;
+declare function date(params?: string | core.$ZodDateParams): ZodDate;
+interface ZodArray<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodArrayInternals<T>, K>, core.$ZodArray<T> {
+    element: T;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    unwrap(): T;
+}
+declare const ZodArray: core.$constructor<ZodArray>;
+declare function array<T extends core.SomeType, K extends KrustyInternals>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T, K>;
+declare function keyof<T extends ZodObject, K extends KrustyInternals>(schema: T): ZodEnum<util.KeysEnum<T['_zod']['output']>, K>;
+interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodIntersectionInternals<A, B>, K>, core.$ZodIntersection<A, B> {
+}
+declare const ZodIntersection: core.$constructor<ZodIntersection>;
+declare function intersection<T extends core.SomeType, U extends core.SomeType, K extends KrustyInternals>(left: T, right: U): ZodIntersection<T, U, K>;
+interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTupleInternals<T, Rest>, K>, core.$ZodTuple<T, Rest> {
+    rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest, K>;
+}
+declare const ZodTuple: core.$constructor<ZodTuple>;
+declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], K extends KrustyInternals>(items: T, params?: string | core.$ZodTupleParams): ZodTuple<T, null, K>;
+declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType, K extends KrustyInternals>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple<T, Rest, K>;
+declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null, KrustyInternals>;
+interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodRecordInternals<Key, Value>, K>, core.$ZodRecord<Key, Value> {
+    keyType: Key;
+    valueType: Value;
+}
+declare const ZodRecord: core.$constructor<ZodRecord>;
+declare function record<Key extends core.$ZodRecordKey, Value extends core.SomeType, K extends KrustyInternals>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value, K>;
+declare function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key & core.$partial, Value>;
+interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodMapInternals<Key, Value>, K>, core.$ZodMap<Key, Value> {
+    keyType: Key;
+    valueType: Value;
+}
+declare const ZodMap: core.$constructor<ZodMap>;
+declare function map<Key extends core.SomeType, Value extends core.SomeType, K extends KrustyInternals>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value, K>;
+interface ZodSet<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSetInternals<T>, K>, core.$ZodSet<T> {
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
+}
+declare const ZodSet: core.$constructor<ZodSet>;
+declare function set<Value extends core.SomeType, K extends KrustyInternals>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value, K>;
+interface ZodEnum<
+/** @ts-expect-error Cast variance */
+out T extends util.EnumLike = util.EnumLike, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodEnumInternals<T>, K>, core.$ZodEnum<T> {
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>, K>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Omit<T, U[number]>>, K>;
+}
+declare const ZodEnum: core.$constructor<ZodEnum>;
+declare function _enum<const T extends readonly string[], K extends KrustyInternals>(values: T, params?: string | core.$ZodEnumParams): ZodEnum<util.ToEnum<T[number]>, K>;
+declare function _enum<const T extends util.EnumLike, K extends KrustyInternals>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T, K>;
+
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+declare function nativeEnum<T extends util.EnumLike, K extends KrustyInternals>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T, K>;
+interface ZodLiteral<T extends util.Literal = util.Literal, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodLiteralInternals<T>, K>, core.$ZodLiteral<T> {
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+declare const ZodLiteral: core.$constructor<ZodLiteral>;
+declare function literal<const T extends ReadonlyArray<util.Literal>, K extends KrustyInternals>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number], K>;
+declare function literal<const T extends util.Literal, K extends KrustyInternals>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T, K>;
+interface ZodFile<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodFileInternals, K>, core.$ZodFile {
+    min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
+}
+declare const ZodFile: core.$constructor<ZodFile>;
+declare function file(params?: string | core.$ZodFileParams): ZodFile;
+interface ZodTransform<O = unknown, I = unknown, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTransformInternals<O, I>, K>, core.$ZodTransform<O, I> {
+}
+declare const ZodTransform: core.$constructor<ZodTransform>;
+declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodTransform<Awaited<O>, I>;
+interface ZodOptional<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodOptionalInternals<T>, K>, core.$ZodOptional<T> {
+    unwrap(): T;
+}
+declare const ZodOptional: core.$constructor<ZodOptional>;
+declare function optional<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodOptional<T, K>;
+interface ZodNullable<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNullableInternals<T>, K>, core.$ZodNullable<T> {
+    unwrap(): T;
+}
+declare const ZodNullable: core.$constructor<ZodNullable>;
+declare function nullable<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodNullable<T, K>;
+declare function nullish<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodOptional<ZodNullable<T, K>, K>;
+interface ZodDefault<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodDefaultInternals<T>, K>, core.$ZodDefault<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+declare const ZodDefault: core.$constructor<ZodDefault>;
+declare function _default<T extends core.SomeType, K extends KrustyInternals>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T, K>;
+interface ZodPrefault<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPrefaultInternals<T>, K>, core.$ZodPrefault<T> {
+    unwrap(): T;
+}
+declare const ZodPrefault: core.$constructor<ZodPrefault>;
+declare function prefault<T extends core.SomeType, K extends KrustyInternals>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodPrefault<T, K>;
+interface ZodNonOptional<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNonOptionalInternals<T>, K>, core.$ZodNonOptional<T> {
+    unwrap(): T;
+}
+declare const ZodNonOptional: core.$constructor<ZodNonOptional>;
+declare function nonoptional<T extends core.SomeType, K extends KrustyInternals>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodNonOptional<T, K>;
+interface ZodSuccess<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSuccessInternals<T>, K>, core.$ZodSuccess<T> {
+    unwrap(): T;
+}
+declare const ZodSuccess: core.$constructor<ZodSuccess>;
+declare function success<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodSuccess<T, K>;
+interface ZodCatch<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodCatchInternals<T>, K>, core.$ZodCatch<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+declare const ZodCatch: core.$constructor<ZodCatch>;
+declare function _catch<T extends core.SomeType, K extends KrustyInternals>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodCatch<T, K>;
+
+interface ZodNaN<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNaNInternals, K>, core.$ZodNaN {
+}
+declare const ZodNaN: core.$constructor<ZodNaN>;
+declare function nan(params?: string | core.$ZodNaNParams): ZodNaN;
+interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPipeInternals<A, B>, K>, core.$ZodPipe<A, B> {
+    in: A;
+    out: B;
+}
+declare const ZodPipe: core.$constructor<ZodPipe>;
+declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>, K extends KrustyInternals = KrustyInternals>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B, K>;
+interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends ZodPipe<A, B, K>, core.$ZodCodec<A, B> {
+    _zod: core.$ZodCodecInternals<A, B>;
+    def: core.$ZodCodecDef<A, B>;
+}
+declare const ZodCodec: core.$constructor<ZodCodec>;
+declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals>(in_: A, out: B, params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+}): ZodCodec<A, B, K>;
+interface ZodReadonly<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodReadonlyInternals<T>, K>, core.$ZodReadonly<T> {
+    unwrap(): T;
+}
+declare const ZodReadonly: core.$constructor<ZodReadonly>;
+declare function readonly<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodReadonly<T, K>;
+interface ZodTemplateLiteral<Template extends string = string, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTemplateLiteralInternals<Template>, K>, core.$ZodTemplateLiteral<Template> {
+}
+declare const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral>;
+declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[], K extends KrustyInternals>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>, K>;
+interface ZodLazy<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodLazyInternals<T>, K>, core.$ZodLazy<T> {
+    unwrap(): T;
+}
+declare const ZodLazy: core.$constructor<ZodLazy>;
+declare function lazy<T extends core.SomeType, K extends KrustyInternals>(getter: () => T): ZodLazy<T, K>;
+interface ZodPromise<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPromiseInternals<T>, K>, core.$ZodPromise<T> {
+    unwrap(): T;
+}
+declare const ZodPromise: core.$constructor<ZodPromise>;
+declare function promise<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodPromise<T, K>;
+interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodFunctionInternals<Args, Returns>, K>, core.$ZodFunction<Args, Returns> {
+    _def: core.$ZodFunctionDef<Args, Returns>;
+    _input: core.$InferInnerFunctionType<Args, Returns>;
+    _output: core.$InferOuterFunctionType<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<core.$ZodTuple<Items, Rest>, Returns, K>;
+    input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns, K>;
+    input(...args: any[]): ZodFunction<any, Returns, K>;
+    output<NewReturns extends core.$ZodType>(output: NewReturns): ZodFunction<Args, NewReturns, K>;
+}
+declare const ZodFunction: core.$constructor<ZodFunction>;
+declare function _function(): ZodFunction;
+declare function _function<const In extends ReadonlyArray<core.$ZodType>, K extends KrustyInternals>(params: {
+    input: In;
+}): ZodFunction<ZodTuple<In, null, K>, core.$ZodFunctionOut, K>;
+declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals>(params: {
+    input: In;
+    output: Out;
+}): ZodFunction<ZodTuple<In, null, K>, Out, K>;
+declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn, K extends KrustyInternals = KrustyInternals>(params: {
+    input: In;
+}): ZodFunction<In, core.$ZodFunctionOut, K>;
+declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals>(params: {
+    output: Out;
+}): ZodFunction<core.$ZodFunctionIn, Out, K>;
+declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodType = core.$ZodType, K extends KrustyInternals = KrustyInternals>(params?: {
+    input: In;
+    output: Out;
+}): ZodFunction<In, Out, K>;
+
+interface ZodCustom<O = unknown, I = unknown, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodCustomInternals<O, I>, K>, core.$ZodCustom<O, I> {
+}
+declare const ZodCustom: core.$constructor<ZodCustom>;
+declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
+declare function custom<O, K extends KrustyInternals>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O, K>;
+declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
+declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, 'type' | 'check' | 'checks' | 'fn' | 'abort' | 'error' | 'params' | 'path'>;
+declare function _instanceof<T extends typeof util.Class, K extends KrustyInternals>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>, K>;
+
+declare const stringbool: <K extends KrustyInternals = KrustyInternals>(_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean, K>;
+type _ZodJSONSchema<K extends KrustyInternals = KrustyInternals> = ZodUnion<[
+    ZodString,
+    ZodNumber,
+    ZodBoolean,
+    ZodNull,
+    ZodArray<ZodJSONSchema, K>,
+    ZodRecord<ZodString, ZodJSONSchema, K>
+], K>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema['_zod'];
+interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+    output: util.JSONType;
+    input: util.JSONType;
+}
+interface ZodJSONSchema<K extends KrustyInternals = KrustyInternals> extends _ZodJSONSchema<K> {
+    _zod: ZodJSONSchemaInternals;
+}
+declare function json<K extends KrustyInternals = KrustyInternals>(params?: string | core.$ZodCustomParams): ZodJSONSchema<K>;
+declare function preprocess<A, U extends core.SomeType, B = unknown, K extends KrustyInternals = KrustyInternals>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U, K>;
+
+declare const fullSchema__$ZodGate: typeof $ZodGate;
+type fullSchema__$ZodGateDef<T extends core.SomeType = core.$ZodType> = $ZodGateDef<T>;
+type fullSchema__$ZodGateInternals<T extends core.SomeType = core.$ZodType> = $ZodGateInternals<T>;
+type fullSchema__IsGateEnabled = IsGateEnabled;
+type fullSchema__KrustyInternals<GateNames extends string = string> = KrustyInternals<GateNames>;
+declare const fullSchema__KrustyType: typeof KrustyType;
+type fullSchema__SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = SafeExtendShape<Base, Ext>;
+declare const fullSchema__ZodAny: typeof ZodAny;
+declare const fullSchema__ZodArray: typeof ZodArray;
+declare const fullSchema__ZodBase64: typeof ZodBase64;
+declare const fullSchema__ZodBase64URL: typeof ZodBase64URL;
+declare const fullSchema__ZodBigInt: typeof ZodBigInt;
+declare const fullSchema__ZodBigIntFormat: typeof ZodBigIntFormat;
+declare const fullSchema__ZodBoolean: typeof ZodBoolean;
+declare const fullSchema__ZodCIDRv4: typeof ZodCIDRv4;
+declare const fullSchema__ZodCIDRv6: typeof ZodCIDRv6;
+declare const fullSchema__ZodCUID: typeof ZodCUID;
+declare const fullSchema__ZodCUID2: typeof ZodCUID2;
+declare const fullSchema__ZodCatch: typeof ZodCatch;
+declare const fullSchema__ZodCodec: typeof ZodCodec;
+declare const fullSchema__ZodCustom: typeof ZodCustom;
+declare const fullSchema__ZodCustomStringFormat: typeof ZodCustomStringFormat;
+declare const fullSchema__ZodDate: typeof ZodDate;
+declare const fullSchema__ZodDefault: typeof ZodDefault;
+declare const fullSchema__ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
+declare const fullSchema__ZodE164: typeof ZodE164;
+declare const fullSchema__ZodEmail: typeof ZodEmail;
+declare const fullSchema__ZodEmoji: typeof ZodEmoji;
+declare const fullSchema__ZodEnum: typeof ZodEnum;
+declare const fullSchema__ZodFile: typeof ZodFile;
+type fullSchema__ZodFloat32 = ZodFloat32;
+type fullSchema__ZodFloat64 = ZodFloat64;
+declare const fullSchema__ZodFunction: typeof ZodFunction;
+declare const fullSchema__ZodGUID: typeof ZodGUID;
+declare const fullSchema__ZodGate: typeof ZodGate;
+declare const fullSchema__ZodIPv4: typeof ZodIPv4;
+declare const fullSchema__ZodIPv6: typeof ZodIPv6;
+type fullSchema__ZodInt = ZodInt;
+type fullSchema__ZodInt32 = ZodInt32;
+declare const fullSchema__ZodIntersection: typeof ZodIntersection;
+type fullSchema__ZodJSONSchema<K extends KrustyInternals = KrustyInternals> = ZodJSONSchema<K>;
+type fullSchema__ZodJSONSchemaInternals = ZodJSONSchemaInternals;
+declare const fullSchema__ZodJWT: typeof ZodJWT;
+declare const fullSchema__ZodKSUID: typeof ZodKSUID;
+declare const fullSchema__ZodLazy: typeof ZodLazy;
+declare const fullSchema__ZodLiteral: typeof ZodLiteral;
+declare const fullSchema__ZodMap: typeof ZodMap;
+declare const fullSchema__ZodNaN: typeof ZodNaN;
+declare const fullSchema__ZodNanoID: typeof ZodNanoID;
+declare const fullSchema__ZodNever: typeof ZodNever;
+declare const fullSchema__ZodNonOptional: typeof ZodNonOptional;
+declare const fullSchema__ZodNull: typeof ZodNull;
+declare const fullSchema__ZodNullable: typeof ZodNullable;
+declare const fullSchema__ZodNumber: typeof ZodNumber;
+declare const fullSchema__ZodNumberFormat: typeof ZodNumberFormat;
+declare const fullSchema__ZodObject: typeof ZodObject;
+declare const fullSchema__ZodOptional: typeof ZodOptional;
+declare const fullSchema__ZodPipe: typeof ZodPipe;
+declare const fullSchema__ZodPrefault: typeof ZodPrefault;
+declare const fullSchema__ZodPromise: typeof ZodPromise;
+declare const fullSchema__ZodReadonly: typeof ZodReadonly;
+declare const fullSchema__ZodRecord: typeof ZodRecord;
+declare const fullSchema__ZodSet: typeof ZodSet;
+declare const fullSchema__ZodString: typeof ZodString;
+declare const fullSchema__ZodStringFormat: typeof ZodStringFormat;
+declare const fullSchema__ZodSuccess: typeof ZodSuccess;
+declare const fullSchema__ZodSymbol: typeof ZodSymbol;
+declare const fullSchema__ZodTemplateLiteral: typeof ZodTemplateLiteral;
+declare const fullSchema__ZodTransform: typeof ZodTransform;
+declare const fullSchema__ZodTuple: typeof ZodTuple;
+type fullSchema__ZodUInt32 = ZodUInt32;
+declare const fullSchema__ZodULID: typeof ZodULID;
+declare const fullSchema__ZodURL: typeof ZodURL;
+declare const fullSchema__ZodUUID: typeof ZodUUID;
+declare const fullSchema__ZodUndefined: typeof ZodUndefined;
+declare const fullSchema__ZodUnion: typeof ZodUnion;
+declare const fullSchema__ZodUnknown: typeof ZodUnknown;
+declare const fullSchema__ZodVoid: typeof ZodVoid;
+declare const fullSchema__ZodXID: typeof ZodXID;
+type fullSchema___KrustyType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals, out KInternals extends KrustyInternals = KrustyInternals> = _KrustyType<Internals, KInternals>;
+type fullSchema___ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals, K extends KrustyInternals = KrustyInternals> = _ZodBigInt<T, K>;
+type fullSchema___ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals, K extends KrustyInternals = KrustyInternals> = _ZodBoolean<T, K>;
+type fullSchema___ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals, K extends KrustyInternals = KrustyInternals> = _ZodDate<T, K>;
+type fullSchema___ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals, K extends KrustyInternals = KrustyInternals> = _ZodNumber<Internals, K>;
+declare const fullSchema___ZodString: typeof _ZodString;
+declare const fullSchema___default: typeof _default;
+declare const fullSchema___function: typeof _function;
+declare const fullSchema__any: typeof any;
+declare const fullSchema__array: typeof array;
+declare const fullSchema__base64: typeof base64;
+declare const fullSchema__base64url: typeof base64url;
+declare const fullSchema__bigint: typeof bigint;
+declare const fullSchema__boolean: typeof boolean;
+declare const fullSchema__check: typeof check;
+declare const fullSchema__cidrv4: typeof cidrv4;
+declare const fullSchema__cidrv6: typeof cidrv6;
+declare const fullSchema__codec: typeof codec;
+declare const fullSchema__cuid: typeof cuid;
+declare const fullSchema__cuid2: typeof cuid2;
+declare const fullSchema__custom: typeof custom;
+declare const fullSchema__date: typeof date;
+declare const fullSchema__discriminatedUnion: typeof discriminatedUnion;
+declare const fullSchema__e164: typeof e164;
+declare const fullSchema__email: typeof email;
+declare const fullSchema__emoji: typeof emoji;
+declare const fullSchema__file: typeof file;
+declare const fullSchema__float32: typeof float32;
+declare const fullSchema__float64: typeof float64;
+declare const fullSchema__gate: typeof gate;
+declare const fullSchema__gatingContext: typeof gatingContext;
+declare const fullSchema__guid: typeof guid;
+declare const fullSchema__hash: typeof hash;
+declare const fullSchema__hex: typeof hex;
+declare const fullSchema__hostname: typeof hostname;
+declare const fullSchema__httpUrl: typeof httpUrl;
+declare const fullSchema__int: typeof int;
+declare const fullSchema__int32: typeof int32;
+declare const fullSchema__int64: typeof int64;
+declare const fullSchema__intersection: typeof intersection;
+declare const fullSchema__ipv4: typeof ipv4;
+declare const fullSchema__ipv6: typeof ipv6;
+declare const fullSchema__isGateIssue: typeof isGateIssue;
+declare const fullSchema__isGateIssueRaw: typeof isGateIssueRaw;
+declare const fullSchema__json: typeof json;
+declare const fullSchema__jwt: typeof jwt;
+declare const fullSchema__keyof: typeof keyof;
+declare const fullSchema__ksuid: typeof ksuid;
+declare const fullSchema__lazy: typeof lazy;
+declare const fullSchema__literal: typeof literal;
+declare const fullSchema__looseObject: typeof looseObject;
+declare const fullSchema__map: typeof map;
+declare const fullSchema__nan: typeof nan;
+declare const fullSchema__nanoid: typeof nanoid;
+declare const fullSchema__nativeEnum: typeof nativeEnum;
+declare const fullSchema__never: typeof never;
+declare const fullSchema__nonoptional: typeof nonoptional;
+declare const fullSchema__nullable: typeof nullable;
+declare const fullSchema__nullish: typeof nullish;
+declare const fullSchema__number: typeof number;
+declare const fullSchema__object: typeof object;
+declare const fullSchema__optional: typeof optional;
+declare const fullSchema__partialRecord: typeof partialRecord;
+declare const fullSchema__pipe: typeof pipe;
+declare const fullSchema__prefault: typeof prefault;
+declare const fullSchema__preprocess: typeof preprocess;
+declare const fullSchema__promise: typeof promise;
+declare const fullSchema__readonly: typeof readonly;
+declare const fullSchema__record: typeof record;
+declare const fullSchema__refine: typeof refine;
+declare const fullSchema__set: typeof set;
+declare const fullSchema__strictObject: typeof strictObject;
+declare const fullSchema__string: typeof string;
+declare const fullSchema__stringFormat: typeof stringFormat;
+declare const fullSchema__stringbool: typeof stringbool;
+declare const fullSchema__success: typeof success;
+declare const fullSchema__superRefine: typeof superRefine;
+declare const fullSchema__symbol: typeof symbol;
+declare const fullSchema__templateLiteral: typeof templateLiteral;
+declare const fullSchema__transform: typeof transform;
+declare const fullSchema__tuple: typeof tuple;
+declare const fullSchema__uint32: typeof uint32;
+declare const fullSchema__uint64: typeof uint64;
+declare const fullSchema__ulid: typeof ulid;
+declare const fullSchema__union: typeof union;
+declare const fullSchema__unknown: typeof unknown;
+declare const fullSchema__url: typeof url;
+declare const fullSchema__uuid: typeof uuid;
+declare const fullSchema__uuidv4: typeof uuidv4;
+declare const fullSchema__uuidv6: typeof uuidv6;
+declare const fullSchema__uuidv7: typeof uuidv7;
+declare const fullSchema__xid: typeof xid;
+declare namespace fullSchema_ {
+  export { fullSchema__$ZodGate as $ZodGate, fullSchema__KrustyType as KrustyType, fullSchema__ZodAny as ZodAny, fullSchema__ZodArray as ZodArray, fullSchema__ZodBase64 as ZodBase64, fullSchema__ZodBase64URL as ZodBase64URL, fullSchema__ZodBigInt as ZodBigInt, fullSchema__ZodBigIntFormat as ZodBigIntFormat, fullSchema__ZodBoolean as ZodBoolean, fullSchema__ZodCIDRv4 as ZodCIDRv4, fullSchema__ZodCIDRv6 as ZodCIDRv6, fullSchema__ZodCUID as ZodCUID, fullSchema__ZodCUID2 as ZodCUID2, fullSchema__ZodCatch as ZodCatch, fullSchema__ZodCodec as ZodCodec, fullSchema__ZodCustom as ZodCustom, fullSchema__ZodCustomStringFormat as ZodCustomStringFormat, fullSchema__ZodDate as ZodDate, fullSchema__ZodDefault as ZodDefault, fullSchema__ZodDiscriminatedUnion as ZodDiscriminatedUnion, fullSchema__ZodE164 as ZodE164, fullSchema__ZodEmail as ZodEmail, fullSchema__ZodEmoji as ZodEmoji, fullSchema__ZodEnum as ZodEnum, fullSchema__ZodFile as ZodFile, fullSchema__ZodFunction as ZodFunction, fullSchema__ZodGUID as ZodGUID, fullSchema__ZodGate as ZodGate, fullSchema__ZodIPv4 as ZodIPv4, fullSchema__ZodIPv6 as ZodIPv6, fullSchema__ZodIntersection as ZodIntersection, fullSchema__ZodJWT as ZodJWT, fullSchema__ZodKSUID as ZodKSUID, fullSchema__ZodLazy as ZodLazy, fullSchema__ZodLiteral as ZodLiteral, fullSchema__ZodMap as ZodMap, fullSchema__ZodNaN as ZodNaN, fullSchema__ZodNanoID as ZodNanoID, fullSchema__ZodNever as ZodNever, fullSchema__ZodNonOptional as ZodNonOptional, fullSchema__ZodNull as ZodNull, fullSchema__ZodNullable as ZodNullable, fullSchema__ZodNumber as ZodNumber, fullSchema__ZodNumberFormat as ZodNumberFormat, fullSchema__ZodObject as ZodObject, fullSchema__ZodOptional as ZodOptional, fullSchema__ZodPipe as ZodPipe, fullSchema__ZodPrefault as ZodPrefault, fullSchema__ZodPromise as ZodPromise, fullSchema__ZodReadonly as ZodReadonly, fullSchema__ZodRecord as ZodRecord, fullSchema__ZodSet as ZodSet, fullSchema__ZodString as ZodString, fullSchema__ZodStringFormat as ZodStringFormat, fullSchema__ZodSuccess as ZodSuccess, fullSchema__ZodSymbol as ZodSymbol, fullSchema__ZodTemplateLiteral as ZodTemplateLiteral, fullSchema__ZodTransform as ZodTransform, fullSchema__ZodTuple as ZodTuple, fullSchema__ZodULID as ZodULID, fullSchema__ZodURL as ZodURL, fullSchema__ZodUUID as ZodUUID, fullSchema__ZodUndefined as ZodUndefined, fullSchema__ZodUnion as ZodUnion, fullSchema__ZodUnknown as ZodUnknown, fullSchema__ZodVoid as ZodVoid, fullSchema__ZodXID as ZodXID, fullSchema___ZodString as _ZodString, fullSchema___default as _default, fullSchema___function as _function, fullSchema__any as any, fullSchema__array as array, fullSchema__base64 as base64, fullSchema__base64url as base64url, fullSchema__bigint as bigint, fullSchema__boolean as boolean, _catch as catch, fullSchema__check as check, fullSchema__cidrv4 as cidrv4, fullSchema__cidrv6 as cidrv6, fullSchema__codec as codec, fullSchema__cuid as cuid, fullSchema__cuid2 as cuid2, fullSchema__custom as custom, fullSchema__date as date, fullSchema__discriminatedUnion as discriminatedUnion, fullSchema__e164 as e164, fullSchema__email as email, fullSchema__emoji as emoji, _enum as enum, fullSchema__file as file, fullSchema__float32 as float32, fullSchema__float64 as float64, _function as function, fullSchema__gate as gate, fullSchema__gatingContext as gatingContext, fullSchema__guid as guid, fullSchema__hash as hash, fullSchema__hex as hex, fullSchema__hostname as hostname, fullSchema__httpUrl as httpUrl, _instanceof as instanceof, fullSchema__int as int, fullSchema__int32 as int32, fullSchema__int64 as int64, fullSchema__intersection as intersection, fullSchema__ipv4 as ipv4, fullSchema__ipv6 as ipv6, fullSchema__isGateIssue as isGateIssue, fullSchema__isGateIssueRaw as isGateIssueRaw, fullSchema__json as json, fullSchema__jwt as jwt, fullSchema__keyof as keyof, fullSchema__ksuid as ksuid, fullSchema__lazy as lazy, fullSchema__literal as literal, fullSchema__looseObject as looseObject, fullSchema__map as map, fullSchema__nan as nan, fullSchema__nanoid as nanoid, fullSchema__nativeEnum as nativeEnum, fullSchema__never as never, fullSchema__nonoptional as nonoptional, _null as null, fullSchema__nullable as nullable, fullSchema__nullish as nullish, fullSchema__number as number, fullSchema__object as object, fullSchema__optional as optional, fullSchema__partialRecord as partialRecord, fullSchema__pipe as pipe, fullSchema__prefault as prefault, fullSchema__preprocess as preprocess, fullSchema__promise as promise, fullSchema__readonly as readonly, fullSchema__record as record, fullSchema__refine as refine, fullSchema__set as set, fullSchema__strictObject as strictObject, fullSchema__string as string, fullSchema__stringFormat as stringFormat, fullSchema__stringbool as stringbool, fullSchema__success as success, fullSchema__superRefine as superRefine, fullSchema__symbol as symbol, fullSchema__templateLiteral as templateLiteral, fullSchema__transform as transform, fullSchema__tuple as tuple, fullSchema__uint32 as uint32, fullSchema__uint64 as uint64, fullSchema__ulid as ulid, _undefined as undefined, fullSchema__union as union, fullSchema__unknown as unknown, fullSchema__url as url, fullSchema__uuid as uuid, fullSchema__uuidv4 as uuidv4, fullSchema__uuidv6 as uuidv6, fullSchema__uuidv7 as uuidv7, _void as void, fullSchema__xid as xid };
+  export type { fullSchema__$ZodGateDef as $ZodGateDef, fullSchema__$ZodGateInternals as $ZodGateInternals, fullSchema__IsGateEnabled as IsGateEnabled, fullSchema__KrustyInternals as KrustyInternals, fullSchema__SafeExtendShape as SafeExtendShape, fullSchema__ZodFloat32 as ZodFloat32, fullSchema__ZodFloat64 as ZodFloat64, fullSchema__ZodInt as ZodInt, fullSchema__ZodInt32 as ZodInt32, fullSchema__ZodJSONSchema as ZodJSONSchema, fullSchema__ZodJSONSchemaInternals as ZodJSONSchemaInternals, fullSchema__ZodUInt32 as ZodUInt32, fullSchema___KrustyType as _KrustyType, fullSchema___ZodBigInt as _ZodBigInt, fullSchema___ZodBoolean as _ZodBoolean, fullSchema___ZodDate as _ZodDate, fullSchema___ZodNumber as _ZodNumber };
+}
+
+declare const fullSchema: typeof fullSchema_;
+declare const miniSchema: {
+    array: typeof array;
+    boolean: typeof boolean;
+    date: typeof date;
+    number: typeof number;
+    int: typeof int;
+    string: typeof string;
+    literal: typeof literal;
+    enum: typeof _enum;
+    union: typeof union;
+    discriminatedUnion: typeof discriminatedUnion;
+    null: typeof _null;
+    record: typeof record;
+    file: typeof file;
+    object: typeof object;
+};
+
+interface BuilderDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, EnhanceRouterOptions<TErrorMap> {
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+}
+declare class Builder<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends BuilderWithMiddlewares<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName> {
+    /**
+     * Set or override the initial context.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
+     */
+    $context<U extends Context>(): Builder<U & Record<never, never>, U, TInputSchema, TOutputSchema, TErrorMap, TMeta, TGateName>;
+    /**
+     * Creates a middleware.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    middleware<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, TInput, TOutput = any>(// = any here is important to make middleware can be used in any output by default
+    middleware: Middleware<TInitialContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, any, TMeta>;
+}
+type ApiBuilder<TMeta extends Meta> = Builder<Record<never, never>, Record<never, never>, Schema<unknown, unknown>, Schema<unknown, unknown>, Record<never, never>, TMeta, never> & typeof miniSchema & {
+    z: typeof fullSchema;
+};
+interface ApiBuilderOpts<TMeta extends Meta> {
+    meta?: TMeta;
+}
+declare function createApiBuilder<TMeta extends Meta = Record<never, never>>(opts?: ApiBuilderOpts<TMeta>): ApiBuilder<TMeta>;
+declare const os: ApiBuilder<Record<never, never>>;
+
+/**
+ * Like `DecoratedProcedure`, but removed all method that can change the contract.
+ */
+interface ImplementedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ImplementedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInput, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, UInput, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<InferSchemaOutput<TInputSchema>, UInput>): ImplementedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Make this procedure callable (works like a function while still being a procedure).
+     *
+     * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+     */
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ImplementedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+}
+/**
+ * Like `ProcedureBuilderWithoutHandler`, but removed all method that can change the contract.
+ */
+interface ProcedureImplementer<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta, string>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    'use'<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ProcedureImplementer<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @info Pass second argument to map the input.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    'use'<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInput, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, UInput, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<InferSchemaOutput<TInputSchema>, UInput>): ProcedureImplementer<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    /**
+     * Defines the handler of the procedure.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+     */
+    'handler'(handler: ProcedureHandler<TCurrentContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, TErrorMap, TMeta>): ImplementedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+}
+
+interface RouterImplementerWithMiddlewares<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): ImplementerInternalWithMiddlewares<T, MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>>;
+    /**
+     * Applies all of the previously defined options to the specified router.
+     * And enforces the router match the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    router<U extends Router<T, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, Record<never, never>>;
+    /**
+     * Create a lazy router
+     * And applies all of the previously defined options to the specified router.
+     * And enforces the router match the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    lazyRoute<U extends Router<T, TInitialContext>>(loader: () => Promise<{
+        default: U;
+    }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, Record<never, never>>;
+}
+type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementerWithMiddlewares<TContract, TInitialContext, TCurrentContext> & {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternalWithMiddlewares<TContract[K], TInitialContext, TCurrentContext> : never;
+};
+
+interface RouterImplementer<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
+    /**
+     * Creates a middleware.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    middleware<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, TInput, TOutput = any>(// = any here is important to make middleware can be used in any output by default
+    middleware: Middleware<TInitialContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, any, InferContractRouterMeta<T>>;
+    /**
+     * Uses a middleware to modify the context or improve the pipeline.
+     *
+     * @info Supports both normal middleware and inline middleware implementations.
+     * @note The current context must be satisfy middleware dependent-context
+     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+     */
+    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): ImplementerInternalWithMiddlewares<T, MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>>;
+    /**
+     * Applies all of the previously defined options to the specified router.
+     * And enforces the router match the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    router<U extends Router<T, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, Record<never, never>>;
+    /**
+     * Create a lazy router
+     * And applies all of the previously defined options to the specified router.
+     * And enforces the router match the contract.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+     */
+    lazyRoute<U extends Router<T, TCurrentContext>>(loader: () => Promise<{
+        default: U;
+    }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, Record<never, never>>;
+}
+type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementer<TContract, TInitialContext, TCurrentContext> & {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternal<TContract[K], TInitialContext, TCurrentContext> : never;
+};
+declare function implementerInternal<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context>(contract: T, middlewares: AnyMiddleware[]): ImplementerInternal<T, TInitialContext, TCurrentContext>;
+type Implementer<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = {
+    /**
+     * Set or override the initial context.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
+     */
+    $context<U extends Context>(): Implementer<TContract, U & Record<never, never>, U>;
+} & ImplementerInternal<TContract, TInitialContext, TCurrentContext>;
+declare function implement<T extends AnyContractRouter, TContext extends Context = Record<never, never>>(contract: T): Implementer<T, TContext, TContext>;
+
+declare function isStartWithMiddlewares(middlewares: readonly AnyMiddleware[], compare: readonly AnyMiddleware[]): boolean;
+declare function mergeMiddlewares(first: readonly AnyMiddleware[], second: readonly AnyMiddleware[], options: {
+    dedupeLeading: boolean;
+}): readonly AnyMiddleware[];
+declare function addMiddleware(middlewares: readonly AnyMiddleware[], addition: AnyMiddleware): AnyMiddleware[];
+
+declare function createAssertedLazyProcedure(lazied: Lazy<any>): Lazy<AnyProcedure>;
+/**
+ * Create a new procedure that ensure the contract is applied to the procedure.
+ */
+declare function createContractedProcedure(procedure: AnyProcedure, contract: AnyContractProcedure): AnyProcedure;
+/**
+ * Directly call a procedure without creating a client.
+ *
+ * @example
+ * ```ts
+ * const output = await call(getting, 'input')
+ * const output = await call(getting, 'input', { context: { db: 'postgres' } })
+ * ```
+ *
+ */
+declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, input: InferSchemaInput<TInputSchema>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, Record<never, never>> & Omit<ClientOptions<Record<never, never>>, 'context'>>): ClientPromiseResult<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+
+type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
+};
+/**
+ * Create Server-side client from a router.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown, unknown>, ErrorMap, Meta, TClientContext>>): RouterClient<T, TClientContext>;
+
+declare function setHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: AnyContractRouter): T;
+declare function getHiddenRouterContract(router: Lazyable<AnyRouter | AnyContractRouter>): AnyContractRouter | undefined;
+
+export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, BuilderWithMiddlewares, Context, CreateProcedureClientOptions, DecoratedProcedure, InferRouterInitialContext, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, Procedure, ProcedureBuilder, ProcedureClient, ProcedureHandler, Router, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getRouter, implement, implementerInternal, isStartWithMiddlewares, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazyRouter };
+export type { AccessibleLazyRouter, ApiBuilder, BuilderDef, ContractProcedureCallbackOptions, DecoratedMiddleware, EnhanceRouterOptions, EnhancedRouter, ImplementedProcedure, Implementer, ImplementerInternal, ImplementerInternalWithMiddlewares, LazyTraverseContractProceduresOptions, ProcedureImplementer, RouterBuilder, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares, TraverseContractProcedureCallbackOptions, TraverseContractProceduresOptions, UnlaziedRouter };