@temporary-name/server 0.0.1-alpha.0cb08cf84b740850e7d8dcd1d8b87f78af26071b

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stainless
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+> [!NOTE]
+> In the spirit of writing the press release first, drafting some content here as we go.
+
+# Crusty [name WIP]
+
+Crusty is an API framework that does the right thing by default.
+
+> Everything should be possible, but correct things should be easy
+
+Have you ever accidentally left out a single line of code and ended up with an unauthenticated API endpoint? Accidentally rendered an incoherent error format (or worse, returned HTML when you 500)?
+
+Crusty takes the lessons from shipping massive production APIs (we built Stripe's API abstractions) and makes them available to everyone.
+
+## What is an API framework?
+
+The frameworks you're probably thinking of are more like HTTP frameworks: they offer routing, middleware, and maybe some helpers around authentication and parameter validation.
+
+This is great, but there's a layer on top of them that's missing, and every company ends up building themselves:
+
+- Authentication & authorization
+- Gating (expose certain request/response params to certain customers)
+- Versioning (this one's gnarly!)
+- Logging
+- Error handling/rendering
+- Rate limiting
+- Idempotency
+- Documentation/spec generation
+
+Middleware is powerful for much of this, but in many ways it's lowest-common-denominator and you still need to build a lot of custom code to make these happen.
+
+Crusty is a layer on top of your HTTP framework that adds best-in-class primitives for all of these.

package/dist/adapters/aws-lambda/index.d.mts

@@ -0,0 +1,26 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CWiZN27E.mjs';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+}
+type AwsLambdaHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+/**
+ * OpenAPI Handler for AWS Lambda.
+ */
+declare class AwsLambdaHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: AwsLambdaHandlerOptions);
+    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<AwsLambdaHandleResult>;
+}
+
+export { AwsLambdaHandler };
+export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions };

package/dist/adapters/aws-lambda/index.d.ts

@@ -0,0 +1,26 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BOkueCuE.js';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+}
+type AwsLambdaHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+/**
+ * OpenAPI Handler for AWS Lambda.
+ */
+declare class AwsLambdaHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: AwsLambdaHandlerOptions);
+    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<AwsLambdaHandleResult>;
+}
+
+export { AwsLambdaHandler };
+export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions };

package/dist/adapters/aws-lambda/index.mjs

@@ -0,0 +1,30 @@
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-aws-lambda';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.JwVIEHL6.mjs';
+import '@temporary-name/server';
+import '@temporary-name/standard-server';
+import 'neoqs';
+import '../../shared/server.D7jtfDRy.mjs';
+import 'rou3';
+import '@temporary-name/zod';
+
+class AwsLambdaHandler {
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(resources, options = {}) {
+    this.standardHandler = new StandardHandler(resources);
+    this.sendStandardResponseOptions = options;
+  }
+  async handle(event, responseStream, ...rest) {
+    const standardRequest = toStandardLazyRequest(event, responseStream);
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
+    return { matched: true };
+  }
+}
+
+export { AwsLambdaHandler };

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

@@ -0,0 +1,23 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, FastifyRequest, FastifyReply } from '@temporary-name/standard-server-fastify';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CWiZN27E.mjs';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type FastifyHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerOptions extends SendStandardResponseOptions {
+}
+declare class FastifyHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<FastifyHandlerOptions>);
+    handle(request: FastifyRequest, reply: FastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<FastifyHandleResult>;
+}
+
+export { FastifyHandler };
+export type { FastifyHandleResult, FastifyHandlerOptions };

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

@@ -0,0 +1,23 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, FastifyRequest, FastifyReply } from '@temporary-name/standard-server-fastify';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BOkueCuE.js';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type FastifyHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerOptions extends SendStandardResponseOptions {
+}
+declare class FastifyHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<FastifyHandlerOptions>);
+    handle(request: FastifyRequest, reply: FastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<FastifyHandleResult>;
+}
+
+export { FastifyHandler };
+export type { FastifyHandleResult, FastifyHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -0,0 +1,30 @@
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-fastify';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.JwVIEHL6.mjs';
+import '@temporary-name/server';
+import '@temporary-name/standard-server';
+import 'neoqs';
+import '../../shared/server.D7jtfDRy.mjs';
+import 'rou3';
+import '@temporary-name/zod';
+
+class FastifyHandler {
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(resources, options = {}) {
+    this.standardHandler = new StandardHandler(resources);
+    this.sendStandardResponseOptions = options;
+  }
+  async handle(request, reply, ...rest) {
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const standardRequest = toStandardLazyRequest(request, reply);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
+    return { matched: true };
+  }
+}
+
+export { FastifyHandler };

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

@@ -0,0 +1,28 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CWiZN27E.mjs';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerOptions extends ToFetchResponseOptions {
+}
+/**
+ * OpenAPI Handler for Fetch Server
+ */
+declare class FetchHandler<T extends ImplementedResource> {
+    private readonly toFetchResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<FetchHandlerOptions>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<FetchHandleResult>;
+}
+
+export { FetchHandler };
+export type { FetchHandleResult, FetchHandlerOptions };

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

@@ -0,0 +1,28 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BOkueCuE.js';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerOptions extends ToFetchResponseOptions {
+}
+/**
+ * OpenAPI Handler for Fetch Server
+ */
+declare class FetchHandler<T extends ImplementedResource> {
+    private readonly toFetchResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<FetchHandlerOptions>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<FetchHandleResult>;
+}
+
+export { FetchHandler };
+export type { FetchHandleResult, FetchHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,32 @@
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@temporary-name/standard-server-fetch';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.JwVIEHL6.mjs';
+import '@temporary-name/server';
+import '@temporary-name/standard-server';
+import 'neoqs';
+import '../../shared/server.D7jtfDRy.mjs';
+import 'rou3';
+import '@temporary-name/zod';
+
+class FetchHandler {
+  toFetchResponseOptions;
+  standardHandler;
+  constructor(resources, options = {}) {
+    this.standardHandler = new StandardHandler(resources);
+    this.toFetchResponseOptions = options;
+  }
+  async handle(request, ...rest) {
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, this.toFetchResponseOptions)
+    };
+  }
+}
+
+export { FetchHandler };

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

@@ -0,0 +1,26 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CWiZN27E.mjs';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerOptions extends SendStandardResponseOptions {
+}
+/**
+ * OpenAPI Handler for Node Server
+ */
+declare class NodeHttpHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<NodeHttpHandlerOptions>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<NodeHttpHandleResult>;
+}
+
+export { NodeHttpHandler };
+export type { NodeHttpHandleResult, NodeHttpHandlerOptions };

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

@@ -0,0 +1,26 @@
+import { MaybeOptionalOptions } from '@temporary-name/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
+import { I as ImplementedResource, a as InferResourceContext } from '../../shared/server.BTVDgKdb.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BOkueCuE.js';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerOptions extends SendStandardResponseOptions {
+}
+/**
+ * OpenAPI Handler for Node Server
+ */
+declare class NodeHttpHandler<T extends ImplementedResource> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(resources: T[], options?: NoInfer<NodeHttpHandlerOptions>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<InferResourceContext<T>>>): Promise<NodeHttpHandleResult>;
+}
+
+export { NodeHttpHandler };
+export type { NodeHttpHandleResult, NodeHttpHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,30 @@
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-node';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.JwVIEHL6.mjs';
+import '@temporary-name/server';
+import '@temporary-name/standard-server';
+import 'neoqs';
+import '../../shared/server.D7jtfDRy.mjs';
+import 'rou3';
+import '@temporary-name/zod';
+
+class NodeHttpHandler {
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(resources, options = {}) {
+    this.standardHandler = new StandardHandler(resources);
+    this.sendStandardResponseOptions = options;
+  }
+  async handle(request, response, ...rest) {
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const standardRequest = toStandardLazyRequest(request, response);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+    return { matched: true };
+  }
+}
+
+export { NodeHttpHandler };

package/dist/handler/index.d.mts

@@ -0,0 +1,22 @@
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, b as StandardHandler, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.CWiZN27E.mjs';
+import { Input, AnyMethod } from '@temporary-name/server';
+import { StandardLazyRequest, StandardResponse, HTTPPath } from '@temporary-name/shared';
+import { aj as AnyMethod$1, I as ImplementedResource } from '../shared/server.BTVDgKdb.mjs';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<Input>;
+declare function encode(output: unknown, method: AnyMethod): StandardResponse;
+
+type StandardMatchResult = {
+    method: AnyMethod$1;
+    params?: Record<string, string>;
+} | undefined;
+declare class StandardOpenAPIMatcher {
+    private readonly tree;
+    constructor(resources: ImplementedResource[]);
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardOpenAPIMatcher, decode, encode };
+export type { StandardMatchResult };

package/dist/handler/index.d.ts

@@ -0,0 +1,22 @@
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, b as StandardHandler, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.BOkueCuE.js';
+import { Input, AnyMethod } from '@temporary-name/server';
+import { StandardLazyRequest, StandardResponse, HTTPPath } from '@temporary-name/shared';
+import { aj as AnyMethod$1, I as ImplementedResource } from '../shared/server.BTVDgKdb.js';
+import '@temporary-name/zod';
+import 'zod/v4/core';
+
+declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<Input>;
+declare function encode(output: unknown, method: AnyMethod): StandardResponse;
+
+type StandardMatchResult = {
+    method: AnyMethod$1;
+    params?: Record<string, string>;
+} | undefined;
+declare class StandardOpenAPIMatcher {
+    private readonly tree;
+    constructor(resources: ImplementedResource[]);
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardOpenAPIMatcher, decode, encode };
+export type { StandardMatchResult };

package/dist/handler/index.mjs

@@ -0,0 +1,8 @@
+export { S as StandardHandler, a as StandardOpenAPIMatcher, d as decode, b as decodeParams, e as encode, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.JwVIEHL6.mjs';
+import '@temporary-name/shared';
+import '../shared/server.D7jtfDRy.mjs';
+import '@temporary-name/zod';
+import '@temporary-name/standard-server';
+import '@temporary-name/server';
+import 'neoqs';
+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 };