@orpc/server 2.0.0-beta.49 → 2.0.0-beta.50

package/dist/builder.js

@@ -1,226 +1,200 @@
-import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from '@orpc/contract';
-import { toArray } from '@orpc/shared';
-import { Lazy } from './lazy.js';
-import { decorateMiddleware } from './middleware-decorated.js';
-import { DecoratedProcedure } from './procedure-decorated.js';
-import { augmentRouter } from './router-utils.js';
+import { Lazy } from "./lazy.js";
+import { decorateMiddleware } from "./middleware-decorated.js";
+import { DecoratedProcedure } from "./procedure-decorated.js";
+import { augmentRouter } from "./router-utils.js";
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+// src/builder.ts
 /**
- * The procedure builder behind `os`. Chain its methods to gradually define
- * context, middleware, errors, schemas, and finally a handler or router.
- *
- * @see {@link https://orpc.dev/docs/procedure | Procedure}
- */
-export class Builder {
-    '~orpc';
-    /**
-     * Private constructor to prevent direct instantiation.
-     * Use the static `create` method to initialize a new instance with a safe initial definition.
-     */
-    constructor(definition) {
-        this['~orpc'] = definition;
-    }
-    /**
-     * Creates a fresh builder with an empty definition.
-     * Prefer the exported `os` instance over calling this directly.
-     *
-     * @see {@link https://orpc.dev/docs/procedure | Procedure}
-     */
-    static 'create'() {
-        // Using `& object` avoids "has no properties in common with type" errors
-        // when combining procedures or routers with compatible but non-overlapping contexts.
-        return new Builder({
-            errorMap: {},
-            meta: {},
-            orderedMiddlewares: [],
-        });
-    }
-    /**
-     * Declares the initial context type that must be provided when executing
-     * procedures built from this builder.
-     *
-     * @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
-     */
-    '$context'() {
-        // Using `& object` avoids "has no properties in common with type" errors
-        // when combining procedures or routers with compatible but non-overlapping contexts.
-        // because we can't call $context after .use method so we don't need reset middlewares here
-        return this;
-    }
-    /**
-     * Overrides the procedure configuration, such as disabling runtime
-     * input/output validation.
-     *
-     * @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
-     */
-    '$config'(config) {
-        return new Builder({
-            ...this['~orpc'],
-            ...config,
-        });
-    }
-    /**
-     * Applies metadata plugins to procedures built from this builder.
-     *
-     * @see {@link https://orpc.dev/docs/metadata | Metadata}
-     */
-    'meta'(...plugins) {
-        const [meta, metaPlugins] = resolveMetaPlugins(this['~orpc'].meta, this['~orpc'].metaPlugins, plugins);
-        return new Builder({
-            ...this['~orpc'],
-            meta,
-            metaPlugins,
-        });
-    }
-    /**
-     * Defines typesafe errors that procedures built from this builder can throw
-     * via the `errors` utility in handlers and middleware.
-     *
-     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
-     */
-    'errors'(errors) {
-        let builder = new Builder({
-            ...this['~orpc'],
-            errorMap: mergeErrorMap(this['~orpc'].errorMap, errors),
-        });
-        const plugins = getHiddenMetaPlugins(errors);
-        if (plugins) {
-            builder = builder.meta(...plugins);
-        }
-        return builder;
-    }
-    /**
-     * Applies a middleware that runs before the handler of every procedure
-     * built from this builder.
-     *
-     * @see {@link https://orpc.dev/docs/middleware | Middleware}
-     */
-    'use'(middleware) {
-        let builder = new Builder({
-            ...this['~orpc'],
-            errorMap: mergeErrorMap(middleware['~orpc']?.errorMap ?? {}, this['~orpc'].errorMap),
-            orderedMiddlewares: [
-                ...this['~orpc'].orderedMiddlewares,
-                {
-                    middleware,
-                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
-                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
-                },
-            ],
-        });
-        if (middleware['~orpc']?.metaPlugins) {
-            builder = builder.meta(...middleware['~orpc']?.metaPlugins);
-        }
-        return builder;
-    }
-    /**
-     * Creates a standalone middleware that can be composed and applied to any
-     * compatible builder or procedure with `.use`.
-     *
-     * @see {@link https://orpc.dev/docs/middleware | Middleware}
-     */
-    'middleware'(middleware) {
-        const allMiddlewares = [
-            ...this['~orpc'].orderedMiddlewares.map(({ middleware }) => middleware),
-            middleware,
-        ];
-        let current = decorateMiddleware(allMiddlewares.shift());
-        for (const mid of allMiddlewares) {
-            current = current.use(mid);
-        }
-        current['~orpc'] = {
-            ...current['~orpc'],
-            errorMap: this['~orpc'].errorMap,
-            metaPlugins: [
-                ...toArray(this['~orpc'].metaPlugins),
-                ...toArray(middleware['~orpc']?.metaPlugins),
-            ],
-        };
-        return current;
-    }
-    /**
-     * Defines the input schema used to validate and type the procedure input.
-     *
-     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
-     */
-    'input'(schema) {
-        let builder = new Builder({
-            ...this['~orpc'],
-            inputSchemas: [...toArray(this['~orpc'].inputSchemas), schema],
-        });
-        const plugins = getHiddenMetaPlugins(schema);
-        if (plugins) {
-            builder = builder.meta(...plugins);
-        }
-        return builder;
-    }
-    /**
-     * Defines the output schema used to validate and type the procedure output.
-     *
-     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
-     */
-    'output'(schema) {
-        let builder = new Builder({
-            ...this['~orpc'],
-            outputSchemas: [...toArray(this['~orpc'].outputSchemas), schema],
-        });
-        const plugins = getHiddenMetaPlugins(schema);
-        if (plugins) {
-            builder = builder.meta(...plugins);
-        }
-        return builder;
-    }
-    /**
-     * Defines the function that implements the procedure and completes the
-     * chain, returning a callable procedure.
-     *
-     * @see {@link https://orpc.dev/docs/procedure | Procedure}
-     */
-    'handler'(handler) {
-        let procedure = new DecoratedProcedure({
-            ...this['~orpc'],
-            handler,
-        });
-        const plugins = getHiddenMetaPlugins(handler);
-        if (plugins) {
-            procedure = procedure.meta(...plugins);
-        }
-        return procedure;
-    }
-    /**
-     * Applies the builder's middleware, errors, and metadata to every procedure
-     * in the given router.
-     *
-     * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
-     */
-    'router'(router) {
-        return augmentRouter(router, {
-            ...this['~orpc'],
-            middlewares: this['~orpc'].orderedMiddlewares.map(({ middleware }) => middleware),
-        });
-    }
-    /**
-     * Like `.router`, but loads the router lazily on first access, which helps
-     * reduce startup time for large applications.
-     *
-     * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
-     */
-    'lazy'(loader) {
-        return new Lazy({
-            loader: async () => {
-                const { default: router } = await loader();
-                return {
-                    default: this.router(router),
-                };
-            },
-            meta: this['~orpc'].meta,
-            metaPlugins: this['~orpc'].metaPlugins,
-        });
-    }
-}
+* The procedure builder behind `os`. Chain its methods to gradually define
+* context, middleware, errors, schemas, and finally a handler or router.
+*
+* @see {@link https://orpc.dev/docs/procedure | Procedure}
+*/
+var Builder = class Builder {
+	"~orpc";
+	/**
+	* Private constructor to prevent direct instantiation.
+	* Use the static `create` method to initialize a new instance with a safe initial definition.
+	*/
+	"constructor"(definition) {
+		this["~orpc"] = definition;
+	}
+	/**
+	* Creates a fresh builder with an empty definition.
+	* Prefer the exported `os` instance over calling this directly.
+	*
+	* @see {@link https://orpc.dev/docs/procedure | Procedure}
+	*/
+	static "create"() {
+		return new Builder({
+			errorMap: {},
+			meta: {},
+			orderedMiddlewares: []
+		});
+	}
+	/**
+	* Declares the initial context type that must be provided when executing
+	* procedures built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
+	*/
+	"$context"() {
+		return this;
+	}
+	/**
+	* Overrides the procedure configuration, such as disabling runtime
+	* input/output validation.
+	*
+	* @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+	*/
+	"$config"(config) {
+		return new Builder({
+			...this["~orpc"],
+			...config
+		});
+	}
+	/**
+	* Applies metadata plugins to procedures built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/metadata | Metadata}
+	*/
+	"meta"(...plugins) {
+		const [meta, metaPlugins] = resolveMetaPlugins(this["~orpc"].meta, this["~orpc"].metaPlugins, plugins);
+		return new Builder({
+			...this["~orpc"],
+			meta,
+			metaPlugins
+		});
+	}
+	/**
+	* Defines typesafe errors that procedures built from this builder can throw
+	* via the `errors` utility in handlers and middleware.
+	*
+	* @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+	*/
+	"errors"(errors) {
+		let builder = new Builder({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+		});
+		const plugins = getHiddenMetaPlugins(errors);
+		if (plugins) builder = builder.meta(...plugins);
+		return builder;
+	}
+	/**
+	* Applies a middleware that runs before the handler of every procedure
+	* built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/middleware | Middleware}
+	*/
+	"use"(middleware) {
+		let builder = new Builder({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+		if (middleware["~orpc"]?.metaPlugins) builder = builder.meta(...middleware["~orpc"]?.metaPlugins);
+		return builder;
+	}
+	/**
+	* Creates a standalone middleware that can be composed and applied to any
+	* compatible builder or procedure with `.use`.
+	*
+	* @see {@link https://orpc.dev/docs/middleware | Middleware}
+	*/
+	"middleware"(middleware) {
+		const allMiddlewares = [...this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware), middleware];
+		let current = decorateMiddleware(allMiddlewares.shift());
+		for (const mid of allMiddlewares) current = current.use(mid);
+		current["~orpc"] = {
+			...current["~orpc"],
+			errorMap: this["~orpc"].errorMap,
+			metaPlugins: [...toArray(this["~orpc"].metaPlugins), ...toArray(middleware["~orpc"]?.metaPlugins)]
+		};
+		return current;
+	}
+	/**
+	* Defines the input schema used to validate and type the procedure input.
+	*
+	* @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+	*/
+	"input"(schema) {
+		let builder = new Builder({
+			...this["~orpc"],
+			inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
+		});
+		const plugins = getHiddenMetaPlugins(schema);
+		if (plugins) builder = builder.meta(...plugins);
+		return builder;
+	}
+	/**
+	* Defines the output schema used to validate and type the procedure output.
+	*
+	* @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+	*/
+	"output"(schema) {
+		let builder = new Builder({
+			...this["~orpc"],
+			outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
+		});
+		const plugins = getHiddenMetaPlugins(schema);
+		if (plugins) builder = builder.meta(...plugins);
+		return builder;
+	}
+	/**
+	* Defines the function that implements the procedure and completes the
+	* chain, returning a callable procedure.
+	*
+	* @see {@link https://orpc.dev/docs/procedure | Procedure}
+	*/
+	"handler"(handler) {
+		let procedure = new DecoratedProcedure({
+			...this["~orpc"],
+			handler
+		});
+		const plugins = getHiddenMetaPlugins(handler);
+		if (plugins) procedure = procedure.meta(...plugins);
+		return procedure;
+	}
+	/**
+	* Applies the builder's middleware, errors, and metadata to every procedure
+	* in the given router.
+	*
+	* @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
+	*/
+	"router"(router) {
+		return augmentRouter(router, {
+			...this["~orpc"],
+			middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
+		});
+	}
+	/**
+	* Like `.router`, but loads the router lazily on first access, which helps
+	* reduce startup time for large applications.
+	*
+	* @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
+	*/
+	"lazy"(loader) {
+		return new Lazy({
+			loader: async () => {
+				const { default: router } = await loader();
+				return { default: this.router(router) };
+			},
+			meta: this["~orpc"].meta,
+			metaPlugins: this["~orpc"].metaPlugins
+		});
+	}
+};
 /**
- * The oRPC procedure builder. Chain methods like `.input`, `.use`, and `.handler`
- * to define procedures, then compose them into routers.
- *
- * @see {@link https://orpc.dev/docs/procedure | Procedure}
- */
-export const os = /* @__PURE__ */ Builder.create();
+* The oRPC procedure builder. Chain methods like `.input`, `.use`, and `.handler`
+* to define procedures, then compose them into routers.
+*
+* @see {@link https://orpc.dev/docs/procedure | Procedure}
+*/
+const os = /* @__PURE__ */ Builder.create();
+export { Builder, os };

package/dist/constants.d.ts

@@ -1,2 +1,2 @@
 export declare const DEFAULT_SUCCESS_STATUS = 200;
-export declare const DEFAULT_ERROR_STATUS = 400;
+export declare const DEFAULT_ERROR_STATUS = 400;

package/dist/constants.js

@@ -1,2 +1,4 @@
-export const DEFAULT_SUCCESS_STATUS = 200;
-export const DEFAULT_ERROR_STATUS = 400;
+// src/constants.ts
+const DEFAULT_SUCCESS_STATUS = 200;
+const DEFAULT_ERROR_STATUS = 400;
+export { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS };

package/dist/context.d.ts

@@ -1,6 +1,6 @@
-import type { DistributiveOmit } from '@orpc/shared';
+import { DistributiveOmit } from "@orpc/shared";
 export interface Context {
-    [key: PropertyKey]: any;
+  [key: PropertyKey]: any;
 }
 export type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = TInContext extends any ? Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & DistributiveOmit<TInContext, keyof TInitial | keyof TOutContext> : never;
-export type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;
+export type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;

package/dist/extensions/callable.d.ts

@@ -1,11 +1,11 @@
-import type { ClientContext } from '@orpc/client';
-import type { AnySchema, ErrorMap } from '@orpc/contract';
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../context.ts';
-import type { ProcedureClient, ProcedureClientOptions } from '../procedure-client.ts';
-import type { Procedure } from '../procedure.ts';
-declare module '@orpc/server' {
-    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-    }
-}
+import { Context } from "../context.js";
+import { Procedure } from "../procedure.js";
+import { ProcedureClient, ProcedureClientOptions } from "../procedure-client.js";
+import { AnySchema, ErrorMap } from "@orpc/contract";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { ClientContext } from "@orpc/client";
+declare module "@orpc/server" {
+  interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+  }
+}

package/dist/extensions/callable.js

@@ -1,7 +1,8 @@
-import { createProcedureClient } from '../procedure-client.js';
-import { DecoratedProcedure } from '../procedure-decorated.js';
+import { createProcedureClient } from "../procedure-client.js";
+import { DecoratedProcedure } from "../procedure-decorated.js";
+// src/extensions/callable.ts
 DecoratedProcedure.prototype.callable = function callable(...rest) {
-    const callable = createProcedureClient(this, ...rest);
-    callable['~orpc'] = this['~orpc'];
-    return callable;
+	const callable = createProcedureClient(this, ...rest);
+	callable["~orpc"] = this["~orpc"];
+	return callable;
 };

package/dist/helpers/base64url.d.ts

@@ -28,4 +28,4 @@ export declare function encodeBase64url(data: Uint8Array): string;
  *
  * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
  */
-export declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
+export declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;

package/dist/helpers/base64url.js

@@ -1,53 +1,48 @@
-import { encodeBase64 } from '@orpc/shared';
+import { encodeBase64 } from "@orpc/shared";
+// src/helpers/base64url.ts
 /**
- * Encodes a Uint8Array to base64url format
- * Base64url is URL-safe and doesn't use padding
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
- */
-export function encodeBase64url(data) {
-    return encodeBase64(data).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+* Encodes a Uint8Array to base64url format
+* Base64url is URL-safe and doesn't use padding
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+function encodeBase64url(data) {
+	return encodeBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 /**
- * Decodes a base64url string to Uint8Array
- * Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
- * returns undefined for anything else, including padded or standard base64 input
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
- */
-export function decodeBase64url(base64url) {
-    try {
-        if (typeof base64url !== 'string') {
-            return undefined;
-        }
-        let base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
-        while (base64.length % 4) {
-            base64 += '=';
-        }
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return encodeBase64url(bytes) === base64url ? bytes : undefined;
-    }
-    catch {
-        return undefined;
-    }
+* Decodes a base64url string to Uint8Array
+* Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
+* returns undefined for anything else, including padded or standard base64 input
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+function decodeBase64url(base64url) {
+	try {
+		if (typeof base64url !== "string") return;
+		let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+		while (base64.length % 4) base64 += "=";
+		const binaryString = atob(base64);
+		const bytes = new Uint8Array(binaryString.length);
+		for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+		return encodeBase64url(bytes) === base64url ? bytes : void 0;
+	} catch {
+		return;
+	}
 }
+export { decodeBase64url, encodeBase64url };

package/dist/helpers/cookie.d.ts

@@ -1,11 +1,11 @@
-import type { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
-export interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
-    /**
-     * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
-     *
-     * @default '/'
-     */
-    path?: string;
+import { ParseOptions, SetCookie, StringifyOptions } from "cookie";
+export interface SetCookieOptions extends Omit<SetCookie, "name" | "value">, StringifyOptions {
+  /**
+   * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
+   *
+   * @default '/'
+   */
+  path?: string;
 }
 /**
  * Sets a cookie in the response headers.
@@ -24,8 +24,7 @@ export interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, Str
  * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 export declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
-export interface GetCookieOptions extends ParseOptions {
-}
+export interface GetCookieOptions extends ParseOptions {}
 /**
  * Gets a cookie value from request headers
  *
@@ -48,4 +47,4 @@ export declare function getCookie(headers: Headers | undefined, name: string, op
  *
  * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
-export declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
+export declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, "maxAge">): void;