@opengeni/contracts 3.1.0-canary.1 → 3.1.2

package/dist/turn-serving-policy.d.ts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+export declare const TURN_SERVING_POLICY_METADATA_KEY: "turnServingPolicyV1";
+export declare const TURN_PENDING_SERVING_POLICY_METADATA_KEY: "turnPendingServingPolicyV1";
+/** One immutable serving receipt, not a replacement for the accepted policy.
+ * The lazy reference keeps the contracts barrel free of initialization cycles.
+ * Connection ids are references only; no credential material belongs here.
+ */
+export declare const TurnServingPolicyV1: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    policy: z.ZodLazy<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        productModelId: z.ZodString;
+        requestedModelId: z.ZodNullable<z.ZodString>;
+        modelSource: z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>;
+        reasoningEffort: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>;
+        reasoningSource: z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>;
+        latencyMode: z.ZodDefault<z.ZodEnum<{
+            fast: "fast";
+            priority: "priority";
+            standard: "standard";
+        }>>;
+        latencyModeSource: z.ZodDefault<z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>>;
+        providerId: z.ZodString;
+        upstreamModelId: z.ZodString;
+        wireApi: z.ZodEnum<{
+            "anthropic-messages": "anthropic-messages";
+            chat: "chat";
+            responses: "responses";
+        }>;
+        credentialSource: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"deployment">;
+            mechanism: z.ZodEnum<{
+                api_key: "api_key";
+                azure_ad_bearer: "azure_ad_bearer";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"connected_subscription">;
+            provider: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                xai: "xai";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"workspace_connection">;
+            mechanism: z.ZodLiteral<"api_key">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"organization_connection">;
+            mechanism: z.ZodLiteral<"api_key">;
+        }, z.core.$strict>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"deployment">;
+            mechanism: z.ZodLiteral<"none">;
+        }, z.core.$strict>]>;
+        billing: z.ZodObject<{
+            upstreamPayer: z.ZodEnum<{
+                connected_subscription: "connected_subscription";
+                deployment: "deployment";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            metering: z.ZodEnum<{
+                external: "external";
+                opengeni_credits: "opengeni_credits";
+            }>;
+        }, z.core.$strict>;
+        definitionVersion: z.ZodString;
+        credentialRestriction: z.ZodOptional<z.ZodLiteral<"developer_setup">>;
+    }, z.core.$strict>>;
+    executionGeneration: z.ZodNumber;
+    connectionId: z.ZodString;
+    reason: z.ZodEnum<{
+        failover_cross_provider: "failover_cross_provider";
+        failover_same_provider: "failover_same_provider";
+        initial: "initial";
+        pinned: "pinned";
+        reselected_cold: "reselected_cold";
+        return_to_preferred: "return_to_preferred";
+        sticky: "sticky";
+    }>;
+    historyPosition: z.ZodNumber;
+}, z.core.$strict>;
+export type TurnServingPolicyV1 = z.infer<typeof TurnServingPolicyV1>;
+/** A recovery proposal, NOT provenance. Its history boundary is assigned only
+ * when a newer claimed generation commits a serving revision. C2 will stage it
+ * atomically with recovery using the transaction-local database helper.
+ */
+export declare const TurnPendingServingPolicyV1: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sourceExecutionGeneration: z.ZodNumber;
+    sourceAttemptId: z.ZodString;
+    policy: z.ZodLazy<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        productModelId: z.ZodString;
+        requestedModelId: z.ZodNullable<z.ZodString>;
+        modelSource: z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>;
+        reasoningEffort: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>;
+        reasoningSource: z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>;
+        latencyMode: z.ZodDefault<z.ZodEnum<{
+            fast: "fast";
+            priority: "priority";
+            standard: "standard";
+        }>>;
+        latencyModeSource: z.ZodDefault<z.ZodEnum<{
+            continuation: "continuation";
+            deployment: "deployment";
+            explicit: "explicit";
+            session: "session";
+        }>>;
+        providerId: z.ZodString;
+        upstreamModelId: z.ZodString;
+        wireApi: z.ZodEnum<{
+            "anthropic-messages": "anthropic-messages";
+            chat: "chat";
+            responses: "responses";
+        }>;
+        credentialSource: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"deployment">;
+            mechanism: z.ZodEnum<{
+                api_key: "api_key";
+                azure_ad_bearer: "azure_ad_bearer";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"connected_subscription">;
+            provider: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                xai: "xai";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"workspace_connection">;
+            mechanism: z.ZodLiteral<"api_key">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"organization_connection">;
+            mechanism: z.ZodLiteral<"api_key">;
+        }, z.core.$strict>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"deployment">;
+            mechanism: z.ZodLiteral<"none">;
+        }, z.core.$strict>]>;
+        billing: z.ZodObject<{
+            upstreamPayer: z.ZodEnum<{
+                connected_subscription: "connected_subscription";
+                deployment: "deployment";
+                organization: "organization";
+                workspace: "workspace";
+            }>;
+            metering: z.ZodEnum<{
+                external: "external";
+                opengeni_credits: "opengeni_credits";
+            }>;
+        }, z.core.$strict>;
+        definitionVersion: z.ZodString;
+        credentialRestriction: z.ZodOptional<z.ZodLiteral<"developer_setup">>;
+    }, z.core.$strict>>;
+    connectionId: z.ZodString;
+    reason: z.ZodEnum<{
+        failover_cross_provider: "failover_cross_provider";
+        failover_same_provider: "failover_same_provider";
+        initial: "initial";
+        pinned: "pinned";
+        reselected_cold: "reselected_cold";
+        return_to_preferred: "return_to_preferred";
+        sticky: "sticky";
+    }>;
+}, z.core.$strict>;
+export type TurnPendingServingPolicyV1 = z.infer<typeof TurnPendingServingPolicyV1>;
+export declare function readTurnPendingServingPolicyV1(metadata: unknown): TurnPendingServingPolicyV1 | null;
+export type TurnServingPolicyReadV1 = {
+    kind: "absent";
+} | {
+    kind: "valid";
+    revisions: TurnServingPolicyV1[];
+};
+/** Only absence is legacy. Malformed present metadata fails closed, without
+ * reflecting untrusted values (which might contain credentials) into errors.
+ */
+export declare function readTurnServingPolicyV1(metadata: unknown): TurnServingPolicyReadV1;
+/** D-39: the first receipt establishes the baseline. Reclaims, account-only
+ * rotations and reasoning changes do not spend the model/provider bound.
+ * Combine this with the all-provider refusal count at the recovery boundary.
+ */
+export declare function countTurnServingPolicyChangesV1(revisions: readonly TurnServingPolicyV1[]): number;

package/dist/usage-allowances.d.ts

@@ -0,0 +1,314 @@
+import { z } from "zod";
+/** Credit amounts are integer USD micros (1 USD = 1,000,000), never floating-point dollars. */
+export declare const AllowanceCredits: z.ZodNumber;
+/**
+ * A share scales with the current workspace pool, including unexpired grants.
+ * Shares may exceed 1 and their sum may exceed 1: they are ceilings, not reserved
+ * allocations. Concurrent/in-flight calls can overshoot a ceiling; enforcement
+ * happens before the next call, after actual usage is settled.
+ * null removes the override and uses the workspace's memberDefault.
+ */
+export declare const MemberAllowanceRule: z.ZodUnion<readonly [z.ZodObject<{
+    share: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    credits: z.ZodNumber;
+}, z.core.$strict>, z.ZodNull]>;
+export type MemberAllowanceRule = z.infer<typeof MemberAllowanceRule>;
+export declare const MemberAllowanceDefault: z.ZodUnion<readonly [z.ZodEnum<{
+    equal_share: "equal_share";
+    none: "none";
+}>, z.ZodObject<{
+    share: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    credits: z.ZodNumber;
+}, z.core.$strict>]>;
+export type MemberAllowanceDefault = z.infer<typeof MemberAllowanceDefault>;
+/**
+ * How model calls that spend no Opengeni credits count: subscription
+ * connections, workspace-owned keys and deployments without credit billing.
+ * "ignore" (the default) keeps the allowance credit-only. "list_price" counts
+ * each such call at its configured list-price estimate in USD micros and
+ * admits those turns against the allowance; calls without a list price are
+ * not counted.
+ */
+export declare const UnbilledUsageMetering: z.ZodEnum<{
+    ignore: "ignore";
+    list_price: "list_price";
+}>;
+export type UnbilledUsageMetering = z.infer<typeof UnbilledUsageMetering>;
+/** Omitted threshold lists default to [0.8, 1]. Monthly boundaries are UTC. */
+export declare const WorkspaceAllowanceConfig: z.ZodObject<{
+    includedCredits: z.ZodNumber;
+    period: z.ZodEnum<{
+        monthly: "monthly";
+        none: "none";
+    }>;
+    anchorDay: z.ZodOptional<z.ZodNumber>;
+    memberDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        equal_share: "equal_share";
+        none: "none";
+    }>, z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        workspace: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        member: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    unbilledUsage: z.ZodOptional<z.ZodEnum<{
+        ignore: "ignore";
+        list_price: "list_price";
+    }>>;
+}, z.core.$strict>;
+export type WorkspaceAllowanceConfig = z.infer<typeof WorkspaceAllowanceConfig>;
+export declare const WorkspaceAllowance: z.ZodObject<{
+    includedCredits: z.ZodNumber;
+    period: z.ZodEnum<{
+        monthly: "monthly";
+        none: "none";
+    }>;
+    anchorDay: z.ZodOptional<z.ZodNumber>;
+    memberDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        equal_share: "equal_share";
+        none: "none";
+    }>, z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        workspace: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        member: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    unbilledUsage: z.ZodOptional<z.ZodEnum<{
+        ignore: "ignore";
+        list_price: "list_price";
+    }>>;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceAllowance = z.infer<typeof WorkspaceAllowance>;
+/**
+ * Lifecycle version survives clear. version=0 means never configured; a null
+ * config with a positive version is cleared. Use this version for recreation.
+ * The existing nullable configuration read remains unchanged.
+ */
+export declare const WorkspaceAllowanceState: z.ZodObject<{
+    version: z.ZodNumber;
+    config: z.ZodNullable<z.ZodObject<{
+        includedCredits: z.ZodNumber;
+        period: z.ZodEnum<{
+            monthly: "monthly";
+            none: "none";
+        }>;
+        anchorDay: z.ZodOptional<z.ZodNumber>;
+        memberDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            equal_share: "equal_share";
+            none: "none";
+        }>, z.ZodObject<{
+            share: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            credits: z.ZodNumber;
+        }, z.core.$strict>]>>;
+        thresholds: z.ZodOptional<z.ZodObject<{
+            workspace: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            member: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>>;
+        unbilledUsage: z.ZodOptional<z.ZodEnum<{
+            ignore: "ignore";
+            list_price: "list_price";
+        }>>;
+        version: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkspaceAllowanceState = z.infer<typeof WorkspaceAllowanceState>;
+export declare const SetWorkspaceAllowanceRequest: z.ZodObject<{
+    includedCredits: z.ZodNumber;
+    period: z.ZodEnum<{
+        monthly: "monthly";
+        none: "none";
+    }>;
+    anchorDay: z.ZodOptional<z.ZodNumber>;
+    memberDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        equal_share: "equal_share";
+        none: "none";
+    }>, z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        workspace: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        member: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    unbilledUsage: z.ZodOptional<z.ZodEnum<{
+        ignore: "ignore";
+        list_price: "list_price";
+    }>>;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strict>;
+export type SetWorkspaceAllowanceRequest = z.infer<typeof SetWorkspaceAllowanceRequest>;
+/** Reuse operationId and the exact expectedVersion to recover a lost clear
+ * receipt. A later lifecycle change conflicts; read the state before deciding
+ * on a new mutation, never guess a version or change it for a retry. */
+export declare const ClearWorkspaceAllowanceRequest: z.ZodObject<{
+    expectedVersion: z.ZodNumber;
+    operationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ClearWorkspaceAllowanceRequest = z.infer<typeof ClearWorkspaceAllowanceRequest>;
+export declare const ClearWorkspaceAllowanceResponse: z.ZodObject<{
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type ClearWorkspaceAllowanceResponse = z.infer<typeof ClearWorkspaceAllowanceResponse>;
+/** Reuse the operationId and exact request to recover an uncertain grant response. */
+export declare const GrantWorkspaceCreditsRequest: z.ZodObject<{
+    operationId: z.ZodString;
+    credits: z.ZodNumber;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type GrantWorkspaceCreditsRequest = z.infer<typeof GrantWorkspaceCreditsRequest>;
+export declare const WorkspaceCreditGrant: z.ZodObject<{
+    operationId: z.ZodString;
+    credits: z.ZodNumber;
+    remaining: z.ZodNumber;
+    expiresAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type WorkspaceCreditGrant = z.infer<typeof WorkspaceCreditGrant>;
+export declare const SetMemberAllowanceRequest: z.ZodObject<{
+    rule: z.ZodUnion<readonly [z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodNull]>;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strict>;
+export type SetMemberAllowanceRequest = z.infer<typeof SetMemberAllowanceRequest>;
+export declare const MemberAllowance: z.ZodObject<{
+    subjectId: z.ZodString;
+    rule: z.ZodUnion<readonly [z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodNull]>;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type MemberAllowance = z.infer<typeof MemberAllowance>;
+export declare const UsageAllowancePeriod: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodString]>;
+export type UsageAllowancePeriod = z.infer<typeof UsageAllowancePeriod>;
+export declare const GetUsageRequest: z.ZodObject<{
+    period: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodString]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GetUsageRequest = z.infer<typeof GetUsageRequest>;
+export declare const GetMyUsageRequest: z.ZodObject<{
+    period: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodString]>>;
+}, z.core.$strict>;
+export type GetMyUsageRequest = z.infer<typeof GetMyUsageRequest>;
+export declare const UsageAllowanceStatus: z.ZodEnum<{
+    exhausted: "exhausted";
+    ok: "ok";
+    warning: "warning";
+}>;
+export type UsageAllowanceStatus = z.infer<typeof UsageAllowanceStatus>;
+export declare const UsageAllowanceWindow: z.ZodObject<{
+    start: z.ZodNullable<z.ZodString>;
+    end: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type UsageAllowanceWindow = z.infer<typeof UsageAllowanceWindow>;
+export declare const WorkspaceAllowanceUsage: z.ZodObject<{
+    limit: z.ZodNullable<z.ZodNumber>;
+    used: z.ZodNumber;
+    remaining: z.ZodNullable<z.ZodNumber>;
+    fraction: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+        exhausted: "exhausted";
+        ok: "ok";
+        warning: "warning";
+    }>;
+    resetsAt: z.ZodNullable<z.ZodString>;
+    includedCredits: z.ZodNumber;
+    grantsRemaining: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceAllowanceUsage = z.infer<typeof WorkspaceAllowanceUsage>;
+export declare const MemberAllowanceUsage: z.ZodObject<{
+    limit: z.ZodNullable<z.ZodNumber>;
+    used: z.ZodNumber;
+    remaining: z.ZodNullable<z.ZodNumber>;
+    fraction: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+        exhausted: "exhausted";
+        ok: "ok";
+        warning: "warning";
+    }>;
+    resetsAt: z.ZodNullable<z.ZodString>;
+    subjectId: z.ZodString;
+    externalIdentity: z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        externalId: z.ZodString;
+    }, z.core.$strict>>;
+    rule: z.ZodUnion<readonly [z.ZodObject<{
+        share: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        credits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodNull]>;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type MemberAllowanceUsage = z.infer<typeof MemberAllowanceUsage>;
+/** /usage/me returns only the authenticated subject's member row, never the roster. */
+export declare const WorkspaceUsageResponse: z.ZodObject<{
+    period: z.ZodObject<{
+        start: z.ZodNullable<z.ZodString>;
+        end: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    workspace: z.ZodObject<{
+        limit: z.ZodNullable<z.ZodNumber>;
+        used: z.ZodNumber;
+        remaining: z.ZodNullable<z.ZodNumber>;
+        fraction: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+            exhausted: "exhausted";
+            ok: "ok";
+            warning: "warning";
+        }>;
+        resetsAt: z.ZodNullable<z.ZodString>;
+        includedCredits: z.ZodNumber;
+        grantsRemaining: z.ZodNumber;
+    }, z.core.$strict>;
+    members: z.ZodArray<z.ZodObject<{
+        limit: z.ZodNullable<z.ZodNumber>;
+        used: z.ZodNumber;
+        remaining: z.ZodNullable<z.ZodNumber>;
+        fraction: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+            exhausted: "exhausted";
+            ok: "ok";
+            warning: "warning";
+        }>;
+        resetsAt: z.ZodNullable<z.ZodString>;
+        subjectId: z.ZodString;
+        externalIdentity: z.ZodNullable<z.ZodObject<{
+            source: z.ZodString;
+            externalId: z.ZodString;
+        }, z.core.$strict>>;
+        rule: z.ZodUnion<readonly [z.ZodObject<{
+            share: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            credits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodNull]>;
+        version: z.ZodNumber;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type WorkspaceUsageResponse = z.infer<typeof WorkspaceUsageResponse>;
+export declare const AllowanceExhaustedRefusal: z.ZodObject<{
+    code: z.ZodLiteral<"allowance_exhausted">;
+    scope: z.ZodEnum<{
+        member: "member";
+        workspace: "workspace";
+    }>;
+    resetsAt: z.ZodNullable<z.ZodString>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type AllowanceExhaustedRefusal = z.infer<typeof AllowanceExhaustedRefusal>;

package/dist/usage-allowances.js

@@ -0,0 +1,52 @@
+import {
+  AllowanceCredits,
+  AllowanceExhaustedRefusal,
+  ClearWorkspaceAllowanceRequest,
+  ClearWorkspaceAllowanceResponse,
+  GetMyUsageRequest,
+  GetUsageRequest,
+  GrantWorkspaceCreditsRequest,
+  MemberAllowance,
+  MemberAllowanceDefault,
+  MemberAllowanceRule,
+  MemberAllowanceUsage,
+  SetMemberAllowanceRequest,
+  SetWorkspaceAllowanceRequest,
+  UnbilledUsageMetering,
+  UsageAllowancePeriod,
+  UsageAllowanceStatus,
+  UsageAllowanceWindow,
+  WorkspaceAllowance,
+  WorkspaceAllowanceConfig,
+  WorkspaceAllowanceState,
+  WorkspaceAllowanceUsage,
+  WorkspaceCreditGrant,
+  WorkspaceUsageResponse
+} from "./chunk-TSWWZMUS.js";
+import "./chunk-56SNIMDO.js";
+export {
+  AllowanceCredits,
+  AllowanceExhaustedRefusal,
+  ClearWorkspaceAllowanceRequest,
+  ClearWorkspaceAllowanceResponse,
+  GetMyUsageRequest,
+  GetUsageRequest,
+  GrantWorkspaceCreditsRequest,
+  MemberAllowance,
+  MemberAllowanceDefault,
+  MemberAllowanceRule,
+  MemberAllowanceUsage,
+  SetMemberAllowanceRequest,
+  SetWorkspaceAllowanceRequest,
+  UnbilledUsageMetering,
+  UsageAllowancePeriod,
+  UsageAllowanceStatus,
+  UsageAllowanceWindow,
+  WorkspaceAllowance,
+  WorkspaceAllowanceConfig,
+  WorkspaceAllowanceState,
+  WorkspaceAllowanceUsage,
+  WorkspaceCreditGrant,
+  WorkspaceUsageResponse
+};
+//# sourceMappingURL=usage-allowances.js.map

package/dist/usage-allowances.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}