@temporary-name/server 1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309

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

@@ -0,0 +1,83 @@
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.js';
+import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandlerOptions, c as StandardHandleOptions } from '../../shared/server.CQyYNJ1H.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.SLLuK6_v.js';
+import compression from '@temporary-name/interop/compression';
+import '@temporary-name/contract';
+import '@temporary-name/standard-server';
+
+interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+}
+declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: NodeHttpRequest;
+    response: NodeHttpResponse;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, Omit<StandardHandlerOptions<T>, 'plugins'> {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
+}
+/**
+ * OpenAPI Handler for Node Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface CompressionPluginOptions extends compression.CompressionOptions {
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly compressionHandler;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,139 @@
+import { once, ORPCError, toArray, intercept, resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import compression from '@temporary-name/interop/compression';
+import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-node';
+import { C as CompositeStandardHandlerPlugin, S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DLsti1Pv.mjs';
+import '@temporary-name/contract';
+import '@temporary-name/standard-server';
+import '@temporary-name/server';
+import 'rou3';
+import '../../shared/server.BKh8I1Ny.mjs';
+import '../../shared/server.BEHw7Eyx.mjs';
+import 'node:async_hooks';
+import 'zod';
+import 'zod/v4/core';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      const checkHeader = once(() => {
+        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+          throw new ORPCError("PAYLOAD_TOO_LARGE");
+        }
+      });
+      const originalEmit = options2.request.emit;
+      let currentBodySize = 0;
+      options2.request.emit = (event, ...args) => {
+        if (event === "data") {
+          checkHeader();
+          currentBodySize += args[0].length;
+          if (currentBodySize > this.maxBodySize) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+        }
+        return originalEmit.call(options2.request, event, ...args);
+      };
+      try {
+        return await options2.next(options2);
+      } finally {
+        options2.request.emit = originalEmit;
+      }
+    });
+  }
+}
+
+class CompressionPlugin {
+  compressionHandler;
+  constructor(options = {}) {
+    this.compressionHandler = compression({
+      ...options,
+      filter: (req, res) => {
+        const hasContentDisposition = res.hasHeader("content-disposition");
+        const contentType = res.getHeader("content-type")?.toString();
+        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
+          return false;
+        }
+        return options.filter ? options.filter(req, res) : compression.filter(req, res);
+      }
+    });
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.unshift(async (options2) => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      const originalWrite = options2.response.write;
+      const originalEnd = options2.response.end;
+      const originalOn = options2.response.on;
+      this.compressionHandler(options2.request, options2.response, async (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          try {
+            resolve(await options2.next());
+          } catch (error) {
+            reject(error);
+          }
+        }
+      });
+      try {
+        return await promise;
+      } finally {
+        options2.response.write = originalWrite;
+        options2.response.end = originalEnd;
+        options2.response.on = originalOn;
+      }
+    });
+  }
+}
+
+class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class NodeHttpHandler {
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router, options);
+    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
+  }
+  async handle(request, response, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        response,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, response2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return { matched: false };
+        }
+        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
+        return { matched: true };
+      }
+    );
+  }
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler };

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

@@ -0,0 +1,42 @@
+export { C as CompositeStandardHandlerPlugin, c as StandardHandleOptions, d as StandardHandleResult, e as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.C1fnTLq0.mjs';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardCodec as StandardCodec$1, StandardParams as StandardParams$1, StandardMatcher as StandardMatcher$1, StandardMatchResult as StandardMatchResult$1 } from '@temporary-name/server/standard';
+import { ORPCError, HTTPPath } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { h as AnyProcedure$1, f as AnyRouter$1 } from '../../shared/server.BKSOrA6h.mjs';
+export { F as FriendlyStandardHandleOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.BeuTpcmO.mjs';
+import '@temporary-name/contract';
+
+declare class StandardOpenAPICodec implements StandardCodec$1 {
+    #private;
+    constructor();
+    decode(request: StandardLazyRequest, params: StandardParams$1 | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardOpenAPIMatcher implements StandardMatcher$1 {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult$1>;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure$1;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter$1): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure$1): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure$1): Promise<unknown>;
+}
+
+export { StandardOpenAPICodec, StandardOpenAPIMatcher };
+export type { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams };

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

@@ -0,0 +1,42 @@
+export { C as CompositeStandardHandlerPlugin, c as StandardHandleOptions, d as StandardHandleResult, e as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.CQyYNJ1H.js';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardCodec as StandardCodec$1, StandardParams as StandardParams$1, StandardMatcher as StandardMatcher$1, StandardMatchResult as StandardMatchResult$1 } from '@temporary-name/server/standard';
+import { ORPCError, HTTPPath } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { h as AnyProcedure$1, f as AnyRouter$1 } from '../../shared/server.BKSOrA6h.js';
+export { F as FriendlyStandardHandleOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.SLLuK6_v.js';
+import '@temporary-name/contract';
+
+declare class StandardOpenAPICodec implements StandardCodec$1 {
+    #private;
+    constructor();
+    decode(request: StandardLazyRequest, params: StandardParams$1 | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardOpenAPIMatcher implements StandardMatcher$1 {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult$1>;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure$1;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter$1): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure$1): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure$1): Promise<unknown>;
+}
+
+export { StandardOpenAPICodec, StandardOpenAPIMatcher };
+export type { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,11 @@
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardOpenAPICodec, b as StandardOpenAPIMatcher, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.DLsti1Pv.mjs';
+import '@temporary-name/shared';
+import '@temporary-name/standard-server';
+import '../../shared/server.BKh8I1Ny.mjs';
+import '@temporary-name/contract';
+import 'node:async_hooks';
+import 'zod';
+import 'zod/v4/core';
+import '../../shared/server.BEHw7Eyx.mjs';
+import '@temporary-name/server';
+import 'rou3';

package/dist/helpers/index.d.mts

@@ -0,0 +1,149 @@
+import { SerializeOptions, ParseOptions } 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)
+ * ```
+ */
+declare function encodeBase64url(data: Uint8Array): string;
+/**
+ * Decodes a base64url string to Uint8Array
+ * Returns undefined if the input is invalid
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ */
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
+
+interface SetCookieOptions extends SerializeOptions {
+    /**
+     * 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; HttpOnly; Max-Age=3600')
+ * ```
+ *
+ */
+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')
+ * ```
+ */
+declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
+/**
+ * Deletes a cookie by marking it expired.
+ */
+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!")
+ * ```
+ */
+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!")
+ * ```
+ */
+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")
+ * ```
+ */
+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")
+ * ```
+ */
+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")
+ * ```
+ */
+declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
+
+export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
+export type { GetCookieOptions, SetCookieOptions };

package/dist/helpers/index.d.ts

@@ -0,0 +1,149 @@
+import { SerializeOptions, ParseOptions } 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)
+ * ```
+ */
+declare function encodeBase64url(data: Uint8Array): string;
+/**
+ * Decodes a base64url string to Uint8Array
+ * Returns undefined if the input is invalid
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ */
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
+
+interface SetCookieOptions extends SerializeOptions {
+    /**
+     * 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; HttpOnly; Max-Age=3600')
+ * ```
+ *
+ */
+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')
+ * ```
+ */
+declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
+/**
+ * Deletes a cookie by marking it expired.
+ */
+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!")
+ * ```
+ */
+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!")
+ * ```
+ */
+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")
+ * ```
+ */
+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")
+ * ```
+ */
+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")
+ * ```
+ */
+declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
+
+export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
+export type { GetCookieOptions, SetCookieOptions };