@orq-ai/node 4.11.0-rc.2 → 4.11.0-rc.20

package/src/lib/matchers.ts

@@ -6,7 +6,7 @@ import { APIError } from "../models/errors/apierror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export type Encoding =
   | "jsonl"

package/src/lib/primitives.ts

@@ -148,3 +148,19 @@ export function allRequired<V extends Record<string, unknown>>(
 
   return v as ReturnType<typeof allRequired<V>>;
 }
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}

package/src/lib/sdks.ts

@@ -24,6 +24,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -132,27 +133,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);
@@ -198,9 +227,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +275,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );

package/src/models/components/apikeybudgetscope.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Per-api-key cap. Replaces the legacy embedded `constraints.budget`
+ *
+ * @remarks
+ *  on auth.apiKeys.
+ */
+export type ApiKeyBudgetScope = {
+  apiKeyId?: string | undefined;
+};
+
+/** @internal */
+export const ApiKeyBudgetScope$inboundSchema: z.ZodType<
+  ApiKeyBudgetScope,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  api_key_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "api_key_id": "apiKeyId",
+  });
+});
+/** @internal */
+export type ApiKeyBudgetScope$Outbound = {
+  api_key_id?: string | undefined;
+};
+
+/** @internal */
+export const ApiKeyBudgetScope$outboundSchema: z.ZodType<
+  ApiKeyBudgetScope$Outbound,
+  z.ZodTypeDef,
+  ApiKeyBudgetScope
+> = z.object({
+  apiKeyId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKeyId: "api_key_id",
+  });
+});
+
+export function apiKeyBudgetScopeToJSON(
+  apiKeyBudgetScope: ApiKeyBudgetScope,
+): string {
+  return JSON.stringify(
+    ApiKeyBudgetScope$outboundSchema.parse(apiKeyBudgetScope),
+  );
+}
+export function apiKeyBudgetScopeFromJSON(
+  jsonString: string,
+): SafeParseResult<ApiKeyBudgetScope, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApiKeyBudgetScope$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApiKeyBudgetScope' from JSON`,
+  );
+}

package/src/models/components/budget.ts

@@ -0,0 +1,102 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { BudgetLimits, BudgetLimits$inboundSchema } from "./budgetlimits.js";
+import { BudgetMatch, BudgetMatch$inboundSchema } from "./budgetmatch.js";
+import { BudgetScope, BudgetScope$inboundSchema } from "./budgetscope.js";
+import { RateLimit, RateLimit$inboundSchema } from "./ratelimit.js";
+
+/**
+ * Budget is the canonical record stored in MongoDB `budgets.entities`.
+ *
+ * @remarks
+ *  It replaces the embedded `constraints.budget` on api-keys and the
+ *  legacy CONTACT-only `budgets.configs` collection (see ADR 0007).
+ */
+export type Budget = {
+  budgetId?: string | undefined;
+  /**
+   * Denormalized metadata for UI rendering, list filters, and the
+   *
+   * @remarks
+   *  resolver's prefilter index. Never consulted for matching — the
+   *  `match` expression is the single source of matching semantics.
+   *  Unset for budgets created from a raw CEL expression ("custom").
+   */
+  scope?: BudgetScope | undefined;
+  /**
+   * The matching semantics of the budget. The enforcement resolver
+   *
+   * @remarks
+   *  evaluates `match.cel` against the request context; a budget
+   *  applies to a request if and only if the expression evaluates to
+   *  true. Scoped creates derive a canonical expression (e.g.
+   *  `provider == "openai"`); an empty expression always matches
+   *  (workspace-wide).
+   */
+  match?: BudgetMatch | undefined;
+  /**
+   * BudgetLimits is the per-period spend and token ceiling. At least one
+   *
+   * @remarks
+   *  of `amount`, `token_limit`, or RateLimit.requests_per_minute MUST be
+   *  set on a Budget; that invariant is enforced by the handler.
+   */
+  limits?: BudgetLimits | undefined;
+  /**
+   * RateLimit is the per-minute request ceiling. Enforced via atomic
+   *
+   * @remarks
+   *  increment-first semantics in the enforcement middleware.
+   */
+  rateLimit?: RateLimit | undefined;
+  isActive?: boolean | undefined;
+  expiresAt?: Date | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+};
+
+/** @internal */
+export const Budget$inboundSchema: z.ZodType<Budget, z.ZodTypeDef, unknown> = z
+  .object({
+    budget_id: z.string().optional(),
+    scope: BudgetScope$inboundSchema.optional(),
+    match: BudgetMatch$inboundSchema.optional(),
+    limits: BudgetLimits$inboundSchema.optional(),
+    rate_limit: RateLimit$inboundSchema.optional(),
+    is_active: z.boolean().optional(),
+    expires_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    created_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    updated_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "budget_id": "budgetId",
+      "rate_limit": "rateLimit",
+      "is_active": "isActive",
+      "expires_at": "expiresAt",
+      "created_at": "createdAt",
+      "updated_at": "updatedAt",
+    });
+  });
+
+export function budgetFromJSON(
+  jsonString: string,
+): SafeParseResult<Budget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Budget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Budget' from JSON`,
+  );
+}

package/src/models/components/budgetlimits.ts

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  BudgetPeriod,
+  BudgetPeriod$inboundSchema,
+  BudgetPeriod$outboundSchema,
+} from "./budgetperiod.js";
+
+/**
+ * BudgetLimits is the per-period spend and token ceiling. At least one
+ *
+ * @remarks
+ *  of `amount`, `token_limit`, or RateLimit.requests_per_minute MUST be
+ *  set on a Budget; that invariant is enforced by the handler.
+ */
+export type BudgetLimits = {
+  period?: BudgetPeriod | undefined;
+  amount?: number | undefined;
+  tokenLimit?: string | undefined;
+};
+
+/** @internal */
+export const BudgetLimits$inboundSchema: z.ZodType<
+  BudgetLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  period: BudgetPeriod$inboundSchema.optional(),
+  amount: z.number().optional(),
+  token_limit: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "token_limit": "tokenLimit",
+  });
+});
+/** @internal */
+export type BudgetLimits$Outbound = {
+  period?: string | undefined;
+  amount?: number | undefined;
+  token_limit?: string | undefined;
+};
+
+/** @internal */
+export const BudgetLimits$outboundSchema: z.ZodType<
+  BudgetLimits$Outbound,
+  z.ZodTypeDef,
+  BudgetLimits
+> = z.object({
+  period: BudgetPeriod$outboundSchema.optional(),
+  amount: z.number().optional(),
+  tokenLimit: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    tokenLimit: "token_limit",
+  });
+});
+
+export function budgetLimitsToJSON(budgetLimits: BudgetLimits): string {
+  return JSON.stringify(BudgetLimits$outboundSchema.parse(budgetLimits));
+}
+export function budgetLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetLimits' from JSON`,
+  );
+}

package/src/models/components/budgetmatch.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * BudgetMatch carries the CEL expression that decides whether a budget
+ *
+ * @remarks
+ *  applies to a request. Available variables: `model`, `provider`,
+ *  `model_id`, `api_key`, `identity`, `project`, `metadata` (map),
+ *  `headers` (map, lowercase keys). An empty expression always matches.
+ *  Expressions are syntax-validated at write time.
+ */
+export type BudgetMatch = {
+  cel?: string | undefined;
+};
+
+/** @internal */
+export const BudgetMatch$inboundSchema: z.ZodType<
+  BudgetMatch,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cel: z.string().optional(),
+});
+/** @internal */
+export type BudgetMatch$Outbound = {
+  cel?: string | undefined;
+};
+
+/** @internal */
+export const BudgetMatch$outboundSchema: z.ZodType<
+  BudgetMatch$Outbound,
+  z.ZodTypeDef,
+  BudgetMatch
+> = z.object({
+  cel: z.string().optional(),
+});
+
+export function budgetMatchToJSON(budgetMatch: BudgetMatch): string {
+  return JSON.stringify(BudgetMatch$outboundSchema.parse(budgetMatch));
+}
+export function budgetMatchFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetMatch, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetMatch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetMatch' from JSON`,
+  );
+}

package/src/models/components/budgetperiod.ts

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const BudgetPeriod = {
+  BudgetPeriodUnspecified: "BUDGET_PERIOD_UNSPECIFIED",
+  BudgetPeriodDaily: "BUDGET_PERIOD_DAILY",
+  BudgetPeriodWeekly: "BUDGET_PERIOD_WEEKLY",
+  BudgetPeriodMonthly: "BUDGET_PERIOD_MONTHLY",
+  BudgetPeriodYearly: "BUDGET_PERIOD_YEARLY",
+  BudgetPeriodOneTime: "BUDGET_PERIOD_ONE_TIME",
+} as const;
+export type BudgetPeriod = ClosedEnum<typeof BudgetPeriod>;
+
+/** @internal */
+export const BudgetPeriod$inboundSchema: z.ZodNativeEnum<typeof BudgetPeriod> =
+  z.nativeEnum(BudgetPeriod);
+/** @internal */
+export const BudgetPeriod$outboundSchema: z.ZodNativeEnum<typeof BudgetPeriod> =
+  BudgetPeriod$inboundSchema;

package/src/models/components/budgetrejection.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * BudgetRejection identifies the budget that caused a 429.
+ */
+export type BudgetRejection = {
+  scopeKind?: string | undefined;
+  scopeTargetId?: string | undefined;
+  dimension?: string | undefined;
+  code?: string | undefined;
+  message?: string | undefined;
+};
+
+/** @internal */
+export const BudgetRejection$inboundSchema: z.ZodType<
+  BudgetRejection,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  scope_kind: z.string().optional(),
+  scope_target_id: z.string().optional(),
+  dimension: z.string().optional(),
+  code: z.string().optional(),
+  message: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "scope_kind": "scopeKind",
+    "scope_target_id": "scopeTargetId",
+  });
+});
+
+export function budgetRejectionFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetRejection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetRejection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetRejection' from JSON`,
+  );
+}

package/src/models/components/budgetscope.ts

@@ -0,0 +1,150 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ApiKeyBudgetScope,
+  ApiKeyBudgetScope$inboundSchema,
+  ApiKeyBudgetScope$Outbound,
+  ApiKeyBudgetScope$outboundSchema,
+} from "./apikeybudgetscope.js";
+import {
+  IdentityBudgetScope,
+  IdentityBudgetScope$inboundSchema,
+  IdentityBudgetScope$Outbound,
+  IdentityBudgetScope$outboundSchema,
+} from "./identitybudgetscope.js";
+import {
+  ModelBudgetScope,
+  ModelBudgetScope$inboundSchema,
+  ModelBudgetScope$Outbound,
+  ModelBudgetScope$outboundSchema,
+} from "./modelbudgetscope.js";
+import {
+  ProjectBudgetScope,
+  ProjectBudgetScope$inboundSchema,
+  ProjectBudgetScope$Outbound,
+  ProjectBudgetScope$outboundSchema,
+} from "./projectbudgetscope.js";
+import {
+  ProviderBudgetScope,
+  ProviderBudgetScope$inboundSchema,
+  ProviderBudgetScope$Outbound,
+  ProviderBudgetScope$outboundSchema,
+} from "./providerbudgetscope.js";
+import {
+  WorkspaceBudgetScope,
+  WorkspaceBudgetScope$inboundSchema,
+  WorkspaceBudgetScope$Outbound,
+  WorkspaceBudgetScope$outboundSchema,
+} from "./workspacebudgetscope.js";
+
+/**
+ * BudgetScope is a closed oneof. Exactly one variant must be set. The
+ *
+ * @remarks
+ *  six variants are ordered by enforcement precedence (most specific to
+ *  most general) and mirror the BudgetScopeKind filter enum.
+ */
+export type BudgetScope = {
+  /**
+   * Workspace-wide ceiling. The implicit target is the caller's workspace.
+   */
+  workspace?: WorkspaceBudgetScope | undefined;
+  /**
+   * Per-project cap.
+   */
+  project?: ProjectBudgetScope | undefined;
+  /**
+   * Per-identity cap. Keyed by the contact's external_id (not the
+   *
+   * @remarks
+   *  internal Mongo `_id`) so the scope is stable across imports.
+   */
+  identity?: IdentityBudgetScope | undefined;
+  /**
+   * Per-api-key cap. Replaces the legacy embedded `constraints.budget`
+   *
+   * @remarks
+   *  on auth.apiKeys.
+   */
+  apiKey?: ApiKeyBudgetScope | undefined;
+  /**
+   * Per-provider cap. The value is the provider enum string (e.g.
+   *
+   * @remarks
+   *  "openai", "anthropic") drawn from ModelIntegrationIdentifier.
+   */
+  provider?: ProviderBudgetScope | undefined;
+  /**
+   * Per-model cap. The value is the FULL model reference as callers send
+   *
+   * @remarks
+   *  it ("openai/gpt-4o", or "workspaceKey@openai/gpt-4o" for private
+   *  models) — NOT the Mongo `_id` of the model master-data document.
+   */
+  model?: ModelBudgetScope | undefined;
+};
+
+/** @internal */
+export const BudgetScope$inboundSchema: z.ZodType<
+  BudgetScope,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  workspace: WorkspaceBudgetScope$inboundSchema.optional(),
+  project: ProjectBudgetScope$inboundSchema.optional(),
+  identity: IdentityBudgetScope$inboundSchema.optional(),
+  api_key: ApiKeyBudgetScope$inboundSchema.optional(),
+  provider: ProviderBudgetScope$inboundSchema.optional(),
+  model: ModelBudgetScope$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "api_key": "apiKey",
+  });
+});
+/** @internal */
+export type BudgetScope$Outbound = {
+  workspace?: WorkspaceBudgetScope$Outbound | undefined;
+  project?: ProjectBudgetScope$Outbound | undefined;
+  identity?: IdentityBudgetScope$Outbound | undefined;
+  api_key?: ApiKeyBudgetScope$Outbound | undefined;
+  provider?: ProviderBudgetScope$Outbound | undefined;
+  model?: ModelBudgetScope$Outbound | undefined;
+};
+
+/** @internal */
+export const BudgetScope$outboundSchema: z.ZodType<
+  BudgetScope$Outbound,
+  z.ZodTypeDef,
+  BudgetScope
+> = z.object({
+  workspace: WorkspaceBudgetScope$outboundSchema.optional(),
+  project: ProjectBudgetScope$outboundSchema.optional(),
+  identity: IdentityBudgetScope$outboundSchema.optional(),
+  apiKey: ApiKeyBudgetScope$outboundSchema.optional(),
+  provider: ProviderBudgetScope$outboundSchema.optional(),
+  model: ModelBudgetScope$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKey: "api_key",
+  });
+});
+
+export function budgetScopeToJSON(budgetScope: BudgetScope): string {
+  return JSON.stringify(BudgetScope$outboundSchema.parse(budgetScope));
+}
+export function budgetScopeFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetScope, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetScope$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetScope' from JSON`,
+  );
+}

package/src/models/components/budgetscopekind.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const BudgetScopeKind = {
+  BudgetScopeKindUnspecified: "BUDGET_SCOPE_KIND_UNSPECIFIED",
+  BudgetScopeKindWorkspace: "BUDGET_SCOPE_KIND_WORKSPACE",
+  BudgetScopeKindProject: "BUDGET_SCOPE_KIND_PROJECT",
+  BudgetScopeKindIdentity: "BUDGET_SCOPE_KIND_IDENTITY",
+  BudgetScopeKindApiKey: "BUDGET_SCOPE_KIND_API_KEY",
+  BudgetScopeKindProvider: "BUDGET_SCOPE_KIND_PROVIDER",
+  BudgetScopeKindModel: "BUDGET_SCOPE_KIND_MODEL",
+} as const;
+export type BudgetScopeKind = ClosedEnum<typeof BudgetScopeKind>;
+
+/** @internal */
+export const BudgetScopeKind$outboundSchema: z.ZodNativeEnum<
+  typeof BudgetScopeKind
+> = z.nativeEnum(BudgetScopeKind);