lambder 6.0.2 → 7.0.2

package/dist/stores/LambderMemoryIdempotencyStore.d.ts

@@ -0,0 +1,63 @@
+import type { LambderIdempotencyStore, LambderIdempotencyDoneRecord, LambderIdempotencyBeginResult } from "../shared/contracts/LambderIdempotencyStore.js";
+type MemoryIdempotencyRecord = {
+    state: "pending";
+    ownerToken: string;
+} | ({
+    state: "done";
+    ownerToken: string;
+} & LambderIdempotencyDoneRecord);
+/**
+ * Idempotency records held in memory: the same claim, settle and replay
+ * semantics as LambderDdbIdempotencyStore (owner tokens, pending expiry, lost
+ * claims as silent no-ops), over a LambderExpiringMap in place of the table
+ * and its TTL. For tests and for the mock runtime; tests/store-conformance
+ * drives this and the DynamoDB store through one set of rules.
+ *
+ * `maxBodyBytes` stands in for the DynamoDB item budget, so the "too-large"
+ * path can be exercised; unbounded by default. `now` is injectable so a test
+ * can expire a claim without waiting.
+ *
+ * `maxEntries` is the map's ceiling, 100,000 by default, and it is the one
+ * way this store differs from a table: a process cannot hold records without
+ * bound, so past the ceiling the SETTLED records are dropped, soonest expiry
+ * first, and a retry whose record was dropped executes again instead of
+ * replaying. Pending claims are never dropped for room, because losing one
+ * lets two concurrent retries execute at once, which is the thing idempotency
+ * exists to prevent; a claim that cannot be made room for is reported as
+ * "pending" instead, so the duplicate is refused rather than run.
+ */
+export declare class LambderMemoryIdempotencyStore implements LambderIdempotencyStore {
+    private readonly records;
+    private readonly maxBodyBytes;
+    private readonly now;
+    private ownerCounter;
+    /** Set while the store is refusing claims, so a flood reports the saturation once rather than once per request. */
+    private claimCeilingReported;
+    constructor(options?: {
+        maxBodyBytes?: number;
+        now?: () => number;
+        maxEntries?: number;
+    });
+    private nowSeconds;
+    /** A settled record as the engine reads it: a copy, so a caller writing onto what it got back cannot rewrite the record. */
+    private static answerOf;
+    peek(scopeKey: string): Promise<LambderIdempotencyDoneRecord | null>;
+    begin(scopeKey: string, { pendingTtlSeconds }: {
+        pendingTtlSeconds: number;
+    }): Promise<LambderIdempotencyBeginResult>;
+    complete(scopeKey: string, ownerToken: string, { statusCode, headers, body, ttlSeconds }: LambderIdempotencyDoneRecord & {
+        ttlSeconds: number;
+    }): Promise<"stored" | "too-large" | "lost">;
+    abandon(scopeKey: string, ownerToken: string): Promise<void>;
+    /**
+     * The record under a scope, for assertions; null when absent or expired.
+     * A copy, like every other read here, so an assertion that pokes at what
+     * it got back cannot edit the stored record.
+     */
+    recordOf(scopeKey: string): MemoryIdempotencyRecord | null;
+    /** Number of live records held. */
+    get size(): number;
+    /** Forgets every record. */
+    reset(): void;
+}
+export {};

package/dist/stores/LambderMemoryIdempotencyStore.js

@@ -0,0 +1,113 @@
+import { LambderExpiringMap, LambderExpiringMapFullError } from "../shared/util/LambderExpiringMap.js";
+/**
+ * Idempotency records held in memory: the same claim, settle and replay
+ * semantics as LambderDdbIdempotencyStore (owner tokens, pending expiry, lost
+ * claims as silent no-ops), over a LambderExpiringMap in place of the table
+ * and its TTL. For tests and for the mock runtime; tests/store-conformance
+ * drives this and the DynamoDB store through one set of rules.
+ *
+ * `maxBodyBytes` stands in for the DynamoDB item budget, so the "too-large"
+ * path can be exercised; unbounded by default. `now` is injectable so a test
+ * can expire a claim without waiting.
+ *
+ * `maxEntries` is the map's ceiling, 100,000 by default, and it is the one
+ * way this store differs from a table: a process cannot hold records without
+ * bound, so past the ceiling the SETTLED records are dropped, soonest expiry
+ * first, and a retry whose record was dropped executes again instead of
+ * replaying. Pending claims are never dropped for room, because losing one
+ * lets two concurrent retries execute at once, which is the thing idempotency
+ * exists to prevent; a claim that cannot be made room for is reported as
+ * "pending" instead, so the duplicate is refused rather than run.
+ */
+export class LambderMemoryIdempotencyStore {
+    records;
+    maxBodyBytes;
+    now;
+    ownerCounter = 0;
+    /** Set while the store is refusing claims, so a flood reports the saturation once rather than once per request. */
+    claimCeilingReported = false;
+    constructor(options = {}) {
+        this.maxBodyBytes = options.maxBodyBytes ?? Number.POSITIVE_INFINITY;
+        this.now = options.now ?? (() => Date.now());
+        this.records = new LambderExpiringMap({ now: this.now, maxEntries: options.maxEntries });
+    }
+    nowSeconds() { return Math.floor(this.now() / 1000); }
+    /** A settled record as the engine reads it: a copy, so a caller writing onto what it got back cannot rewrite the record. */
+    static answerOf(record) {
+        return { statusCode: record.statusCode, headers: structuredClone(record.headers), body: record.body };
+    }
+    async peek(scopeKey) {
+        const record = this.records.get(scopeKey);
+        if (record?.state !== "done")
+            return null;
+        return LambderMemoryIdempotencyStore.answerOf(record);
+    }
+    async begin(scopeKey, { pendingTtlSeconds }) {
+        const existing = this.records.get(scopeKey);
+        if (existing) {
+            if (existing.state === "done")
+                return { state: "done", ...LambderMemoryIdempotencyStore.answerOf(existing) };
+            return { state: "pending" };
+        }
+        this.ownerCounter += 1;
+        const ownerToken = `owner-${this.ownerCounter}`;
+        try {
+            // Not evictable: the claim is the only thing standing between two
+            // concurrent retries and two executions, and it is also the entry
+            // the soonest-expiry rule would otherwise take first, since a
+            // claim lives for minutes and the record it becomes for a day.
+            this.records.set(scopeKey, { state: "pending", ownerToken }, this.nowSeconds() + pendingTtlSeconds, { evictable: false });
+        }
+        catch (error) {
+            if (!(error instanceof LambderExpiringMapFullError))
+                throw error;
+            // Every record held is a live claim, so there is no room and
+            // nothing safe to take. "pending" is the interface's shape for
+            // "the claim is not yours": the caller refuses the duplicate,
+            // which is the answer that cannot execute anything twice, and a
+            // retry once the flood drains claims normally.
+            if (!this.claimCeilingReported) {
+                this.claimCeilingReported = true;
+                console.error("LambderMemoryIdempotencyStore: every record held is a live claim, so new requests are refused as duplicates until one settles. Raise maxEntries or move to LambderDdbIdempotencyStore.");
+            }
+            return { state: "pending" };
+        }
+        this.claimCeilingReported = false;
+        return { state: "new", ownerToken };
+    }
+    async complete(scopeKey, ownerToken, { statusCode, headers, body, ttlSeconds }) {
+        // Size first, ownership second, the order LambderDdbIdempotencyStore works
+        // in: it settles with one conditional write, so the only thing it can
+        // decide before going to the table is whether the body fits.
+        if (new TextEncoder().encode(body).length > this.maxBodyBytes)
+            return "too-large";
+        const existing = this.records.get(scopeKey);
+        if (!existing || existing.ownerToken !== ownerToken)
+            return "lost";
+        // Settled records ARE evictable: the claim's job is done, and a record
+        // the ceiling drops costs a retry its replay, not its exclusivity.
+        // The key is already held, so this write cannot cross the ceiling.
+        this.records.set(scopeKey, { state: "done", ownerToken, statusCode, headers: structuredClone(headers), body }, this.nowSeconds() + ttlSeconds);
+        return "stored";
+    }
+    async abandon(scopeKey, ownerToken) {
+        const existing = this.records.get(scopeKey);
+        if (existing && existing.ownerToken === ownerToken)
+            this.records.delete(scopeKey);
+    }
+    /**
+     * The record under a scope, for assertions; null when absent or expired.
+     * A copy, like every other read here, so an assertion that pokes at what
+     * it got back cannot edit the stored record.
+     */
+    recordOf(scopeKey) {
+        const record = this.records.get(scopeKey);
+        return record ? structuredClone(record) : null;
+    }
+    /** Number of live records held. */
+    get size() { return this.records.size; }
+    /** Forgets every record. */
+    reset() {
+        this.records.clear();
+    }
+}

package/dist/stores/LambderMemoryRateLimiter.d.ts

@@ -0,0 +1,34 @@
+import { type LambderRateLimiter, type LambderRateLimitPolicy, type LambderRateLimitResult, type LambderRateLimitWindow } from "../shared/contracts/LambderRateLimiter.js";
+/**
+ * Fixed-window rate limiter held in memory: the same windows, the same
+ * attempts-count semantics and the same evaluation order as
+ * LambderDdbRateLimiter, with a Map in place of the table. For tests and
+ * for the mock runtime; a single-process server could use it too, with the
+ * caveat that its counters are per process and vanish with it.
+ *
+ * `now` is injectable so a test can move time forward and watch a window
+ * reset without waiting for it.
+ *
+ * `maxEntries` is the ceiling on counters held at once, 100,000 by default,
+ * and it is the one way this limiter differs from the table: a process cannot
+ * hold counters without bound, so past the ceiling the counters closest to
+ * their window's end are dropped and a key whose counter was dropped starts
+ * that window again from zero. It takes one distinct key per counter to get
+ * there (a limit keyed per IP under a flood from many of them), and the
+ * counters with the most life left, which are the long-window ones, are the
+ * last to go. A deployment where that matters wants LambderDdbRateLimiter,
+ * whose counters are not held in the process at all.
+ */
+export declare class LambderMemoryRateLimiter implements LambderRateLimiter {
+    private readonly counters;
+    private readonly now;
+    constructor(options?: {
+        now?: () => number;
+        maxEntries?: number;
+    });
+    isRateLimited(trackerKey: string, policy: LambderRateLimitPolicy): Promise<LambderRateLimitResult>;
+    /** The attempts counted so far for a key in the current window of `window`; for assertions. */
+    countOf(trackerKey: string, window: LambderRateLimitWindow): number;
+    /** Forgets every counter. */
+    reset(): void;
+}

package/dist/stores/LambderMemoryRateLimiter.js

@@ -0,0 +1,64 @@
+import { RATE_LIMIT_WINDOWS, } from "../shared/contracts/LambderRateLimiter.js";
+import { LambderExpiringMap } from "../shared/util/LambderExpiringMap.js";
+import { joinKeyFields } from "../shared/util/LambderKeyFields.js";
+/**
+ * Fixed-window rate limiter held in memory: the same windows, the same
+ * attempts-count semantics and the same evaluation order as
+ * LambderDdbRateLimiter, with a Map in place of the table. For tests and
+ * for the mock runtime; a single-process server could use it too, with the
+ * caveat that its counters are per process and vanish with it.
+ *
+ * `now` is injectable so a test can move time forward and watch a window
+ * reset without waiting for it.
+ *
+ * `maxEntries` is the ceiling on counters held at once, 100,000 by default,
+ * and it is the one way this limiter differs from the table: a process cannot
+ * hold counters without bound, so past the ceiling the counters closest to
+ * their window's end are dropped and a key whose counter was dropped starts
+ * that window again from zero. It takes one distinct key per counter to get
+ * there (a limit keyed per IP under a flood from many of them), and the
+ * counters with the most life left, which are the long-window ones, are the
+ * last to go. A deployment where that matters wants LambderDdbRateLimiter,
+ * whose counters are not held in the process at all.
+ */
+export class LambderMemoryRateLimiter {
+    counters;
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => Date.now());
+        this.counters = new LambderExpiringMap({ now: this.now, maxEntries: options.maxEntries });
+    }
+    async isRateLimited(trackerKey, policy) {
+        const nowSeconds = Math.floor(this.now() / 1000);
+        for (const { key, seconds } of RATE_LIMIT_WINDOWS) {
+            const limit = policy[key];
+            if (!limit)
+                continue;
+            const windowStart = Math.floor(nowSeconds / seconds) * seconds;
+            // The table gives the tracker key and the window separate
+            // attributes; one string here has to keep them as distinct, so the
+            // fields are joined through the escaping join rather than glued.
+            const counterKey = joinKeyFields(trackerKey, key, String(windowStart));
+            const counter = this.counters.get(counterKey) ?? { count: 0 };
+            // The DynamoDB limiter's conditional ADD: allowed while the count
+            // before this attempt is under the limit, and the refused attempt
+            // leaves the counter where it was.
+            if (counter.count >= limit)
+                return { window: key, limit, resetAt: windowStart + seconds };
+            counter.count += 1;
+            // The counter dies with its window, which is also the table's TTL.
+            this.counters.set(counterKey, counter, windowStart + seconds);
+        }
+        return false;
+    }
+    /** The attempts counted so far for a key in the current window of `window`; for assertions. */
+    countOf(trackerKey, window) {
+        const seconds = RATE_LIMIT_WINDOWS.find((entry) => entry.key === window).seconds;
+        const windowStart = Math.floor(Math.floor(this.now() / 1000) / seconds) * seconds;
+        return this.counters.get(joinKeyFields(trackerKey, window, String(windowStart)))?.count ?? 0;
+    }
+    /** Forgets every counter. */
+    reset() {
+        this.counters.clear();
+    }
+}

package/dist/stores/LambderMemorySessionStore.d.ts

@@ -0,0 +1,48 @@
+import type { LambderSessionRecord, LambderSessionStore } from "../shared/contracts/LambderSessionStore.js";
+/**
+ * Session records held in memory: a Map in place of the DynamoDB table. For
+ * tests and for the mock runtime, where the session model (tokens, expiry,
+ * sliding writes, dataRefresh) runs as it does in production over a store
+ * that lives for the life of the process or page.
+ *
+ * Records are copied on the way in and out through JSON, the way a real store
+ * serializes them, so a caller mutating a fetched record changes nothing until
+ * it is put back, and data DynamoDB would reject is rejected here too. A
+ * record also leaves at its own expiresAt, the way the table's TTL removes
+ * it, so a long-lived process does not hold every session it ever issued.
+ */
+export declare class LambderMemorySessionStore<SessionData = unknown> implements LambderSessionStore<SessionData> {
+    /** Nothing here outlives the process. */
+    readonly isMemoryOnly = true;
+    private readonly records;
+    /**
+     * `now` is injectable so a test can move past an expiry without waiting.
+     * `maxEntries` caps how many live sessions are held; at the ceiling the
+     * soonest to expire is evicted, and an evicted session is a logout for
+     * whoever held it.
+     */
+    constructor(options?: {
+        now?: () => number;
+        maxEntries?: number;
+    });
+    private static keyOf;
+    /**
+     * A record the way a real store hands it back: through JSON, so an
+     * undefined field is gone and a cyclic value throws here exactly as it
+     * throws on the way into DynamoDB. structuredClone did neither, which made
+     * the memory store the more forgiving of the two and let a test pass over
+     * data the production store would reject.
+     */
+    private static storedCopy;
+    get(sessionKeyHash: string, secretHash: string): Promise<LambderSessionRecord<SessionData> | null>;
+    put(record: LambderSessionRecord<SessionData>): Promise<void>;
+    delete(sessionKeyHash: string, secretHash: string): Promise<void>;
+    listSecretHashes(sessionKeyHash: string): Promise<string[]>;
+    markDataExpired(sessionKeyHash: string, secretHash: string, at: number): Promise<void>;
+    /** Every live record held, for assertions. */
+    list(): LambderSessionRecord<SessionData>[];
+    /** Number of live records held. */
+    get size(): number;
+    /** Forgets every record: everyone is signed out. */
+    reset(): void;
+}

package/dist/stores/LambderMemorySessionStore.js

@@ -0,0 +1,74 @@
+import { LambderExpiringMap } from "../shared/util/LambderExpiringMap.js";
+import { joinKeyFields } from "../shared/util/LambderKeyFields.js";
+/**
+ * Session records held in memory: a Map in place of the DynamoDB table. For
+ * tests and for the mock runtime, where the session model (tokens, expiry,
+ * sliding writes, dataRefresh) runs as it does in production over a store
+ * that lives for the life of the process or page.
+ *
+ * Records are copied on the way in and out through JSON, the way a real store
+ * serializes them, so a caller mutating a fetched record changes nothing until
+ * it is put back, and data DynamoDB would reject is rejected here too. A
+ * record also leaves at its own expiresAt, the way the table's TTL removes
+ * it, so a long-lived process does not hold every session it ever issued.
+ */
+export class LambderMemorySessionStore {
+    /** Nothing here outlives the process. */
+    isMemoryOnly = true;
+    records;
+    /**
+     * `now` is injectable so a test can move past an expiry without waiting.
+     * `maxEntries` caps how many live sessions are held; at the ceiling the
+     * soonest to expire is evicted, and an evicted session is a logout for
+     * whoever held it.
+     */
+    constructor(options = {}) {
+        this.records = new LambderExpiringMap(options);
+    }
+    static keyOf(sessionKeyHash, secretHash) {
+        // Escaped rather than joined plainly: both halves are hex today, but a
+        // custom LambderSessionCrypto writes whatever it likes into them, and
+        // two records sharing one key would be one session silently.
+        return joinKeyFields(sessionKeyHash, secretHash);
+    }
+    /**
+     * A record the way a real store hands it back: through JSON, so an
+     * undefined field is gone and a cyclic value throws here exactly as it
+     * throws on the way into DynamoDB. structuredClone did neither, which made
+     * the memory store the more forgiving of the two and let a test pass over
+     * data the production store would reject.
+     */
+    static storedCopy(record) {
+        return JSON.parse(JSON.stringify(record));
+    }
+    async get(sessionKeyHash, secretHash) {
+        const record = this.records.get(LambderMemorySessionStore.keyOf(sessionKeyHash, secretHash));
+        return record ? LambderMemorySessionStore.storedCopy(record) : null;
+    }
+    async put(record) {
+        this.records.set(LambderMemorySessionStore.keyOf(record.sessionKeyHash, record.secretHash), LambderMemorySessionStore.storedCopy(record), record.expiresAt);
+    }
+    async delete(sessionKeyHash, secretHash) {
+        this.records.delete(LambderMemorySessionStore.keyOf(sessionKeyHash, secretHash));
+    }
+    async listSecretHashes(sessionKeyHash) {
+        return this.records.values()
+            .filter((record) => record.sessionKeyHash === sessionKeyHash)
+            .map((record) => record.secretHash);
+    }
+    async markDataExpired(sessionKeyHash, secretHash, at) {
+        const record = this.records.get(LambderMemorySessionStore.keyOf(sessionKeyHash, secretHash));
+        if (record)
+            record.dataExpiresAt = at;
+    }
+    /** Every live record held, for assertions. */
+    list() {
+        return this.records.values().map((record) => LambderMemorySessionStore.storedCopy(record));
+    }
+    /** Number of live records held. */
+    get size() { return this.records.size; }
+    /** Forgets every record: everyone is signed out. */
+    reset() {
+        this.records.clear();
+    }
+}

package/dist/stores/LambderS3FileSource.d.ts

@@ -1,5 +1,5 @@
 import type { S3Client, S3ClientConfig } from "@aws-sdk/client-s3";
-import { type LambderFile, type LambderFileSource } from "../core/LambderFiles.js";
+import { type LambderFile, type LambderFileSource } from "../shared/contracts/LambderFileSource.js";
 export type LambderS3FileSourceOptions = {
     bucket: string;
     /** Literal key prefix the relative path is appended to, so include the trailing slash: "web/v42/". Default: none. */

package/dist/stores/LambderS3FileSource.js

@@ -1,4 +1,4 @@
-import { remoteStoreFile } from "../core/LambderFiles.js";
+import { remoteStoreFile } from "../shared/contracts/LambderFileSource.js";
 /**
  * Files from an S3 bucket, or any S3-compatible store such as Cloudflare
  * R2 (pass its endpoint in clientConfig). Needs @aws-sdk/client-s3, an

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "lambder",
-  "version": "6.0.2",
+  "version": "7.0.2",
+  "sideEffects": false,
   "description": "Opinionated serverless web framework for TypeScript on AWS Lambda: type-safe APIs from Zod schemas, DynamoDB sessions, and declarative rate limits, authorization guards and idempotency.",
   "keywords": [
     "lambda",
@@ -44,18 +45,19 @@
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
-    "./testing": {
-      "types": "./dist/testing.d.ts",
-      "default": "./dist/testing.js"
-    }
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "default": "./dist/mock.js"
+    },
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       "client": [
         "./dist/client.d.ts"
       ],
-      "testing": [
-        "./dist/testing.d.ts"
+      "mock": [
+        "./dist/mock.d.ts"
       ]
     }
   },
@@ -66,24 +68,29 @@
     "crypto": false
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "typecheck": "tsc -p tsconfig.tests.json",
-    "test": "npm run typecheck && vitest run",
+    "test": "npm run typecheck && npm run lint && npm run build && vitest run",
     "test:watch": "vitest",
-    "build": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix"
+    "build": "rm -rf dist && tsc",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "eslint . --ext .ts,.tsx --fix",
+    "prepublishOnly": "npm test"
   },
   "dependencies": {
+    "@types/aws-lambda": "^8.10.136",
     "cookie": "^1.0.2",
     "js-cookie": "^3.0.5",
     "lru-cache": "^11.5.2",
     "mime-types": "^2.1.35",
-    "path-to-regexp": "^6.2.1"
+    "path-to-regexp": "^6.2.1",
+    "tough-cookie": "^6.0.2"
   },
   "peerDependencies": {
     "@aws-sdk/client-dynamodb": "^3.574.0",
@@ -108,9 +115,6 @@
     },
     "msw": {
       "optional": true
-    },
-    "zod": {
-      "optional": true
     }
   },
   "devDependencies": {
@@ -118,16 +122,14 @@
     "@aws-sdk/client-lambda": "^3.1131.0",
     "@aws-sdk/client-s3": "^3.1127.0",
     "@aws-sdk/lib-dynamodb": "^3.913.0",
-    "@types/aws-lambda": "^8.10.136",
-    "@types/cookie": "^0.6.0",
     "@types/js-cookie": "^3.0.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^24.9.0",
-    "@types/path-to-regexp": "^1.7.0",
     "@typescript-eslint/eslint-plugin": "^8.70.0",
     "@typescript-eslint/parser": "^8.70.0",
     "aws-sdk-client-mock": "^4.1.0",
     "eslint": "^8.57.0",
+    "msw": "^2.15.0",
     "typescript": "^6.0.3",
     "vitest": "^5.0.0",
     "zod": "^4.6.2"

package/dist/client/LambderMSW.d.ts

@@ -1,69 +0,0 @@
-import type { ApiContractShape } from '../shared/LambderApiContract.js';
-type RequestHandler = any;
-/** The parts of the msw module LambderMSW uses: `import { http, HttpResponse } from "msw"`. */
-export type LambderMswModule = {
-    http: {
-        post: (path: string, resolver: (info: {
-            request: Request;
-        }) => any) => any;
-    };
-    HttpResponse: {
-        json: (body: any, init?: {
-            status?: number;
-        }) => any;
-    };
-};
-type MockApiOptions = {
-    versionExpired?: boolean;
-    sessionExpired?: boolean;
-    notAuthorized?: boolean;
-    message?: any;
-    errorMessage?: any;
-    logList?: any[];
-    delay?: number;
-};
-export default class LambderMSW<TContract extends ApiContractShape = any> {
-    private apiPath;
-    private apiVersion?;
-    private http;
-    private HttpResponse;
-    constructor({ apiPath, apiVersion, msw, }: {
-        apiPath: string;
-        apiVersion?: string;
-        /** Pass the msw module: `import * as msw from "msw"` (ESM-safe; no hidden require). */
-        msw: LambderMswModule;
-    });
-    /**
-     * Mock an API endpoint with MSW
-     * @param apiName - The name of the API to mock
-     * @param handler - Function that returns the mock payload
-     * @param options - Additional response options (session expired, version expired, etc.)
-     *
-     * Note: TypeScript will check that the return type is assignable to the output type,
-     * but due to structural typing, extra properties are allowed. Enable strict checks
-     * in your tsconfig.json with "noUncheckedIndexedAccess" and "exactOptionalPropertyTypes"
-     * for better type safety.
-     */
-    mockApi<TApiName extends keyof TContract>(apiName: TApiName, handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'], options?: MockApiOptions): RequestHandler;
-    /**
-     * Mock an API endpoint that returns a session expired error
-     */
-    mockSessionExpired<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
-    /**
-     * Mock an API endpoint that returns a version expired error
-     */
-    mockVersionExpired<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
-    /**
-     * Mock an API endpoint that returns a not authorized error
-     */
-    mockNotAuthorized<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
-    /**
-     * Mock an API endpoint that returns an error message
-     */
-    mockError<TApiName extends keyof TContract>(apiName: TApiName, errorMessage: string): RequestHandler;
-    /**
-     * Mock an API endpoint with a custom message
-     */
-    mockWithMessage<TApiName extends keyof TContract>(apiName: TApiName, handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'], message: any): RequestHandler;
-}
-export {};