@anchrd/colab-sdk 0.0.0-stage → 0.1.0

package/dist/operators/operators.d.ts

@@ -0,0 +1,898 @@
+import { z } from "zod";
+export declare const operatorProviders: readonly [{
+    readonly provider: "claude";
+    readonly name: "Claude";
+    readonly vendor: "Anthropic";
+    readonly selectable: true;
+    readonly kinds: readonly ["subscription", "apikey", "gateway"];
+    readonly beta: false;
+    readonly models: readonly ["opus", "sonnet", "haiku"];
+    readonly defaultModel: "sonnet";
+    readonly gateway: {
+        readonly models: readonly ["opus", "sonnet"];
+        readonly defaultModel: "sonnet";
+    };
+    readonly subagents: true;
+    readonly costs: true;
+}, {
+    readonly provider: "codex";
+    readonly name: "Codex";
+    readonly vendor: "OpenAI";
+    readonly selectable: true;
+    readonly kinds: readonly ["apikey", "gateway"];
+    readonly beta: true;
+    readonly models: readonly ["gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna"];
+    readonly defaultModel: "gpt-6.1-sol";
+    readonly gateway: {
+        readonly models: readonly ["gpt-6.1-sol", "gpt-6-luna"];
+        readonly defaultModel: "gpt-6.1-sol";
+    };
+    readonly subagents: false;
+    readonly costs: false;
+}, {
+    readonly provider: "gemini";
+    readonly name: "Gemini";
+    readonly vendor: "Google";
+    readonly selectable: true;
+    readonly kinds: readonly ["apikey", "gateway"];
+    readonly beta: true;
+    readonly models: readonly ["pro", "flash", "flash-lite"];
+    readonly defaultModel: "flash";
+    readonly gateway: {
+        readonly models: readonly ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"];
+        readonly defaultModel: "gemini-2.5-flash";
+    };
+    readonly subagents: false;
+    readonly costs: false;
+}];
+export type OperatorProviderEntry = (typeof operatorProviders)[number];
+export declare function modelsOf(entry: OperatorProviderEntry, kind: CredentialKind): {
+    models: readonly OperatorModel[];
+    defaultModel: OperatorModel;
+};
+export declare const CredentialKind: z.ZodEnum<{
+    subscription: "subscription";
+    apikey: "apikey";
+    gateway: "gateway";
+}>;
+export type CredentialKind = z.infer<typeof CredentialKind>;
+export declare const CredentialState: z.ZodEnum<{
+    invalid: "invalid";
+    valid: "valid";
+}>;
+export type CredentialState = z.infer<typeof CredentialState>;
+export declare const OperatorModel: z.ZodEnum<{
+    opus: "opus";
+    sonnet: "sonnet";
+    haiku: "haiku";
+    "gpt-6-astra": "gpt-6-astra";
+    "gpt-6.1-sol": "gpt-6.1-sol";
+    "gpt-6-luna": "gpt-6-luna";
+    pro: "pro";
+    flash: "flash";
+    "flash-lite": "flash-lite";
+    "gemini-2.5-pro": "gemini-2.5-pro";
+    "gemini-2.5-flash": "gemini-2.5-flash";
+    "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+}>;
+export type OperatorModel = z.infer<typeof OperatorModel>;
+export declare const CredentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+export declare const GatewayTarget: z.ZodObject<{
+    accountId: z.ZodString;
+    gatewayId: z.ZodString;
+}, z.core.$strict>;
+export type GatewayTarget = z.infer<typeof GatewayTarget>;
+export declare const CredentialListInput: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`credential_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type CredentialListInput = z.infer<typeof CredentialListInput>;
+export declare const CredentialGetInput: z.ZodObject<{
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+}, z.core.$strict>;
+export type CredentialGetInput = z.infer<typeof CredentialGetInput>;
+export declare const CredentialCreateInput: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>>;
+    kind: z.ZodEnum<{
+        subscription: "subscription";
+        apikey: "apikey";
+        gateway: "gateway";
+    }>;
+    name: z.ZodString;
+    value: z.ZodString;
+    gateway: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodString;
+        gatewayId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CredentialCreateInput = z.infer<typeof CredentialCreateInput>;
+export declare const CredentialUpdateInput: z.ZodObject<{
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+    name: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    gateway: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodString;
+        gatewayId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CredentialUpdateInput = z.infer<typeof CredentialUpdateInput>;
+export declare const CredentialTestInput: z.ZodObject<{
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+}, z.core.$strict>;
+export type CredentialTestInput = z.infer<typeof CredentialTestInput>;
+export declare const CredentialRevokeInput: z.ZodObject<{
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+}, z.core.$strict>;
+export type CredentialRevokeInput = z.infer<typeof CredentialRevokeInput>;
+export declare const Credential: z.ZodObject<{
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+    provider: z.ZodNullable<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>>;
+    kind: z.ZodEnum<{
+        subscription: "subscription";
+        apikey: "apikey";
+        gateway: "gateway";
+    }>;
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        invalid: "invalid";
+        valid: "valid";
+    }>;
+    checkedAt: z.ZodNullable<z.ZodISODateTime>;
+    setAt: z.ZodISODateTime;
+    machineIds: z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type Credential = z.infer<typeof Credential>;
+export declare const CredentialList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+        provider: z.ZodNullable<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>>;
+        kind: z.ZodEnum<{
+            subscription: "subscription";
+            apikey: "apikey";
+            gateway: "gateway";
+        }>;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            invalid: "invalid";
+            valid: "valid";
+        }>;
+        checkedAt: z.ZodNullable<z.ZodISODateTime>;
+        setAt: z.ZodISODateTime;
+        machineIds: z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>;
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`credential_${string}`>>;
+}, z.core.$strict>;
+export type CredentialList = z.infer<typeof CredentialList>;
+export declare const CredentialTestResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$strict>], "ok">;
+export type CredentialTestResult = z.infer<typeof CredentialTestResult>;
+export declare const CredentialTested: z.ZodObject<{
+    credential: z.ZodObject<{
+        credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+        provider: z.ZodNullable<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>>;
+        kind: z.ZodEnum<{
+            subscription: "subscription";
+            apikey: "apikey";
+            gateway: "gateway";
+        }>;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            invalid: "invalid";
+            valid: "valid";
+        }>;
+        checkedAt: z.ZodNullable<z.ZodISODateTime>;
+        setAt: z.ZodISODateTime;
+        machineIds: z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>;
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    test: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        error: z.ZodString;
+    }, z.core.$strict>], "ok">;
+}, z.core.$strict>;
+export type CredentialTested = z.infer<typeof CredentialTested>;
+export declare const Subagents: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    max: z.ZodInt;
+}, z.core.$strict>;
+export type Subagents = z.infer<typeof Subagents>;
+export declare const Trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    on: z.ZodLiteral<"change">;
+    quietMinutes: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    on: z.ZodLiteral<"schedule">;
+    schedule: z.ZodObject<{
+        rhythm: z.ZodEnum<{
+            manual: "manual";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            dates: "dates";
+        }>;
+        days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            monday: "monday";
+            tuesday: "tuesday";
+            wednesday: "wednesday";
+            thursday: "thursday";
+            friday: "friday";
+            saturday: "saturday";
+            sunday: "sunday";
+        }>>>;
+        dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+        times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        zone: z.ZodOptional<z.ZodString>;
+        whileOpen: z.ZodOptional<z.ZodEnum<{
+            wait: "wait";
+            continue: "continue";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "on">;
+export type Trigger = z.infer<typeof Trigger>;
+export declare const OperatorLimits: z.ZodObject<{
+    maxRunMinutes: z.ZodInt;
+    maxRunsPerDay: z.ZodInt;
+}, z.core.$strict>;
+export type OperatorLimits = z.infer<typeof OperatorLimits>;
+export declare const operatorDefaults: {
+    readonly model: "sonnet";
+    readonly subagents: {
+        readonly allowed: false;
+        readonly max: 3;
+    };
+    readonly trigger: {
+        readonly on: "change";
+        readonly quietMinutes: 5;
+    };
+    readonly limits: {
+        readonly maxRunMinutes: 30;
+        readonly maxRunsPerDay: 50;
+    };
+};
+export declare const OperatorState: z.ZodEnum<{
+    ready: "ready";
+    paused: "paused";
+    no_role: "no_role";
+}>;
+export type OperatorState = z.infer<typeof OperatorState>;
+export declare const PauseReason: z.ZodEnum<{
+    credential: "credential";
+    limit: "limit";
+    manual: "manual";
+    failures: "failures";
+}>;
+export type PauseReason = z.infer<typeof PauseReason>;
+export declare const MachineListInput: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type MachineListInput = z.infer<typeof MachineListInput>;
+export declare const MachineGetInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineGetInput = z.infer<typeof MachineGetInput>;
+export declare const OperatorMachineCreateInput: z.ZodObject<{
+    name: z.ZodString;
+    roleIds: z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`role_${string}`>>>;
+    provider: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>;
+    credentialId: z.ZodTemplateLiteral<`credential_${string}`>;
+    model: z.ZodOptional<z.ZodEnum<{
+        opus: "opus";
+        sonnet: "sonnet";
+        haiku: "haiku";
+        "gpt-6-astra": "gpt-6-astra";
+        "gpt-6.1-sol": "gpt-6.1-sol";
+        "gpt-6-luna": "gpt-6-luna";
+        pro: "pro";
+        flash: "flash";
+        "flash-lite": "flash-lite";
+        "gemini-2.5-pro": "gemini-2.5-pro";
+        "gemini-2.5-flash": "gemini-2.5-flash";
+        "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+    }>>;
+    subagents: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        max: z.ZodInt;
+    }, z.core.$strict>>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        on: z.ZodLiteral<"change">;
+        quietMinutes: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        on: z.ZodLiteral<"schedule">;
+        schedule: z.ZodObject<{
+            rhythm: z.ZodEnum<{
+                manual: "manual";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                dates: "dates";
+            }>;
+            days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>>;
+            dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+            times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            zone: z.ZodOptional<z.ZodString>;
+            whileOpen: z.ZodOptional<z.ZodEnum<{
+                wait: "wait";
+                continue: "continue";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "on">>;
+    limits: z.ZodOptional<z.ZodObject<{
+        maxRunMinutes: z.ZodOptional<z.ZodInt>;
+        maxRunsPerDay: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OperatorMachineCreateInput = z.infer<typeof OperatorMachineCreateInput>;
+export declare const OperatorMachineUpdateInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+    credentialId: z.ZodOptional<z.ZodTemplateLiteral<`credential_${string}`>>;
+    model: z.ZodOptional<z.ZodEnum<{
+        opus: "opus";
+        sonnet: "sonnet";
+        haiku: "haiku";
+        "gpt-6-astra": "gpt-6-astra";
+        "gpt-6.1-sol": "gpt-6.1-sol";
+        "gpt-6-luna": "gpt-6-luna";
+        pro: "pro";
+        flash: "flash";
+        "flash-lite": "flash-lite";
+        "gemini-2.5-pro": "gemini-2.5-pro";
+        "gemini-2.5-flash": "gemini-2.5-flash";
+        "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+    }>>;
+    subagents: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        max: z.ZodInt;
+    }, z.core.$strict>>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        on: z.ZodLiteral<"change">;
+        quietMinutes: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        on: z.ZodLiteral<"schedule">;
+        schedule: z.ZodObject<{
+            rhythm: z.ZodEnum<{
+                manual: "manual";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                dates: "dates";
+            }>;
+            days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>>;
+            dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+            times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            zone: z.ZodOptional<z.ZodString>;
+            whileOpen: z.ZodOptional<z.ZodEnum<{
+                wait: "wait";
+                continue: "continue";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "on">>;
+    limits: z.ZodOptional<z.ZodObject<{
+        maxRunMinutes: z.ZodOptional<z.ZodInt>;
+        maxRunsPerDay: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    responsibleId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+}, z.core.$strict>;
+export type OperatorMachineUpdateInput = z.infer<typeof OperatorMachineUpdateInput>;
+export declare const MachineDisableInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineDisableInput = z.infer<typeof MachineDisableInput>;
+export declare const MachineEnableInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type MachineEnableInput = z.infer<typeof MachineEnableInput>;
+export declare const OperatorMachineArchiveInput: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type OperatorMachineArchiveInput = z.infer<typeof OperatorMachineArchiveInput>;
+export declare const Operator: z.ZodObject<{
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+    name: z.ZodString;
+    provider: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>;
+    credentialId: z.ZodNullable<z.ZodTemplateLiteral<`credential_${string}`>>;
+    model: z.ZodEnum<{
+        opus: "opus";
+        sonnet: "sonnet";
+        haiku: "haiku";
+        "gpt-6-astra": "gpt-6-astra";
+        "gpt-6.1-sol": "gpt-6.1-sol";
+        "gpt-6-luna": "gpt-6-luna";
+        pro: "pro";
+        flash: "flash";
+        "flash-lite": "flash-lite";
+        "gemini-2.5-pro": "gemini-2.5-pro";
+        "gemini-2.5-flash": "gemini-2.5-flash";
+        "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+    }>;
+    subagents: z.ZodObject<{
+        allowed: z.ZodBoolean;
+        max: z.ZodInt;
+    }, z.core.$strict>;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        on: z.ZodLiteral<"change">;
+        quietMinutes: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        on: z.ZodLiteral<"schedule">;
+        schedule: z.ZodObject<{
+            rhythm: z.ZodEnum<{
+                manual: "manual";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                dates: "dates";
+            }>;
+            days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                monday: "monday";
+                tuesday: "tuesday";
+                wednesday: "wednesday";
+                thursday: "thursday";
+                friday: "friday";
+                saturday: "saturday";
+                sunday: "sunday";
+            }>>>;
+            dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+            times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            zone: z.ZodOptional<z.ZodString>;
+            whileOpen: z.ZodOptional<z.ZodEnum<{
+                wait: "wait";
+                continue: "continue";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "on">;
+    limits: z.ZodObject<{
+        maxRunMinutes: z.ZodInt;
+        maxRunsPerDay: z.ZodInt;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+        ready: "ready";
+        paused: "paused";
+        no_role: "no_role";
+    }>;
+    pausedReason: z.ZodNullable<z.ZodEnum<{
+        credential: "credential";
+        limit: "limit";
+        manual: "manual";
+        failures: "failures";
+    }>>;
+    pausedAt: z.ZodNullable<z.ZodISODateTime>;
+    running: z.ZodNullable<z.ZodObject<{
+        runId: z.ZodTemplateLiteral<`run_${string}`>;
+        startedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type Operator = z.infer<typeof Operator>;
+export declare const OperatorList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        machineId: z.ZodTemplateLiteral<`user_${string}`>;
+        name: z.ZodString;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>;
+        credentialId: z.ZodNullable<z.ZodTemplateLiteral<`credential_${string}`>>;
+        model: z.ZodEnum<{
+            opus: "opus";
+            sonnet: "sonnet";
+            haiku: "haiku";
+            "gpt-6-astra": "gpt-6-astra";
+            "gpt-6.1-sol": "gpt-6.1-sol";
+            "gpt-6-luna": "gpt-6-luna";
+            pro: "pro";
+            flash: "flash";
+            "flash-lite": "flash-lite";
+            "gemini-2.5-pro": "gemini-2.5-pro";
+            "gemini-2.5-flash": "gemini-2.5-flash";
+            "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+        }>;
+        subagents: z.ZodObject<{
+            allowed: z.ZodBoolean;
+            max: z.ZodInt;
+        }, z.core.$strict>;
+        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            on: z.ZodLiteral<"change">;
+            quietMinutes: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            on: z.ZodLiteral<"schedule">;
+            schedule: z.ZodObject<{
+                rhythm: z.ZodEnum<{
+                    manual: "manual";
+                    daily: "daily";
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    dates: "dates";
+                }>;
+                days: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>>>;
+                dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodInt>>;
+                times: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                zone: z.ZodOptional<z.ZodString>;
+                whileOpen: z.ZodOptional<z.ZodEnum<{
+                    wait: "wait";
+                    continue: "continue";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "on">;
+        limits: z.ZodObject<{
+            maxRunMinutes: z.ZodInt;
+            maxRunsPerDay: z.ZodInt;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            ready: "ready";
+            paused: "paused";
+            no_role: "no_role";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            credential: "credential";
+            limit: "limit";
+            manual: "manual";
+            failures: "failures";
+        }>>;
+        pausedAt: z.ZodNullable<z.ZodISODateTime>;
+        running: z.ZodNullable<z.ZodObject<{
+            runId: z.ZodTemplateLiteral<`run_${string}`>;
+            startedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+}, z.core.$strict>;
+export type OperatorList = z.infer<typeof OperatorList>;
+export declare const OperatorRunId: z.ZodTemplateLiteral<`run_${string}`>;
+export type OperatorRunId = z.infer<typeof OperatorRunId>;
+export declare const OperatorRunStatus: z.ZodEnum<{
+    running: "running";
+    failed: "failed";
+    completed: "completed";
+}>;
+export type OperatorRunStatus = z.infer<typeof OperatorRunStatus>;
+export declare const OperatorRunReason: z.ZodEnum<{
+    error: "error";
+    credential: "credential";
+    provider: "provider";
+    container: "container";
+    timeout: "timeout";
+    crash: "crash";
+    noresult: "noresult";
+}>;
+export type OperatorRunReason = z.infer<typeof OperatorRunReason>;
+export declare const OperatorRunTrigger: z.ZodEnum<{
+    schedule: "schedule";
+    change: "change";
+    retry: "retry";
+}>;
+export type OperatorRunTrigger = z.infer<typeof OperatorRunTrigger>;
+export declare const OperatorRunTokens: z.ZodObject<{
+    input: z.ZodInt;
+    output: z.ZodInt;
+    cacheRead: z.ZodInt;
+    cacheWrite: z.ZodInt;
+}, z.core.$strict>;
+export type OperatorRunTokens = z.infer<typeof OperatorRunTokens>;
+export declare const OperatorRunTouched: z.ZodObject<{
+    processes: z.ZodArray<z.ZodString>;
+    connectors: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type OperatorRunTouched = z.infer<typeof OperatorRunTouched>;
+export declare const OperatorRun: z.ZodObject<{
+    trigger: z.ZodEnum<{
+        schedule: "schedule";
+        change: "change";
+        retry: "retry";
+    }>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        credential: "credential";
+        provider: "provider";
+        container: "container";
+        timeout: "timeout";
+        crash: "crash";
+        noresult: "noresult";
+    }>>;
+    detail: z.ZodNullable<z.ZodString>;
+    summary: z.ZodNullable<z.ZodString>;
+    touched: z.ZodObject<{
+        processes: z.ZodArray<z.ZodString>;
+        connectors: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    credentialKind: z.ZodNullable<z.ZodEnum<{
+        subscription: "subscription";
+        apikey: "apikey";
+        gateway: "gateway";
+    }>>;
+    costUsd: z.ZodNullable<z.ZodNumber>;
+    tokens: z.ZodNullable<z.ZodObject<{
+        input: z.ZodInt;
+        output: z.ZodInt;
+        cacheRead: z.ZodInt;
+        cacheWrite: z.ZodInt;
+    }, z.core.$strict>>;
+    startedAt: z.ZodISODateTime;
+    endedAt: z.ZodNullable<z.ZodISODateTime>;
+    durationMs: z.ZodNullable<z.ZodInt>;
+    machineId: z.ZodTemplateLiteral<`user_${string}`>;
+    machineName: z.ZodString;
+    machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+}, z.core.$strict>;
+export type OperatorRun = z.infer<typeof OperatorRun>;
+export declare const OperatorRunListInput: z.ZodObject<{
+    machineId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    from: z.ZodOptional<z.ZodISODateTime>;
+    to: z.ZodOptional<z.ZodISODateTime>;
+    search: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`run_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type OperatorRunListInput = z.infer<typeof OperatorRunListInput>;
+export declare const OperatorRunGetInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+}, z.core.$strict>;
+export type OperatorRunGetInput = z.infer<typeof OperatorRunGetInput>;
+export declare const OperatorRunUsage: z.ZodObject<{
+    byMachine: z.ZodArray<z.ZodObject<{
+        runs: z.ZodInt;
+        costUsd: z.ZodNumber;
+        tokens: z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>;
+        machineId: z.ZodTemplateLiteral<`user_${string}`>;
+        machineName: z.ZodString;
+        machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    byDay: z.ZodArray<z.ZodObject<{
+        runs: z.ZodInt;
+        costUsd: z.ZodNumber;
+        tokens: z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>;
+        day: z.ZodISODate;
+    }, z.core.$strict>>;
+    byKind: z.ZodArray<z.ZodObject<{
+        runs: z.ZodInt;
+        costUsd: z.ZodNumber;
+        tokens: z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            subscription: "subscription";
+            apikey: "apikey";
+            gateway: "gateway";
+        }>;
+    }, z.core.$strict>>;
+    byProvider: z.ZodArray<z.ZodObject<{
+        runs: z.ZodInt;
+        costUsd: z.ZodNumber;
+        tokens: z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>;
+    }, z.core.$strict>>;
+    runs: z.ZodInt;
+    costUsd: z.ZodNumber;
+    tokens: z.ZodObject<{
+        input: z.ZodInt;
+        output: z.ZodInt;
+        cacheRead: z.ZodInt;
+        cacheWrite: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type OperatorRunUsage = z.infer<typeof OperatorRunUsage>;
+export declare const OperatorRunList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        trigger: z.ZodEnum<{
+            schedule: "schedule";
+            change: "change";
+            retry: "retry";
+        }>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            completed: "completed";
+        }>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            credential: "credential";
+            provider: "provider";
+            container: "container";
+            timeout: "timeout";
+            crash: "crash";
+            noresult: "noresult";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+        summary: z.ZodNullable<z.ZodString>;
+        touched: z.ZodObject<{
+            processes: z.ZodArray<z.ZodString>;
+            connectors: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        credentialKind: z.ZodNullable<z.ZodEnum<{
+            subscription: "subscription";
+            apikey: "apikey";
+            gateway: "gateway";
+        }>>;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        tokens: z.ZodNullable<z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>>;
+        startedAt: z.ZodISODateTime;
+        endedAt: z.ZodNullable<z.ZodISODateTime>;
+        durationMs: z.ZodNullable<z.ZodInt>;
+        machineId: z.ZodTemplateLiteral<`user_${string}`>;
+        machineName: z.ZodString;
+        machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
+        runId: z.ZodTemplateLiteral<`run_${string}`>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`run_${string}`>>;
+    usage: z.ZodObject<{
+        byMachine: z.ZodArray<z.ZodObject<{
+            runs: z.ZodInt;
+            costUsd: z.ZodNumber;
+            tokens: z.ZodObject<{
+                input: z.ZodInt;
+                output: z.ZodInt;
+                cacheRead: z.ZodInt;
+                cacheWrite: z.ZodInt;
+            }, z.core.$strict>;
+            machineId: z.ZodTemplateLiteral<`user_${string}`>;
+            machineName: z.ZodString;
+            machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        byDay: z.ZodArray<z.ZodObject<{
+            runs: z.ZodInt;
+            costUsd: z.ZodNumber;
+            tokens: z.ZodObject<{
+                input: z.ZodInt;
+                output: z.ZodInt;
+                cacheRead: z.ZodInt;
+                cacheWrite: z.ZodInt;
+            }, z.core.$strict>;
+            day: z.ZodISODate;
+        }, z.core.$strict>>;
+        byKind: z.ZodArray<z.ZodObject<{
+            runs: z.ZodInt;
+            costUsd: z.ZodNumber;
+            tokens: z.ZodObject<{
+                input: z.ZodInt;
+                output: z.ZodInt;
+                cacheRead: z.ZodInt;
+                cacheWrite: z.ZodInt;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                subscription: "subscription";
+                apikey: "apikey";
+                gateway: "gateway";
+            }>;
+        }, z.core.$strict>>;
+        byProvider: z.ZodArray<z.ZodObject<{
+            runs: z.ZodInt;
+            costUsd: z.ZodNumber;
+            tokens: z.ZodObject<{
+                input: z.ZodInt;
+                output: z.ZodInt;
+                cacheRead: z.ZodInt;
+                cacheWrite: z.ZodInt;
+            }, z.core.$strict>;
+            provider: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                gemini: "gemini";
+            }>;
+        }, z.core.$strict>>;
+        runs: z.ZodInt;
+        costUsd: z.ZodNumber;
+        tokens: z.ZodObject<{
+            input: z.ZodInt;
+            output: z.ZodInt;
+            cacheRead: z.ZodInt;
+            cacheWrite: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type OperatorRunList = z.infer<typeof OperatorRunList>;