@orq-ai/node 4.11.0-rc.7 → 4.11.0-rc.70

package/src/models/components/budget.ts

@@ -0,0 +1,114 @@
+/*
+ * 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 { BudgetUsage, BudgetUsage$inboundSchema } from "./budgetusage.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;
+  /**
+   * Live consumption for the current period, read from the Redis
+   *
+   * @remarks
+   *  counters the enforcement gate maintains. Populated by read paths
+   *  (Get / List); omitted on write responses (Create / Update / Reset)
+   *  where it carries no signal. Absent or all-zero for a budget that
+   *  has not been spent against in the current period.
+   */
+  usage?: BudgetUsage | 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(),
+    usage: BudgetUsage$inboundSchema.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,84 @@
+/*
+ * 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;
+  /**
+   * Token ceiling. Carried as a double so it serializes as a JSON number
+   *
+   * @remarks
+   *  (proto int64 would serialize as a quoted string); token counts are
+   *  whole and well within double's exact-integer range (2^53). Stored as
+   *  an integer server-side.
+   */
+  tokenLimit?: number | 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.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "token_limit": "tokenLimit",
+  });
+});
+/** @internal */
+export type BudgetLimits$Outbound = {
+  period?: string | undefined;
+  amount?: number | undefined;
+  token_limit?: number | 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.number().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);

package/src/models/components/budgetsortfield.ts

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const BudgetSortField = {
+  BudgetSortFieldUnspecified: "BUDGET_SORT_FIELD_UNSPECIFIED",
+  BudgetSortFieldExpiresAt: "BUDGET_SORT_FIELD_EXPIRES_AT",
+  BudgetSortFieldCreatedAt: "BUDGET_SORT_FIELD_CREATED_AT",
+  BudgetSortFieldUpdatedAt: "BUDGET_SORT_FIELD_UPDATED_AT",
+} as const;
+export type BudgetSortField = ClosedEnum<typeof BudgetSortField>;
+
+/** @internal */
+export const BudgetSortField$outboundSchema: z.ZodNativeEnum<
+  typeof BudgetSortField
+> = z.nativeEnum(BudgetSortField);

package/src/models/components/budgetusage.ts

@@ -0,0 +1,54 @@
+/*
+ * 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";
+
+/**
+ * BudgetUsage is the current-period consumption of a budget, sourced
+ *
+ * @remarks
+ *  from the live Redis counters (not the exact ledger). Each dimension is
+ *  the consumed side of the matching limit dimension: `amount` is the
+ *  accumulated cost in USD (vs limits.amount), `tokens` is the accumulated
+ *  token count (vs limits.token_limit), and `requests` is the count in the
+ *  rolling 60-second window (vs rate_limit.requests_per_minute). All three
+ *  are explicit-presence so the triple is always emitted in full, zeros
+ *  included — a never-spent budget serializes {amount:0, tokens:0,
+ *  requests:0} rather than dropping its zero dimensions.
+ */
+export type BudgetUsage = {
+  amount?: number | undefined;
+  /**
+   * Carried as a double (not int64) so it serializes as a JSON number
+   *
+   * @remarks
+   *  rather than a quoted string, matching limits.token_limit.
+   */
+  tokens?: number | undefined;
+  requests?: number | undefined;
+};
+
+/** @internal */
+export const BudgetUsage$inboundSchema: z.ZodType<
+  BudgetUsage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number().optional(),
+  tokens: z.number().optional(),
+  requests: z.number().int().optional(),
+});
+
+export function budgetUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetUsage' from JSON`,
+  );
+}

package/src/models/components/checkbudgetsrequest.ts

@@ -0,0 +1,111 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+/**
+ * Request metadata forwarded for dynamic-budget matching
+ *
+ * @remarks
+ *  (`metadata.team == "ml"`). Free-form JSON object from the request
+ *  body's `metadata` field.
+ */
+export type Metadata = {};
+
+export type CheckBudgetsRequest = {
+  /**
+   * API key that issued the request (if any).
+   */
+  apiKeyId?: string | undefined;
+  /**
+   * Project the request targets (if any).
+   */
+  projectId?: string | undefined;
+  /**
+   * Identity external id for contact-scoped budgets (if any).
+   */
+  identityExternalId?: string | undefined;
+  /**
+   * Provider enum value for provider-scoped budgets (if any).
+   */
+  provider?: string | undefined;
+  /**
+   * Full model reference for model-scoped budgets (if any), exactly as
+   *
+   * @remarks
+   *  the caller sent it: "provider/model" or "workspaceKey@provider/model".
+   */
+  modelId?: string | undefined;
+  /**
+   * Request metadata forwarded for dynamic-budget matching
+   *
+   * @remarks
+   *  (`metadata.team == "ml"`). Free-form JSON object from the request
+   *  body's `metadata` field.
+   */
+  metadata?: Metadata | undefined;
+  /**
+   * Request headers (lowercase keys) forwarded for dynamic-budget
+   *
+   * @remarks
+   *  matching (`headers["x-env"] == "prod"`).
+   */
+  headers?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export type Metadata$Outbound = {};
+
+/** @internal */
+export const Metadata$outboundSchema: z.ZodType<
+  Metadata$Outbound,
+  z.ZodTypeDef,
+  Metadata
+> = z.object({});
+
+export function metadataToJSON(metadata: Metadata): string {
+  return JSON.stringify(Metadata$outboundSchema.parse(metadata));
+}
+
+/** @internal */
+export type CheckBudgetsRequest$Outbound = {
+  api_key_id?: string | undefined;
+  project_id?: string | undefined;
+  identity_external_id?: string | undefined;
+  provider?: string | undefined;
+  model_id?: string | undefined;
+  metadata?: Metadata$Outbound | undefined;
+  headers?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const CheckBudgetsRequest$outboundSchema: z.ZodType<
+  CheckBudgetsRequest$Outbound,
+  z.ZodTypeDef,
+  CheckBudgetsRequest
+> = z.object({
+  apiKeyId: z.string().optional(),
+  projectId: z.string().optional(),
+  identityExternalId: z.string().optional(),
+  provider: z.string().optional(),
+  modelId: z.string().optional(),
+  metadata: z.lazy(() => Metadata$outboundSchema).optional(),
+  headers: z.record(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKeyId: "api_key_id",
+    projectId: "project_id",
+    identityExternalId: "identity_external_id",
+    modelId: "model_id",
+  });
+});
+
+export function checkBudgetsRequestToJSON(
+  checkBudgetsRequest: CheckBudgetsRequest,
+): string {
+  return JSON.stringify(
+    CheckBudgetsRequest$outboundSchema.parse(checkBudgetsRequest),
+  );
+}