@shipeasy/openapi 1.6.0 → 2.2.0

package/dist/resources/experiments.d.ts

@@ -1,849 +0,0 @@
-import { z } from 'zod';
-import { experimentCreateSchema, experimentUpdateSchema } from '../schemas/experiments.js';
-import { PageQuery, Page } from '../schemas/pagination.js';
-import { Transport } from '../transport.js';
-
-/**
- * Input shape callers send (defaults still optional). The server applies
- * defaults via `.parse()`, so consumers can omit `significance_threshold`,
- * `min_runtime_days`, `params`, etc. — `z.input` expresses that.
- */
-type ExperimentCreateInput = z.input<typeof experimentCreateSchema>;
-type ExperimentUpdateInput = z.input<typeof experimentUpdateSchema>;
-interface Experiment {
-    id: string;
-    name: string;
-    status: "draft" | "running" | "stopped" | "archived" | string;
-    universe: string;
-    allocationPct: number;
-    significance_threshold?: number;
-    min_runtime_days?: number;
-    startedAt?: string | null;
-    started_at?: string | null;
-    updatedAt?: string;
-}
-interface ExperimentResult {
-    metric: string;
-    group_name: string;
-    ds: string;
-    n: number | null;
-    mean: number | null;
-    delta_pct: number | null;
-    p_value: number | null;
-    srm_detected: number | null;
-}
-interface ExperimentTimeseriesPoint {
-    ds: string;
-    group_name: string;
-    metric: string;
-    value: number | null;
-}
-type ExperimentStatus = "draft" | "running" | "stopped" | "archived";
-interface ExperimentMetricsInput {
-    metrics: {
-        metric_id: string;
-        role: "goal" | "guardrail" | "secondary";
-    }[];
-}
-interface ExperimentsClient {
-    list(opts?: Partial<PageQuery>): Promise<Page<Experiment>>;
-    listAll(): Promise<Experiment[]>;
-    get(id: string): Promise<Experiment>;
-    resolve(idOrName: string): Promise<Experiment>;
-    create(input: ExperimentCreateInput): Promise<Experiment>;
-    update(id: string, input: ExperimentUpdateInput): Promise<Experiment>;
-    delete(id: string): Promise<{
-        ok: true;
-    }>;
-    setStatus(id: string, status: ExperimentStatus): Promise<Experiment>;
-    start(id: string): Promise<Experiment>;
-    stop(id: string): Promise<Experiment>;
-    archive(id: string): Promise<Experiment>;
-    /** Restore a soft-deleted (archived) experiment back to `draft`. */
-    restore(id: string): Promise<Experiment>;
-    setMetrics(id: string, input: ExperimentMetricsInput): Promise<unknown>;
-    results(id: string): Promise<ExperimentResult[]>;
-    timeseries(id: string, metric?: string): Promise<ExperimentTimeseriesPoint[]>;
-    reanalyze(id: string): Promise<{
-        ok: true;
-    }>;
-}
-declare function experimentsClient(t: Transport): ExperimentsClient;
-declare const experimentsResource: {
-    readonly name: "experiments";
-    readonly basePath: "/api/admin/experiments";
-    readonly describeOne: "experiment";
-    readonly describeMany: "experiments";
-    readonly tag: {
-        readonly name: "Experiments";
-        readonly description: string;
-    };
-    readonly schemas: {
-        readonly create: z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            hypothesis: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            tag: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            owner_email: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            audience: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            bucket_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            universe: z.ZodString;
-            targeting_gate: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            allocation_pct: z.ZodDefault<z.ZodNumber>;
-            salt: z.ZodOptional<z.ZodString>;
-            params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-                string: "string";
-                number: "number";
-                bool: "bool";
-            }>>>;
-            groups: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                weight: z.ZodNumber;
-                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>;
-            significance_threshold: z.ZodDefault<z.ZodNumber>;
-            min_runtime_days: z.ZodDefault<z.ZodNumber>;
-            min_sample_size: z.ZodDefault<z.ZodNumber>;
-            sequential_testing: z.ZodDefault<z.ZodBoolean>;
-            goal_metric: z.ZodOptional<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>;
-            guardrail_metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-        readonly update: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            hypothesis: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            owner_email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            audience: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            bucket_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            targeting_gate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            allocation_pct: z.ZodOptional<z.ZodNumber>;
-            salt: z.ZodOptional<z.ZodString>;
-            universe: z.ZodOptional<z.ZodString>;
-            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-                string: "string";
-                number: "number";
-                bool: "bool";
-            }>>>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                weight: z.ZodNumber;
-                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>>;
-            significance_threshold: z.ZodOptional<z.ZodNumber>;
-            min_runtime_days: z.ZodOptional<z.ZodNumber>;
-            min_sample_size: z.ZodOptional<z.ZodNumber>;
-            sequential_testing: z.ZodOptional<z.ZodBoolean>;
-            goal_metric: z.ZodOptional<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>;
-            guardrail_metrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-    };
-    readonly actions: readonly [{
-        readonly name: "start";
-        readonly description: "Transition draft experiment to running";
-    }, {
-        readonly name: "stop";
-        readonly description: "Stop a running experiment";
-    }, {
-        readonly name: "archive";
-        readonly description: "Archive a stopped experiment";
-    }, {
-        readonly name: "restore";
-        readonly description: "Restore an archived (never-started) experiment to draft";
-    }, {
-        readonly name: "reanalyze";
-        readonly description: "Re-run analysis pass for the experiment";
-    }];
-    readonly endpoints: readonly [{
-        readonly operationId: "listExperiments";
-        readonly method: "GET";
-        readonly path: "";
-        readonly summary: "List experiments";
-        readonly description: "Returns a single page of non-archived experiments ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.";
-        readonly response: z.ZodObject<{
-            data: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodString;
-                description: z.ZodNullable<z.ZodString>;
-                hypothesis: z.ZodNullable<z.ZodString>;
-                tag: z.ZodNullable<z.ZodString>;
-                ownerEmail: z.ZodNullable<z.ZodString>;
-                audience: z.ZodNullable<z.ZodString>;
-                bucketBy: z.ZodNullable<z.ZodString>;
-                folder: z.ZodNullable<z.ZodString>;
-                status: z.ZodEnum<{
-                    draft: "draft";
-                    running: "running";
-                    stopped: "stopped";
-                    archived: "archived";
-                }>;
-                universe: z.ZodString;
-                targetingGate: z.ZodNullable<z.ZodString>;
-                allocationPct: z.ZodNumber;
-                salt: z.ZodString;
-                params: z.ZodRecord<z.ZodString, z.ZodEnum<{
-                    string: "string";
-                    number: "number";
-                    bool: "bool";
-                }>>;
-                groups: z.ZodArray<z.ZodObject<{
-                    name: z.ZodString;
-                    weight: z.ZodNumber;
-                    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                }, z.core.$strip>>;
-                significanceThreshold: z.ZodNumber;
-                minRuntimeDays: z.ZodNumber;
-                minSampleSize: z.ZodNumber;
-                sequentialTesting: z.ZodBoolean;
-                startedAt: z.ZodNullable<z.ZodString>;
-                stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                updatedAt: z.ZodString;
-            }, z.core.$strip>>;
-            next_cursor: z.ZodNullable<z.ZodString>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                readonly data: readonly [{
-                    id: string;
-                    name: string;
-                    description: string;
-                    tag: string;
-                    status: string;
-                    universe: string;
-                    targetingGate: null;
-                    allocationPct: number;
-                    salt: string;
-                    params: {
-                        cta_color: string;
-                    };
-                    groups: {
-                        name: string;
-                        weight: number;
-                        params: {
-                            cta_color: string;
-                        };
-                    }[];
-                    significanceThreshold: number;
-                    minRuntimeDays: number;
-                    minSampleSize: number;
-                    sequentialTesting: boolean;
-                    startedAt: string;
-                    stoppedAt: null;
-                    updatedAt: string;
-                }];
-                readonly next_cursor: null;
-            };
-        };
-        readonly useCase: "Snapshot every active experiment in the project — e.g. render an overview dashboard or drive a CI check that no experiment has been running past its `min_runtime_days`.";
-    }, {
-        readonly operationId: "getExperiment";
-        readonly method: "GET";
-        readonly path: "/{id}";
-        readonly summary: "Get one experiment";
-        readonly description: "Returns the full experiment row including groups, params, allocation, and lifecycle timestamps.";
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id (`exp_…`) or the experiment's `name`.";
-        };
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            description: z.ZodNullable<z.ZodString>;
-            hypothesis: z.ZodNullable<z.ZodString>;
-            tag: z.ZodNullable<z.ZodString>;
-            ownerEmail: z.ZodNullable<z.ZodString>;
-            audience: z.ZodNullable<z.ZodString>;
-            bucketBy: z.ZodNullable<z.ZodString>;
-            folder: z.ZodNullable<z.ZodString>;
-            status: z.ZodEnum<{
-                draft: "draft";
-                running: "running";
-                stopped: "stopped";
-                archived: "archived";
-            }>;
-            universe: z.ZodString;
-            targetingGate: z.ZodNullable<z.ZodString>;
-            allocationPct: z.ZodNumber;
-            salt: z.ZodString;
-            params: z.ZodRecord<z.ZodString, z.ZodEnum<{
-                string: "string";
-                number: "number";
-                bool: "bool";
-            }>>;
-            groups: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                weight: z.ZodNumber;
-                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>;
-            significanceThreshold: z.ZodNumber;
-            minRuntimeDays: z.ZodNumber;
-            minSampleSize: z.ZodNumber;
-            sequentialTesting: z.ZodBoolean;
-            startedAt: z.ZodNullable<z.ZodString>;
-            stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            updatedAt: z.ZodString;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                id: string;
-                name: string;
-                description: string;
-                tag: string;
-                status: string;
-                universe: string;
-                targetingGate: null;
-                allocationPct: number;
-                salt: string;
-                params: {
-                    cta_color: string;
-                };
-                groups: {
-                    name: string;
-                    weight: number;
-                    params: {
-                        cta_color: string;
-                    };
-                }[];
-                significanceThreshold: number;
-                minRuntimeDays: number;
-                minSampleSize: number;
-                sequentialTesting: boolean;
-                startedAt: string;
-                stoppedAt: null;
-                updatedAt: string;
-            };
-        };
-        readonly useCase: "Fetch one experiment to render the detail page or to inspect its current allocation and group weights.";
-    }, {
-        readonly operationId: "createExperiment";
-        readonly method: "POST";
-        readonly path: "";
-        readonly summary: "Create an experiment";
-        readonly description: string;
-        readonly successStatus: 201;
-        readonly request: z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            hypothesis: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            tag: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            owner_email: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            audience: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            bucket_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            universe: z.ZodString;
-            targeting_gate: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            allocation_pct: z.ZodDefault<z.ZodNumber>;
-            salt: z.ZodOptional<z.ZodString>;
-            params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-                string: "string";
-                number: "number";
-                bool: "bool";
-            }>>>;
-            groups: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                weight: z.ZodNumber;
-                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>;
-            significance_threshold: z.ZodDefault<z.ZodNumber>;
-            min_runtime_days: z.ZodDefault<z.ZodNumber>;
-            min_sample_size: z.ZodDefault<z.ZodNumber>;
-            sequential_testing: z.ZodDefault<z.ZodBoolean>;
-            goal_metric: z.ZodOptional<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>;
-            guardrail_metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly requestExamples: {
-                readonly minimal: {
-                    readonly summary: "Minimal — two-group 50/50";
-                    readonly description: "Smallest valid body. Two groups at 50/50, no allocation, no targeting.";
-                    readonly value: {
-                        readonly name: "checkout_button_color";
-                        readonly universe: "primary_users";
-                        readonly groups: readonly [{
-                            readonly name: "control";
-                            readonly weight: 5000;
-                        }, {
-                            readonly name: "treatment";
-                            readonly weight: 5000;
-                        }];
-                    };
-                };
-                readonly targeted: {
-                    readonly summary: "Targeted — gate + allocation + params";
-                    readonly description: "Gate the audience with a `targeting_gate`, allocate 50% of it, and parameterise the variants.";
-                    readonly value: {
-                        readonly name: "checkout_button_color";
-                        readonly description: "Green CTA on checkout for Pro users.";
-                        readonly universe: "primary_users";
-                        readonly targeting_gate: "pro_plan_only";
-                        readonly allocation_pct: 5000;
-                        readonly params: {
-                            readonly cta_color: "string";
-                        };
-                        readonly groups: readonly [{
-                            readonly name: "control";
-                            readonly weight: 5000;
-                            readonly params: {
-                                readonly cta_color: "blue";
-                            };
-                        }, {
-                            readonly name: "treatment";
-                            readonly weight: 5000;
-                            readonly params: {
-                                readonly cta_color: "green";
-                            };
-                        }];
-                    };
-                };
-                readonly multivariant: {
-                    readonly summary: "Multivariant — three groups";
-                    readonly description: "Three variants splitting 40/30/30. Requires the sum to equal 10000.";
-                    readonly value: {
-                        readonly name: "headline_test";
-                        readonly universe: "primary_users";
-                        readonly groups: readonly [{
-                            readonly name: "control";
-                            readonly weight: 4000;
-                        }, {
-                            readonly name: "alt_a";
-                            readonly weight: 3000;
-                        }, {
-                            readonly name: "alt_b";
-                            readonly weight: 3000;
-                        }];
-                    };
-                };
-                readonly sequential: {
-                    readonly summary: "Sequential testing — Premium plan";
-                    readonly description: "Enable always-valid sequential tests. Requires Premium plan or higher.";
-                    readonly value: {
-                        readonly name: "checkout_button_color";
-                        readonly universe: "primary_users";
-                        readonly groups: readonly [{
-                            readonly name: "control";
-                            readonly weight: 5000;
-                        }, {
-                            readonly name: "treatment";
-                            readonly weight: 5000;
-                        }];
-                        readonly sequential_testing: true;
-                        readonly min_runtime_days: 14;
-                    };
-                };
-            };
-            readonly response: {
-                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                readonly name: "checkout_button_color";
-            };
-        };
-        readonly useCase: string;
-    }, {
-        readonly operationId: "updateExperiment";
-        readonly method: "PATCH";
-        readonly path: "/{id}";
-        readonly summary: "Update an experiment";
-        readonly description: string;
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly request: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            hypothesis: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            owner_email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            audience: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            bucket_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            targeting_gate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            allocation_pct: z.ZodOptional<z.ZodNumber>;
-            salt: z.ZodOptional<z.ZodString>;
-            universe: z.ZodOptional<z.ZodString>;
-            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-                string: "string";
-                number: "number";
-                bool: "bool";
-            }>>>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                weight: z.ZodNumber;
-                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>>;
-            significance_threshold: z.ZodOptional<z.ZodNumber>;
-            min_runtime_days: z.ZodOptional<z.ZodNumber>;
-            min_sample_size: z.ZodOptional<z.ZodNumber>;
-            sequential_testing: z.ZodOptional<z.ZodBoolean>;
-            goal_metric: z.ZodOptional<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>;
-            guardrail_metrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                query: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly requestExamples: {
-                readonly rampAllocation: {
-                    readonly summary: "Ramp allocation — 0 → 50%";
-                    readonly description: "Bumps the share of the targeted audience enrolled. Allowed only when the experiment is in `draft`.";
-                    readonly value: {
-                        readonly allocation_pct: 5000;
-                    };
-                };
-                readonly changeWeights: {
-                    readonly summary: "Change group weights";
-                    readonly description: "Replace the groups array — weights must still sum to 10000.";
-                    readonly value: {
-                        readonly groups: readonly [{
-                            readonly name: "control";
-                            readonly weight: 2500;
-                        }, {
-                            readonly name: "treatment";
-                            readonly weight: 7500;
-                        }];
-                    };
-                };
-                readonly tighterSignificance: {
-                    readonly summary: "Tighter significance threshold";
-                    readonly description: "Drop the p-value cutoff from 0.05 → 0.01. Requires Pro plan or higher.";
-                    readonly value: {
-                        readonly significance_threshold: 0.01;
-                    };
-                };
-                readonly updateMetadata: {
-                    readonly summary: "Update metadata";
-                    readonly description: "Change description/tag/targeting_gate freely on running experiments.";
-                    readonly value: {
-                        readonly description: "Bumped to 50% after passing canary on 25%.";
-                        readonly tag: "checkout";
-                    };
-                };
-            };
-            readonly response: {
-                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-            };
-        };
-        readonly useCase: string;
-    }, {
-        readonly operationId: "deleteExperiment";
-        readonly method: "DELETE";
-        readonly path: "/{id}";
-        readonly summary: "Delete an experiment";
-        readonly description: "Archives the experiment (soft-delete via status transition). Returns `409` if the experiment is still `running` — stop it first.";
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly response: z.ZodObject<{
-            ok: z.ZodLiteral<true>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                readonly ok: true;
-            };
-        };
-        readonly useCase: "Tear down an experiment after the analysis is signed off.";
-    }, {
-        readonly operationId: "setExperimentStatus";
-        readonly method: "POST";
-        readonly path: "/{id}/status";
-        readonly summary: "Transition experiment status";
-        readonly description: string;
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly request: z.ZodObject<{
-            status: z.ZodEnum<{
-                draft: "draft";
-                running: "running";
-                stopped: "stopped";
-                archived: "archived";
-            }>;
-        }, z.core.$strip>;
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-            status: z.ZodEnum<{
-                draft: "draft";
-                running: "running";
-                stopped: "stopped";
-                archived: "archived";
-            }>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly requestExamples: {
-                readonly start: {
-                    readonly summary: "Start — draft → running";
-                    readonly description: "Begins allocation. The experiment counts against the plan's `experiments_running` limit.";
-                    readonly value: {
-                        readonly status: "running";
-                    };
-                };
-                readonly stop: {
-                    readonly summary: "Stop — running → stopped";
-                    readonly description: "Halts allocation. Existing exposures remain analysable.";
-                    readonly value: {
-                        readonly status: "stopped";
-                    };
-                };
-                readonly archive: {
-                    readonly summary: "Archive — stopped → archived";
-                    readonly description: "Soft-deletes the experiment. List endpoints exclude archived rows by default.";
-                    readonly value: {
-                        readonly status: "archived";
-                    };
-                };
-                readonly restore: {
-                    readonly summary: "Restore — archived → draft";
-                    readonly description: "Un-deletes a soft-deleted experiment so it can be re-completed and started. Allowed only if it never ran.";
-                    readonly value: {
-                        readonly status: "draft";
-                    };
-                };
-            };
-            readonly response: {
-                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                readonly status: "running";
-            };
-        };
-        readonly useCase: string;
-    }, {
-        readonly operationId: "setExperimentMetrics";
-        readonly method: "POST";
-        readonly path: "/{id}/metrics";
-        readonly summary: "Attach metrics";
-        readonly description: string;
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly request: z.ZodObject<{
-            metrics: z.ZodArray<z.ZodObject<{
-                metric_id: z.ZodString;
-                role: z.ZodEnum<{
-                    goal: "goal";
-                    guardrail: "guardrail";
-                    secondary: "secondary";
-                }>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-            metrics: z.ZodArray<z.ZodObject<{
-                metric_id: z.ZodString;
-                role: z.ZodEnum<{
-                    goal: "goal";
-                    guardrail: "guardrail";
-                    secondary: "secondary";
-                }>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly requestExamples: {
-                readonly standard: {
-                    readonly summary: "Standard — one goal + one guardrail";
-                    readonly description: "Attaches one decision metric and one safety metric.";
-                    readonly value: {
-                        readonly metrics: readonly [{
-                            readonly metric_id: "met_checkout_completed";
-                            readonly role: "goal";
-                        }, {
-                            readonly metric_id: "met_page_errors";
-                            readonly role: "guardrail";
-                        }];
-                    };
-                };
-                readonly detach: {
-                    readonly summary: "Detach all";
-                    readonly description: "Send an empty array to clear every metric.";
-                    readonly value: {
-                        readonly metrics: readonly [];
-                    };
-                };
-            };
-            readonly response: {
-                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                readonly metrics: readonly [{
-                    readonly metric_id: "met_checkout_completed";
-                    readonly role: "goal";
-                }, {
-                    readonly metric_id: "met_page_errors";
-                    readonly role: "guardrail";
-                }];
-            };
-        };
-        readonly useCase: string;
-    }, {
-        readonly operationId: "getExperimentResults";
-        readonly method: "GET";
-        readonly path: "/{id}/results";
-        readonly summary: "Get analysis results";
-        readonly description: "Returns the latest analysis output for the experiment — one row per metric/group/day, including sample size, mean, % delta vs. control, p-value, and a sample-ratio mismatch flag.";
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly response: z.ZodObject<{
-            experiment: z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodString;
-                status: z.ZodEnum<{
-                    draft: "draft";
-                    running: "running";
-                    stopped: "stopped";
-                    archived: "archived";
-                }>;
-            }, z.core.$strip>;
-            results: z.ZodArray<z.ZodObject<{
-                metric: z.ZodString;
-                group_name: z.ZodString;
-                ds: z.ZodString;
-                n: z.ZodNullable<z.ZodNumber>;
-                mean: z.ZodNullable<z.ZodNumber>;
-                delta_pct: z.ZodNullable<z.ZodNumber>;
-                p_value: z.ZodNullable<z.ZodNumber>;
-                srm_detected: z.ZodNullable<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                readonly experiment: {
-                    readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                    readonly name: "checkout_button_color";
-                    readonly status: "running";
-                };
-                readonly results: readonly [{
-                    readonly metric: "checkout_completed";
-                    readonly group_name: "control";
-                    readonly ds: "2026-05-09";
-                    readonly n: 12421;
-                    readonly mean: 0.1834;
-                    readonly delta_pct: null;
-                    readonly p_value: null;
-                    readonly srm_detected: 0;
-                }, {
-                    readonly metric: "checkout_completed";
-                    readonly group_name: "treatment";
-                    readonly ds: "2026-05-09";
-                    readonly n: 12519;
-                    readonly mean: 0.1922;
-                    readonly delta_pct: 4.8;
-                    readonly p_value: 0.018;
-                    readonly srm_detected: 0;
-                }];
-            };
-        };
-        readonly useCase: "Render the results table on the experiment detail page or drive an automated decision once a `goal` metric reaches significance.";
-    }, {
-        readonly operationId: "getExperimentTimeseries";
-        readonly method: "GET";
-        readonly path: "/{id}/timeseries";
-        readonly summary: "Get analysis timeseries";
-        readonly description: "Same row shape as `/results`, but returns every daily slice rather than the latest. Filter to a single metric with the `metric` query parameter.";
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly queryParams: {
-            readonly metric: {
-                readonly schema: z.ZodOptional<z.ZodString>;
-                readonly description: "Optional metric name to filter the series.";
-            };
-        };
-        readonly response: z.ZodObject<{
-            experiment: z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodString;
-                status: z.ZodEnum<{
-                    draft: "draft";
-                    running: "running";
-                    stopped: "stopped";
-                    archived: "archived";
-                }>;
-            }, z.core.$strip>;
-            series: z.ZodArray<z.ZodObject<{
-                metric: z.ZodString;
-                group_name: z.ZodString;
-                ds: z.ZodString;
-                n: z.ZodNullable<z.ZodNumber>;
-                mean: z.ZodNullable<z.ZodNumber>;
-                delta_pct: z.ZodNullable<z.ZodNumber>;
-                p_value: z.ZodNullable<z.ZodNumber>;
-                srm_detected: z.ZodNullable<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                readonly experiment: {
-                    readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                    readonly name: "checkout_button_color";
-                    readonly status: "running";
-                };
-                readonly series: readonly [{
-                    readonly metric: "checkout_completed";
-                    readonly group_name: "treatment";
-                    readonly ds: "2026-05-08";
-                    readonly n: 11200;
-                    readonly mean: 0.1903;
-                    readonly delta_pct: 3.9;
-                    readonly p_value: 0.034;
-                    readonly srm_detected: 0;
-                }, {
-                    readonly metric: "checkout_completed";
-                    readonly group_name: "treatment";
-                    readonly ds: "2026-05-09";
-                    readonly n: 12519;
-                    readonly mean: 0.1922;
-                    readonly delta_pct: 4.8;
-                    readonly p_value: 0.018;
-                    readonly srm_detected: 0;
-                }];
-            };
-        };
-        readonly useCase: "Drive a chart of metric movement over the experiment runtime, or sanity-check the lift is monotonic before deciding.";
-    }, {
-        readonly operationId: "reanalyzeExperiment";
-        readonly method: "POST";
-        readonly path: "/{id}/reanalyze";
-        readonly summary: "Re-queue analysis";
-        readonly description: "Requeues the daily analysis pass for this experiment outside the normal cron cadence. Useful after attaching a new metric or correcting an event taxonomy. The job runs asynchronously.";
-        readonly pathParams: {
-            readonly id: "Stable opaque experiment id.";
-        };
-        readonly response: z.ZodObject<{
-            id: z.ZodString;
-            queued: z.ZodLiteral<true>;
-        }, z.core.$strip>;
-        readonly examples: {
-            readonly response: {
-                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
-                readonly queued: true;
-            };
-        };
-        readonly useCase: "Force-refresh results after wiring up a new metric without waiting for the next nightly cron tick.";
-    }];
-};
-
-export { type Experiment, type ExperimentCreateInput, type ExperimentMetricsInput, type ExperimentResult, type ExperimentStatus, type ExperimentTimeseriesPoint, type ExperimentUpdateInput, type ExperimentsClient, experimentsClient, experimentsResource };