@shipeasy/openapi 1.0.0

package/dist/resources/killswitches.d.ts

@@ -0,0 +1,432 @@
+import { z } from 'zod';
+import { killswitchCreateSchema, killswitchUpdateSchema, killswitchSwitchSetSchema, killswitchSwitchUnsetSchema } from '@shipeasy/core/schemas/killswitches';
+import { PageQuery, Page } from '@shipeasy/core/pagination';
+import { Transport } from '../transport.js';
+
+type KillswitchCreateInput = z.input<typeof killswitchCreateSchema>;
+type KillswitchUpdateInput = z.input<typeof killswitchUpdateSchema>;
+type KillswitchSwitchSetInput = z.input<typeof killswitchSwitchSetSchema>;
+type KillswitchSwitchUnsetInput = z.input<typeof killswitchSwitchUnsetSchema>;
+interface Killswitch {
+    id: string;
+    name: string;
+    description: string | null;
+    updatedAt: string;
+    envs: Record<string, {
+        value: boolean;
+        switches?: Record<string, boolean>;
+        version: number;
+        publishedAt: string;
+    }>;
+}
+interface KillswitchesClient {
+    list(opts?: Partial<PageQuery>): Promise<Page<Killswitch>>;
+    listAll(): Promise<Killswitch[]>;
+    get(id: string): Promise<Killswitch>;
+    resolve(idOrName: string): Promise<Killswitch>;
+    create(input: KillswitchCreateInput): Promise<{
+        id: string;
+        name: string;
+    }>;
+    update(id: string, input: KillswitchUpdateInput): Promise<{
+        id: string;
+    }>;
+    delete(id: string): Promise<{
+        ok: true;
+    }>;
+    setSwitch(id: string, input: KillswitchSwitchSetInput): Promise<unknown>;
+    unsetSwitch(id: string, input: KillswitchSwitchUnsetInput): Promise<unknown>;
+}
+declare function killswitchesClient(t: Transport): KillswitchesClient;
+declare const killswitchesResource: {
+    readonly name: "killswitches";
+    readonly basePath: "/api/admin/killswitches";
+    readonly describeOne: "killswitch";
+    readonly describeMany: "killswitches";
+    readonly tag: {
+        readonly name: "Killswitches";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodBoolean>;
+            switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        }, z.core.$strip>;
+        readonly update: z.ZodObject<{
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            value: z.ZodOptional<z.ZodBoolean>;
+            switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        }, z.core.$strip>;
+        readonly setSwitch: z.ZodObject<{
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+            value: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly unsetSwitch: z.ZodObject<{
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly actions: readonly [{
+        readonly name: "setSwitch";
+        readonly description: "Set or update one switch entry on one env";
+    }, {
+        readonly name: "unsetSwitch";
+        readonly description: "Remove one switch entry from one env";
+    }];
+    readonly endpoints: readonly [{
+        readonly operationId: "listKillswitches";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List killswitches";
+        readonly description: "Returns a single page of killswitches ordered by `updated_at desc, id desc`. Each row includes the latest published `value`/`switches`/`version` per env.";
+        readonly response: z.ZodObject<{
+            data: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodNullable<z.ZodString>;
+                updatedAt: z.ZodString;
+                envs: z.ZodRecord<z.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, z.ZodObject<{
+                    value: z.ZodBoolean;
+                    switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+                    version: z.ZodNumber;
+                    publishedAt: z.ZodString;
+                }, z.core.$strip>>;
+            }, 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;
+                    updatedAt: string;
+                    envs: {
+                        dev: {
+                            value: boolean;
+                            version: number;
+                            publishedAt: string;
+                        };
+                        stage: {
+                            value: boolean;
+                            version: number;
+                            publishedAt: string;
+                        };
+                        prod: {
+                            value: boolean;
+                            switches: {
+                                eu_region: boolean;
+                            };
+                            version: number;
+                            publishedAt: string;
+                        };
+                    };
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every killswitch in the project — e.g. to render an incident-response runbook listing every kill and its current trip state.";
+    }, {
+        readonly operationId: "getKillswitch";
+        readonly method: "GET";
+        readonly path: "/{id}";
+        readonly summary: "Get one killswitch";
+        readonly description: "Returns the killswitch metadata plus the latest published `value`/`switches`/`version` per env.";
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id (`ksw_…`).";
+        };
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            updatedAt: z.ZodString;
+            envs: z.ZodRecord<z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, z.ZodObject<{
+                value: z.ZodBoolean;
+                switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+                version: z.ZodNumber;
+                publishedAt: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly examples: {
+            readonly response: {
+                id: string;
+                name: string;
+                description: string;
+                updatedAt: string;
+                envs: {
+                    dev: {
+                        value: boolean;
+                        version: number;
+                        publishedAt: string;
+                    };
+                    stage: {
+                        value: boolean;
+                        version: number;
+                        publishedAt: string;
+                    };
+                    prod: {
+                        value: boolean;
+                        switches: {
+                            eu_region: boolean;
+                        };
+                        version: number;
+                        publishedAt: string;
+                    };
+                };
+            };
+        };
+        readonly useCase: "Fetch the current state of one killswitch — e.g. to verify a trip propagated before declaring an incident mitigated.";
+    }, {
+        readonly operationId: "createKillswitch";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create a killswitch";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodBoolean>;
+            switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        }, 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 — name only, untripped";
+                    readonly description: "Smallest valid body. Creates a killswitch with `value: false` on every env.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                    };
+                };
+                readonly preTripped: {
+                    readonly summary: "Pre-tripped on create";
+                    readonly description: "Ship the killswitch already tripped (`value: true`) — useful when provisioning a kill ahead of a deploy you want to ship with the feature off.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                        readonly description: "Master kill for the new checkout flow.";
+                        readonly value: true;
+                    };
+                };
+                readonly withSwitches: {
+                    readonly summary: "With per-region switches";
+                    readonly description: "Seed a `switches` map so specific named call sites can be tripped independently of the flat `value`.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                        readonly value: false;
+                        readonly switches: {
+                            readonly eu_region: true;
+                            readonly apac_region: false;
+                        };
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly name: "payments.checkout";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateKillswitch";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update a killswitch";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: z.ZodObject<{
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            value: z.ZodOptional<z.ZodBoolean>;
+            switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly trip: {
+                    readonly summary: "Trip the killswitch on every env";
+                    readonly description: "Sets `value: true` on dev/stage/prod, bumping each env's version by one.";
+                    readonly value: {
+                        readonly value: true;
+                    };
+                };
+                readonly untrip: {
+                    readonly summary: "Untrip on every env";
+                    readonly description: "Sets `value: false` on every env.";
+                    readonly value: {
+                        readonly value: false;
+                    };
+                };
+                readonly replaceSwitches: {
+                    readonly summary: "Replace switches map";
+                    readonly description: "Replaces the per-key overrides wholesale on every env. Pass `{}` to clear.";
+                    readonly value: {
+                        readonly switches: {
+                            readonly eu_region: true;
+                            readonly apac_region: true;
+                        };
+                    };
+                };
+                readonly updateDescription: {
+                    readonly summary: "Description-only update";
+                    readonly description: "Doesn't bump versions or trigger a republish — only metadata changes.";
+                    readonly value: {
+                        readonly description: "Master kill — owner: payments-platform";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteKillswitch";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete a killswitch";
+        readonly description: "Soft-deletes the killswitch and rebuilds the project's flags KV blob so SDKs stop seeing it.";
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down a killswitch after the feature it protected has been removed.";
+    }, {
+        readonly operationId: "setKillswitchSwitch";
+        readonly method: "PUT";
+        readonly path: "/{id}/switch";
+        readonly summary: "Set one switch entry";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: z.ZodObject<{
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+            value: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+            value: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly tripRegion: {
+                    readonly summary: "Trip eu_region on prod";
+                    readonly description: "Sets `switches.eu_region = true` on prod only. Other envs and the flat `value` are unchanged.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                        readonly value: true;
+                    };
+                };
+                readonly untripRegion: {
+                    readonly summary: "Untrip eu_region on prod";
+                    readonly description: "Flip the same entry back off without removing it from the map.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                        readonly value: false;
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly env: "prod";
+                readonly switchKey: "eu_region";
+                readonly value: true;
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "unsetKillswitchSwitch";
+        readonly method: "DELETE";
+        readonly path: "/{id}/switch";
+        readonly summary: "Remove one switch entry";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: z.ZodObject<{
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+            env: z.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: z.ZodString;
+            removed: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly removeRegion: {
+                    readonly summary: "Remove eu_region from prod";
+                    readonly description: "Drops the `eu_region` override on prod so the flat `value` applies again.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly env: "prod";
+                readonly switchKey: "eu_region";
+                readonly removed: true;
+            };
+        };
+        readonly useCase: "Clean up a per-region override after the incident is resolved so the flat `value` governs again.";
+    }];
+};
+
+export { type Killswitch, type KillswitchCreateInput, type KillswitchSwitchSetInput, type KillswitchSwitchUnsetInput, type KillswitchUpdateInput, type KillswitchesClient, killswitchesClient, killswitchesResource };