@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/model-account-choice.d.ts

@@ -0,0 +1,237 @@
+import { z } from "zod";
+/** Why a listed account cannot be chosen for this session. */
+export declare const ModelAccountChoiceRefusal: z.ZodEnum<{
+    inactive: "inactive";
+    personal_not_allowed: "personal_not_allowed";
+    personal_not_owner_work: "personal_not_owner_work";
+    session_has_no_owner: "session_has_no_owner";
+}>;
+export type ModelAccountChoiceRefusal = z.infer<typeof ModelAccountChoiceRefusal>;
+/**
+ * Stored observation only, not a live check or a promise of available capacity.
+ * Source/time describe the snapshot, not each retained window. Windows can be
+ * partial, unknown or stale; a past reset does not prove replenishment.
+ */
+export declare const ModelAccountUsageSnapshot: z.ZodObject<{
+    observedAt: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodEnum<{
+        refusal: "refusal";
+        response_headers: "response_headers";
+        usage_endpoint: "usage_endpoint";
+    }>>;
+    windows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        usedPercent: z.ZodNullable<z.ZodNumber>;
+        resetsAt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            exhausted: "exhausted";
+            ok: "ok";
+            unknown: "unknown";
+            warning: "warning";
+        }>;
+    }, z.core.$strip>>;
+    exhaustedUntil: z.ZodNullable<z.ZodString>;
+    exhaustedKind: z.ZodNullable<z.ZodEnum<{
+        quota: "quota";
+        rate_limit: "rate_limit";
+    }>>;
+}, z.core.$strip>;
+export type ModelAccountUsageSnapshot = z.infer<typeof ModelAccountUsageSnapshot>;
+export declare const ModelAccountChoiceOption: z.ZodObject<{
+    provider: z.ZodString;
+    connectionId: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+    accountEmail: z.ZodNullable<z.ZodString>;
+    planType: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    personal: z.ZodBoolean;
+    source: z.ZodEnum<{
+        organization: "organization";
+        personal: "personal";
+        workspace: "workspace";
+    }>;
+    allowedModelIds: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    choosable: z.ZodBoolean;
+    refusal: z.ZodNullable<z.ZodEnum<{
+        inactive: "inactive";
+        personal_not_allowed: "personal_not_allowed";
+        personal_not_owner_work: "personal_not_owner_work";
+        session_has_no_owner: "session_has_no_owner";
+    }>>;
+    usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        observedAt: z.ZodNullable<z.ZodString>;
+        source: z.ZodNullable<z.ZodEnum<{
+            refusal: "refusal";
+            response_headers: "response_headers";
+            usage_endpoint: "usage_endpoint";
+        }>>;
+        windows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            usedPercent: z.ZodNullable<z.ZodNumber>;
+            resetsAt: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                exhausted: "exhausted";
+                ok: "ok";
+                unknown: "unknown";
+                warning: "warning";
+            }>;
+        }, z.core.$strip>>;
+        exhaustedUntil: z.ZodNullable<z.ZodString>;
+        exhaustedKind: z.ZodNullable<z.ZodEnum<{
+            quota: "quota";
+            rate_limit: "rate_limit";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ModelAccountChoiceOption = z.infer<typeof ModelAccountChoiceOption>;
+/** Last lease-backed selection, not a queued choice or an unplaced proposal. */
+export declare const SessionModelAccountServing: z.ZodObject<{
+    turnId: z.ZodString;
+    provider: z.ZodString;
+    connectionId: z.ZodNullable<z.ZodString>;
+    modelId: z.ZodString;
+    preferredModelId: z.ZodString;
+    reasoningEffort: z.ZodLazy<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        minimal: "minimal";
+        none: "none";
+        xhigh: "xhigh";
+    }>>;
+    latencyMode: z.ZodLazy<z.ZodEnum<{
+        fast: "fast";
+        priority: "priority";
+        standard: "standard";
+        ultrafast: "ultrafast";
+    }>>;
+}, z.core.$strip>;
+export type SessionModelAccountServing = z.infer<typeof SessionModelAccountServing>;
+export declare const SessionModelAccountChoiceResponse: z.ZodObject<{
+    binding: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        connectionId: z.ZodNullable<z.ZodString>;
+        choice: z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+        }>;
+    }, z.core.$strip>>;
+    bindings: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        connectionId: z.ZodNullable<z.ZodString>;
+        choice: z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+        }>;
+    }, z.core.$strip>>;
+    serving: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        turnId: z.ZodString;
+        provider: z.ZodString;
+        connectionId: z.ZodNullable<z.ZodString>;
+        modelId: z.ZodString;
+        preferredModelId: z.ZodString;
+        reasoningEffort: z.ZodLazy<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>;
+        latencyMode: z.ZodLazy<z.ZodEnum<{
+            fast: "fast";
+            priority: "priority";
+            standard: "standard";
+            ultrafast: "ultrafast";
+        }>>;
+    }, z.core.$strip>>>;
+    accounts: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        connectionId: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+        accountEmail: z.ZodNullable<z.ZodString>;
+        planType: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        personal: z.ZodBoolean;
+        source: z.ZodEnum<{
+            organization: "organization";
+            personal: "personal";
+            workspace: "workspace";
+        }>;
+        allowedModelIds: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        choosable: z.ZodBoolean;
+        refusal: z.ZodNullable<z.ZodEnum<{
+            inactive: "inactive";
+            personal_not_allowed: "personal_not_allowed";
+            personal_not_owner_work: "personal_not_owner_work";
+            session_has_no_owner: "session_has_no_owner";
+        }>>;
+        usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            observedAt: z.ZodNullable<z.ZodString>;
+            source: z.ZodNullable<z.ZodEnum<{
+                refusal: "refusal";
+                response_headers: "response_headers";
+                usage_endpoint: "usage_endpoint";
+            }>>;
+            windows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                usedPercent: z.ZodNullable<z.ZodNumber>;
+                resetsAt: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    exhausted: "exhausted";
+                    ok: "ok";
+                    unknown: "unknown";
+                    warning: "warning";
+                }>;
+            }, z.core.$strip>>;
+            exhaustedUntil: z.ZodNullable<z.ZodString>;
+            exhaustedKind: z.ZodNullable<z.ZodEnum<{
+                quota: "quota";
+                rate_limit: "rate_limit";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    personal: z.ZodObject<{
+        connectionsAllowed: z.ZodBoolean;
+        fallbackAllowed: z.ZodBoolean;
+        fallbackOptIn: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SessionModelAccountChoiceResponse = z.infer<typeof SessionModelAccountChoiceResponse>;
+/**
+ * A connection makes it the session's choice for that connection's provider;
+ * other providers' choices stay. `connectionId: null` returns the session to
+ * automatic account selection: only `provider`'s choice when given, else
+ * every provider's.
+ */
+export declare const SetSessionModelAccountChoiceRequest: z.ZodObject<{
+    connectionId: z.ZodNullable<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SetSessionModelAccountChoiceRequest = z.infer<typeof SetSessionModelAccountChoiceRequest>;
+export declare const SetSessionModelAccountChoiceResponse: z.ZodObject<{
+    changed: z.ZodBoolean;
+    appliedTo: z.ZodEnum<{
+        next_turn: "next_turn";
+        waiting_turn: "waiting_turn";
+    }>;
+    provider: z.ZodNullable<z.ZodString>;
+    connectionId: z.ZodNullable<z.ZodString>;
+    choice: z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+    }>;
+}, z.core.$strip>;
+export type SetSessionModelAccountChoiceResponse = z.infer<typeof SetSessionModelAccountChoiceResponse>;
+export declare const ModelAccountPreferences: z.ZodObject<{
+    personalFallbackOptIn: z.ZodBoolean;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+export type ModelAccountPreferences = z.infer<typeof ModelAccountPreferences>;
+export declare const UpdateModelAccountPreferencesRequest: z.ZodObject<{
+    personalFallbackOptIn: z.ZodBoolean;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateModelAccountPreferencesRequest = z.infer<typeof UpdateModelAccountPreferencesRequest>;

package/dist/model-account-settings.d.ts

@@ -0,0 +1,422 @@
+import { z } from "zod";
+/**
+ * Organization model-account settings with lockable workspace overrides and
+ * the organization overview (contract SUB-SET-01..05). The organization sets
+ * every value; a shared workspace may override a value unless the
+ * organization locked it. Each effective value reports where it comes from.
+ */
+export declare const MODEL_ACCOUNT_SETTING_KEYS: readonly ["rotation", "providers", "crossProviderFailover", "fallbackOrder", "personalConnectionsAllowed", "personalFallbackAllowed"];
+export declare const ModelAccountSettingKey: z.ZodEnum<{
+    crossProviderFailover: "crossProviderFailover";
+    fallbackOrder: "fallbackOrder";
+    personalConnectionsAllowed: "personalConnectionsAllowed";
+    personalFallbackAllowed: "personalFallbackAllowed";
+    providers: "providers";
+    rotation: "rotation";
+}>;
+export type ModelAccountSettingKey = z.infer<typeof ModelAccountSettingKey>;
+/** organization: the organization value; workspace: this workspace's override; locked: the organization value, which workspaces cannot override. */
+export declare const ModelAccountSettingSource: z.ZodEnum<{
+    locked: "locked";
+    organization: "organization";
+    workspace: "workspace";
+}>;
+export type ModelAccountSettingSource = z.infer<typeof ModelAccountSettingSource>;
+export declare const ModelAccountRotationMode: z.ZodEnum<{
+    primary_first: "primary_first";
+    spread: "spread";
+}>;
+export type ModelAccountRotationMode = z.infer<typeof ModelAccountRotationMode>;
+/** Ordered fallback models for a preferred model (at most 64 models, 8 fallbacks each). */
+export declare const ModelAccountFallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+export declare const ModelAccountSettingValues: z.ZodObject<{
+    rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+        mode: z.ZodEnum<{
+            primary_first: "primary_first";
+            spread: "spread";
+        }>;
+        primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        inferenceSource: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+        useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+    crossProviderFailover: z.ZodBoolean;
+    fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    personalConnectionsAllowed: z.ZodBoolean;
+    personalFallbackAllowed: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModelAccountSettingValues = z.infer<typeof ModelAccountSettingValues>;
+export declare const OrganizationModelAccountSettings: z.ZodObject<{
+    organizationId: z.ZodString;
+    values: z.ZodObject<{
+        rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodEnum<{
+                primary_first: "primary_first";
+                spread: "spread";
+            }>;
+            primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            inferenceSource: z.ZodOptional<z.ZodEnum<{
+                automatic: "automatic";
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+            useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        crossProviderFailover: z.ZodBoolean;
+        fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        personalConnectionsAllowed: z.ZodBoolean;
+        personalFallbackAllowed: z.ZodBoolean;
+    }, z.core.$strip>;
+    locked: z.ZodArray<z.ZodEnum<{
+        crossProviderFailover: "crossProviderFailover";
+        fallbackOrder: "fallbackOrder";
+        personalConnectionsAllowed: "personalConnectionsAllowed";
+        personalFallbackAllowed: "personalFallbackAllowed";
+        providers: "providers";
+        rotation: "rotation";
+    }>>;
+    version: z.ZodNumber;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type OrganizationModelAccountSettings = z.infer<typeof OrganizationModelAccountSettings>;
+/**
+ * PATCH body for the organization: omitted fields are kept; `fallbackOrder`
+ * and `locked` replace the stored value; `rotation` sets the mode of each
+ * named provider whose accounts run on the shared core. Locking a setting
+ * clears every workspace override of it.
+ */
+export declare const UpdateOrganizationModelAccountSettingsRequest: z.ZodObject<{
+    crossProviderFailover: z.ZodOptional<z.ZodBoolean>;
+    fallbackOrder: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    personalConnectionsAllowed: z.ZodOptional<z.ZodBoolean>;
+    personalFallbackAllowed: z.ZodOptional<z.ZodBoolean>;
+    rotation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        mode: z.ZodEnum<{
+            primary_first: "primary_first";
+            spread: "spread";
+        }>;
+    }, z.core.$strict>>>;
+    locked: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        crossProviderFailover: "crossProviderFailover";
+        fallbackOrder: "fallbackOrder";
+        personalConnectionsAllowed: "personalConnectionsAllowed";
+        personalFallbackAllowed: "personalFallbackAllowed";
+        providers: "providers";
+        rotation: "rotation";
+    }>>>;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateOrganizationModelAccountSettingsRequest = z.infer<typeof UpdateOrganizationModelAccountSettingsRequest>;
+/** A workspace's stored overrides: null follows the organization. */
+export declare const ModelAccountSettingOverrides: z.ZodObject<{
+    rotation: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    providers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    crossProviderFailover: z.ZodNullable<z.ZodBoolean>;
+    fallbackOrder: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    personalConnectionsAllowed: z.ZodNullable<z.ZodBoolean>;
+    personalFallbackAllowed: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const WorkspaceModelAccountSettings: z.ZodObject<{
+    values: z.ZodObject<{
+        rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodEnum<{
+                primary_first: "primary_first";
+                spread: "spread";
+            }>;
+            primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            inferenceSource: z.ZodOptional<z.ZodEnum<{
+                automatic: "automatic";
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+            useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        crossProviderFailover: z.ZodBoolean;
+        fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        personalConnectionsAllowed: z.ZodBoolean;
+        personalFallbackAllowed: z.ZodBoolean;
+    }, z.core.$strip>;
+    sources: z.ZodObject<{
+        rotation: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        providers: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        crossProviderFailover: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        fallbackOrder: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        personalConnectionsAllowed: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        personalFallbackAllowed: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+    }, z.core.$strip>;
+    entrySources: z.ZodObject<{
+        rotation: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+        fallbackOrder: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strip>;
+    workspaceId: z.ZodString;
+    locked: z.ZodArray<z.ZodEnum<{
+        crossProviderFailover: "crossProviderFailover";
+        fallbackOrder: "fallbackOrder";
+        personalConnectionsAllowed: "personalConnectionsAllowed";
+        personalFallbackAllowed: "personalFallbackAllowed";
+        providers: "providers";
+        rotation: "rotation";
+    }>>;
+    overrides: z.ZodObject<{
+        rotation: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        providers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        crossProviderFailover: z.ZodNullable<z.ZodBoolean>;
+        fallbackOrder: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        personalConnectionsAllowed: z.ZodNullable<z.ZodBoolean>;
+        personalFallbackAllowed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>;
+    version: z.ZodNumber;
+    updatedAt: z.ZodNullable<z.ZodString>;
+    canEdit: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkspaceModelAccountSettings = z.infer<typeof WorkspaceModelAccountSettings>;
+/**
+ * PATCH body for a workspace: omitted fields are kept and `null` follows the
+ * organization again. `fallbackOrder` and `rotation` change entry by entry;
+ * a `null` entry follows the organization for that entry. A setting the
+ * organization locked cannot be set.
+ */
+export declare const UpdateWorkspaceModelAccountSettingsRequest: z.ZodObject<{
+    crossProviderFailover: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    personalConnectionsAllowed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    personalFallbackAllowed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    fallbackOrder: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodArray<z.ZodString>>>>>;
+    rotation: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        mode: z.ZodEnum<{
+            primary_first: "primary_first";
+            spread: "spread";
+        }>;
+    }, z.core.$strict>>>>>;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateWorkspaceModelAccountSettingsRequest = z.infer<typeof UpdateWorkspaceModelAccountSettingsRequest>;
+export declare const ModelAccountSettingsOverviewWorkspace: z.ZodObject<{
+    values: z.ZodObject<{
+        rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodEnum<{
+                primary_first: "primary_first";
+                spread: "spread";
+            }>;
+            primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            inferenceSource: z.ZodOptional<z.ZodEnum<{
+                automatic: "automatic";
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+            useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        crossProviderFailover: z.ZodBoolean;
+        fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        personalConnectionsAllowed: z.ZodBoolean;
+        personalFallbackAllowed: z.ZodBoolean;
+    }, z.core.$strip>;
+    sources: z.ZodObject<{
+        rotation: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        providers: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        crossProviderFailover: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        fallbackOrder: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        personalConnectionsAllowed: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+        personalFallbackAllowed: z.ZodEnum<{
+            locked: "locked";
+            organization: "organization";
+            workspace: "workspace";
+        }>;
+    }, z.core.$strip>;
+    entrySources: z.ZodObject<{
+        rotation: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+        fallbackOrder: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            organization: "organization";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strip>;
+    workspaceId: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+/** Every shared workspace's effective settings and sources, in pages ordered by workspace id. */
+export declare const ModelAccountSettingsOverview: z.ZodObject<{
+    organization: z.ZodObject<{
+        organizationId: z.ZodString;
+        values: z.ZodObject<{
+            rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+                mode: z.ZodEnum<{
+                    primary_first: "primary_first";
+                    spread: "spread";
+                }>;
+                primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+                inferenceSource: z.ZodOptional<z.ZodEnum<{
+                    automatic: "automatic";
+                    organization: "organization";
+                    workspace: "workspace";
+                }>>;
+                useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+                enabled: z.ZodBoolean;
+            }, z.core.$strip>>;
+            crossProviderFailover: z.ZodBoolean;
+            fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+            personalConnectionsAllowed: z.ZodBoolean;
+            personalFallbackAllowed: z.ZodBoolean;
+        }, z.core.$strip>;
+        locked: z.ZodArray<z.ZodEnum<{
+            crossProviderFailover: "crossProviderFailover";
+            fallbackOrder: "fallbackOrder";
+            personalConnectionsAllowed: "personalConnectionsAllowed";
+            personalFallbackAllowed: "personalFallbackAllowed";
+            providers: "providers";
+            rotation: "rotation";
+        }>>;
+        version: z.ZodNumber;
+        updatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    workspaces: z.ZodArray<z.ZodObject<{
+        values: z.ZodObject<{
+            rotation: z.ZodRecord<z.ZodString, z.ZodObject<{
+                mode: z.ZodEnum<{
+                    primary_first: "primary_first";
+                    spread: "spread";
+                }>;
+                primaryConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+                inferenceSource: z.ZodOptional<z.ZodEnum<{
+                    automatic: "automatic";
+                    organization: "organization";
+                    workspace: "workspace";
+                }>>;
+                useOrganizationAccounts: z.ZodDefault<z.ZodBoolean>;
+                enabled: z.ZodBoolean;
+            }, z.core.$strip>>;
+            crossProviderFailover: z.ZodBoolean;
+            fallbackOrder: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+            personalConnectionsAllowed: z.ZodBoolean;
+            personalFallbackAllowed: z.ZodBoolean;
+        }, z.core.$strip>;
+        sources: z.ZodObject<{
+            rotation: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            providers: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            crossProviderFailover: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            fallbackOrder: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            personalConnectionsAllowed: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            personalFallbackAllowed: z.ZodEnum<{
+                locked: "locked";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+        }, z.core.$strip>;
+        entrySources: z.ZodObject<{
+            rotation: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+            providers: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+            fallbackOrder: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                organization: "organization";
+                workspace: "workspace";
+            }>>;
+        }, z.core.$strip>;
+        workspaceId: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ModelAccountSettingsOverview = z.infer<typeof ModelAccountSettingsOverview>;

package/dist/model-availability.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `details.code` on a 422 `validation_failed` envelope when the requested or
+ * stored model is not in the live model catalog (retired, removed, or never
+ * offered). Retrying the same request cannot succeed; the client must choose
+ * another model. Additive to the public error envelope: `code` stays
+ * `validation_failed` and the message keeps its historical text.
+ */
+export declare const MODEL_UNAVAILABLE_ERROR_CODE: "model_unavailable";
+/** Typed cause for a model that is not selectable in the live catalog. */
+export declare class ModelUnavailableError extends Error {
+    readonly modelId: string;
+    readonly code: "model_unavailable";
+    constructor(modelId: string);
+}
+export declare function isModelUnavailableError(error: unknown): error is ModelUnavailableError;