@zahid15/mockline 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1057 @@
+import { z } from 'zod';
+
+declare const responseShape: z.ZodObject<{
+    status: z.ZodOptional<z.ZodNumber>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    delay: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    delay?: number | undefined;
+    status?: number | undefined;
+    body?: unknown;
+    headers?: Record<string, string> | undefined;
+}, {
+    delay?: number | undefined;
+    status?: number | undefined;
+    body?: unknown;
+    headers?: Record<string, string> | undefined;
+}>;
+declare const conditionSchema: z.ZodObject<{
+    location: z.ZodEnum<["query", "header", "body"]>;
+    name: z.ZodString;
+    op: z.ZodDefault<z.ZodEnum<["eq", "contains", "regex"]>>;
+    value: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    location: "body" | "query" | "header";
+    name: string;
+    op: "eq" | "contains" | "regex";
+    value?: unknown;
+}, {
+    location: "body" | "query" | "header";
+    name: string;
+    value?: unknown;
+    op?: "eq" | "contains" | "regex" | undefined;
+}>;
+declare const overrideSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodNumber>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    delay: z.ZodOptional<z.ZodNumber>;
+    sequence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        status: z.ZodOptional<z.ZodNumber>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        delay: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }>, "many">>;
+    loop: z.ZodDefault<z.ZodBoolean>;
+    when: z.ZodOptional<z.ZodObject<{
+        location: z.ZodEnum<["query", "header", "body"]>;
+        name: z.ZodString;
+        op: z.ZodDefault<z.ZodEnum<["eq", "contains", "regex"]>>;
+        value: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        location: "body" | "query" | "header";
+        name: string;
+        op: "eq" | "contains" | "regex";
+        value?: unknown;
+    }, {
+        location: "body" | "query" | "header";
+        name: string;
+        value?: unknown;
+        op?: "eq" | "contains" | "regex" | undefined;
+    }>>;
+    response: z.ZodOptional<z.ZodObject<{
+        status: z.ZodOptional<z.ZodNumber>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        delay: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodObject<{
+            location: z.ZodEnum<["query", "header", "body"]>;
+            name: z.ZodString;
+            op: z.ZodDefault<z.ZodEnum<["eq", "contains", "regex"]>>;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        }, {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        }>;
+        response: z.ZodObject<{
+            status: z.ZodOptional<z.ZodNumber>;
+            body: z.ZodOptional<z.ZodUnknown>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            delay: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        when: {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        };
+        response: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        };
+    }, {
+        when: {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        };
+        response: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        };
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    loop: boolean;
+    delay?: number | undefined;
+    status?: number | undefined;
+    body?: unknown;
+    headers?: Record<string, string> | undefined;
+    sequence?: {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }[] | undefined;
+    when?: {
+        location: "body" | "query" | "header";
+        name: string;
+        op: "eq" | "contains" | "regex";
+        value?: unknown;
+    } | undefined;
+    response?: {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    } | undefined;
+    rules?: {
+        when: {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        };
+        response: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        };
+    }[] | undefined;
+}, {
+    delay?: number | undefined;
+    status?: number | undefined;
+    body?: unknown;
+    headers?: Record<string, string> | undefined;
+    sequence?: {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    }[] | undefined;
+    loop?: boolean | undefined;
+    when?: {
+        location: "body" | "query" | "header";
+        name: string;
+        value?: unknown;
+        op?: "eq" | "contains" | "regex" | undefined;
+    } | undefined;
+    response?: {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+    } | undefined;
+    rules?: {
+        when: {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        };
+        response: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        };
+    }[] | undefined;
+}>;
+declare const configSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    host: z.ZodDefault<z.ZodString>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    prefer: z.ZodDefault<z.ZodEnum<["example", "generate"]>>;
+    latency: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, [number, number], [number, number]>, z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        fixed: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        distribution: z.ZodDefault<z.ZodEnum<["uniform", "normal"]>>;
+    }, "strip", z.ZodTypeAny, {
+        distribution: "uniform" | "normal";
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+        distribution?: "uniform" | "normal" | undefined;
+    }>, {
+        distribution: "uniform" | "normal";
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+        distribution?: "uniform" | "normal" | undefined;
+    }>, {
+        distribution: "uniform" | "normal";
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+        distribution?: "uniform" | "normal" | undefined;
+    }>]>>;
+    errors: z.ZodDefault<z.ZodObject<{
+        rate: z.ZodDefault<z.ZodNumber>;
+        statuses: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+        perOperationRates: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        rate: number;
+        statuses: number[];
+        perOperationRates: Record<string, number>;
+    }, {
+        rate?: number | undefined;
+        statuses?: number[] | undefined;
+        perOperationRates?: Record<string, number> | undefined;
+    }>>;
+    validate: z.ZodDefault<z.ZodEnum<["off", "warn", "strict"]>>;
+    stateful: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        seedItems: z.ZodDefault<z.ZodNumber>;
+        idProperty: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        seedItems: number;
+        idProperty: string;
+    }, {
+        enabled?: boolean | undefined;
+        seedItems?: number | undefined;
+        idProperty?: string | undefined;
+    }>>;
+    overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodOptional<z.ZodNumber>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        delay: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            status: z.ZodOptional<z.ZodNumber>;
+            body: z.ZodOptional<z.ZodUnknown>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            delay: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }>, "many">>;
+        loop: z.ZodDefault<z.ZodBoolean>;
+        when: z.ZodOptional<z.ZodObject<{
+            location: z.ZodEnum<["query", "header", "body"]>;
+            name: z.ZodString;
+            op: z.ZodDefault<z.ZodEnum<["eq", "contains", "regex"]>>;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        }, {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        }>>;
+        response: z.ZodOptional<z.ZodObject<{
+            status: z.ZodOptional<z.ZodNumber>;
+            body: z.ZodOptional<z.ZodUnknown>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            delay: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }, {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodObject<{
+                location: z.ZodEnum<["query", "header", "body"]>;
+                name: z.ZodString;
+                op: z.ZodDefault<z.ZodEnum<["eq", "contains", "regex"]>>;
+                value: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                location: "body" | "query" | "header";
+                name: string;
+                op: "eq" | "contains" | "regex";
+                value?: unknown;
+            }, {
+                location: "body" | "query" | "header";
+                name: string;
+                value?: unknown;
+                op?: "eq" | "contains" | "regex" | undefined;
+            }>;
+            response: z.ZodObject<{
+                status: z.ZodOptional<z.ZodNumber>;
+                body: z.ZodOptional<z.ZodUnknown>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                delay: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            }, {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                op: "eq" | "contains" | "regex";
+                value?: unknown;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }, {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                value?: unknown;
+                op?: "eq" | "contains" | "regex" | undefined;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        loop: boolean;
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+        sequence?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }[] | undefined;
+        when?: {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        } | undefined;
+        response?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        } | undefined;
+        rules?: {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                op: "eq" | "contains" | "regex";
+                value?: unknown;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }[] | undefined;
+    }, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+        sequence?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }[] | undefined;
+        loop?: boolean | undefined;
+        when?: {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        } | undefined;
+        response?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        } | undefined;
+        rules?: {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                value?: unknown;
+                op?: "eq" | "contains" | "regex" | undefined;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }[] | undefined;
+    }>>>;
+    proxy: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        all: z.ZodDefault<z.ZodBoolean>;
+        allowPrivate: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        recordFile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        all: boolean;
+        allowPrivate: boolean;
+        timeoutMs: number;
+        recordFile?: string | undefined;
+        url?: string | undefined;
+    }, {
+        recordFile?: string | undefined;
+        url?: string | undefined;
+        all?: boolean | undefined;
+        allowPrivate?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    }>, {
+        all: boolean;
+        allowPrivate: boolean;
+        timeoutMs: number;
+        recordFile?: string | undefined;
+        url?: string | undefined;
+    }, {
+        recordFile?: string | undefined;
+        url?: string | undefined;
+        all?: boolean | undefined;
+        allowPrivate?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    }>>;
+    cors: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        origins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        origins: string[];
+    }, {
+        enabled?: boolean | undefined;
+        origins?: string[] | undefined;
+    }>>;
+    recording: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        file: z.ZodOptional<z.ZodString>;
+        maxRequests: z.ZodDefault<z.ZodNumber>;
+        redactHeaders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxRequests: number;
+        redactHeaders: string[];
+        file?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        file?: string | undefined;
+        maxRequests?: number | undefined;
+        redactHeaders?: string[] | undefined;
+    }>>;
+    generation: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        hints: z.ZodDefault<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>>]>>;
+        counter: z.ZodDefault<z.ZodBoolean>;
+        maxDepth: z.ZodDefault<z.ZodNumber>;
+        minArrayItems: z.ZodDefault<z.ZodNumber>;
+        maxArrayItems: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        hints: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
+        counter: boolean;
+        maxDepth: number;
+        minArrayItems: number;
+        maxArrayItems: number;
+    }, {
+        hints?: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        counter?: boolean | undefined;
+        maxDepth?: number | undefined;
+        minArrayItems?: number | undefined;
+        maxArrayItems?: number | undefined;
+    }>, {
+        hints: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
+        counter: boolean;
+        maxDepth: number;
+        minArrayItems: number;
+        maxArrayItems: number;
+    }, {
+        hints?: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        counter?: boolean | undefined;
+        maxDepth?: number | undefined;
+        minArrayItems?: number | undefined;
+        maxArrayItems?: number | undefined;
+    }>>;
+    controlHeaders: z.ZodDefault<z.ZodObject<{
+        allow: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        allow: boolean;
+    }, {
+        allow?: boolean | undefined;
+    }>>;
+    inspector: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+    enforceAuth: z.ZodDefault<z.ZodBoolean>;
+    requestBodyLimit: z.ZodDefault<z.ZodNumber>;
+    requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    host: string;
+    prefer: "example" | "generate";
+    validate: "off" | "warn" | "strict";
+    stateful: {
+        enabled: boolean;
+        seedItems: number;
+        idProperty: string;
+    };
+    proxy: {
+        all: boolean;
+        allowPrivate: boolean;
+        timeoutMs: number;
+        recordFile?: string | undefined;
+        url?: string | undefined;
+    };
+    cors: {
+        enabled: boolean;
+        origins: string[];
+    };
+    inspector: {
+        enabled?: boolean | undefined;
+    };
+    enforceAuth: boolean;
+    latency: number | [number, number] | {
+        distribution: "uniform" | "normal";
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+    };
+    errors: {
+        rate: number;
+        statuses: number[];
+        perOperationRates: Record<string, number>;
+    };
+    overrides: Record<string, {
+        loop: boolean;
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+        sequence?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }[] | undefined;
+        when?: {
+            location: "body" | "query" | "header";
+            name: string;
+            op: "eq" | "contains" | "regex";
+            value?: unknown;
+        } | undefined;
+        response?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        } | undefined;
+        rules?: {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                op: "eq" | "contains" | "regex";
+                value?: unknown;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }[] | undefined;
+    }>;
+    recording: {
+        enabled: boolean;
+        maxRequests: number;
+        redactHeaders: string[];
+        file?: string | undefined;
+    };
+    generation: {
+        hints: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
+        counter: boolean;
+        maxDepth: number;
+        minArrayItems: number;
+        maxArrayItems: number;
+    };
+    controlHeaders: {
+        allow: boolean;
+    };
+    requestBodyLimit: number;
+    requestTimeoutMs: number;
+    seed?: number | undefined;
+}, {
+    port?: number | undefined;
+    host?: string | undefined;
+    seed?: number | undefined;
+    prefer?: "example" | "generate" | undefined;
+    validate?: "off" | "warn" | "strict" | undefined;
+    stateful?: {
+        enabled?: boolean | undefined;
+        seedItems?: number | undefined;
+        idProperty?: string | undefined;
+    } | undefined;
+    proxy?: {
+        recordFile?: string | undefined;
+        url?: string | undefined;
+        all?: boolean | undefined;
+        allowPrivate?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    } | undefined;
+    cors?: {
+        enabled?: boolean | undefined;
+        origins?: string[] | undefined;
+    } | undefined;
+    inspector?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    enforceAuth?: boolean | undefined;
+    latency?: number | [number, number] | {
+        min?: number | undefined;
+        max?: number | undefined;
+        fixed?: number | undefined;
+        distribution?: "uniform" | "normal" | undefined;
+    } | undefined;
+    errors?: {
+        rate?: number | undefined;
+        statuses?: number[] | undefined;
+        perOperationRates?: Record<string, number> | undefined;
+    } | undefined;
+    overrides?: Record<string, {
+        delay?: number | undefined;
+        status?: number | undefined;
+        body?: unknown;
+        headers?: Record<string, string> | undefined;
+        sequence?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        }[] | undefined;
+        loop?: boolean | undefined;
+        when?: {
+            location: "body" | "query" | "header";
+            name: string;
+            value?: unknown;
+            op?: "eq" | "contains" | "regex" | undefined;
+        } | undefined;
+        response?: {
+            delay?: number | undefined;
+            status?: number | undefined;
+            body?: unknown;
+            headers?: Record<string, string> | undefined;
+        } | undefined;
+        rules?: {
+            when: {
+                location: "body" | "query" | "header";
+                name: string;
+                value?: unknown;
+                op?: "eq" | "contains" | "regex" | undefined;
+            };
+            response: {
+                delay?: number | undefined;
+                status?: number | undefined;
+                body?: unknown;
+                headers?: Record<string, string> | undefined;
+            };
+        }[] | undefined;
+    }> | undefined;
+    recording?: {
+        enabled?: boolean | undefined;
+        file?: string | undefined;
+        maxRequests?: number | undefined;
+        redactHeaders?: string[] | undefined;
+    } | undefined;
+    generation?: {
+        hints?: boolean | Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        counter?: boolean | undefined;
+        maxDepth?: number | undefined;
+        minArrayItems?: number | undefined;
+        maxArrayItems?: number | undefined;
+    } | undefined;
+    controlHeaders?: {
+        allow?: boolean | undefined;
+    } | undefined;
+    requestBodyLimit?: number | undefined;
+    requestTimeoutMs?: number | undefined;
+}>;
+type MocklineConfig = z.infer<typeof configSchema>;
+type OverrideConfig = z.input<typeof overrideSchema>;
+type NormalizedOverrideConfig = MocklineConfig['overrides'][string];
+type OverrideResponseConfig = z.infer<typeof responseShape>;
+type ConditionConfig = z.infer<typeof conditionSchema>;
+type ConditionInput = z.input<typeof conditionSchema>;
+declare const defaultConfig: MocklineConfig;
+
+interface Logger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+}
+
+type UnknownRecord = Record<string, unknown>;
+interface JsonSchema extends UnknownRecord {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: string[];
+    enum?: unknown[];
+    const?: unknown;
+    $ref?: string;
+}
+interface MediaTypeObject extends UnknownRecord {
+    schema?: JsonSchema;
+    example?: unknown;
+    examples?: Record<string, ExampleObject | unknown>;
+}
+interface ExampleObject extends UnknownRecord {
+    value?: unknown;
+    externalValue?: string;
+    summary?: string;
+}
+interface ApiResponse extends UnknownRecord {
+    description?: string;
+    content?: Record<string, MediaTypeObject>;
+    headers?: Record<string, UnknownRecord>;
+}
+interface ApiParameter extends UnknownRecord {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required?: boolean;
+    schema?: JsonSchema;
+    style?: string;
+    explode?: boolean;
+}
+interface ApiOperation extends UnknownRecord {
+    operationId?: string;
+    parameters?: ApiParameter[];
+    requestBody?: UnknownRecord;
+    responses?: Record<string, ApiResponse>;
+    security?: Array<Record<string, string[]>>;
+    summary?: string;
+}
+interface ApiPathItem extends UnknownRecord {
+    parameters?: ApiParameter[];
+    servers?: Array<{
+        url: string;
+    }>;
+}
+interface ApiServer {
+    url: string;
+    variables?: Record<string, {
+        default?: string;
+        enum?: string[];
+    }>;
+}
+interface OpenApiDocument extends UnknownRecord {
+    openapi?: string;
+    swagger?: string;
+    info?: UnknownRecord;
+    servers?: ApiServer[];
+    paths?: Record<string, ApiPathItem>;
+    components?: {
+        schemas?: Record<string, JsonSchema>;
+        securitySchemes?: Record<string, UnknownRecord>;
+        [key: string]: unknown;
+    };
+    security?: Array<Record<string, string[]>>;
+}
+interface MatchedRoute {
+    method: string;
+    path: string;
+    routePath: string;
+    operationId: string;
+    operation: ApiOperation;
+    pathItem: ApiPathItem;
+    parameters: ApiParameter[];
+    score: number;
+}
+type ResponseSource = 'example' | 'generated' | 'override' | 'proxy' | 'state';
+interface RecordedRequest {
+    id: string;
+    timestamp: string;
+    method: string;
+    url: string;
+    operationId?: string;
+    matchedPath?: string;
+    headers: Record<string, string | string[]>;
+    body?: unknown;
+    responseStatus: number;
+    responseSource: ResponseSource | 'inspector' | 'error';
+    durationMs: number;
+    validationErrors: string[];
+}
+interface RequestFilter {
+    method?: string;
+    path?: string;
+    status?: number;
+    operationId?: string;
+    since?: string | Date;
+    limit?: number;
+}
+interface MockResponse {
+    status: number;
+    body?: unknown;
+    headers?: Record<string, string>;
+    delay?: number;
+    source: ResponseSource;
+}
+interface SummaryOperation {
+    method: string;
+    path: string;
+    operationId: string;
+    defaultStatus: string;
+    source: 'example' | 'override' | 'schema generation';
+}
+
+interface RequestAccessor {
+    (filter?: RequestFilter): RecordedRequest[];
+    get(id: string): RecordedRequest | undefined;
+    clear(): void;
+}
+interface MockServer {
+    readonly url: string;
+    readonly requests: RequestAccessor;
+    reset(): Promise<void>;
+    setOverride(key: string, override: OverrideConfig): void;
+    close(): Promise<void>;
+}
+type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+interface CreateMockServerOptions {
+    spec: string;
+    port?: number;
+    host?: string;
+    seed?: number;
+    config?: DeepPartial<MocklineConfig>;
+    inspector?: boolean;
+    logger?: Logger;
+    clock?: () => Date;
+    fetch?: typeof globalThis.fetch;
+    watch?: boolean;
+    configFile?: string;
+    reloadConfig?: () => Promise<MocklineConfig>;
+}
+declare function createMockServer(options: CreateMockServerOptions): Promise<MockServer>;
+
+interface SpecWarning {
+    message: string;
+    operationId?: string;
+    path?: string;
+}
+interface LoadedSpec {
+    file: string;
+    document: OpenApiDocument;
+    dereferenced: OpenApiDocument;
+    warnings: SpecWarning[];
+}
+declare function inspectSpec(document: OpenApiDocument): SpecWarning[];
+declare function loadSpec(file: string): Promise<LoadedSpec>;
+
+declare function defaultStatus(responses: Record<string, ApiResponse> | undefined): string;
+declare function summarizeSpec(spec: LoadedSpec, overrideKeys?: string[]): SummaryOperation[];
+
+interface RouteMatch {
+    route: MatchedRoute;
+    params: Record<string, string>;
+}
+interface Router {
+    routes: MatchedRoute[];
+    match(method: string, pathname: string): RouteMatch | undefined;
+    methodsForPath(pathname: string): string[];
+    nearestPath(pathname: string): string | undefined;
+}
+declare function normalizePath(value: string): string;
+declare function createRouter(document: OpenApiDocument): Router;
+
+declare function hashSeed(input: string | number): number;
+declare function deriveSeed(seed: number | undefined, ...parts: Array<string | number>): number;
+declare class SeededRandom {
+    private state;
+    constructor(seed: number);
+    next(): number;
+    int(min: number, max: number): number;
+    float(min: number, max: number): number;
+    bool(probability?: number): boolean;
+    pick<T>(items: readonly T[]): T | undefined;
+}
+
+type HintValue = string | number | boolean | null;
+type GenerationHints = Record<string, HintValue | readonly HintValue[]>;
+
+interface GenerationOptions {
+    seed?: number;
+    root?: OpenApiDocument;
+    maxDepth?: number;
+    minArrayItems?: number;
+    maxArrayItems?: number;
+    hints?: boolean | GenerationHints;
+    mode?: 'response' | 'request';
+}
+interface GeneratorWarning {
+    message: string;
+}
+interface GenerationResult {
+    value: unknown;
+    warnings: GeneratorWarning[];
+}
+declare function generateFromSchema(schema: JsonSchema, options?: GenerationOptions): GenerationResult;
+declare function generateValue(schema: JsonSchema, options?: GenerationOptions): unknown;
+
+interface ValidationIssue {
+    location: string;
+    message: string;
+    keyword?: string;
+}
+interface RequestValidationInput {
+    root: OpenApiDocument;
+    route: MatchedRoute;
+    params: Record<string, string>;
+    url: URL;
+    headers: Record<string, string | string[] | undefined>;
+    body: unknown;
+    bodyPresent: boolean;
+}
+interface RequestValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    bodyInvalid: boolean;
+}
+declare function validateRequest(input: RequestValidationInput): RequestValidationResult;
+declare function checkSecurityPresence(root: OpenApiDocument, operation: ApiOperation, headers: RequestValidationInput['headers'], url: URL): {
+    authorized: boolean;
+    missing: string[];
+};
+
+interface ResourceCollection {
+    path: string;
+    idParam: string;
+    idProperty: string;
+    listRoute: MatchedRoute;
+    createRoute: MatchedRoute;
+    itemRoutes: Map<string, MatchedRoute>;
+    itemSchema: JsonSchema;
+    createSchema?: JsonSchema;
+    limitParam?: string;
+    offsetParam?: string;
+}
+declare function detectCollections(router: Router, root: OpenApiDocument, idProperty?: string): ResourceCollection[];
+
+declare class ResourceStore {
+    readonly collections: ResourceCollection[];
+    private readonly root;
+    private seed;
+    private config;
+    private readonly data;
+    private readonly routeIndex;
+    constructor(router: Router, root: OpenApiDocument, config: MocklineConfig);
+    setConfig(config: MocklineConfig): void;
+    reset(): void;
+    handle(route: MatchedRoute, params: Record<string, string>, url: URL, body: unknown): MockResponse | undefined;
+    private ensureId;
+}
+
+export { type ConditionConfig, type ConditionInput, type CreateMockServerOptions, type DeepPartial, type GenerationOptions, type GeneratorWarning, type LoadedSpec, type MockServer, type MocklineConfig, type NormalizedOverrideConfig, type OverrideConfig, type OverrideResponseConfig, type RecordedRequest, type RequestAccessor, type RequestFilter, type RequestValidationInput, type RequestValidationResult, type ResourceCollection, ResourceStore, type ResponseSource, type RouteMatch, type Router, SeededRandom, type SpecWarning, type ValidationIssue, checkSecurityPresence, configSchema, createMockServer, createRouter, defaultConfig, defaultStatus, deriveSeed, detectCollections, generateFromSchema, generateValue, hashSeed, inspectSpec, loadSpec, normalizePath, summarizeSpec, validateRequest };