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

package/dist/adapters/message-port/index.mjs

@@ -1,87 +0,0 @@
-import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
-import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standard-server/peer';
-import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-import '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
-
-class MessagePortHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.transfer = options.experimental_transfer;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
-  }
-  peers = /* @__PURE__ */ new WeakMap();
-  transfer;
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
-  /**
-   * Attaches message and close listeners to a message port.
-   *
-   * Prefer this over calling `.message()` and `.close()` manually.
-   */
-  upgrade(port, ...rest) {
-    onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
-    onMessagePortClose(port, () => this.close(port));
-  }
-  /**
-   * Handles a single message received from a message port.
-   *
-   * @param port The message port instance. Use the same instance for all messages.
-   */
-  async message(port, data, ...rest) {
-    let peer = this.peers.get(port);
-    if (!peer) {
-      this.peers.set(port, peer = new ServerPeer(async (message) => {
-        const transfer = await value(this.transfer, message, port);
-        if (transfer) {
-          postMessagePortMessage(port, message, transfer);
-        } else {
-          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
-        }
-      }));
-    }
-    let peerMessage;
-    if (typeof data === "string" || data instanceof Uint8Array) {
-      const result = decodePeerMessage(data, this.decodePeerMessageOptions);
-      if (result.matched && isClientPeerSendMessage(result.message)) {
-        peerMessage = result.message;
-      }
-    } else if (isPeerMessage(data) && isClientPeerSendMessage(data)) {
-      peerMessage = data;
-    }
-    if (peerMessage === void 0) {
-      return { matched: false };
-    }
-    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
-    return { matched: true };
-  }
-  /**
-   * Cleans up peer state for a closed message port.
-   *
-   * @param port The same message port instance passed to `.message()`.
-   */
-  async close(port) {
-    const peer = this.peers.get(port);
-    if (peer) {
-      this.peers.delete(port);
-      await peer.close();
-    }
-  }
-}
-
-class RPCHandler extends MessagePortHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { MessagePortHandler, RPCHandler };

package/dist/adapters/node/index.d.mts

@@ -1,44 +0,0 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CTV_mC2P.mjs';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
-import { Context } from '../../index.mjs';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import { Router } from '../../index.mjs';
-import { RPCHandlerCodecOptions } from '../standard/index.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type NodeHttpHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface NodeHttpHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-declare class NodeHttpHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol using Node.js built-in
- * HTTP request/response objects.
- *
- * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
- */
-declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,41 +0,0 @@
-export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/node';
-import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '@standard-server/fetch';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
-
-class NodeHttpHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
-    this.sendStandardResponseOptions = options.sendStandardResponse;
-  }
-  sendStandardResponseOptions;
-  async handle(request, response, ...rest) {
-    const standardRequest = toStandardLazyRequest(request, response);
-    const result = await this.standardHandler.handle(
-      standardRequest,
-      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
-    );
-    if (!result.matched) {
-      return result;
-    }
-    await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
-    return result;
-  }
-}
-
-class RPCHandler extends NodeHttpHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { NodeHttpHandler, RPCHandler };

package/dist/adapters/standard/index.d.mts

@@ -1,95 +0,0 @@
-import { R as ResolvedStandardHandlerHandleOptions, f as StandardHandlerCodec, g as StandardHandlerCodecResolvedProcedure } from '../../shared/server.9B1jEm5a.mjs';
-export { S as StandardHandler, a as StandardHandlerHandleOptions, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, e as StandardHandlerInterceptorOptions, c as StandardHandlerOptions, b as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, d as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.9B1jEm5a.mjs';
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Public, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { AnyProcedure, Context } from '../../index.mjs';
-import { AnyRouter } from '../../index.mjs';
-import { AnyProcedureContract } from '@orpc/contract';
-export { F as FriendlyStandardHandlerHandleOptions, r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.BvG3boBj.mjs';
-
-/**
- * Methods that can invoke procedures by default. Browsers cannot trigger them
- * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
- * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
- * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
- * invoke a procedure that can modify data.
- *
- * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
- */
-declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
-interface RPCMatcherOptions {
-    /**
-     * Filter which procedures are exposed for matching. Return `false` to exclude.
-     *
-     * @default true
-     */
-    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
-    /**
-     * Restricts which HTTP methods can invoke procedures, either with a list of allowed
-     * methods or decided per request via a function. Requests using a disallowed method
-     * are treated as unmatched. `GET` is excluded by default because it is exposed to
-     * Cross-Site Request Forgery (CSRF) attacks.
-     *
-     * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
-     * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
-     */
-    allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
-}
-declare class RPCMatcher {
-    private readonly filter;
-    private readonly allowMethodsSet;
-    private readonly allowMethodsFn;
-    private readonly rootRouter;
-    private readonly tree;
-    private readonly pendingLazyRouters;
-    /** segment count of the deepest pending key, never lowered so it stays an upper bound */
-    private maxPendingLazyRouterDepth;
-    constructor(router: AnyRouter, options?: RPCMatcherOptions);
-    private index;
-    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-    private resolvePendingLazyRouters;
-    private loadPendingLazyRouter;
-    private indexPendingLazyRouter;
-    private resolveProcedure;
-}
-
-interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Public<RPCSerializer> | undefined;
-    /**
-     * Resolve HTTP status for encoded successful outputs.
-     *
-     * Value should be in the `2xx` range and must be less than `400`.
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_SUCCESS_STATUS (200)
-     */
-    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>]> | undefined;
-    /**
-     * Mapping ORPCError Code -> HTTP Status Code
-     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
-     * Codes missing from the map fall back to `DEFAULT_ERROR_STATUS` (400).
-     *
-     * @default COMMON_ERROR_STATUS_MAP
-     */
-    errorStatusMap?: Record<string, number> | undefined;
-}
-declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
-    private readonly matcher;
-    private readonly serializer;
-    private readonly errorStatusMap;
-    private readonly outputStatus;
-    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { RPCHandlerCodec, RPCMatcher, RPC_DEFAULT_ALLOW_METHODS, ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure };
-export type { RPCHandlerCodecOptions, RPCMatcherOptions };

package/dist/adapters/standard/index.mjs

@@ -1,8 +0,0 @@
-export { R as RPCHandlerCodec, a as RPCMatcher, b as RPC_DEFAULT_ALLOW_METHODS, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@orpc/shared';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';

package/dist/adapters/standard-peer/index.d.mts

@@ -1,11 +0,0 @@
-import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { Context } from '../../index.mjs';
-import { StandardHandler } from '../standard/index.mjs';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/shared';
-
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
-
-export { createStandardPeerRequestHandler };

package/dist/adapters/standard-peer/index.mjs

@@ -1,10 +0,0 @@
-import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-
-function createStandardPeerRequestHandler(handler, options) {
-  return async (request) => {
-    const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createStandardPeerRequestHandler };

package/dist/adapters/websocket/index.mjs

@@ -1,87 +0,0 @@
-import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
-import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-import '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
-
-class WebSocketHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
-  }
-  peers = /* @__PURE__ */ new WeakMap();
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
-  /**
-   * Handles a single WebSocket message.
-   *
-   * Message order matters. Call this immediately after receiving a message,
-   * before any other async work, to preserve ordering.
-   *
-   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-   * directly (for example, `arraybuffer`).
-   *
-   * @param ws The WebSocket instance. Use the same instance for all messages.
-   * @param data The received message. Binary data should already be loaded (not a `Blob`).
-   */
-  async message(ws, data, ...rest) {
-    let peer = this.peers.get(ws);
-    if (!peer) {
-      this.peers.set(ws, peer = new ServerPeer(async (message) => {
-        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
-        await ws.send(encoded2);
-      }));
-    }
-    const encoded = toStringOrBytes(data);
-    const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-    }
-    return result;
-  }
-  /**
-   * Cleans up peer state for a closed WebSocket.
-   *
-   * @param ws The same WebSocket instance passed to `.message()`.
-   */
-  async close(ws) {
-    const peer = this.peers.get(ws);
-    if (peer) {
-      this.peers.delete(ws);
-      await peer.close();
-    }
-  }
-  /**
-   * Attaches message, close, and error event listeners to a WebSocket.
-   *
-   * Prefer this over calling `.message()` and `.close()` manually.
-   */
-  upgrade(ws, ...rest) {
-    ws.addEventListener("message", sequential(async (event) => {
-      const data = event.data instanceof Blob ? await loadBytes(event.data) : event.data;
-      this.message(ws, data, ...rest);
-    }));
-    ws.addEventListener("close", () => this.close(ws));
-    ws.addEventListener("error", () => {
-    });
-  }
-}
-
-class RPCHandler extends WebSocketHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { RPCHandler, WebSocketHandler };

package/dist/extensions/callable.d.mts

@@ -1,10 +0,0 @@
-import { ClientContext } from '@orpc/client';
-import { AnySchema, ErrorMap } from '@orpc/contract';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.mjs';
-
-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.mjs

@@ -1,11 +0,0 @@
-import { c as createProcedureClient } from '../shared/server.BB464y-6.mjs';
-import { D as DecoratedProcedure } from '../shared/server.sBQSgqK3.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/shared';
-
-DecoratedProcedure.prototype.callable = function callable(...rest) {
-  const callable2 = createProcedureClient(this, ...rest);
-  callable2["~orpc"] = this["~orpc"];
-  return callable2;
-};

package/dist/helpers/index.d.mts

@@ -1,167 +0,0 @@
-import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
-
-/**
- * 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}
- */
-declare function encodeBase64url(data: Uint8Array): string;
-/**
- * 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}
- */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
-
-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.
- *
- * Does nothing if `headers` is `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers()
- *
- * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
- *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
- */
-declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
-interface GetCookieOptions extends ParseOptions {
-}
-/**
- * Gets a cookie value from request headers
- *
- * Returns `undefined` if the cookie is not found or headers are `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
- *
- * const sessionId = getCookie(headers, 'sessionId')
- *
- * expect(sessionId).toEqual('abc123')
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
- */
-declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
-/**
- * Deletes a cookie by marking it expired.
- *
- * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
- */
-declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
-
-/**
- * Encrypts a string using AES-GCM with a secret key.
- * The output is base64url encoded to be URL-safe.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
- */
-declare function encrypt(value: string, secret: string): Promise<string>;
-/**
- * Decrypts a base64url encoded string using AES-GCM with a secret key.
- * Returns the original string if decryption is successful, or undefined if it fails.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
- */
-declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
-
-/**
- * Signs a string value using HMAC-SHA256 with a secret key.
- *
- * This function creates a cryptographic signature that can be used to verify
- * the integrity and authenticity of the data. The signature is appended to
- * the original value, separated by a dot, using base64url encoding (no padding).
- *
- * @example
- * ```ts
- * const signedValue = await sign("user123", "my-secret-key")
- * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function sign(value: string, secret: string): Promise<string>;
-/**
- * Verifies and extracts the original value from a signed string.
- *
- * This function validates the signature of a previously signed value using the same
- * secret key. If the signature is valid, it returns the original value. If the
- * signature is invalid or the format is incorrect, it returns undefined.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const originalValue = await unsign(signedValue, "my-secret-key")
- * expect(originalValue).toEqual("user123")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
-/**
- * Extracts the value part from a signed string without verification.
- *
- * This function simply extracts the original value from a signed string
- * without performing any signature verification. It's useful when you need
- * to access the value quickly without the overhead of cryptographic verification.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const value = getSignedValue(signedValue)
- * expect(value).toEqual("user123")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
-
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
-export type { GetCookieOptions, SetCookieOptions };