// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  accountId: "account_id",
  accountTag: "account_tag",
  aggregatedValue: "aggregated_value",
  amountDue: "amount_due",
  amountPaid: "amount_paid",
  amountRemaining: "amount_remaining",
  attemptCount: "attempt_count",
  autoAdvance: "auto_advance",
  baseUrl: "base_url",
  cacheInvalidateOnUpdate: "cache_invalidate_on_update",
  cacheTtl: "cache_ttl",
  clientSecret: "client_secret",
  collectLogs: "collect_logs",
  contentType: "content_type",
  createdAt: "created_at",
  createdBy: "created_by",
  creditBalanceTransaction: "credit_balance_transaction",
  curlExample: "curl_example",
  customCost: "custom_cost",
  datasetIds: "dataset_ids",
  defaultConfig: "default_config",
  deploymentId: "deployment_id",
  endTime: "end_time",
  evaluationId: "evaluation_id",
  evaluationTypeId: "evaluation_type_id",
  evaluationTypeIds: "evaluation_type_ids",
  firstTopupSuccess: "first_topup_success",
  gatewayId: "gateway_id",
  hasDefaultPaymentMethod: "has_default_payment_method",
  hasMore: "has_more",
  invoiceLines: "invoice_lines",
  invoiceOrigin: "invoice_origin",
  invoicePdf: "invoice_pdf",
  isDefault: "is_default",
  isValid: "is_valid",
  jsExample: "js_example",
  logManagement: "log_management",
  logManagementStrategy: "log_management_strategy",
  logpushPublicKey: "logpush_public_key",
  modelType: "model_type",
  modifiedAt: "modified_at",
  orderBy: "order_by",
  orderByDirection: "order_by_direction",
  p1: "P1",
  paymentIntentId: "payment_intent_id",
  paymentMethod: "payment_method",
  perPage: "per_page",
  periodEnd: "period_end",
  periodStart: "period_start",
  pretaxCreditAmounts: "pretax_credit_amounts",
  providerSlug: "provider_slug",
  rateLimit: "rate_limit",
  rateLimitPeriod: "rate_limit_period",
  rateLimitingInterval: "rate_limiting_interval",
  rateLimitingLimit: "rate_limiting_limit",
  rateLimitingTechnique: "rate_limiting_technique",
  requestContentType: "request_content_type",
  requestHead: "request_head",
  requestHeadComplete: "request_head_complete",
  requestSize: "request_size",
  requestType: "request_type",
  responseContentType: "response_content_type",
  responseHead: "response_head",
  responseHeadComplete: "response_head_complete",
  responseSize: "response_size",
  resultInfo: "result_info",
  retryBackoff: "retry_backoff",
  retryDelay: "retry_delay",
  retryMaxAttempts: "retry_max_attempts",
  s1: "S1",
  s10: "S10",
  s11: "S11",
  s12: "S12",
  s13: "S13",
  s2: "S2",
  s3: "S3",
  s4: "S4",
  s5: "S5",
  s6: "S6",
  s7: "S7",
  s8: "S8",
  s9: "S9",
  secretId: "secret_id",
  secretPreview: "secret_preview",
  spendLimits: "spend_limits",
  startTime: "start_time",
  statusCode: "status_code",
  statusDescription: "status_description",
  storeId: "store_id",
  tokensIn: "tokens_in",
  tokensOut: "tokens_out",
  topupConfig: "topup_config",
  totalCount: "total_count",
  totalLogs: "total_logs",
  unitAmountDecimal: "unit_amount_decimal",
  usageEvents: "usage_events",
  versionId: "version_id",
  workersAiBillingMode: "workers_ai_billing_mode",
};

export class AiGatewaySpendingLimitDeprecated
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<AiGatewaySpendingLimitDeprecated>()(
      "AiGatewaySpendingLimitDeprecated",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ message: { includes: "spending limits are deprecated" } }],
  ) {}

export class DatasetNameAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<DatasetNameAlreadyExists>()(
      "DatasetNameAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 400, message: { includes: "already exists" } }],
  ) {}

export class DatasetNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<DatasetNotFound>()("DatasetNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7002 }],
  ) {}

export class EvaluationNameAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<EvaluationNameAlreadyExists>()(
      "EvaluationNameAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 400, message: { includes: "already exists" } }],
  ) {}

export class EvaluationNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<EvaluationNotFound>()("EvaluationNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7002 }],
  ) {}

export class GatewayAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<GatewayAlreadyExists>()(
      "GatewayAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 7001 }, { status: 504 }],
  ) {}

export class GatewayNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<GatewayNotFound>()("GatewayNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7002 }],
  ) {}

export class NoManualTopup
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<NoManualTopup>()("NoManualTopup", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 1000, message: { includes: "NO_MANUAL_TOPUP" } }],
  ) {}

export class ProviderConfigAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ProviderConfigAlreadyExists>()(
      "ProviderConfigAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 7001, message: { includes: "already exists" } }],
  ) {}

export class ProviderConfigNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ProviderConfigNotFound>()(
      "ProviderConfigNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 7002 }],
  ) {}

export class ProviderConfigSecretNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ProviderConfigSecretNotFound>()(
      "ProviderConfigSecretNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 7001, message: { includes: "was not found" } }],
  ) {}

export class RouteAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RouteAlreadyExists>()("RouteAlreadyExists", {
      code: S.Number,
      message: S.String,
    }),
    [
      { code: 7005, message: { includes: "already exists" } },
      {
        status: 500,
        message: { includes: "UNIQUE constraint failed: routes.name" },
      },
    ],
  ) {}

export class RouteNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<RouteNotFound>()("RouteNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7005, message: { includes: "not found" } }],
  ) {}

export type CreateRequestLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const CreateRequestLogManagementStrategy = /*@__PURE__*/ S.String;

export type CreateRequestRateLimitingTechnique = "fixed" | "sliding";
export const CreateRequestRateLimitingTechnique = /*@__PURE__*/ S.String;

export type CreateRequestRetryBackoff = "constant" | "linear" | "exponential";
export const CreateRequestRetryBackoff = /*@__PURE__*/ S.String;

export type CreateRequestWorkersAiBillingMode = "postpaid";
export const CreateRequestWorkersAiBillingMode = /*@__PURE__*/ S.String;

export interface CreateAiGatewayRequest {
  accountId: string;
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number | null;
  collectLogs: boolean;
  rateLimitingInterval: number | null;
  rateLimitingLimit: number | null;
  authentication?: boolean;
  logManagement?: number;
  logManagementStrategy?: CreateRequestLogManagementStrategy | (string & {});
  logpush?: boolean;
  logpushPublicKey?: string;
  rateLimitingTechnique?: CreateRequestRateLimitingTechnique | (string & {});
  /** Backoff strategy for retry delays */
  retryBackoff?: CreateRequestRetryBackoff | (string & {});
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: CreateRequestWorkersAiBillingMode | (string & {});
  zdr?: boolean;
}
export const CreateAiGatewayRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.NullOr(S.Number).pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    rateLimitingInterval: S.NullOr(S.Number).pipe(
      T.Body("rate_limiting_interval"),
    ),
    rateLimitingLimit: S.NullOr(S.Number).pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.Boolean),
    logManagement: S.optional(S.Number.pipe(T.Body("log_management"))),
    logManagementStrategy: S.optional(
      CreateRequestLogManagementStrategy.pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.Boolean),
    logpushPublicKey: S.optional(S.String.pipe(T.Body("logpush_public_key"))),
    rateLimitingTechnique: S.optional(
      CreateRequestRateLimitingTechnique.pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      CreateRequestRetryBackoff.pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.Number.pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(S.Number.pipe(T.Body("retry_max_attempts"))),
    workersAiBillingMode: S.optional(
      CreateRequestWorkersAiBillingMode.pipe(T.Body("workers_ai_billing_mode")),
    ),
    zdr: S.optional(S.Boolean),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAiGatewayRequest",
}) as any as S.Schema<CreateAiGatewayRequest>;

export type CreateResponseDlpCase0Action = "BLOCK" | "FLAG";
export const CreateResponseDlpCase0Action = /*@__PURE__*/ S.String;

export type CreateResponseDlpCase0ProfilesList = Array<string>;
export const CreateResponseDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CreateResponseDlpCase0ProfilesList>;

export interface CreateResponseDlpCase0 {
  action: CreateResponseDlpCase0Action;
  enabled: boolean;
  profiles: CreateResponseDlpCase0ProfilesList;
}
export const CreateResponseDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: CreateResponseDlpCase0Action,
    enabled: S.Boolean,
    profiles: CreateResponseDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "CreateResponseDlpCase0",
}) as any as S.Schema<CreateResponseDlpCase0>;

export type CreateResponseDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const CreateResponseDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type CreateResponseDlpCase1PoliciesItemCheckItem =
  | "REQUEST"
  | "RESPONSE";
export const CreateResponseDlpCase1PoliciesItemCheckItem =
  /*@__PURE__*/ S.String;

export type CreateResponseDlpCase1PoliciesItemCheckList =
  Array<CreateResponseDlpCase1PoliciesItemCheckItem>;
export const CreateResponseDlpCase1PoliciesItemCheckList =
  /*@__PURE__*/ S.Array(
    CreateResponseDlpCase1PoliciesItemCheckItem,
  ) as any as S.Schema<CreateResponseDlpCase1PoliciesItemCheckList>;

export type CreateResponseDlpCase1PoliciesItemProfilesList = Array<string>;
export const CreateResponseDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<CreateResponseDlpCase1PoliciesItemProfilesList>;

export interface CreateResponseDlpCase1PoliciesItem {
  id: string;
  action: CreateResponseDlpCase1PoliciesItemAction;
  check: CreateResponseDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: CreateResponseDlpCase1PoliciesItemProfilesList;
}
export const CreateResponseDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: CreateResponseDlpCase1PoliciesItemAction,
    check: CreateResponseDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: CreateResponseDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "CreateResponseDlpCase1PoliciesItem",
}) as any as S.Schema<CreateResponseDlpCase1PoliciesItem>;

export type CreateResponseDlpCase1PoliciesList =
  Array<CreateResponseDlpCase1PoliciesItem>;
export const CreateResponseDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  CreateResponseDlpCase1PoliciesItem,
) as any as S.Schema<CreateResponseDlpCase1PoliciesList>;

export interface CreateResponseDlpCase1 {
  enabled: boolean;
  policies: CreateResponseDlpCase1PoliciesList;
}
export const CreateResponseDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: CreateResponseDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "CreateResponseDlpCase1",
}) as any as S.Schema<CreateResponseDlpCase1>;

export type CreateResponseDlp = CreateResponseDlpCase0 | CreateResponseDlpCase1;
export const CreateResponseDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type CreateResponseGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface CreateResponseGuardrailsPrompt {
  p1?: CreateResponseGuardrailsPromptP1 | null;
  s1?: CreateResponseGuardrailsPromptS1 | null;
  s10?: CreateResponseGuardrailsPromptS10 | null;
  s11?: CreateResponseGuardrailsPromptS11 | null;
  s12?: CreateResponseGuardrailsPromptS12 | null;
  s13?: CreateResponseGuardrailsPromptS13 | null;
  s2?: CreateResponseGuardrailsPromptS2 | null;
  s3?: CreateResponseGuardrailsPromptS3 | null;
  s4?: CreateResponseGuardrailsPromptS4 | null;
  s5?: CreateResponseGuardrailsPromptS5 | null;
  s6?: CreateResponseGuardrailsPromptS6 | null;
  s7?: CreateResponseGuardrailsPromptS7 | null;
  s8?: CreateResponseGuardrailsPromptS8 | null;
  s9?: CreateResponseGuardrailsPromptS9 | null;
}
export const CreateResponseGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(CreateResponseGuardrailsPromptS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "CreateResponseGuardrailsPrompt",
}) as any as S.Schema<CreateResponseGuardrailsPrompt>;

export type CreateResponseGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type CreateResponseGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const CreateResponseGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface CreateResponseGuardrailsResponse {
  p1?: CreateResponseGuardrailsResponseP1 | null;
  s1?: CreateResponseGuardrailsResponseS1 | null;
  s10?: CreateResponseGuardrailsResponseS10 | null;
  s11?: CreateResponseGuardrailsResponseS11 | null;
  s12?: CreateResponseGuardrailsResponseS12 | null;
  s13?: CreateResponseGuardrailsResponseS13 | null;
  s2?: CreateResponseGuardrailsResponseS2 | null;
  s3?: CreateResponseGuardrailsResponseS3 | null;
  s4?: CreateResponseGuardrailsResponseS4 | null;
  s5?: CreateResponseGuardrailsResponseS5 | null;
  s6?: CreateResponseGuardrailsResponseS6 | null;
  s7?: CreateResponseGuardrailsResponseS7 | null;
  s8?: CreateResponseGuardrailsResponseS8 | null;
  s9?: CreateResponseGuardrailsResponseS9 | null;
}
export const CreateResponseGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(CreateResponseGuardrailsResponseS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "CreateResponseGuardrailsResponse",
}) as any as S.Schema<CreateResponseGuardrailsResponse>;

export interface CreateResponseGuardrails {
  prompt: CreateResponseGuardrailsPrompt;
  response: CreateResponseGuardrailsResponse;
}
export const CreateResponseGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: CreateResponseGuardrailsPrompt,
    response: CreateResponseGuardrailsResponse,
  }),
).annotate({
  identifier: "CreateResponseGuardrails",
}) as any as S.Schema<CreateResponseGuardrails>;

export type CreateResponseLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const CreateResponseLogManagementStrategy = /*@__PURE__*/ S.String;

export type CreateResponseOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const CreateResponseOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<CreateResponseOtelItemHeadersMap>;

export type CreateResponseOtelItemContentType = "json" | "protobuf";
export const CreateResponseOtelItemContentType = /*@__PURE__*/ S.String;

export interface CreateResponseOtelItem {
  headers: CreateResponseOtelItemHeadersMap;
  url: string;
  authorization?: string | null;
  contentType?: CreateResponseOtelItemContentType | null;
}
export const CreateResponseOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: CreateResponseOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.NullOr(S.String)),
    contentType: S.optional(
      S.NullOr(CreateResponseOtelItemContentType).pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "CreateResponseOtelItem",
}) as any as S.Schema<CreateResponseOtelItem>;

export type CreateResponseOtelList = Array<CreateResponseOtelItem>;
export const CreateResponseOtelList = /*@__PURE__*/ S.Array(
  CreateResponseOtelItem,
) as any as S.Schema<CreateResponseOtelList>;

export type CreateResponseRateLimitingTechnique = "fixed" | "sliding";
export const CreateResponseRateLimitingTechnique = /*@__PURE__*/ S.String;

export type CreateResponseRetryBackoff = "constant" | "linear" | "exponential";
export const CreateResponseRetryBackoff = /*@__PURE__*/ S.String;

export type CreateResponseSpendLimitsRulesItemLimitType = "cost";
export const CreateResponseSpendLimitsRulesItemLimitType =
  /*@__PURE__*/ S.String;

export type UntypedMetadataMap = { [key: string]: unknown | undefined };
export const UntypedMetadataMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<UntypedMetadataMap>;

export type CreateResponseSpendLimitsRulesItemModelMode = "filter";
export const CreateResponseSpendLimitsRulesItemModelMode =
  /*@__PURE__*/ S.String;

export type CreateResponseSpendLimitsRulesItemModelValuesList = Array<string>;
export const CreateResponseSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<CreateResponseSpendLimitsRulesItemModelValuesList>;

export interface CreateResponseSpendLimitsRulesItemModel {
  mode: CreateResponseSpendLimitsRulesItemModelMode;
  values: CreateResponseSpendLimitsRulesItemModelValuesList;
}
export const CreateResponseSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: CreateResponseSpendLimitsRulesItemModelMode,
      values: CreateResponseSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "CreateResponseSpendLimitsRulesItemModel",
}) as any as S.Schema<CreateResponseSpendLimitsRulesItemModel>;

export type CreateResponseSpendLimitsRulesItemProviderMode = "filter";
export const CreateResponseSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type CreateResponseSpendLimitsRulesItemProviderValuesList =
  Array<string>;
export const CreateResponseSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<CreateResponseSpendLimitsRulesItemProviderValuesList>;

export interface CreateResponseSpendLimitsRulesItemProvider {
  mode: CreateResponseSpendLimitsRulesItemProviderMode;
  values: CreateResponseSpendLimitsRulesItemProviderValuesList;
}
export const CreateResponseSpendLimitsRulesItemProvider =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mode: CreateResponseSpendLimitsRulesItemProviderMode,
      values: CreateResponseSpendLimitsRulesItemProviderValuesList,
    }),
  ).annotate({
    identifier: "CreateResponseSpendLimitsRulesItemProvider",
  }) as any as S.Schema<CreateResponseSpendLimitsRulesItemProvider>;

export type CreateResponseSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const CreateResponseSpendLimitsRulesItemTechnique =
  /*@__PURE__*/ S.String;

export interface CreateResponseSpendLimitsRulesItem {
  limit: number;
  limitType: CreateResponseSpendLimitsRulesItemLimitType;
  window: number;
  id?: string | null;
  enabled?: boolean | null;
  metadata?: UntypedMetadataMap | null;
  model?: CreateResponseSpendLimitsRulesItemModel | null;
  provider?: CreateResponseSpendLimitsRulesItemProvider | null;
  technique?: CreateResponseSpendLimitsRulesItemTechnique | null;
}
export const CreateResponseSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: CreateResponseSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    metadata: S.optional(S.NullOr(UntypedMetadataMap)),
    model: S.optional(S.NullOr(CreateResponseSpendLimitsRulesItemModel)),
    provider: S.optional(S.NullOr(CreateResponseSpendLimitsRulesItemProvider)),
    technique: S.optional(
      S.NullOr(CreateResponseSpendLimitsRulesItemTechnique),
    ),
  }),
).annotate({
  identifier: "CreateResponseSpendLimitsRulesItem",
}) as any as S.Schema<CreateResponseSpendLimitsRulesItem>;

export type CreateResponseSpendLimitsRulesList =
  Array<CreateResponseSpendLimitsRulesItem>;
export const CreateResponseSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  CreateResponseSpendLimitsRulesItem,
) as any as S.Schema<CreateResponseSpendLimitsRulesList>;

export interface CreateResponseSpendLimits {
  enabled?: boolean | null;
  rules?: CreateResponseSpendLimitsRulesList | null;
}
export const CreateResponseSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.NullOr(S.Boolean)),
    rules: S.optional(S.NullOr(CreateResponseSpendLimitsRulesList)),
  }),
).annotate({
  identifier: "CreateResponseSpendLimits",
}) as any as S.Schema<CreateResponseSpendLimits>;

export interface CreateResponseStripeUsageEventsItem {
  payload: string;
}
export const CreateResponseStripeUsageEventsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    payload: S.String,
  }),
).annotate({
  identifier: "CreateResponseStripeUsageEventsItem",
}) as any as S.Schema<CreateResponseStripeUsageEventsItem>;

export type CreateResponseStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const CreateResponseStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<CreateResponseStripeUsageEventsList>;

export interface CreateResponseStripe {
  authorization: string;
  usageEvents: CreateResponseStripeUsageEventsList;
}
export const CreateResponseStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: CreateResponseStripeUsageEventsList.pipe(
      T.Body("usage_events"),
    ),
  }),
).annotate({
  identifier: "CreateResponseStripe",
}) as any as S.Schema<CreateResponseStripe>;

export type CreateResponseWorkersAiBillingMode = "postpaid";
export const CreateResponseWorkersAiBillingMode = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateAiGatewayResponse {
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number;
  collectLogs: boolean;
  createdAt: string;
  modifiedAt: string;
  rateLimitingInterval: number;
  rateLimitingLimit: number;
  authentication?: boolean | null;
  dlp?: CreateResponseDlp | null;
  guardrails?: CreateResponseGuardrails | null;
  isDefault?: boolean | null;
  logManagement?: number | null;
  logManagementStrategy?: CreateResponseLogManagementStrategy | null;
  logpush?: boolean | null;
  logpushPublicKey?: string | null;
  otel?: CreateResponseOtelList | null;
  rateLimitingTechnique?: CreateResponseRateLimitingTechnique | null;
  /** Backoff strategy for retry delays */
  retryBackoff?: CreateResponseRetryBackoff | null;
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number | null;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number | null;
  spendLimits?: CreateResponseSpendLimits | null;
  storeId?: string | null;
  stripe?: CreateResponseStripe | null;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: CreateResponseWorkersAiBillingMode | null;
  zdr?: boolean | null;
}
export const CreateAiGatewayResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.Number.pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    rateLimitingInterval: S.Number.pipe(T.Body("rate_limiting_interval")),
    rateLimitingLimit: S.Number.pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.NullOr(S.Boolean)),
    dlp: S.optional(S.NullOr(CreateResponseDlp)),
    guardrails: S.optional(S.NullOr(CreateResponseGuardrails)),
    isDefault: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_default"))),
    logManagement: S.optional(
      S.NullOr(S.Number).pipe(T.Body("log_management")),
    ),
    logManagementStrategy: S.optional(
      S.NullOr(CreateResponseLogManagementStrategy).pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.NullOr(S.Boolean)),
    logpushPublicKey: S.optional(
      S.NullOr(S.String).pipe(T.Body("logpush_public_key")),
    ),
    otel: S.optional(S.NullOr(CreateResponseOtelList)),
    rateLimitingTechnique: S.optional(
      S.NullOr(CreateResponseRateLimitingTechnique).pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      S.NullOr(CreateResponseRetryBackoff).pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(
      S.NullOr(S.Number).pipe(T.Body("retry_max_attempts")),
    ),
    spendLimits: S.optional(
      S.NullOr(CreateResponseSpendLimits).pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.NullOr(S.String).pipe(T.Body("store_id"))),
    stripe: S.optional(S.NullOr(CreateResponseStripe)),
    workersAiBillingMode: S.optional(
      S.NullOr(CreateResponseWorkersAiBillingMode).pipe(
        T.Body("workers_ai_billing_mode"),
      ),
    ),
    zdr: S.optional(S.NullOr(S.Boolean)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAiGatewayResponse",
}) as any as S.Schema<CreateAiGatewayResponse>;

export type BillingSpendingLimitCreateRequestDuration =
  | "daily"
  | "weekly"
  | "monthly";
export const BillingSpendingLimitCreateRequestDuration = /*@__PURE__*/ S.String;

export type BillingSpendingLimitCreateRequestStrategy = "fixed" | "sliding";
export const BillingSpendingLimitCreateRequestStrategy = /*@__PURE__*/ S.String;

export interface CreateBillingSpendingLimitRequest {
  accountId: string;
  /** Spending limit amount in cents (min 100). */
  amount: number;
  /** Spending limit duration. */
  duration: BillingSpendingLimitCreateRequestDuration | (string & {});
  /** Spending limit strategy. */
  strategy: BillingSpendingLimitCreateRequestStrategy | (string & {});
}
export const CreateBillingSpendingLimitRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    amount: S.Number,
    duration: BillingSpendingLimitCreateRequestDuration,
    strategy: BillingSpendingLimitCreateRequestStrategy,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/billing/spending-limit",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingSpendingLimitRequest",
}) as any as S.Schema<CreateBillingSpendingLimitRequest>;

export type CreateBillingSpendingLimitResponse = unknown;
export const CreateBillingSpendingLimitResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingSpendingLimitResponse",
}) as any as S.Schema<CreateBillingSpendingLimitResponse>;

export interface CreateBillingTopupRequest {
  accountId: string;
  /** Top-up amount in cents (min 1000). */
  amount: number;
}
export const CreateBillingTopupRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    amount: S.Number,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/billing/topup",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingTopupRequest",
}) as any as S.Schema<CreateBillingTopupRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateBillingTopupResponse {
  /** Stripe PaymentIntent client secret. */
  clientSecret: string;
  /** Whether the user was already onboarded. */
  onboarding: boolean;
  /** Stripe invoice ID. */
  paymentIntentId: string;
  /** Card brand (visa, mastercard, etc.). */
  brand?: string | null;
  /** Last 4 digits of card. */
  last4?: string | null;
}
export const CreateBillingTopupResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    clientSecret: S.String.pipe(T.Body("client_secret")),
    onboarding: S.Boolean,
    paymentIntentId: S.String.pipe(T.Body("payment_intent_id")),
    brand: S.optional(S.NullOr(S.String)),
    last4: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingTopupResponse",
}) as any as S.Schema<CreateBillingTopupResponse>;

export interface CreateBillingTopupConfigRequest {
  accountId: string;
  /** Auto top-up amount in cents (min 1000). */
  amount: number;
  /** Balance threshold in cents that triggers auto top-up (min 500). */
  threshold: number;
}
export const CreateBillingTopupConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    amount: S.Number,
    threshold: S.Number,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/billing/topup/config",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingTopupConfigRequest",
}) as any as S.Schema<CreateBillingTopupConfigRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateBillingTopupConfigResponse {
  amount: number;
  threshold: number;
}
export const CreateBillingTopupConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    amount: S.Number,
    threshold: S.Number,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBillingTopupConfigResponse",
}) as any as S.Schema<CreateBillingTopupConfigResponse>;

export interface CreateCustomProviderRequest {
  accountId: string;
  baseUrl: string;
  name: string;
  slug: string;
  beta?: boolean;
  curlExample?: string;
  description?: string;
  enable?: boolean;
  headers?: string;
  jsExample?: string;
  link?: string;
  position?: number;
}
export const CreateCustomProviderRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    baseUrl: S.String.pipe(T.Body("base_url")),
    name: S.String,
    slug: S.String,
    beta: S.optional(S.Boolean),
    curlExample: S.optional(S.String.pipe(T.Body("curl_example"))),
    description: S.optional(S.String),
    enable: S.optional(S.Boolean),
    headers: S.optional(S.String),
    jsExample: S.optional(S.String.pipe(T.Body("js_example"))),
    link: S.optional(S.String),
    position: S.optional(S.Number),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/custom-providers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCustomProviderRequest",
}) as any as S.Schema<CreateCustomProviderRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateCustomProviderResponse {
  id: string;
  baseUrl: string;
  createdAt: string;
  modifiedAt: string;
  name: string;
  slug: string;
  beta?: boolean | null;
  curlExample?: string | null;
  description?: string | null;
  enable?: boolean | null;
  headers?: string | null;
  jsExample?: string | null;
  link?: string | null;
  logo?: string | null;
  position?: number | null;
}
export const CreateCustomProviderResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    baseUrl: S.String.pipe(T.Body("base_url")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    slug: S.String,
    beta: S.optional(S.NullOr(S.Boolean)),
    curlExample: S.optional(S.NullOr(S.String).pipe(T.Body("curl_example"))),
    description: S.optional(S.NullOr(S.String)),
    enable: S.optional(S.NullOr(S.Boolean)),
    headers: S.optional(S.NullOr(S.String)),
    jsExample: S.optional(S.NullOr(S.String).pipe(T.Body("js_example"))),
    link: S.optional(S.NullOr(S.String)),
    logo: S.optional(S.NullOr(S.String)),
    position: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCustomProviderResponse",
}) as any as S.Schema<CreateCustomProviderResponse>;

export type DatasetsCreateRequestFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsCreateRequestFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsCreateRequestFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsCreateRequestFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsCreateRequestFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsCreateRequestFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsCreateRequestFiltersItemValueList =
  Array<DatasetsCreateRequestFiltersItemValueItem>;
export const DatasetsCreateRequestFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsCreateRequestFiltersItemValueItem,
) as any as S.Schema<DatasetsCreateRequestFiltersItemValueList>;

export interface DatasetsCreateRequestFiltersItem {
  key: DatasetsCreateRequestFiltersItemKey | (string & {});
  operator: DatasetsCreateRequestFiltersItemOperator | (string & {});
  value: DatasetsCreateRequestFiltersItemValueList;
}
export const DatasetsCreateRequestFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsCreateRequestFiltersItemKey,
    operator: DatasetsCreateRequestFiltersItemOperator,
    value: DatasetsCreateRequestFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsCreateRequestFiltersItem",
}) as any as S.Schema<DatasetsCreateRequestFiltersItem>;

export type DatasetsCreateRequestFiltersList =
  Array<DatasetsCreateRequestFiltersItem>;
export const DatasetsCreateRequestFiltersList = /*@__PURE__*/ S.Array(
  DatasetsCreateRequestFiltersItem,
) as any as S.Schema<DatasetsCreateRequestFiltersList>;

export interface CreateDatasetRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  enable: boolean;
  filters: DatasetsCreateRequestFiltersList;
  name: string;
}
export const CreateDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    enable: S.Boolean,
    filters: DatasetsCreateRequestFiltersList,
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/datasets",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDatasetRequest",
}) as any as S.Schema<CreateDatasetRequest>;

export type DatasetsCreateResponseFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsCreateResponseFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsCreateResponseFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsCreateResponseFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsCreateResponseFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsCreateResponseFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsCreateResponseFiltersItemValueList =
  Array<DatasetsCreateResponseFiltersItemValueItem>;
export const DatasetsCreateResponseFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsCreateResponseFiltersItemValueItem,
) as any as S.Schema<DatasetsCreateResponseFiltersItemValueList>;

export interface DatasetsCreateResponseFiltersItem {
  key: DatasetsCreateResponseFiltersItemKey;
  operator: DatasetsCreateResponseFiltersItemOperator;
  value: DatasetsCreateResponseFiltersItemValueList;
}
export const DatasetsCreateResponseFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsCreateResponseFiltersItemKey,
    operator: DatasetsCreateResponseFiltersItemOperator,
    value: DatasetsCreateResponseFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsCreateResponseFiltersItem",
}) as any as S.Schema<DatasetsCreateResponseFiltersItem>;

export type DatasetsCreateResponseFiltersList =
  Array<DatasetsCreateResponseFiltersItem>;
export const DatasetsCreateResponseFiltersList = /*@__PURE__*/ S.Array(
  DatasetsCreateResponseFiltersItem,
) as any as S.Schema<DatasetsCreateResponseFiltersList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateDatasetResponse {
  id: string;
  createdAt: string;
  enable: boolean;
  filters: DatasetsCreateResponseFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const CreateDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: DatasetsCreateResponseFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDatasetResponse",
}) as any as S.Schema<CreateDatasetResponse>;

export interface CreateDeploymentDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
  versionId: string;
}
export const CreateDeploymentDynamicRoutingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      gatewayId: S.String.pipe(T.Label("gateway_id")),
      id: S.String.pipe(T.Label()),
      versionId: S.String.pipe(T.Body("version_id")),
    })
      .pipe(
        T.Http({
          method: "POST",
          uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}/deployments",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDeploymentDynamicRoutingRequest",
}) as any as S.Schema<CreateDeploymentDynamicRoutingRequest>;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext {
  elementId: string;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      elementId: S.String,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext>;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs {
  next: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      next: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase0Type =
  "start";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase0Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase0>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs {
  false: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
  true: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      false: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext,
      true: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs>;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties {
  conditions?: unknown | null;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      conditions: S.optional(S.NullOr(S.Unknown)),
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase1Type =
  "conditional";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase1Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase1>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase2OutputsMap =
  { [key: string]: unknown | undefined };
export const DynamicRoutingCreateDeploymentResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase2Type =
  "percentage";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase2Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs:
        DynamicRoutingCreateDeploymentResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase2>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs {
  fallback: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
  success: DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      fallback:
        DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext,
      success:
        DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingCreateDeploymentResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingCreateDeploymentResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase3Type =
  "rate";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase3Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase3Properties,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase3>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties {
  model: string;
  provider: string;
  retries: number;
  timeout: number;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      model: S.String,
      provider: S.String,
      retries: S.Number,
      timeout: S.Number,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase4Type =
  "model";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase4Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase4>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase5OutputsMap =
  { [key: string]: unknown | undefined };
export const DynamicRoutingCreateDeploymentResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingCreateDeploymentResponseElementsItemCase5Type = "end";
export const DynamicRoutingCreateDeploymentResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateDeploymentResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingCreateDeploymentResponseElementsItemCase5Type;
}
export const DynamicRoutingCreateDeploymentResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs:
        DynamicRoutingCreateDeploymentResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingCreateDeploymentResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateDeploymentResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsItemCase5>;

export type DynamicRoutingCreateDeploymentResponseElementsItem =
  | DynamicRoutingCreateDeploymentResponseElementsItemCase0
  | DynamicRoutingCreateDeploymentResponseElementsItemCase1
  | DynamicRoutingCreateDeploymentResponseElementsItemCase2
  | DynamicRoutingCreateDeploymentResponseElementsItemCase3
  | DynamicRoutingCreateDeploymentResponseElementsItemCase4
  | DynamicRoutingCreateDeploymentResponseElementsItemCase5;
export const DynamicRoutingCreateDeploymentResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingCreateDeploymentResponseElementsList =
  Array<DynamicRoutingCreateDeploymentResponseElementsItem>;
export const DynamicRoutingCreateDeploymentResponseElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingCreateDeploymentResponseElementsItem,
  ) as any as S.Schema<DynamicRoutingCreateDeploymentResponseElementsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateDeploymentDynamicRoutingResponse {
  id: string;
  createdAt: string;
  elements: DynamicRoutingCreateDeploymentResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const CreateDeploymentDynamicRoutingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      elements: DynamicRoutingCreateDeploymentResponseElementsList,
      gatewayId: S.String.pipe(T.Body("gateway_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      name: S.String,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDeploymentDynamicRoutingResponse",
}) as any as S.Schema<CreateDeploymentDynamicRoutingResponse>;

export type DynamicRoutingCreateRequestElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingCreateRequestElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingCreateRequestElementsItemCase0Type = "start";
export const DynamicRoutingCreateRequestElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingCreateRequestElementsItemCase0Type;
}
export const DynamicRoutingCreateRequestElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingCreateRequestElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase0>;

export type DynamicRoutingCreateRequestElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingCreateRequestElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingCreateRequestElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingCreateRequestElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingCreateRequestElementsItemCase1Type = "conditional";
export const DynamicRoutingCreateRequestElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingCreateRequestElementsItemCase1Type;
}
export const DynamicRoutingCreateRequestElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingCreateRequestElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase1>;

export type DynamicRoutingCreateRequestElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateRequestElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase2OutputsMap>;

export type DynamicRoutingCreateRequestElementsItemCase2Type = "percentage";
export const DynamicRoutingCreateRequestElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingCreateRequestElementsItemCase2OutputsMap;
  type: DynamicRoutingCreateRequestElementsItemCase2Type;
}
export const DynamicRoutingCreateRequestElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateRequestElementsItemCase2OutputsMap,
      type: DynamicRoutingCreateRequestElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase2>;

export type DynamicRoutingCreateRequestElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateRequestElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateRequestElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingCreateRequestElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType:
    | DynamicRoutingCreateRequestElementsItemCase3PropertiesLimitType
    | (string & {});
  window: number;
}
export const DynamicRoutingCreateRequestElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingCreateRequestElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase3Properties>;

export type DynamicRoutingCreateRequestElementsItemCase3Type = "rate";
export const DynamicRoutingCreateRequestElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateRequestElementsItemCase3Properties;
  type: DynamicRoutingCreateRequestElementsItemCase3Type;
}
export const DynamicRoutingCreateRequestElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingCreateRequestElementsItemCase3Properties,
      type: DynamicRoutingCreateRequestElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase3>;

export type DynamicRoutingCreateRequestElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateRequestElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateRequestElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateRequestElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateRequestElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingCreateRequestElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingCreateRequestElementsItemCase4Type = "model";
export const DynamicRoutingCreateRequestElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingCreateRequestElementsItemCase4Type;
}
export const DynamicRoutingCreateRequestElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingCreateRequestElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase4>;

export type DynamicRoutingCreateRequestElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateRequestElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase5OutputsMap>;

export type DynamicRoutingCreateRequestElementsItemCase5Type = "end";
export const DynamicRoutingCreateRequestElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateRequestElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingCreateRequestElementsItemCase5OutputsMap;
  type: DynamicRoutingCreateRequestElementsItemCase5Type;
}
export const DynamicRoutingCreateRequestElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateRequestElementsItemCase5OutputsMap,
      type: DynamicRoutingCreateRequestElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateRequestElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingCreateRequestElementsItemCase5>;

export type DynamicRoutingCreateRequestElementsItem =
  | DynamicRoutingCreateRequestElementsItemCase0
  | DynamicRoutingCreateRequestElementsItemCase1
  | DynamicRoutingCreateRequestElementsItemCase2
  | DynamicRoutingCreateRequestElementsItemCase3
  | DynamicRoutingCreateRequestElementsItemCase4
  | DynamicRoutingCreateRequestElementsItemCase5;
export const DynamicRoutingCreateRequestElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingCreateRequestElementsList =
  Array<DynamicRoutingCreateRequestElementsItem>;
export const DynamicRoutingCreateRequestElementsList = /*@__PURE__*/ S.Array(
  DynamicRoutingCreateRequestElementsItem,
) as any as S.Schema<DynamicRoutingCreateRequestElementsList>;

export interface CreateDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  elements: DynamicRoutingCreateRequestElementsList;
  name: string;
}
export const CreateDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    elements: DynamicRoutingCreateRequestElementsList,
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDynamicRoutingRequest",
}) as any as S.Schema<CreateDynamicRoutingRequest>;

export interface DynamicRoutingCreateResponseDeployment {
  createdAt: string;
  deploymentId: string;
  versionId: string;
}
export const DynamicRoutingCreateResponseDeployment = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      createdAt: S.String.pipe(T.Body("created_at")),
      deploymentId: S.String.pipe(T.Body("deployment_id")),
      versionId: S.String.pipe(T.Body("version_id")),
    }),
).annotate({
  identifier: "DynamicRoutingCreateResponseDeployment",
}) as any as S.Schema<DynamicRoutingCreateResponseDeployment>;

export type DynamicRoutingCreateResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingCreateResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingCreateResponseElementsItemCase0Type = "start";
export const DynamicRoutingCreateResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingCreateResponseElementsItemCase0Type;
}
export const DynamicRoutingCreateResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingCreateResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase0>;

export type DynamicRoutingCreateResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingCreateResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingCreateResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingCreateResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingCreateResponseElementsItemCase1Type = "conditional";
export const DynamicRoutingCreateResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingCreateResponseElementsItemCase1Type;
}
export const DynamicRoutingCreateResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingCreateResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase1>;

export type DynamicRoutingCreateResponseElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingCreateResponseElementsItemCase2Type = "percentage";
export const DynamicRoutingCreateResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingCreateResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingCreateResponseElementsItemCase2Type;
}
export const DynamicRoutingCreateResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingCreateResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase2>;

export type DynamicRoutingCreateResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingCreateResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingCreateResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingCreateResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingCreateResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase3Properties>;

export type DynamicRoutingCreateResponseElementsItemCase3Type = "rate";
export const DynamicRoutingCreateResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateResponseElementsItemCase3Properties;
  type: DynamicRoutingCreateResponseElementsItemCase3Type;
}
export const DynamicRoutingCreateResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingCreateResponseElementsItemCase3Properties,
      type: DynamicRoutingCreateResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase3>;

export type DynamicRoutingCreateResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingCreateResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingCreateResponseElementsItemCase4Type = "model";
export const DynamicRoutingCreateResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingCreateResponseElementsItemCase4Type;
}
export const DynamicRoutingCreateResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingCreateResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase4>;

export type DynamicRoutingCreateResponseElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingCreateResponseElementsItemCase5Type = "end";
export const DynamicRoutingCreateResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingCreateResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingCreateResponseElementsItemCase5Type;
}
export const DynamicRoutingCreateResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingCreateResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingCreateResponseElementsItemCase5>;

export type DynamicRoutingCreateResponseElementsItem =
  | DynamicRoutingCreateResponseElementsItemCase0
  | DynamicRoutingCreateResponseElementsItemCase1
  | DynamicRoutingCreateResponseElementsItemCase2
  | DynamicRoutingCreateResponseElementsItemCase3
  | DynamicRoutingCreateResponseElementsItemCase4
  | DynamicRoutingCreateResponseElementsItemCase5;
export const DynamicRoutingCreateResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingCreateResponseElementsList =
  Array<DynamicRoutingCreateResponseElementsItem>;
export const DynamicRoutingCreateResponseElementsList = /*@__PURE__*/ S.Array(
  DynamicRoutingCreateResponseElementsItem,
) as any as S.Schema<DynamicRoutingCreateResponseElementsList>;

export type DynamicRoutingCreateResponseVersionActive = "true" | "false";
export const DynamicRoutingCreateResponseVersionActive = /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateResponseVersion {
  active: DynamicRoutingCreateResponseVersionActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  versionId: string;
  isValid?: boolean | null;
}
export const DynamicRoutingCreateResponseVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    active: DynamicRoutingCreateResponseVersionActive,
    createdAt: S.String.pipe(T.Body("created_at")),
    data: DynamicRoutingCreateRequestElementsList,
    versionId: S.String.pipe(T.Body("version_id")),
    isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
  }),
).annotate({
  identifier: "DynamicRoutingCreateResponseVersion",
}) as any as S.Schema<DynamicRoutingCreateResponseVersion>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateDynamicRoutingResponse {
  id: string;
  createdAt: string;
  deployment: DynamicRoutingCreateResponseDeployment;
  elements: DynamicRoutingCreateResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  version: DynamicRoutingCreateResponseVersion;
}
export const CreateDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    deployment: DynamicRoutingCreateResponseDeployment,
    elements: DynamicRoutingCreateResponseElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: DynamicRoutingCreateResponseVersion,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDynamicRoutingResponse",
}) as any as S.Schema<CreateDynamicRoutingResponse>;

export type EvaluationsCreateRequestDatasetIdsList = Array<string>;
export const EvaluationsCreateRequestDatasetIdsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<EvaluationsCreateRequestDatasetIdsList>;

export type EvaluationsCreateRequestEvaluationTypeIdsList = Array<string>;
export const EvaluationsCreateRequestEvaluationTypeIdsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<EvaluationsCreateRequestEvaluationTypeIdsList>;

export interface CreateEvaluationRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  datasetIds: EvaluationsCreateRequestDatasetIdsList;
  evaluationTypeIds: EvaluationsCreateRequestEvaluationTypeIdsList;
  name: string;
}
export const CreateEvaluationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    datasetIds: EvaluationsCreateRequestDatasetIdsList.pipe(
      T.Body("dataset_ids"),
    ),
    evaluationTypeIds: EvaluationsCreateRequestEvaluationTypeIdsList.pipe(
      T.Body("evaluation_type_ids"),
    ),
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/evaluations",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateEvaluationRequest",
}) as any as S.Schema<CreateEvaluationRequest>;

export type EvaluationsCreateResponseDatasetsItemFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const EvaluationsCreateResponseDatasetsItemFiltersItemKey =
  /*@__PURE__*/ S.String;

export type EvaluationsCreateResponseDatasetsItemFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const EvaluationsCreateResponseDatasetsItemFiltersItemOperator =
  /*@__PURE__*/ S.String;

export type EvaluationsCreateResponseDatasetsItemFiltersItemValueItem =
  | string
  | number
  | boolean;
export const EvaluationsCreateResponseDatasetsItemFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type EvaluationsCreateResponseDatasetsItemFiltersItemValueList =
  Array<EvaluationsCreateResponseDatasetsItemFiltersItemValueItem>;
export const EvaluationsCreateResponseDatasetsItemFiltersItemValueList =
  /*@__PURE__*/ S.Array(
    EvaluationsCreateResponseDatasetsItemFiltersItemValueItem,
  ) as any as S.Schema<EvaluationsCreateResponseDatasetsItemFiltersItemValueList>;

export interface EvaluationsCreateResponseDatasetsItemFiltersItem {
  key: EvaluationsCreateResponseDatasetsItemFiltersItemKey;
  operator: EvaluationsCreateResponseDatasetsItemFiltersItemOperator;
  value: EvaluationsCreateResponseDatasetsItemFiltersItemValueList;
}
export const EvaluationsCreateResponseDatasetsItemFiltersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: EvaluationsCreateResponseDatasetsItemFiltersItemKey,
      operator: EvaluationsCreateResponseDatasetsItemFiltersItemOperator,
      value: EvaluationsCreateResponseDatasetsItemFiltersItemValueList,
    }),
  ).annotate({
    identifier: "EvaluationsCreateResponseDatasetsItemFiltersItem",
  }) as any as S.Schema<EvaluationsCreateResponseDatasetsItemFiltersItem>;

export type EvaluationsCreateResponseDatasetsItemFiltersList =
  Array<EvaluationsCreateResponseDatasetsItemFiltersItem>;
export const EvaluationsCreateResponseDatasetsItemFiltersList =
  /*@__PURE__*/ S.Array(
    EvaluationsCreateResponseDatasetsItemFiltersItem,
  ) as any as S.Schema<EvaluationsCreateResponseDatasetsItemFiltersList>;

export interface EvaluationsCreateResponseDatasetsItem {
  id: string;
  accountId: string;
  accountTag: string;
  createdAt: string;
  enable: boolean;
  filters: EvaluationsCreateResponseDatasetsItemFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const EvaluationsCreateResponseDatasetsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accountId: S.String.pipe(T.Body("account_id")),
      accountTag: S.String.pipe(T.Body("account_tag")),
      createdAt: S.String.pipe(T.Body("created_at")),
      enable: S.Boolean,
      filters: EvaluationsCreateResponseDatasetsItemFiltersList,
      gatewayId: S.String.pipe(T.Body("gateway_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      name: S.String,
    }),
).annotate({
  identifier: "EvaluationsCreateResponseDatasetsItem",
}) as any as S.Schema<EvaluationsCreateResponseDatasetsItem>;

export type EvaluationsCreateResponseDatasetsList =
  Array<EvaluationsCreateResponseDatasetsItem>;
export const EvaluationsCreateResponseDatasetsList = /*@__PURE__*/ S.Array(
  EvaluationsCreateResponseDatasetsItem,
) as any as S.Schema<EvaluationsCreateResponseDatasetsList>;

export interface EvaluationsCreateResponseResultsItem {
  id: string;
  createdAt: string;
  evaluationId: string;
  evaluationTypeId: string;
  modifiedAt: string;
  result: string;
  status: number;
  statusDescription: string;
  totalLogs: number;
}
export const EvaluationsCreateResponseResultsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      createdAt: S.String.pipe(T.Body("created_at")),
      evaluationId: S.String.pipe(T.Body("evaluation_id")),
      evaluationTypeId: S.String.pipe(T.Body("evaluation_type_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      result: S.String,
      status: S.Number,
      statusDescription: S.String.pipe(T.Body("status_description")),
      totalLogs: S.Number.pipe(T.Body("total_logs")),
    }),
).annotate({
  identifier: "EvaluationsCreateResponseResultsItem",
}) as any as S.Schema<EvaluationsCreateResponseResultsItem>;

export type EvaluationsCreateResponseResultsList =
  Array<EvaluationsCreateResponseResultsItem>;
export const EvaluationsCreateResponseResultsList = /*@__PURE__*/ S.Array(
  EvaluationsCreateResponseResultsItem,
) as any as S.Schema<EvaluationsCreateResponseResultsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateEvaluationResponse {
  id: string;
  createdAt: string;
  datasets: EvaluationsCreateResponseDatasetsList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
  processed: boolean;
  results: EvaluationsCreateResponseResultsList;
  totalLogs: number;
}
export const CreateEvaluationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    datasets: EvaluationsCreateResponseDatasetsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    processed: S.Boolean,
    results: EvaluationsCreateResponseResultsList,
    totalLogs: S.Number.pipe(T.Body("total_logs")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateEvaluationResponse",
}) as any as S.Schema<CreateEvaluationResponse>;

export interface CreateProviderConfigRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  alias: string;
  defaultConfig: boolean;
  providerSlug: string;
  rateLimit?: number;
  rateLimitPeriod?: number;
  secret?: string;
  secretId?: string;
}
export const CreateProviderConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    alias: S.String,
    defaultConfig: S.Boolean.pipe(T.Body("default_config")),
    providerSlug: S.String.pipe(T.Body("provider_slug")),
    rateLimit: S.optional(S.Number.pipe(T.Body("rate_limit"))),
    rateLimitPeriod: S.optional(S.Number.pipe(T.Body("rate_limit_period"))),
    secret: S.optional(S.String),
    secretId: S.optional(S.String.pipe(T.Body("secret_id"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/provider_configs",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateProviderConfigRequest",
}) as any as S.Schema<CreateProviderConfigRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateProviderConfigResponse {
  id: string;
  alias: string;
  defaultConfig: boolean;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  providerSlug: string;
  secretId: string;
  secretPreview: string;
  rateLimit?: number | null;
  rateLimitPeriod?: number | null;
}
export const CreateProviderConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    alias: S.String,
    defaultConfig: S.Boolean.pipe(T.Body("default_config")),
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    providerSlug: S.String.pipe(T.Body("provider_slug")),
    secretId: S.String.pipe(T.Body("secret_id")),
    secretPreview: S.String.pipe(T.Body("secret_preview")),
    rateLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("rate_limit"))),
    rateLimitPeriod: S.optional(
      S.NullOr(S.Number).pipe(T.Body("rate_limit_period")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateProviderConfigResponse",
}) as any as S.Schema<CreateProviderConfigResponse>;

export type DynamicRoutingCreateVersionRequestElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingCreateVersionRequestElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingCreateVersionRequestElementsItemCase0Type = "start";
export const DynamicRoutingCreateVersionRequestElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingCreateVersionRequestElementsItemCase0Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingCreateVersionRequestElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase0>;

export type DynamicRoutingCreateVersionRequestElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingCreateVersionRequestElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export interface DynamicRoutingCreateVersionRequestElementsItemCase1Properties {
  conditions?: unknown;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase1Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      conditions: S.optional(S.Unknown),
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase1Properties",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase1Properties>;

export type DynamicRoutingCreateVersionRequestElementsItemCase1Type =
  "conditional";
export const DynamicRoutingCreateVersionRequestElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateVersionRequestElementsItemCase1Properties;
  type: DynamicRoutingCreateVersionRequestElementsItemCase1Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties: DynamicRoutingCreateVersionRequestElementsItemCase1Properties,
      type: DynamicRoutingCreateVersionRequestElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase1>;

export type DynamicRoutingCreateVersionRequestElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateVersionRequestElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase2OutputsMap>;

export type DynamicRoutingCreateVersionRequestElementsItemCase2Type =
  "percentage";
export const DynamicRoutingCreateVersionRequestElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingCreateVersionRequestElementsItemCase2OutputsMap;
  type: DynamicRoutingCreateVersionRequestElementsItemCase2Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateVersionRequestElementsItemCase2OutputsMap,
      type: DynamicRoutingCreateVersionRequestElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase2>;

export type DynamicRoutingCreateVersionRequestElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateVersionRequestElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateVersionRequestElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingCreateVersionRequestElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType:
    | DynamicRoutingCreateVersionRequestElementsItemCase3PropertiesLimitType
    | (string & {});
  window: number;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingCreateVersionRequestElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase3Properties>;

export type DynamicRoutingCreateVersionRequestElementsItemCase3Type = "rate";
export const DynamicRoutingCreateVersionRequestElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateVersionRequestElementsItemCase3Properties;
  type: DynamicRoutingCreateVersionRequestElementsItemCase3Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingCreateVersionRequestElementsItemCase3Properties,
      type: DynamicRoutingCreateVersionRequestElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase3>;

export type DynamicRoutingCreateVersionRequestElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionRequestElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionRequestElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateVersionRequestElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateVersionRequestElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingCreateVersionRequestElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingCreateVersionRequestElementsItemCase4Type = "model";
export const DynamicRoutingCreateVersionRequestElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingCreateVersionRequestElementsItemCase4Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingCreateVersionRequestElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase4>;

export type DynamicRoutingCreateVersionRequestElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateVersionRequestElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase5OutputsMap>;

export type DynamicRoutingCreateVersionRequestElementsItemCase5Type = "end";
export const DynamicRoutingCreateVersionRequestElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionRequestElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingCreateVersionRequestElementsItemCase5OutputsMap;
  type: DynamicRoutingCreateVersionRequestElementsItemCase5Type;
}
export const DynamicRoutingCreateVersionRequestElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateVersionRequestElementsItemCase5OutputsMap,
      type: DynamicRoutingCreateVersionRequestElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionRequestElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsItemCase5>;

export type DynamicRoutingCreateVersionRequestElementsItem =
  | DynamicRoutingCreateVersionRequestElementsItemCase0
  | DynamicRoutingCreateVersionRequestElementsItemCase1
  | DynamicRoutingCreateVersionRequestElementsItemCase2
  | DynamicRoutingCreateVersionRequestElementsItemCase3
  | DynamicRoutingCreateVersionRequestElementsItemCase4
  | DynamicRoutingCreateVersionRequestElementsItemCase5;
export const DynamicRoutingCreateVersionRequestElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingCreateVersionRequestElementsList =
  Array<DynamicRoutingCreateVersionRequestElementsItem>;
export const DynamicRoutingCreateVersionRequestElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingCreateVersionRequestElementsItem,
  ) as any as S.Schema<DynamicRoutingCreateVersionRequestElementsList>;

export interface CreateVersionDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
  elements: DynamicRoutingCreateVersionRequestElementsList;
}
export const CreateVersionDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
    elements: DynamicRoutingCreateVersionRequestElementsList,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}/versions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateVersionDynamicRoutingRequest",
}) as any as S.Schema<CreateVersionDynamicRoutingRequest>;

export type DynamicRoutingCreateVersionResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingCreateVersionResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingCreateVersionResponseElementsItemCase0Type = "start";
export const DynamicRoutingCreateVersionResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingCreateVersionResponseElementsItemCase0Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingCreateVersionResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase0>;

export type DynamicRoutingCreateVersionResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingCreateVersionResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingCreateVersionResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingCreateVersionResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingCreateVersionResponseElementsItemCase1Type =
  "conditional";
export const DynamicRoutingCreateVersionResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingCreateVersionResponseElementsItemCase1Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingCreateVersionResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase1>;

export type DynamicRoutingCreateVersionResponseElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateVersionResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingCreateVersionResponseElementsItemCase2Type =
  "percentage";
export const DynamicRoutingCreateVersionResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingCreateVersionResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingCreateVersionResponseElementsItemCase2Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateVersionResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingCreateVersionResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase2>;

export type DynamicRoutingCreateVersionResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateVersionResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateVersionResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingCreateVersionResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingCreateVersionResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingCreateVersionResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingCreateVersionResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase3Properties>;

export type DynamicRoutingCreateVersionResponseElementsItemCase3Type = "rate";
export const DynamicRoutingCreateVersionResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateVersionResponseElementsItemCase3Properties;
  type: DynamicRoutingCreateVersionResponseElementsItemCase3Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateVersionResponseElementsItemCase3Properties,
      type: DynamicRoutingCreateVersionResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase3>;

export type DynamicRoutingCreateVersionResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingCreateVersionResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingCreateVersionResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingCreateVersionResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingCreateVersionResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingCreateVersionResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingCreateVersionResponseElementsItemCase4Type = "model";
export const DynamicRoutingCreateVersionResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingCreateVersionResponseElementsItemCase4Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingCreateVersionResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase4>;

export type DynamicRoutingCreateVersionResponseElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingCreateVersionResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingCreateVersionResponseElementsItemCase5Type = "end";
export const DynamicRoutingCreateVersionResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingCreateVersionResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingCreateVersionResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingCreateVersionResponseElementsItemCase5Type;
}
export const DynamicRoutingCreateVersionResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateVersionResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingCreateVersionResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingCreateVersionResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsItemCase5>;

export type DynamicRoutingCreateVersionResponseElementsItem =
  | DynamicRoutingCreateVersionResponseElementsItemCase0
  | DynamicRoutingCreateVersionResponseElementsItemCase1
  | DynamicRoutingCreateVersionResponseElementsItemCase2
  | DynamicRoutingCreateVersionResponseElementsItemCase3
  | DynamicRoutingCreateVersionResponseElementsItemCase4
  | DynamicRoutingCreateVersionResponseElementsItemCase5;
export const DynamicRoutingCreateVersionResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingCreateVersionResponseElementsList =
  Array<DynamicRoutingCreateVersionResponseElementsItem>;
export const DynamicRoutingCreateVersionResponseElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingCreateVersionResponseElementsItem,
  ) as any as S.Schema<DynamicRoutingCreateVersionResponseElementsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateVersionDynamicRoutingResponse {
  id: string;
  createdAt: string;
  elements: DynamicRoutingCreateVersionResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  /** Identifier of the newly created version (top-level on the live wire; the docs' nested shape is stale). */
  versionId: string;
}
export const CreateVersionDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    elements: DynamicRoutingCreateVersionResponseElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    versionId: S.String.pipe(T.Body("version_id")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateVersionDynamicRoutingResponse",
}) as any as S.Schema<CreateVersionDynamicRoutingResponse>;

export interface CreditBalanceBillingRequest {
  accountId: string;
}
export const CreditBalanceBillingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/credit-balance",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreditBalanceBillingRequest",
}) as any as S.Schema<CreditBalanceBillingRequest>;

export interface BillingCreditBalanceResponsePaymentMethod {
  brand?: string | null;
  last4?: string | null;
}
export const BillingCreditBalanceResponsePaymentMethod =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      brand: S.optional(S.NullOr(S.String)),
      last4: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "BillingCreditBalanceResponsePaymentMethod",
  }) as any as S.Schema<BillingCreditBalanceResponsePaymentMethod>;

export interface BillingCreditBalanceResponseTopupConfig {
  amount: number;
  disabledReason: string;
  error: string;
  lastFailedAt: number;
  threshold: number;
}
export const BillingCreditBalanceResponseTopupConfig = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      amount: S.Number,
      disabledReason: S.String,
      error: S.String,
      lastFailedAt: S.Number,
      threshold: S.Number,
    }),
).annotate({
  identifier: "BillingCreditBalanceResponseTopupConfig",
}) as any as S.Schema<BillingCreditBalanceResponseTopupConfig>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreditBalanceBillingResponse {
  balance: number;
  hasDefaultPaymentMethod: boolean;
  paymentMethod: BillingCreditBalanceResponsePaymentMethod;
  topupConfig: BillingCreditBalanceResponseTopupConfig;
  firstTopupSuccess?: boolean | null;
}
export const CreditBalanceBillingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    balance: S.Number,
    hasDefaultPaymentMethod: S.Boolean.pipe(
      T.Body("has_default_payment_method"),
    ),
    paymentMethod: BillingCreditBalanceResponsePaymentMethod.pipe(
      T.Body("payment_method"),
    ),
    topupConfig: BillingCreditBalanceResponseTopupConfig.pipe(
      T.Body("topup_config"),
    ),
    firstTopupSuccess: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("first_topup_success")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreditBalanceBillingResponse",
}) as any as S.Schema<CreditBalanceBillingResponse>;

export interface DeleteAiGatewayRequest {
  accountId: string;
  /** gateway id */
  id: string;
}
export const DeleteAiGatewayRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAiGatewayRequest",
}) as any as S.Schema<DeleteAiGatewayRequest>;

export type DeleteResponseDlpCase0Action = "BLOCK" | "FLAG";
export const DeleteResponseDlpCase0Action = /*@__PURE__*/ S.String;

export type DeleteResponseDlpCase0ProfilesList = Array<string>;
export const DeleteResponseDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<DeleteResponseDlpCase0ProfilesList>;

export interface DeleteResponseDlpCase0 {
  action: DeleteResponseDlpCase0Action;
  enabled: boolean;
  profiles: DeleteResponseDlpCase0ProfilesList;
}
export const DeleteResponseDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: DeleteResponseDlpCase0Action,
    enabled: S.Boolean,
    profiles: DeleteResponseDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "DeleteResponseDlpCase0",
}) as any as S.Schema<DeleteResponseDlpCase0>;

export type DeleteResponseDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const DeleteResponseDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type DeleteResponseDlpCase1PoliciesItemCheckItem =
  | "REQUEST"
  | "RESPONSE";
export const DeleteResponseDlpCase1PoliciesItemCheckItem =
  /*@__PURE__*/ S.String;

export type DeleteResponseDlpCase1PoliciesItemCheckList =
  Array<DeleteResponseDlpCase1PoliciesItemCheckItem>;
export const DeleteResponseDlpCase1PoliciesItemCheckList =
  /*@__PURE__*/ S.Array(
    DeleteResponseDlpCase1PoliciesItemCheckItem,
  ) as any as S.Schema<DeleteResponseDlpCase1PoliciesItemCheckList>;

export type DeleteResponseDlpCase1PoliciesItemProfilesList = Array<string>;
export const DeleteResponseDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DeleteResponseDlpCase1PoliciesItemProfilesList>;

export interface DeleteResponseDlpCase1PoliciesItem {
  id: string;
  action: DeleteResponseDlpCase1PoliciesItemAction;
  check: DeleteResponseDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: DeleteResponseDlpCase1PoliciesItemProfilesList;
}
export const DeleteResponseDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: DeleteResponseDlpCase1PoliciesItemAction,
    check: DeleteResponseDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: DeleteResponseDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "DeleteResponseDlpCase1PoliciesItem",
}) as any as S.Schema<DeleteResponseDlpCase1PoliciesItem>;

export type DeleteResponseDlpCase1PoliciesList =
  Array<DeleteResponseDlpCase1PoliciesItem>;
export const DeleteResponseDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  DeleteResponseDlpCase1PoliciesItem,
) as any as S.Schema<DeleteResponseDlpCase1PoliciesList>;

export interface DeleteResponseDlpCase1 {
  enabled: boolean;
  policies: DeleteResponseDlpCase1PoliciesList;
}
export const DeleteResponseDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: DeleteResponseDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "DeleteResponseDlpCase1",
}) as any as S.Schema<DeleteResponseDlpCase1>;

export type DeleteResponseDlp = DeleteResponseDlpCase0 | DeleteResponseDlpCase1;
export const DeleteResponseDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type DeleteResponseGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface DeleteResponseGuardrailsPrompt {
  p1?: DeleteResponseGuardrailsPromptP1 | null;
  s1?: DeleteResponseGuardrailsPromptS1 | null;
  s10?: DeleteResponseGuardrailsPromptS10 | null;
  s11?: DeleteResponseGuardrailsPromptS11 | null;
  s12?: DeleteResponseGuardrailsPromptS12 | null;
  s13?: DeleteResponseGuardrailsPromptS13 | null;
  s2?: DeleteResponseGuardrailsPromptS2 | null;
  s3?: DeleteResponseGuardrailsPromptS3 | null;
  s4?: DeleteResponseGuardrailsPromptS4 | null;
  s5?: DeleteResponseGuardrailsPromptS5 | null;
  s6?: DeleteResponseGuardrailsPromptS6 | null;
  s7?: DeleteResponseGuardrailsPromptS7 | null;
  s8?: DeleteResponseGuardrailsPromptS8 | null;
  s9?: DeleteResponseGuardrailsPromptS9 | null;
}
export const DeleteResponseGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(DeleteResponseGuardrailsPromptS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "DeleteResponseGuardrailsPrompt",
}) as any as S.Schema<DeleteResponseGuardrailsPrompt>;

export type DeleteResponseGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type DeleteResponseGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const DeleteResponseGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface DeleteResponseGuardrailsResponse {
  p1?: DeleteResponseGuardrailsResponseP1 | null;
  s1?: DeleteResponseGuardrailsResponseS1 | null;
  s10?: DeleteResponseGuardrailsResponseS10 | null;
  s11?: DeleteResponseGuardrailsResponseS11 | null;
  s12?: DeleteResponseGuardrailsResponseS12 | null;
  s13?: DeleteResponseGuardrailsResponseS13 | null;
  s2?: DeleteResponseGuardrailsResponseS2 | null;
  s3?: DeleteResponseGuardrailsResponseS3 | null;
  s4?: DeleteResponseGuardrailsResponseS4 | null;
  s5?: DeleteResponseGuardrailsResponseS5 | null;
  s6?: DeleteResponseGuardrailsResponseS6 | null;
  s7?: DeleteResponseGuardrailsResponseS7 | null;
  s8?: DeleteResponseGuardrailsResponseS8 | null;
  s9?: DeleteResponseGuardrailsResponseS9 | null;
}
export const DeleteResponseGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(DeleteResponseGuardrailsResponseS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "DeleteResponseGuardrailsResponse",
}) as any as S.Schema<DeleteResponseGuardrailsResponse>;

export interface DeleteResponseGuardrails {
  prompt: DeleteResponseGuardrailsPrompt;
  response: DeleteResponseGuardrailsResponse;
}
export const DeleteResponseGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: DeleteResponseGuardrailsPrompt,
    response: DeleteResponseGuardrailsResponse,
  }),
).annotate({
  identifier: "DeleteResponseGuardrails",
}) as any as S.Schema<DeleteResponseGuardrails>;

export type DeleteResponseLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const DeleteResponseLogManagementStrategy = /*@__PURE__*/ S.String;

export type DeleteResponseOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const DeleteResponseOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<DeleteResponseOtelItemHeadersMap>;

export type DeleteResponseOtelItemContentType = "json" | "protobuf";
export const DeleteResponseOtelItemContentType = /*@__PURE__*/ S.String;

export interface DeleteResponseOtelItem {
  headers: DeleteResponseOtelItemHeadersMap;
  url: string;
  authorization?: string | null;
  contentType?: DeleteResponseOtelItemContentType | null;
}
export const DeleteResponseOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: DeleteResponseOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.NullOr(S.String)),
    contentType: S.optional(
      S.NullOr(DeleteResponseOtelItemContentType).pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "DeleteResponseOtelItem",
}) as any as S.Schema<DeleteResponseOtelItem>;

export type DeleteResponseOtelList = Array<DeleteResponseOtelItem>;
export const DeleteResponseOtelList = /*@__PURE__*/ S.Array(
  DeleteResponseOtelItem,
) as any as S.Schema<DeleteResponseOtelList>;

export type DeleteResponseRateLimitingTechnique = "fixed" | "sliding";
export const DeleteResponseRateLimitingTechnique = /*@__PURE__*/ S.String;

export type DeleteResponseRetryBackoff = "constant" | "linear" | "exponential";
export const DeleteResponseRetryBackoff = /*@__PURE__*/ S.String;

export type DeleteResponseSpendLimitsRulesItemLimitType = "cost";
export const DeleteResponseSpendLimitsRulesItemLimitType =
  /*@__PURE__*/ S.String;

export type DeleteResponseSpendLimitsRulesItemModelMode = "filter";
export const DeleteResponseSpendLimitsRulesItemModelMode =
  /*@__PURE__*/ S.String;

export type DeleteResponseSpendLimitsRulesItemModelValuesList = Array<string>;
export const DeleteResponseSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DeleteResponseSpendLimitsRulesItemModelValuesList>;

export interface DeleteResponseSpendLimitsRulesItemModel {
  mode: DeleteResponseSpendLimitsRulesItemModelMode;
  values: DeleteResponseSpendLimitsRulesItemModelValuesList;
}
export const DeleteResponseSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: DeleteResponseSpendLimitsRulesItemModelMode,
      values: DeleteResponseSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "DeleteResponseSpendLimitsRulesItemModel",
}) as any as S.Schema<DeleteResponseSpendLimitsRulesItemModel>;

export type DeleteResponseSpendLimitsRulesItemProviderMode = "filter";
export const DeleteResponseSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type DeleteResponseSpendLimitsRulesItemProviderValuesList =
  Array<string>;
export const DeleteResponseSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DeleteResponseSpendLimitsRulesItemProviderValuesList>;

export interface DeleteResponseSpendLimitsRulesItemProvider {
  mode: DeleteResponseSpendLimitsRulesItemProviderMode;
  values: DeleteResponseSpendLimitsRulesItemProviderValuesList;
}
export const DeleteResponseSpendLimitsRulesItemProvider =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mode: DeleteResponseSpendLimitsRulesItemProviderMode,
      values: DeleteResponseSpendLimitsRulesItemProviderValuesList,
    }),
  ).annotate({
    identifier: "DeleteResponseSpendLimitsRulesItemProvider",
  }) as any as S.Schema<DeleteResponseSpendLimitsRulesItemProvider>;

export type DeleteResponseSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const DeleteResponseSpendLimitsRulesItemTechnique =
  /*@__PURE__*/ S.String;

export interface DeleteResponseSpendLimitsRulesItem {
  limit: number;
  limitType: DeleteResponseSpendLimitsRulesItemLimitType;
  window: number;
  id?: string | null;
  enabled?: boolean | null;
  metadata?: UntypedMetadataMap | null;
  model?: DeleteResponseSpendLimitsRulesItemModel | null;
  provider?: DeleteResponseSpendLimitsRulesItemProvider | null;
  technique?: DeleteResponseSpendLimitsRulesItemTechnique | null;
}
export const DeleteResponseSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: DeleteResponseSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    metadata: S.optional(S.NullOr(UntypedMetadataMap)),
    model: S.optional(S.NullOr(DeleteResponseSpendLimitsRulesItemModel)),
    provider: S.optional(S.NullOr(DeleteResponseSpendLimitsRulesItemProvider)),
    technique: S.optional(
      S.NullOr(DeleteResponseSpendLimitsRulesItemTechnique),
    ),
  }),
).annotate({
  identifier: "DeleteResponseSpendLimitsRulesItem",
}) as any as S.Schema<DeleteResponseSpendLimitsRulesItem>;

export type DeleteResponseSpendLimitsRulesList =
  Array<DeleteResponseSpendLimitsRulesItem>;
export const DeleteResponseSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  DeleteResponseSpendLimitsRulesItem,
) as any as S.Schema<DeleteResponseSpendLimitsRulesList>;

export interface DeleteResponseSpendLimits {
  enabled?: boolean | null;
  rules?: DeleteResponseSpendLimitsRulesList | null;
}
export const DeleteResponseSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.NullOr(S.Boolean)),
    rules: S.optional(S.NullOr(DeleteResponseSpendLimitsRulesList)),
  }),
).annotate({
  identifier: "DeleteResponseSpendLimits",
}) as any as S.Schema<DeleteResponseSpendLimits>;

export type DeleteResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;
export const DeleteResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;

export type DeleteResponseStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const DeleteResponseStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<DeleteResponseStripeUsageEventsList>;

export interface DeleteResponseStripe {
  authorization: string;
  usageEvents: DeleteResponseStripeUsageEventsList;
}
export const DeleteResponseStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: DeleteResponseStripeUsageEventsList.pipe(
      T.Body("usage_events"),
    ),
  }),
).annotate({
  identifier: "DeleteResponseStripe",
}) as any as S.Schema<DeleteResponseStripe>;

export type DeleteResponseWorkersAiBillingMode = "postpaid";
export const DeleteResponseWorkersAiBillingMode = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteAiGatewayResponse {
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number;
  collectLogs: boolean;
  createdAt: string;
  modifiedAt: string;
  rateLimitingInterval: number;
  rateLimitingLimit: number;
  authentication?: boolean | null;
  dlp?: DeleteResponseDlp | null;
  guardrails?: DeleteResponseGuardrails | null;
  isDefault?: boolean | null;
  logManagement?: number | null;
  logManagementStrategy?: DeleteResponseLogManagementStrategy | null;
  logpush?: boolean | null;
  logpushPublicKey?: string | null;
  otel?: DeleteResponseOtelList | null;
  rateLimitingTechnique?: DeleteResponseRateLimitingTechnique | null;
  /** Backoff strategy for retry delays */
  retryBackoff?: DeleteResponseRetryBackoff | null;
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number | null;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number | null;
  spendLimits?: DeleteResponseSpendLimits | null;
  storeId?: string | null;
  stripe?: DeleteResponseStripe | null;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: DeleteResponseWorkersAiBillingMode | null;
  zdr?: boolean | null;
}
export const DeleteAiGatewayResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.Number.pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    rateLimitingInterval: S.Number.pipe(T.Body("rate_limiting_interval")),
    rateLimitingLimit: S.Number.pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.NullOr(S.Boolean)),
    dlp: S.optional(S.NullOr(DeleteResponseDlp)),
    guardrails: S.optional(S.NullOr(DeleteResponseGuardrails)),
    isDefault: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_default"))),
    logManagement: S.optional(
      S.NullOr(S.Number).pipe(T.Body("log_management")),
    ),
    logManagementStrategy: S.optional(
      S.NullOr(DeleteResponseLogManagementStrategy).pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.NullOr(S.Boolean)),
    logpushPublicKey: S.optional(
      S.NullOr(S.String).pipe(T.Body("logpush_public_key")),
    ),
    otel: S.optional(S.NullOr(DeleteResponseOtelList)),
    rateLimitingTechnique: S.optional(
      S.NullOr(DeleteResponseRateLimitingTechnique).pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      S.NullOr(DeleteResponseRetryBackoff).pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(
      S.NullOr(S.Number).pipe(T.Body("retry_max_attempts")),
    ),
    spendLimits: S.optional(
      S.NullOr(DeleteResponseSpendLimits).pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.NullOr(S.String).pipe(T.Body("store_id"))),
    stripe: S.optional(S.NullOr(DeleteResponseStripe)),
    workersAiBillingMode: S.optional(
      S.NullOr(DeleteResponseWorkersAiBillingMode).pipe(
        T.Body("workers_ai_billing_mode"),
      ),
    ),
    zdr: S.optional(S.NullOr(S.Boolean)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAiGatewayResponse",
}) as any as S.Schema<DeleteAiGatewayResponse>;

export interface DeleteBillingSpendingLimitRequest {
  accountId: string;
}
export const DeleteBillingSpendingLimitRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/billing/spending-limit",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteBillingSpendingLimitRequest",
}) as any as S.Schema<DeleteBillingSpendingLimitRequest>;

export type DeleteBillingSpendingLimitResponse = unknown;
export const DeleteBillingSpendingLimitResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteBillingSpendingLimitResponse",
}) as any as S.Schema<DeleteBillingSpendingLimitResponse>;

export interface DeleteBillingTopupConfigRequest {
  accountId: string;
}
export const DeleteBillingTopupConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/billing/topup/config",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteBillingTopupConfigRequest",
}) as any as S.Schema<DeleteBillingTopupConfigRequest>;

export type DeleteBillingTopupConfigResponse = unknown;
export const DeleteBillingTopupConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteBillingTopupConfigResponse",
}) as any as S.Schema<DeleteBillingTopupConfigResponse>;

export interface DeleteCustomProviderRequest {
  accountId: string;
  id: string;
}
export const DeleteCustomProviderRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/custom-providers/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCustomProviderRequest",
}) as any as S.Schema<DeleteCustomProviderRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteCustomProviderResponse {
  id: string;
  baseUrl: string;
  createdAt: string;
  modifiedAt: string;
  name: string;
  slug: string;
  beta?: boolean | null;
  curlExample?: string | null;
  description?: string | null;
  enable?: boolean | null;
  headers?: string | null;
  jsExample?: string | null;
  link?: string | null;
  logo?: string | null;
  position?: number | null;
}
export const DeleteCustomProviderResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    baseUrl: S.String.pipe(T.Body("base_url")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    slug: S.String,
    beta: S.optional(S.NullOr(S.Boolean)),
    curlExample: S.optional(S.NullOr(S.String).pipe(T.Body("curl_example"))),
    description: S.optional(S.NullOr(S.String)),
    enable: S.optional(S.NullOr(S.Boolean)),
    headers: S.optional(S.NullOr(S.String)),
    jsExample: S.optional(S.NullOr(S.String).pipe(T.Body("js_example"))),
    link: S.optional(S.NullOr(S.String)),
    logo: S.optional(S.NullOr(S.String)),
    position: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCustomProviderResponse",
}) as any as S.Schema<DeleteCustomProviderResponse>;

export interface DeleteDatasetRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const DeleteDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/datasets/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDatasetRequest",
}) as any as S.Schema<DeleteDatasetRequest>;

export type DatasetsDeleteResponseFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsDeleteResponseFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsDeleteResponseFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsDeleteResponseFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsDeleteResponseFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsDeleteResponseFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsDeleteResponseFiltersItemValueList =
  Array<DatasetsDeleteResponseFiltersItemValueItem>;
export const DatasetsDeleteResponseFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsDeleteResponseFiltersItemValueItem,
) as any as S.Schema<DatasetsDeleteResponseFiltersItemValueList>;

export interface DatasetsDeleteResponseFiltersItem {
  key: DatasetsDeleteResponseFiltersItemKey;
  operator: DatasetsDeleteResponseFiltersItemOperator;
  value: DatasetsDeleteResponseFiltersItemValueList;
}
export const DatasetsDeleteResponseFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsDeleteResponseFiltersItemKey,
    operator: DatasetsDeleteResponseFiltersItemOperator,
    value: DatasetsDeleteResponseFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsDeleteResponseFiltersItem",
}) as any as S.Schema<DatasetsDeleteResponseFiltersItem>;

export type DatasetsDeleteResponseFiltersList =
  Array<DatasetsDeleteResponseFiltersItem>;
export const DatasetsDeleteResponseFiltersList = /*@__PURE__*/ S.Array(
  DatasetsDeleteResponseFiltersItem,
) as any as S.Schema<DatasetsDeleteResponseFiltersList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteDatasetResponse {
  id: string;
  createdAt: string;
  enable: boolean;
  filters: DatasetsDeleteResponseFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const DeleteDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: DatasetsDeleteResponseFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDatasetResponse",
}) as any as S.Schema<DeleteDatasetResponse>;

export interface DeleteDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
}
export const DeleteDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDynamicRoutingRequest",
}) as any as S.Schema<DeleteDynamicRoutingRequest>;

export type DynamicRoutingDeleteResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingDeleteResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingDeleteResponseElementsItemCase0Type = "start";
export const DynamicRoutingDeleteResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingDeleteResponseElementsItemCase0Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingDeleteResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase0>;

export type DynamicRoutingDeleteResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingDeleteResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingDeleteResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingDeleteResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingDeleteResponseElementsItemCase1Type = "conditional";
export const DynamicRoutingDeleteResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingDeleteResponseElementsItemCase1Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingDeleteResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase1>;

export type DynamicRoutingDeleteResponseElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingDeleteResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingDeleteResponseElementsItemCase2Type = "percentage";
export const DynamicRoutingDeleteResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingDeleteResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingDeleteResponseElementsItemCase2Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingDeleteResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingDeleteResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase2>;

export type DynamicRoutingDeleteResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingDeleteResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingDeleteResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingDeleteResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingDeleteResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingDeleteResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingDeleteResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase3Properties>;

export type DynamicRoutingDeleteResponseElementsItemCase3Type = "rate";
export const DynamicRoutingDeleteResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingDeleteResponseElementsItemCase3Properties;
  type: DynamicRoutingDeleteResponseElementsItemCase3Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingDeleteResponseElementsItemCase3Properties,
      type: DynamicRoutingDeleteResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase3>;

export type DynamicRoutingDeleteResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingDeleteResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingDeleteResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingDeleteResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingDeleteResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingDeleteResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingDeleteResponseElementsItemCase4Type = "model";
export const DynamicRoutingDeleteResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingDeleteResponseElementsItemCase4Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingDeleteResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase4>;

export type DynamicRoutingDeleteResponseElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingDeleteResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingDeleteResponseElementsItemCase5Type = "end";
export const DynamicRoutingDeleteResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingDeleteResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingDeleteResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingDeleteResponseElementsItemCase5Type;
}
export const DynamicRoutingDeleteResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingDeleteResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingDeleteResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingDeleteResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingDeleteResponseElementsItemCase5>;

export type DynamicRoutingDeleteResponseElementsItem =
  | DynamicRoutingDeleteResponseElementsItemCase0
  | DynamicRoutingDeleteResponseElementsItemCase1
  | DynamicRoutingDeleteResponseElementsItemCase2
  | DynamicRoutingDeleteResponseElementsItemCase3
  | DynamicRoutingDeleteResponseElementsItemCase4
  | DynamicRoutingDeleteResponseElementsItemCase5;
export const DynamicRoutingDeleteResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingDeleteResponseElementsList =
  Array<DynamicRoutingDeleteResponseElementsItem>;
export const DynamicRoutingDeleteResponseElementsList = /*@__PURE__*/ S.Array(
  DynamicRoutingDeleteResponseElementsItem,
) as any as S.Schema<DynamicRoutingDeleteResponseElementsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteDynamicRoutingResponse {
  id: string;
  createdAt: string;
  elements: DynamicRoutingDeleteResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const DeleteDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    elements: DynamicRoutingDeleteResponseElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDynamicRoutingResponse",
}) as any as S.Schema<DeleteDynamicRoutingResponse>;

export interface DeleteEvaluationRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const DeleteEvaluationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/evaluations/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteEvaluationRequest",
}) as any as S.Schema<DeleteEvaluationRequest>;

export type EvaluationsDeleteResponseDatasetsItemFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const EvaluationsDeleteResponseDatasetsItemFiltersItemKey =
  /*@__PURE__*/ S.String;

export type EvaluationsDeleteResponseDatasetsItemFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const EvaluationsDeleteResponseDatasetsItemFiltersItemOperator =
  /*@__PURE__*/ S.String;

export type EvaluationsDeleteResponseDatasetsItemFiltersItemValueItem =
  | string
  | number
  | boolean;
export const EvaluationsDeleteResponseDatasetsItemFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type EvaluationsDeleteResponseDatasetsItemFiltersItemValueList =
  Array<EvaluationsDeleteResponseDatasetsItemFiltersItemValueItem>;
export const EvaluationsDeleteResponseDatasetsItemFiltersItemValueList =
  /*@__PURE__*/ S.Array(
    EvaluationsDeleteResponseDatasetsItemFiltersItemValueItem,
  ) as any as S.Schema<EvaluationsDeleteResponseDatasetsItemFiltersItemValueList>;

export interface EvaluationsDeleteResponseDatasetsItemFiltersItem {
  key: EvaluationsDeleteResponseDatasetsItemFiltersItemKey;
  operator: EvaluationsDeleteResponseDatasetsItemFiltersItemOperator;
  value: EvaluationsDeleteResponseDatasetsItemFiltersItemValueList;
}
export const EvaluationsDeleteResponseDatasetsItemFiltersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: EvaluationsDeleteResponseDatasetsItemFiltersItemKey,
      operator: EvaluationsDeleteResponseDatasetsItemFiltersItemOperator,
      value: EvaluationsDeleteResponseDatasetsItemFiltersItemValueList,
    }),
  ).annotate({
    identifier: "EvaluationsDeleteResponseDatasetsItemFiltersItem",
  }) as any as S.Schema<EvaluationsDeleteResponseDatasetsItemFiltersItem>;

export type EvaluationsDeleteResponseDatasetsItemFiltersList =
  Array<EvaluationsDeleteResponseDatasetsItemFiltersItem>;
export const EvaluationsDeleteResponseDatasetsItemFiltersList =
  /*@__PURE__*/ S.Array(
    EvaluationsDeleteResponseDatasetsItemFiltersItem,
  ) as any as S.Schema<EvaluationsDeleteResponseDatasetsItemFiltersList>;

export interface EvaluationsDeleteResponseDatasetsItem {
  id: string;
  accountId: string;
  accountTag: string;
  createdAt: string;
  enable: boolean;
  filters: EvaluationsDeleteResponseDatasetsItemFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const EvaluationsDeleteResponseDatasetsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accountId: S.String.pipe(T.Body("account_id")),
      accountTag: S.String.pipe(T.Body("account_tag")),
      createdAt: S.String.pipe(T.Body("created_at")),
      enable: S.Boolean,
      filters: EvaluationsDeleteResponseDatasetsItemFiltersList,
      gatewayId: S.String.pipe(T.Body("gateway_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      name: S.String,
    }),
).annotate({
  identifier: "EvaluationsDeleteResponseDatasetsItem",
}) as any as S.Schema<EvaluationsDeleteResponseDatasetsItem>;

export type EvaluationsDeleteResponseDatasetsList =
  Array<EvaluationsDeleteResponseDatasetsItem>;
export const EvaluationsDeleteResponseDatasetsList = /*@__PURE__*/ S.Array(
  EvaluationsDeleteResponseDatasetsItem,
) as any as S.Schema<EvaluationsDeleteResponseDatasetsList>;

export type EvaluationsDeleteResponseResultsItem =
  EvaluationsCreateResponseResultsItem;
export const EvaluationsDeleteResponseResultsItem =
  EvaluationsCreateResponseResultsItem;

export type EvaluationsDeleteResponseResultsList =
  Array<EvaluationsCreateResponseResultsItem>;
export const EvaluationsDeleteResponseResultsList = /*@__PURE__*/ S.Array(
  EvaluationsCreateResponseResultsItem,
) as any as S.Schema<EvaluationsDeleteResponseResultsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteEvaluationResponse {
  id: string;
  createdAt: string;
  datasets: EvaluationsDeleteResponseDatasetsList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
  processed: boolean;
  results: EvaluationsDeleteResponseResultsList;
  totalLogs: number;
}
export const DeleteEvaluationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    datasets: EvaluationsDeleteResponseDatasetsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    processed: S.Boolean,
    results: EvaluationsDeleteResponseResultsList,
    totalLogs: S.Number.pipe(T.Body("total_logs")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteEvaluationResponse",
}) as any as S.Schema<DeleteEvaluationResponse>;

export type LogsDeleteRequestFiltersList = Array<string>;
export const LogsDeleteRequestFiltersList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<LogsDeleteRequestFiltersList>;

export type LogsDeleteRequestOrderBy =
  | "created_at"
  | "provider"
  | "model"
  | "model_type"
  | "success"
  | "cached"
  | "cost"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const LogsDeleteRequestOrderBy = /*@__PURE__*/ S.String;

export type LogsDeleteRequestOrderByDirection = "asc" | "desc";
export const LogsDeleteRequestOrderByDirection = /*@__PURE__*/ S.String;

export interface DeleteLogRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  filters?: LogsDeleteRequestFiltersList;
  limit?: number;
  orderBy?: LogsDeleteRequestOrderBy | (string & {});
  orderByDirection?: LogsDeleteRequestOrderByDirection | (string & {});
}
export const DeleteLogRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    filters: S.optional(LogsDeleteRequestFiltersList.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    orderBy: S.optional(LogsDeleteRequestOrderBy.pipe(T.Query("order_by"))),
    orderByDirection: S.optional(
      LogsDeleteRequestOrderByDirection.pipe(T.Query("order_by_direction")),
    ),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteLogRequest",
}) as any as S.Schema<DeleteLogRequest>;

export interface DeleteLogResponse {}
export const DeleteLogResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteLogResponse",
}) as any as S.Schema<DeleteLogResponse>;

export interface DeleteProviderConfigRequest {
  /** Identifier. */
  accountId: string;
  gatewayId: string;
  id: string;
}
export const DeleteProviderConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/provider_configs/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteProviderConfigRequest",
}) as any as S.Schema<DeleteProviderConfigRequest>;

export type DeleteProviderConfigResponse = unknown;
export const DeleteProviderConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteProviderConfigResponse",
}) as any as S.Schema<DeleteProviderConfigResponse>;

export interface GetAiGatewayRequest {
  accountId: string;
  /** gateway id */
  id: string;
}
export const GetAiGatewayRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAiGatewayRequest",
}) as any as S.Schema<GetAiGatewayRequest>;

export type GetResponseDlpCase0Action = "BLOCK" | "FLAG";
export const GetResponseDlpCase0Action = /*@__PURE__*/ S.String;

export type GetResponseDlpCase0ProfilesList = Array<string>;
export const GetResponseDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<GetResponseDlpCase0ProfilesList>;

export interface GetResponseDlpCase0 {
  action: GetResponseDlpCase0Action;
  enabled: boolean;
  profiles: GetResponseDlpCase0ProfilesList;
}
export const GetResponseDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: GetResponseDlpCase0Action,
    enabled: S.Boolean,
    profiles: GetResponseDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "GetResponseDlpCase0",
}) as any as S.Schema<GetResponseDlpCase0>;

export type GetResponseDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const GetResponseDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type GetResponseDlpCase1PoliciesItemCheckItem = "REQUEST" | "RESPONSE";
export const GetResponseDlpCase1PoliciesItemCheckItem = /*@__PURE__*/ S.String;

export type GetResponseDlpCase1PoliciesItemCheckList =
  Array<GetResponseDlpCase1PoliciesItemCheckItem>;
export const GetResponseDlpCase1PoliciesItemCheckList = /*@__PURE__*/ S.Array(
  GetResponseDlpCase1PoliciesItemCheckItem,
) as any as S.Schema<GetResponseDlpCase1PoliciesItemCheckList>;

export type GetResponseDlpCase1PoliciesItemProfilesList = Array<string>;
export const GetResponseDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<GetResponseDlpCase1PoliciesItemProfilesList>;

export interface GetResponseDlpCase1PoliciesItem {
  id: string;
  action: GetResponseDlpCase1PoliciesItemAction;
  check: GetResponseDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: GetResponseDlpCase1PoliciesItemProfilesList;
}
export const GetResponseDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: GetResponseDlpCase1PoliciesItemAction,
    check: GetResponseDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: GetResponseDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "GetResponseDlpCase1PoliciesItem",
}) as any as S.Schema<GetResponseDlpCase1PoliciesItem>;

export type GetResponseDlpCase1PoliciesList =
  Array<GetResponseDlpCase1PoliciesItem>;
export const GetResponseDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  GetResponseDlpCase1PoliciesItem,
) as any as S.Schema<GetResponseDlpCase1PoliciesList>;

export interface GetResponseDlpCase1 {
  enabled: boolean;
  policies: GetResponseDlpCase1PoliciesList;
}
export const GetResponseDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: GetResponseDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "GetResponseDlpCase1",
}) as any as S.Schema<GetResponseDlpCase1>;

export type GetResponseDlp = GetResponseDlpCase0 | GetResponseDlpCase1;
export const GetResponseDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type GetResponseGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface GetResponseGuardrailsPrompt {
  p1?: GetResponseGuardrailsPromptP1 | null;
  s1?: GetResponseGuardrailsPromptS1 | null;
  s10?: GetResponseGuardrailsPromptS10 | null;
  s11?: GetResponseGuardrailsPromptS11 | null;
  s12?: GetResponseGuardrailsPromptS12 | null;
  s13?: GetResponseGuardrailsPromptS13 | null;
  s2?: GetResponseGuardrailsPromptS2 | null;
  s3?: GetResponseGuardrailsPromptS3 | null;
  s4?: GetResponseGuardrailsPromptS4 | null;
  s5?: GetResponseGuardrailsPromptS5 | null;
  s6?: GetResponseGuardrailsPromptS6 | null;
  s7?: GetResponseGuardrailsPromptS7 | null;
  s8?: GetResponseGuardrailsPromptS8 | null;
  s9?: GetResponseGuardrailsPromptS9 | null;
}
export const GetResponseGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(S.NullOr(GetResponseGuardrailsPromptP1).pipe(T.Body("P1"))),
    s1: S.optional(S.NullOr(GetResponseGuardrailsPromptS1).pipe(T.Body("S1"))),
    s10: S.optional(
      S.NullOr(GetResponseGuardrailsPromptS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(GetResponseGuardrailsPromptS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(GetResponseGuardrailsPromptS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(GetResponseGuardrailsPromptS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(S.NullOr(GetResponseGuardrailsPromptS2).pipe(T.Body("S2"))),
    s3: S.optional(S.NullOr(GetResponseGuardrailsPromptS3).pipe(T.Body("S3"))),
    s4: S.optional(S.NullOr(GetResponseGuardrailsPromptS4).pipe(T.Body("S4"))),
    s5: S.optional(S.NullOr(GetResponseGuardrailsPromptS5).pipe(T.Body("S5"))),
    s6: S.optional(S.NullOr(GetResponseGuardrailsPromptS6).pipe(T.Body("S6"))),
    s7: S.optional(S.NullOr(GetResponseGuardrailsPromptS7).pipe(T.Body("S7"))),
    s8: S.optional(S.NullOr(GetResponseGuardrailsPromptS8).pipe(T.Body("S8"))),
    s9: S.optional(S.NullOr(GetResponseGuardrailsPromptS9).pipe(T.Body("S9"))),
  }),
).annotate({
  identifier: "GetResponseGuardrailsPrompt",
}) as any as S.Schema<GetResponseGuardrailsPrompt>;

export type GetResponseGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type GetResponseGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const GetResponseGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface GetResponseGuardrailsResponse {
  p1?: GetResponseGuardrailsResponseP1 | null;
  s1?: GetResponseGuardrailsResponseS1 | null;
  s10?: GetResponseGuardrailsResponseS10 | null;
  s11?: GetResponseGuardrailsResponseS11 | null;
  s12?: GetResponseGuardrailsResponseS12 | null;
  s13?: GetResponseGuardrailsResponseS13 | null;
  s2?: GetResponseGuardrailsResponseS2 | null;
  s3?: GetResponseGuardrailsResponseS3 | null;
  s4?: GetResponseGuardrailsResponseS4 | null;
  s5?: GetResponseGuardrailsResponseS5 | null;
  s6?: GetResponseGuardrailsResponseS6 | null;
  s7?: GetResponseGuardrailsResponseS7 | null;
  s8?: GetResponseGuardrailsResponseS8 | null;
  s9?: GetResponseGuardrailsResponseS9 | null;
}
export const GetResponseGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(GetResponseGuardrailsResponseP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(GetResponseGuardrailsResponseS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "GetResponseGuardrailsResponse",
}) as any as S.Schema<GetResponseGuardrailsResponse>;

export interface GetResponseGuardrails {
  prompt: GetResponseGuardrailsPrompt;
  response: GetResponseGuardrailsResponse;
}
export const GetResponseGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: GetResponseGuardrailsPrompt,
    response: GetResponseGuardrailsResponse,
  }),
).annotate({
  identifier: "GetResponseGuardrails",
}) as any as S.Schema<GetResponseGuardrails>;

export type GetResponseLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const GetResponseLogManagementStrategy = /*@__PURE__*/ S.String;

export type GetResponseOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const GetResponseOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<GetResponseOtelItemHeadersMap>;

export type GetResponseOtelItemContentType = "json" | "protobuf";
export const GetResponseOtelItemContentType = /*@__PURE__*/ S.String;

export interface GetResponseOtelItem {
  headers: GetResponseOtelItemHeadersMap;
  url: string;
  authorization?: string | null;
  contentType?: GetResponseOtelItemContentType | null;
}
export const GetResponseOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: GetResponseOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.NullOr(S.String)),
    contentType: S.optional(
      S.NullOr(GetResponseOtelItemContentType).pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "GetResponseOtelItem",
}) as any as S.Schema<GetResponseOtelItem>;

export type GetResponseOtelList = Array<GetResponseOtelItem>;
export const GetResponseOtelList = /*@__PURE__*/ S.Array(
  GetResponseOtelItem,
) as any as S.Schema<GetResponseOtelList>;

export type GetResponseRateLimitingTechnique = "fixed" | "sliding";
export const GetResponseRateLimitingTechnique = /*@__PURE__*/ S.String;

export type GetResponseRetryBackoff = "constant" | "linear" | "exponential";
export const GetResponseRetryBackoff = /*@__PURE__*/ S.String;

export type GetResponseSpendLimitsRulesItemLimitType = "cost";
export const GetResponseSpendLimitsRulesItemLimitType = /*@__PURE__*/ S.String;

export type GetResponseSpendLimitsRulesItemModelMode = "filter";
export const GetResponseSpendLimitsRulesItemModelMode = /*@__PURE__*/ S.String;

export type GetResponseSpendLimitsRulesItemModelValuesList = Array<string>;
export const GetResponseSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<GetResponseSpendLimitsRulesItemModelValuesList>;

export interface GetResponseSpendLimitsRulesItemModel {
  mode: GetResponseSpendLimitsRulesItemModelMode;
  values: GetResponseSpendLimitsRulesItemModelValuesList;
}
export const GetResponseSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: GetResponseSpendLimitsRulesItemModelMode,
      values: GetResponseSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "GetResponseSpendLimitsRulesItemModel",
}) as any as S.Schema<GetResponseSpendLimitsRulesItemModel>;

export type GetResponseSpendLimitsRulesItemProviderMode = "filter";
export const GetResponseSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type GetResponseSpendLimitsRulesItemProviderValuesList = Array<string>;
export const GetResponseSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<GetResponseSpendLimitsRulesItemProviderValuesList>;

export interface GetResponseSpendLimitsRulesItemProvider {
  mode: GetResponseSpendLimitsRulesItemProviderMode;
  values: GetResponseSpendLimitsRulesItemProviderValuesList;
}
export const GetResponseSpendLimitsRulesItemProvider = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: GetResponseSpendLimitsRulesItemProviderMode,
      values: GetResponseSpendLimitsRulesItemProviderValuesList,
    }),
).annotate({
  identifier: "GetResponseSpendLimitsRulesItemProvider",
}) as any as S.Schema<GetResponseSpendLimitsRulesItemProvider>;

export type GetResponseSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const GetResponseSpendLimitsRulesItemTechnique = /*@__PURE__*/ S.String;

export interface GetResponseSpendLimitsRulesItem {
  limit: number;
  limitType: GetResponseSpendLimitsRulesItemLimitType;
  window: number;
  id?: string | null;
  enabled?: boolean | null;
  metadata?: UntypedMetadataMap | null;
  model?: GetResponseSpendLimitsRulesItemModel | null;
  provider?: GetResponseSpendLimitsRulesItemProvider | null;
  technique?: GetResponseSpendLimitsRulesItemTechnique | null;
}
export const GetResponseSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: GetResponseSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    metadata: S.optional(S.NullOr(UntypedMetadataMap)),
    model: S.optional(S.NullOr(GetResponseSpendLimitsRulesItemModel)),
    provider: S.optional(S.NullOr(GetResponseSpendLimitsRulesItemProvider)),
    technique: S.optional(S.NullOr(GetResponseSpendLimitsRulesItemTechnique)),
  }),
).annotate({
  identifier: "GetResponseSpendLimitsRulesItem",
}) as any as S.Schema<GetResponseSpendLimitsRulesItem>;

export type GetResponseSpendLimitsRulesList =
  Array<GetResponseSpendLimitsRulesItem>;
export const GetResponseSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  GetResponseSpendLimitsRulesItem,
) as any as S.Schema<GetResponseSpendLimitsRulesList>;

export interface GetResponseSpendLimits {
  enabled?: boolean | null;
  rules?: GetResponseSpendLimitsRulesList | null;
}
export const GetResponseSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.NullOr(S.Boolean)),
    rules: S.optional(S.NullOr(GetResponseSpendLimitsRulesList)),
  }),
).annotate({
  identifier: "GetResponseSpendLimits",
}) as any as S.Schema<GetResponseSpendLimits>;

export type GetResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;
export const GetResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;

export type GetResponseStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const GetResponseStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<GetResponseStripeUsageEventsList>;

export interface GetResponseStripe {
  authorization: string;
  usageEvents: GetResponseStripeUsageEventsList;
}
export const GetResponseStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: GetResponseStripeUsageEventsList.pipe(T.Body("usage_events")),
  }),
).annotate({
  identifier: "GetResponseStripe",
}) as any as S.Schema<GetResponseStripe>;

export type GetResponseWorkersAiBillingMode = "postpaid";
export const GetResponseWorkersAiBillingMode = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetAiGatewayResponse {
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number;
  collectLogs: boolean;
  createdAt: string;
  modifiedAt: string;
  rateLimitingInterval: number;
  rateLimitingLimit: number;
  authentication?: boolean | null;
  dlp?: GetResponseDlp | null;
  guardrails?: GetResponseGuardrails | null;
  isDefault?: boolean | null;
  logManagement?: number | null;
  logManagementStrategy?: GetResponseLogManagementStrategy | null;
  logpush?: boolean | null;
  logpushPublicKey?: string | null;
  otel?: GetResponseOtelList | null;
  rateLimitingTechnique?: GetResponseRateLimitingTechnique | null;
  /** Backoff strategy for retry delays */
  retryBackoff?: GetResponseRetryBackoff | null;
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number | null;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number | null;
  spendLimits?: GetResponseSpendLimits | null;
  storeId?: string | null;
  stripe?: GetResponseStripe | null;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: GetResponseWorkersAiBillingMode | null;
  zdr?: boolean | null;
}
export const GetAiGatewayResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.Number.pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    rateLimitingInterval: S.Number.pipe(T.Body("rate_limiting_interval")),
    rateLimitingLimit: S.Number.pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.NullOr(S.Boolean)),
    dlp: S.optional(S.NullOr(GetResponseDlp)),
    guardrails: S.optional(S.NullOr(GetResponseGuardrails)),
    isDefault: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_default"))),
    logManagement: S.optional(
      S.NullOr(S.Number).pipe(T.Body("log_management")),
    ),
    logManagementStrategy: S.optional(
      S.NullOr(GetResponseLogManagementStrategy).pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.NullOr(S.Boolean)),
    logpushPublicKey: S.optional(
      S.NullOr(S.String).pipe(T.Body("logpush_public_key")),
    ),
    otel: S.optional(S.NullOr(GetResponseOtelList)),
    rateLimitingTechnique: S.optional(
      S.NullOr(GetResponseRateLimitingTechnique).pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      S.NullOr(GetResponseRetryBackoff).pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(
      S.NullOr(S.Number).pipe(T.Body("retry_max_attempts")),
    ),
    spendLimits: S.optional(
      S.NullOr(GetResponseSpendLimits).pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.NullOr(S.String).pipe(T.Body("store_id"))),
    stripe: S.optional(S.NullOr(GetResponseStripe)),
    workersAiBillingMode: S.optional(
      S.NullOr(GetResponseWorkersAiBillingMode).pipe(
        T.Body("workers_ai_billing_mode"),
      ),
    ),
    zdr: S.optional(S.NullOr(S.Boolean)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAiGatewayResponse",
}) as any as S.Schema<GetAiGatewayResponse>;

export interface GetBillingSpendingLimitRequest {
  accountId: string;
}
export const GetBillingSpendingLimitRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/spending-limit",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingSpendingLimitRequest",
}) as any as S.Schema<GetBillingSpendingLimitRequest>;

export interface BillingSpendingLimitGetResponseConfig {
  amount: number;
  duration: string;
  strategy: string;
}
export const BillingSpendingLimitGetResponseConfig = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      amount: S.Number,
      duration: S.String,
      strategy: S.String,
    }),
).annotate({
  identifier: "BillingSpendingLimitGetResponseConfig",
}) as any as S.Schema<BillingSpendingLimitGetResponseConfig>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetBillingSpendingLimitResponse {
  config: BillingSpendingLimitGetResponseConfig;
  enabled: boolean;
}
export const GetBillingSpendingLimitResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    config: BillingSpendingLimitGetResponseConfig,
    enabled: S.Boolean,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingSpendingLimitResponse",
}) as any as S.Schema<GetBillingSpendingLimitResponse>;

export interface GetBillingTopupConfigRequest {
  accountId: string;
}
export const GetBillingTopupConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/topup/config",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingTopupConfigRequest",
}) as any as S.Schema<GetBillingTopupConfigRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetBillingTopupConfigResponse {
  amount: number;
  disabledReason: string;
  error: string;
  lastFailedAt: number;
  threshold: number;
}
export const GetBillingTopupConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    amount: S.Number,
    disabledReason: S.String,
    error: S.String,
    lastFailedAt: S.Number,
    threshold: S.Number,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingTopupConfigResponse",
}) as any as S.Schema<GetBillingTopupConfigResponse>;

export interface GetCustomProviderRequest {
  accountId: string;
  id: string;
}
export const GetCustomProviderRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/custom-providers/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCustomProviderRequest",
}) as any as S.Schema<GetCustomProviderRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetCustomProviderResponse {
  id: string;
  baseUrl: string;
  createdAt: string;
  modifiedAt: string;
  name: string;
  slug: string;
  beta?: boolean | null;
  curlExample?: string | null;
  description?: string | null;
  enable?: boolean | null;
  headers?: string | null;
  jsExample?: string | null;
  link?: string | null;
  logo?: string | null;
  position?: number | null;
}
export const GetCustomProviderResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    baseUrl: S.String.pipe(T.Body("base_url")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    slug: S.String,
    beta: S.optional(S.NullOr(S.Boolean)),
    curlExample: S.optional(S.NullOr(S.String).pipe(T.Body("curl_example"))),
    description: S.optional(S.NullOr(S.String)),
    enable: S.optional(S.NullOr(S.Boolean)),
    headers: S.optional(S.NullOr(S.String)),
    jsExample: S.optional(S.NullOr(S.String).pipe(T.Body("js_example"))),
    link: S.optional(S.NullOr(S.String)),
    logo: S.optional(S.NullOr(S.String)),
    position: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCustomProviderResponse",
}) as any as S.Schema<GetCustomProviderResponse>;

export interface GetDatasetRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const GetDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/datasets/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDatasetRequest",
}) as any as S.Schema<GetDatasetRequest>;

export type DatasetsGetResponseFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsGetResponseFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsGetResponseFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsGetResponseFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsGetResponseFiltersItemValueItem = string | number | boolean;
export const DatasetsGetResponseFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsGetResponseFiltersItemValueList =
  Array<DatasetsGetResponseFiltersItemValueItem>;
export const DatasetsGetResponseFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsGetResponseFiltersItemValueItem,
) as any as S.Schema<DatasetsGetResponseFiltersItemValueList>;

export interface DatasetsGetResponseFiltersItem {
  key: DatasetsGetResponseFiltersItemKey;
  operator: DatasetsGetResponseFiltersItemOperator;
  value: DatasetsGetResponseFiltersItemValueList;
}
export const DatasetsGetResponseFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsGetResponseFiltersItemKey,
    operator: DatasetsGetResponseFiltersItemOperator,
    value: DatasetsGetResponseFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsGetResponseFiltersItem",
}) as any as S.Schema<DatasetsGetResponseFiltersItem>;

export type DatasetsGetResponseFiltersList =
  Array<DatasetsGetResponseFiltersItem>;
export const DatasetsGetResponseFiltersList = /*@__PURE__*/ S.Array(
  DatasetsGetResponseFiltersItem,
) as any as S.Schema<DatasetsGetResponseFiltersList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetDatasetResponse {
  id: string;
  createdAt: string;
  enable: boolean;
  filters: DatasetsGetResponseFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const GetDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: DatasetsGetResponseFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDatasetResponse",
}) as any as S.Schema<GetDatasetResponse>;

export interface GetDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
}
export const GetDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDynamicRoutingRequest",
}) as any as S.Schema<GetDynamicRoutingRequest>;

export type DynamicRoutingGetResponseDeployment =
  DynamicRoutingCreateResponseDeployment;
export const DynamicRoutingGetResponseDeployment =
  DynamicRoutingCreateResponseDeployment;

export type DynamicRoutingGetResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingGetResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingGetResponseElementsItemCase0Type = "start";
export const DynamicRoutingGetResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingGetResponseElementsItemCase0Type;
}
export const DynamicRoutingGetResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingGetResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase0>;

export type DynamicRoutingGetResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingGetResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingGetResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingGetResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingGetResponseElementsItemCase1Type = "conditional";
export const DynamicRoutingGetResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingGetResponseElementsItemCase1Type;
}
export const DynamicRoutingGetResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingGetResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase1>;

export type DynamicRoutingGetResponseElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingGetResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingGetResponseElementsItemCase2Type = "percentage";
export const DynamicRoutingGetResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingGetResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingGetResponseElementsItemCase2Type;
}
export const DynamicRoutingGetResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingGetResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingGetResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase2>;

export type DynamicRoutingGetResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingGetResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingGetResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingGetResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingGetResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingGetResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType: DynamicRoutingGetResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase3Properties>;

export type DynamicRoutingGetResponseElementsItemCase3Type = "rate";
export const DynamicRoutingGetResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingGetResponseElementsItemCase3Properties;
  type: DynamicRoutingGetResponseElementsItemCase3Type;
}
export const DynamicRoutingGetResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingGetResponseElementsItemCase3Properties,
      type: DynamicRoutingGetResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase3>;

export type DynamicRoutingGetResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingGetResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingGetResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingGetResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingGetResponseElementsItemCase4Type = "model";
export const DynamicRoutingGetResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingGetResponseElementsItemCase4Type;
}
export const DynamicRoutingGetResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingGetResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase4>;

export type DynamicRoutingGetResponseElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingGetResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingGetResponseElementsItemCase5Type = "end";
export const DynamicRoutingGetResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingGetResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingGetResponseElementsItemCase5Type;
}
export const DynamicRoutingGetResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingGetResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingGetResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingGetResponseElementsItemCase5>;

export type DynamicRoutingGetResponseElementsItem =
  | DynamicRoutingGetResponseElementsItemCase0
  | DynamicRoutingGetResponseElementsItemCase1
  | DynamicRoutingGetResponseElementsItemCase2
  | DynamicRoutingGetResponseElementsItemCase3
  | DynamicRoutingGetResponseElementsItemCase4
  | DynamicRoutingGetResponseElementsItemCase5;
export const DynamicRoutingGetResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingGetResponseElementsList =
  Array<DynamicRoutingGetResponseElementsItem>;
export const DynamicRoutingGetResponseElementsList = /*@__PURE__*/ S.Array(
  DynamicRoutingGetResponseElementsItem,
) as any as S.Schema<DynamicRoutingGetResponseElementsList>;

export type DynamicRoutingGetResponseVersionActive = "true" | "false";
export const DynamicRoutingGetResponseVersionActive = /*@__PURE__*/ S.String;

export interface DynamicRoutingGetResponseVersion {
  active: DynamicRoutingGetResponseVersionActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  versionId: string;
  isValid?: boolean | null;
}
export const DynamicRoutingGetResponseVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    active: DynamicRoutingGetResponseVersionActive,
    createdAt: S.String.pipe(T.Body("created_at")),
    data: DynamicRoutingCreateRequestElementsList,
    versionId: S.String.pipe(T.Body("version_id")),
    isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
  }),
).annotate({
  identifier: "DynamicRoutingGetResponseVersion",
}) as any as S.Schema<DynamicRoutingGetResponseVersion>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetDynamicRoutingResponse {
  id: string;
  createdAt: string;
  deployment: DynamicRoutingCreateResponseDeployment;
  elements: DynamicRoutingGetResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  version: DynamicRoutingGetResponseVersion;
}
export const GetDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    deployment: DynamicRoutingCreateResponseDeployment,
    elements: DynamicRoutingGetResponseElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: DynamicRoutingGetResponseVersion,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDynamicRoutingResponse",
}) as any as S.Schema<GetDynamicRoutingResponse>;

export interface GetEvaluationRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const GetEvaluationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/evaluations/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetEvaluationRequest",
}) as any as S.Schema<GetEvaluationRequest>;

export type EvaluationsGetResponseDatasetsItemFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const EvaluationsGetResponseDatasetsItemFiltersItemKey =
  /*@__PURE__*/ S.String;

export type EvaluationsGetResponseDatasetsItemFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const EvaluationsGetResponseDatasetsItemFiltersItemOperator =
  /*@__PURE__*/ S.String;

export type EvaluationsGetResponseDatasetsItemFiltersItemValueItem =
  | string
  | number
  | boolean;
export const EvaluationsGetResponseDatasetsItemFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type EvaluationsGetResponseDatasetsItemFiltersItemValueList =
  Array<EvaluationsGetResponseDatasetsItemFiltersItemValueItem>;
export const EvaluationsGetResponseDatasetsItemFiltersItemValueList =
  /*@__PURE__*/ S.Array(
    EvaluationsGetResponseDatasetsItemFiltersItemValueItem,
  ) as any as S.Schema<EvaluationsGetResponseDatasetsItemFiltersItemValueList>;

export interface EvaluationsGetResponseDatasetsItemFiltersItem {
  key: EvaluationsGetResponseDatasetsItemFiltersItemKey;
  operator: EvaluationsGetResponseDatasetsItemFiltersItemOperator;
  value: EvaluationsGetResponseDatasetsItemFiltersItemValueList;
}
export const EvaluationsGetResponseDatasetsItemFiltersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: EvaluationsGetResponseDatasetsItemFiltersItemKey,
      operator: EvaluationsGetResponseDatasetsItemFiltersItemOperator,
      value: EvaluationsGetResponseDatasetsItemFiltersItemValueList,
    }),
  ).annotate({
    identifier: "EvaluationsGetResponseDatasetsItemFiltersItem",
  }) as any as S.Schema<EvaluationsGetResponseDatasetsItemFiltersItem>;

export type EvaluationsGetResponseDatasetsItemFiltersList =
  Array<EvaluationsGetResponseDatasetsItemFiltersItem>;
export const EvaluationsGetResponseDatasetsItemFiltersList =
  /*@__PURE__*/ S.Array(
    EvaluationsGetResponseDatasetsItemFiltersItem,
  ) as any as S.Schema<EvaluationsGetResponseDatasetsItemFiltersList>;

export interface EvaluationsGetResponseDatasetsItem {
  id: string;
  accountId: string;
  accountTag: string;
  createdAt: string;
  enable: boolean;
  filters: EvaluationsGetResponseDatasetsItemFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const EvaluationsGetResponseDatasetsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountId: S.String.pipe(T.Body("account_id")),
    accountTag: S.String.pipe(T.Body("account_tag")),
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: EvaluationsGetResponseDatasetsItemFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }),
).annotate({
  identifier: "EvaluationsGetResponseDatasetsItem",
}) as any as S.Schema<EvaluationsGetResponseDatasetsItem>;

export type EvaluationsGetResponseDatasetsList =
  Array<EvaluationsGetResponseDatasetsItem>;
export const EvaluationsGetResponseDatasetsList = /*@__PURE__*/ S.Array(
  EvaluationsGetResponseDatasetsItem,
) as any as S.Schema<EvaluationsGetResponseDatasetsList>;

export type EvaluationsGetResponseResultsItem =
  EvaluationsCreateResponseResultsItem;
export const EvaluationsGetResponseResultsItem =
  EvaluationsCreateResponseResultsItem;

export type EvaluationsGetResponseResultsList =
  Array<EvaluationsCreateResponseResultsItem>;
export const EvaluationsGetResponseResultsList = /*@__PURE__*/ S.Array(
  EvaluationsCreateResponseResultsItem,
) as any as S.Schema<EvaluationsGetResponseResultsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetEvaluationResponse {
  id: string;
  createdAt: string;
  datasets: EvaluationsGetResponseDatasetsList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
  processed: boolean;
  results: EvaluationsGetResponseResultsList;
  totalLogs: number;
}
export const GetEvaluationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    datasets: EvaluationsGetResponseDatasetsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    processed: S.Boolean,
    results: EvaluationsGetResponseResultsList,
    totalLogs: S.Number.pipe(T.Body("total_logs")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetEvaluationResponse",
}) as any as S.Schema<GetEvaluationResponse>;

export interface GetLogRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const GetLogRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetLogRequest" }) as any as S.Schema<GetLogRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetLogResponse {
  id: string;
  cached: boolean;
  createdAt: string;
  duration: number;
  model: string;
  path: string;
  provider: string;
  success: boolean;
  tokensIn: number;
  tokensOut: number;
  cost?: number | null;
  customCost?: boolean | null;
  metadata?: string | null;
  modelType?: string | null;
  requestContentType?: string | null;
  requestHead?: string | null;
  requestHeadComplete?: boolean | null;
  requestSize?: number | null;
  requestType?: string | null;
  responseContentType?: string | null;
  responseHead?: string | null;
  responseHeadComplete?: boolean | null;
  responseSize?: number | null;
  statusCode?: number | null;
  step?: number | null;
}
export const GetLogResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cached: S.Boolean,
    createdAt: S.String.pipe(T.Body("created_at")),
    duration: S.Number,
    model: S.String,
    path: S.String,
    provider: S.String,
    success: S.Boolean,
    tokensIn: S.Number.pipe(T.Body("tokens_in")),
    tokensOut: S.Number.pipe(T.Body("tokens_out")),
    cost: S.optional(S.NullOr(S.Number)),
    customCost: S.optional(S.NullOr(S.Boolean).pipe(T.Body("custom_cost"))),
    metadata: S.optional(S.NullOr(S.String)),
    modelType: S.optional(S.NullOr(S.String).pipe(T.Body("model_type"))),
    requestContentType: S.optional(
      S.NullOr(S.String).pipe(T.Body("request_content_type")),
    ),
    requestHead: S.optional(S.NullOr(S.String).pipe(T.Body("request_head"))),
    requestHeadComplete: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("request_head_complete")),
    ),
    requestSize: S.optional(S.NullOr(S.Number).pipe(T.Body("request_size"))),
    requestType: S.optional(S.NullOr(S.String).pipe(T.Body("request_type"))),
    responseContentType: S.optional(
      S.NullOr(S.String).pipe(T.Body("response_content_type")),
    ),
    responseHead: S.optional(S.NullOr(S.String).pipe(T.Body("response_head"))),
    responseHeadComplete: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("response_head_complete")),
    ),
    responseSize: S.optional(S.NullOr(S.Number).pipe(T.Body("response_size"))),
    statusCode: S.optional(S.NullOr(S.Number).pipe(T.Body("status_code"))),
    step: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetLogResponse" }) as any as S.Schema<GetLogResponse>;

export interface GetUrlRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  provider: string;
}
export const GetUrlRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    provider: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/url/{provider}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetUrlRequest" }) as any as S.Schema<GetUrlRequest>;

export type GetUrlResponse = string;
export const GetUrlResponse = /*@__PURE__*/ S.suspend(() =>
  S.String.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetUrlResponse" }) as any as S.Schema<GetUrlResponse>;

export interface GetVersionDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
  versionId: string;
}
export const GetVersionDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
    versionId: S.String.pipe(T.Label("version_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}/versions/{version_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetVersionDynamicRoutingRequest",
}) as any as S.Schema<GetVersionDynamicRoutingRequest>;

export type DynamicRoutingGetVersionResponseActive = "true" | "false";
export const DynamicRoutingGetVersionResponseActive = /*@__PURE__*/ S.String;

export type DynamicRoutingGetVersionResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingGetVersionResponseElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingGetVersionResponseElementsItemCase0Type = "start";
export const DynamicRoutingGetVersionResponseElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingGetVersionResponseElementsItemCase0Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingGetVersionResponseElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase0>;

export type DynamicRoutingGetVersionResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingGetVersionResponseElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingGetVersionResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingGetVersionResponseElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingGetVersionResponseElementsItemCase1Type =
  "conditional";
export const DynamicRoutingGetVersionResponseElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingGetVersionResponseElementsItemCase1Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingGetVersionResponseElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase1>;

export type DynamicRoutingGetVersionResponseElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingGetVersionResponseElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase2OutputsMap>;

export type DynamicRoutingGetVersionResponseElementsItemCase2Type =
  "percentage";
export const DynamicRoutingGetVersionResponseElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingGetVersionResponseElementsItemCase2OutputsMap;
  type: DynamicRoutingGetVersionResponseElementsItemCase2Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingGetVersionResponseElementsItemCase2OutputsMap,
      type: DynamicRoutingGetVersionResponseElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase2>;

export type DynamicRoutingGetVersionResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingGetVersionResponseElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingGetVersionResponseElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingGetVersionResponseElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingGetVersionResponseElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingGetVersionResponseElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingGetVersionResponseElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase3Properties>;

export type DynamicRoutingGetVersionResponseElementsItemCase3Type = "rate";
export const DynamicRoutingGetVersionResponseElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingGetVersionResponseElementsItemCase3Properties;
  type: DynamicRoutingGetVersionResponseElementsItemCase3Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingGetVersionResponseElementsItemCase3Properties,
      type: DynamicRoutingGetVersionResponseElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase3>;

export type DynamicRoutingGetVersionResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingGetVersionResponseElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingGetVersionResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingGetVersionResponseElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingGetVersionResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingGetVersionResponseElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingGetVersionResponseElementsItemCase4Type = "model";
export const DynamicRoutingGetVersionResponseElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingGetVersionResponseElementsItemCase4Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingGetVersionResponseElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase4>;

export type DynamicRoutingGetVersionResponseElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingGetVersionResponseElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase5OutputsMap>;

export type DynamicRoutingGetVersionResponseElementsItemCase5Type = "end";
export const DynamicRoutingGetVersionResponseElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingGetVersionResponseElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingGetVersionResponseElementsItemCase5OutputsMap;
  type: DynamicRoutingGetVersionResponseElementsItemCase5Type;
}
export const DynamicRoutingGetVersionResponseElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingGetVersionResponseElementsItemCase5OutputsMap,
      type: DynamicRoutingGetVersionResponseElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingGetVersionResponseElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingGetVersionResponseElementsItemCase5>;

export type DynamicRoutingGetVersionResponseElementsItem =
  | DynamicRoutingGetVersionResponseElementsItemCase0
  | DynamicRoutingGetVersionResponseElementsItemCase1
  | DynamicRoutingGetVersionResponseElementsItemCase2
  | DynamicRoutingGetVersionResponseElementsItemCase3
  | DynamicRoutingGetVersionResponseElementsItemCase4
  | DynamicRoutingGetVersionResponseElementsItemCase5;
export const DynamicRoutingGetVersionResponseElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingGetVersionResponseElementsList =
  Array<DynamicRoutingGetVersionResponseElementsItem>;
export const DynamicRoutingGetVersionResponseElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingGetVersionResponseElementsItem,
  ) as any as S.Schema<DynamicRoutingGetVersionResponseElementsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetVersionDynamicRoutingResponse {
  id: string;
  active: DynamicRoutingGetVersionResponseActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  elements: DynamicRoutingGetVersionResponseElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  versionId: string;
  isValid?: boolean | null;
}
export const GetVersionDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    active: DynamicRoutingGetVersionResponseActive,
    createdAt: S.String.pipe(T.Body("created_at")),
    data: DynamicRoutingCreateRequestElementsList,
    elements: DynamicRoutingGetVersionResponseElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    versionId: S.String.pipe(T.Body("version_id")),
    isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetVersionDynamicRoutingResponse",
}) as any as S.Schema<GetVersionDynamicRoutingResponse>;

export type BillingInvoiceHistoryRequestType = "auto" | "all" | "manual";
export const BillingInvoiceHistoryRequestType = /*@__PURE__*/ S.String;

export interface InvoiceHistoryBillingRequest {
  accountId: string;
  /** Filter invoice type: auto, manual, or all. */
  type?: BillingInvoiceHistoryRequestType | (string & {});
}
export const InvoiceHistoryBillingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    type: S.optional(BillingInvoiceHistoryRequestType.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/invoice-history",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "InvoiceHistoryBillingRequest",
}) as any as S.Schema<InvoiceHistoryBillingRequest>;

export interface BillingInvoiceHistoryResponseInvoicesItem {
  amountDue: number;
  amountPaid: number;
  amountRemaining: number;
  currency: string;
  id?: string | null;
  attemptCount?: number | null;
  attempted?: boolean | null;
  autoAdvance?: boolean | null;
  created?: number | null;
  createdBy?: string | null;
  description?: string | null;
  invoiceOrigin?: string | null;
  invoicePdf?: string | null;
  status?: string | null;
}
export const BillingInvoiceHistoryResponseInvoicesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      amountDue: S.Number.pipe(T.Body("amount_due")),
      amountPaid: S.Number.pipe(T.Body("amount_paid")),
      amountRemaining: S.Number.pipe(T.Body("amount_remaining")),
      currency: S.String,
      id: S.optional(S.NullOr(S.String)),
      attemptCount: S.optional(
        S.NullOr(S.Number).pipe(T.Body("attempt_count")),
      ),
      attempted: S.optional(S.NullOr(S.Boolean)),
      autoAdvance: S.optional(S.NullOr(S.Boolean).pipe(T.Body("auto_advance"))),
      created: S.optional(S.NullOr(S.Number)),
      createdBy: S.optional(S.NullOr(S.String).pipe(T.Body("created_by"))),
      description: S.optional(S.NullOr(S.String)),
      invoiceOrigin: S.optional(
        S.NullOr(S.String).pipe(T.Body("invoice_origin")),
      ),
      invoicePdf: S.optional(S.NullOr(S.String).pipe(T.Body("invoice_pdf"))),
      status: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "BillingInvoiceHistoryResponseInvoicesItem",
  }) as any as S.Schema<BillingInvoiceHistoryResponseInvoicesItem>;

export type BillingInvoiceHistoryResponseInvoicesList =
  Array<BillingInvoiceHistoryResponseInvoicesItem>;
export const BillingInvoiceHistoryResponseInvoicesList = /*@__PURE__*/ S.Array(
  BillingInvoiceHistoryResponseInvoicesItem,
) as any as S.Schema<BillingInvoiceHistoryResponseInvoicesList>;

export interface BillingInvoiceHistoryResponsePagination {
  hasMore: boolean;
  page: number;
  perPage: number;
  totalCount: number;
}
export const BillingInvoiceHistoryResponsePagination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      hasMore: S.Boolean.pipe(T.Body("has_more")),
      page: S.Number,
      perPage: S.Number.pipe(T.Body("per_page")),
      totalCount: S.Number.pipe(T.Body("total_count")),
    }),
).annotate({
  identifier: "BillingInvoiceHistoryResponsePagination",
}) as any as S.Schema<BillingInvoiceHistoryResponsePagination>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface InvoiceHistoryBillingResponse {
  invoices: BillingInvoiceHistoryResponseInvoicesList;
  pagination: BillingInvoiceHistoryResponsePagination;
}
export const InvoiceHistoryBillingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    invoices: BillingInvoiceHistoryResponseInvoicesList,
    pagination: BillingInvoiceHistoryResponsePagination,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "InvoiceHistoryBillingResponse",
}) as any as S.Schema<InvoiceHistoryBillingResponse>;

export interface InvoicePreviewBillingRequest {
  accountId: string;
}
export const InvoicePreviewBillingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/invoice-preview",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "InvoicePreviewBillingRequest",
}) as any as S.Schema<InvoicePreviewBillingRequest>;

export interface BillingInvoicePreviewResponseInvoiceLinesItemPeriod {
  end: number;
  start: number;
}
export const BillingInvoicePreviewResponseInvoiceLinesItemPeriod =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      end: S.Number,
      start: S.Number,
    }),
  ).annotate({
    identifier: "BillingInvoicePreviewResponseInvoiceLinesItemPeriod",
  }) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesItemPeriod>;

export interface BillingInvoicePreviewResponseInvoiceLinesItemPricing {
  unitAmountDecimal: string;
}
export const BillingInvoicePreviewResponseInvoiceLinesItemPricing =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      unitAmountDecimal: S.String.pipe(T.Body("unit_amount_decimal")),
    }),
  ).annotate({
    identifier: "BillingInvoicePreviewResponseInvoiceLinesItemPricing",
  }) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesItemPricing>;

export interface BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem {
  amount: number;
  type: string;
  creditBalanceTransaction?: string | null;
  discount?: string | null;
}
export const BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      amount: S.Number,
      type: S.String,
      creditBalanceTransaction: S.optional(
        S.NullOr(S.String).pipe(T.Body("credit_balance_transaction")),
      ),
      discount: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem",
  }) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem>;

export type BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsList =
  Array<BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem>;
export const BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsList =
  /*@__PURE__*/ S.Array(
    BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsItem,
  ) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsList>;

export interface BillingInvoicePreviewResponseInvoiceLinesItem {
  amount: number;
  currency: string;
  description: string;
  period: BillingInvoicePreviewResponseInvoiceLinesItemPeriod;
  pricing: BillingInvoicePreviewResponseInvoiceLinesItemPricing;
  quantity: number;
  pretaxCreditAmounts?: BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsList | null;
}
export const BillingInvoicePreviewResponseInvoiceLinesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      amount: S.Number,
      currency: S.String,
      description: S.String,
      period: BillingInvoicePreviewResponseInvoiceLinesItemPeriod,
      pricing: BillingInvoicePreviewResponseInvoiceLinesItemPricing,
      quantity: S.Number,
      pretaxCreditAmounts: S.optional(
        S.NullOr(
          BillingInvoicePreviewResponseInvoiceLinesItemPretaxCreditAmountsList,
        ).pipe(T.Body("pretax_credit_amounts")),
      ),
    }),
  ).annotate({
    identifier: "BillingInvoicePreviewResponseInvoiceLinesItem",
  }) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesItem>;

export type BillingInvoicePreviewResponseInvoiceLinesList =
  Array<BillingInvoicePreviewResponseInvoiceLinesItem>;
export const BillingInvoicePreviewResponseInvoiceLinesList =
  /*@__PURE__*/ S.Array(
    BillingInvoicePreviewResponseInvoiceLinesItem,
  ) as any as S.Schema<BillingInvoicePreviewResponseInvoiceLinesList>;

export type BillingInvoicePreviewResponseStatus =
  | "draft"
  | "open"
  | "paid"
  | "uncollectible"
  | "void";
export const BillingInvoicePreviewResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface InvoicePreviewBillingResponse {
  id: string;
  amountDue: number;
  amountPaid: number;
  amountRemaining: number;
  currency: string;
  invoiceLines: BillingInvoicePreviewResponseInvoiceLinesList;
  periodEnd: number;
  periodStart: number;
  status: BillingInvoicePreviewResponseStatus;
}
export const InvoicePreviewBillingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    amountDue: S.Number.pipe(T.Body("amount_due")),
    amountPaid: S.Number.pipe(T.Body("amount_paid")),
    amountRemaining: S.Number.pipe(T.Body("amount_remaining")),
    currency: S.String,
    invoiceLines: BillingInvoicePreviewResponseInvoiceLinesList.pipe(
      T.Body("invoice_lines"),
    ),
    periodEnd: S.Number.pipe(T.Body("period_end")),
    periodStart: S.Number.pipe(T.Body("period_start")),
    status: BillingInvoicePreviewResponseStatus,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "InvoicePreviewBillingResponse",
}) as any as S.Schema<InvoicePreviewBillingResponse>;

export interface ListAiGatewaysRequest {
  accountId: string;
  page?: number;
  perPage?: number;
  /** Search by id */
  search?: string;
}
export const ListAiGatewaysRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAiGatewaysRequest",
}) as any as S.Schema<ListAiGatewaysRequest>;

export type ListResultItemDlpCase0Action = "BLOCK" | "FLAG";
export const ListResultItemDlpCase0Action = /*@__PURE__*/ S.String;

export type ListResultItemDlpCase0ProfilesList = Array<string>;
export const ListResultItemDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<ListResultItemDlpCase0ProfilesList>;

export interface ListResultItemDlpCase0 {
  action: ListResultItemDlpCase0Action;
  enabled: boolean;
  profiles: ListResultItemDlpCase0ProfilesList;
}
export const ListResultItemDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: ListResultItemDlpCase0Action,
    enabled: S.Boolean,
    profiles: ListResultItemDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "ListResultItemDlpCase0",
}) as any as S.Schema<ListResultItemDlpCase0>;

export type ListResultItemDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const ListResultItemDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type ListResultItemDlpCase1PoliciesItemCheckItem =
  | "REQUEST"
  | "RESPONSE";
export const ListResultItemDlpCase1PoliciesItemCheckItem =
  /*@__PURE__*/ S.String;

export type ListResultItemDlpCase1PoliciesItemCheckList =
  Array<ListResultItemDlpCase1PoliciesItemCheckItem>;
export const ListResultItemDlpCase1PoliciesItemCheckList =
  /*@__PURE__*/ S.Array(
    ListResultItemDlpCase1PoliciesItemCheckItem,
  ) as any as S.Schema<ListResultItemDlpCase1PoliciesItemCheckList>;

export type ListResultItemDlpCase1PoliciesItemProfilesList = Array<string>;
export const ListResultItemDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ListResultItemDlpCase1PoliciesItemProfilesList>;

export interface ListResultItemDlpCase1PoliciesItem {
  id: string;
  action: ListResultItemDlpCase1PoliciesItemAction;
  check: ListResultItemDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: ListResultItemDlpCase1PoliciesItemProfilesList;
}
export const ListResultItemDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: ListResultItemDlpCase1PoliciesItemAction,
    check: ListResultItemDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: ListResultItemDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "ListResultItemDlpCase1PoliciesItem",
}) as any as S.Schema<ListResultItemDlpCase1PoliciesItem>;

export type ListResultItemDlpCase1PoliciesList =
  Array<ListResultItemDlpCase1PoliciesItem>;
export const ListResultItemDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  ListResultItemDlpCase1PoliciesItem,
) as any as S.Schema<ListResultItemDlpCase1PoliciesList>;

export interface ListResultItemDlpCase1 {
  enabled: boolean;
  policies: ListResultItemDlpCase1PoliciesList;
}
export const ListResultItemDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: ListResultItemDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "ListResultItemDlpCase1",
}) as any as S.Schema<ListResultItemDlpCase1>;

export type ListResultItemDlp = ListResultItemDlpCase0 | ListResultItemDlpCase1;
export const ListResultItemDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type ListResultItemGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface ListResultItemGuardrailsPrompt {
  p1?: ListResultItemGuardrailsPromptP1 | null;
  s1?: ListResultItemGuardrailsPromptS1 | null;
  s10?: ListResultItemGuardrailsPromptS10 | null;
  s11?: ListResultItemGuardrailsPromptS11 | null;
  s12?: ListResultItemGuardrailsPromptS12 | null;
  s13?: ListResultItemGuardrailsPromptS13 | null;
  s2?: ListResultItemGuardrailsPromptS2 | null;
  s3?: ListResultItemGuardrailsPromptS3 | null;
  s4?: ListResultItemGuardrailsPromptS4 | null;
  s5?: ListResultItemGuardrailsPromptS5 | null;
  s6?: ListResultItemGuardrailsPromptS6 | null;
  s7?: ListResultItemGuardrailsPromptS7 | null;
  s8?: ListResultItemGuardrailsPromptS8 | null;
  s9?: ListResultItemGuardrailsPromptS9 | null;
}
export const ListResultItemGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(ListResultItemGuardrailsPromptS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "ListResultItemGuardrailsPrompt",
}) as any as S.Schema<ListResultItemGuardrailsPrompt>;

export type ListResultItemGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type ListResultItemGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const ListResultItemGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface ListResultItemGuardrailsResponse {
  p1?: ListResultItemGuardrailsResponseP1 | null;
  s1?: ListResultItemGuardrailsResponseS1 | null;
  s10?: ListResultItemGuardrailsResponseS10 | null;
  s11?: ListResultItemGuardrailsResponseS11 | null;
  s12?: ListResultItemGuardrailsResponseS12 | null;
  s13?: ListResultItemGuardrailsResponseS13 | null;
  s2?: ListResultItemGuardrailsResponseS2 | null;
  s3?: ListResultItemGuardrailsResponseS3 | null;
  s4?: ListResultItemGuardrailsResponseS4 | null;
  s5?: ListResultItemGuardrailsResponseS5 | null;
  s6?: ListResultItemGuardrailsResponseS6 | null;
  s7?: ListResultItemGuardrailsResponseS7 | null;
  s8?: ListResultItemGuardrailsResponseS8 | null;
  s9?: ListResultItemGuardrailsResponseS9 | null;
}
export const ListResultItemGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(ListResultItemGuardrailsResponseS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "ListResultItemGuardrailsResponse",
}) as any as S.Schema<ListResultItemGuardrailsResponse>;

export interface ListResultItemGuardrails {
  prompt: ListResultItemGuardrailsPrompt;
  response: ListResultItemGuardrailsResponse;
}
export const ListResultItemGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: ListResultItemGuardrailsPrompt,
    response: ListResultItemGuardrailsResponse,
  }),
).annotate({
  identifier: "ListResultItemGuardrails",
}) as any as S.Schema<ListResultItemGuardrails>;

export type ListResultItemLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const ListResultItemLogManagementStrategy = /*@__PURE__*/ S.String;

export type ListResultItemOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const ListResultItemOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<ListResultItemOtelItemHeadersMap>;

export type ListResultItemOtelItemContentType = "json" | "protobuf";
export const ListResultItemOtelItemContentType = /*@__PURE__*/ S.String;

export interface ListResultItemOtelItem {
  headers: ListResultItemOtelItemHeadersMap;
  url: string;
  authorization?: string | null;
  contentType?: ListResultItemOtelItemContentType | null;
}
export const ListResultItemOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: ListResultItemOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.NullOr(S.String)),
    contentType: S.optional(
      S.NullOr(ListResultItemOtelItemContentType).pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "ListResultItemOtelItem",
}) as any as S.Schema<ListResultItemOtelItem>;

export type ListResultItemOtelList = Array<ListResultItemOtelItem>;
export const ListResultItemOtelList = /*@__PURE__*/ S.Array(
  ListResultItemOtelItem,
) as any as S.Schema<ListResultItemOtelList>;

export type ListResultItemRateLimitingTechnique = "fixed" | "sliding";
export const ListResultItemRateLimitingTechnique = /*@__PURE__*/ S.String;

export type ListResultItemRetryBackoff = "constant" | "linear" | "exponential";
export const ListResultItemRetryBackoff = /*@__PURE__*/ S.String;

export type ListResultItemSpendLimitsRulesItemLimitType = "cost";
export const ListResultItemSpendLimitsRulesItemLimitType =
  /*@__PURE__*/ S.String;

export type ListResultItemSpendLimitsRulesItemModelMode = "filter";
export const ListResultItemSpendLimitsRulesItemModelMode =
  /*@__PURE__*/ S.String;

export type ListResultItemSpendLimitsRulesItemModelValuesList = Array<string>;
export const ListResultItemSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ListResultItemSpendLimitsRulesItemModelValuesList>;

export interface ListResultItemSpendLimitsRulesItemModel {
  mode: ListResultItemSpendLimitsRulesItemModelMode;
  values: ListResultItemSpendLimitsRulesItemModelValuesList;
}
export const ListResultItemSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: ListResultItemSpendLimitsRulesItemModelMode,
      values: ListResultItemSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "ListResultItemSpendLimitsRulesItemModel",
}) as any as S.Schema<ListResultItemSpendLimitsRulesItemModel>;

export type ListResultItemSpendLimitsRulesItemProviderMode = "filter";
export const ListResultItemSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type ListResultItemSpendLimitsRulesItemProviderValuesList =
  Array<string>;
export const ListResultItemSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<ListResultItemSpendLimitsRulesItemProviderValuesList>;

export interface ListResultItemSpendLimitsRulesItemProvider {
  mode: ListResultItemSpendLimitsRulesItemProviderMode;
  values: ListResultItemSpendLimitsRulesItemProviderValuesList;
}
export const ListResultItemSpendLimitsRulesItemProvider =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mode: ListResultItemSpendLimitsRulesItemProviderMode,
      values: ListResultItemSpendLimitsRulesItemProviderValuesList,
    }),
  ).annotate({
    identifier: "ListResultItemSpendLimitsRulesItemProvider",
  }) as any as S.Schema<ListResultItemSpendLimitsRulesItemProvider>;

export type ListResultItemSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const ListResultItemSpendLimitsRulesItemTechnique =
  /*@__PURE__*/ S.String;

export interface ListResultItemSpendLimitsRulesItem {
  limit: number;
  limitType: ListResultItemSpendLimitsRulesItemLimitType;
  window: number;
  id?: string | null;
  enabled?: boolean | null;
  metadata?: UntypedMetadataMap | null;
  model?: ListResultItemSpendLimitsRulesItemModel | null;
  provider?: ListResultItemSpendLimitsRulesItemProvider | null;
  technique?: ListResultItemSpendLimitsRulesItemTechnique | null;
}
export const ListResultItemSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: ListResultItemSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    metadata: S.optional(S.NullOr(UntypedMetadataMap)),
    model: S.optional(S.NullOr(ListResultItemSpendLimitsRulesItemModel)),
    provider: S.optional(S.NullOr(ListResultItemSpendLimitsRulesItemProvider)),
    technique: S.optional(
      S.NullOr(ListResultItemSpendLimitsRulesItemTechnique),
    ),
  }),
).annotate({
  identifier: "ListResultItemSpendLimitsRulesItem",
}) as any as S.Schema<ListResultItemSpendLimitsRulesItem>;

export type ListResultItemSpendLimitsRulesList =
  Array<ListResultItemSpendLimitsRulesItem>;
export const ListResultItemSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  ListResultItemSpendLimitsRulesItem,
) as any as S.Schema<ListResultItemSpendLimitsRulesList>;

export interface ListResultItemSpendLimits {
  enabled?: boolean | null;
  rules?: ListResultItemSpendLimitsRulesList | null;
}
export const ListResultItemSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.NullOr(S.Boolean)),
    rules: S.optional(S.NullOr(ListResultItemSpendLimitsRulesList)),
  }),
).annotate({
  identifier: "ListResultItemSpendLimits",
}) as any as S.Schema<ListResultItemSpendLimits>;

export type ListResultItemStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;
export const ListResultItemStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;

export type ListResultItemStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const ListResultItemStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<ListResultItemStripeUsageEventsList>;

export interface ListResultItemStripe {
  authorization: string;
  usageEvents: ListResultItemStripeUsageEventsList;
}
export const ListResultItemStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: ListResultItemStripeUsageEventsList.pipe(
      T.Body("usage_events"),
    ),
  }),
).annotate({
  identifier: "ListResultItemStripe",
}) as any as S.Schema<ListResultItemStripe>;

export type ListResultItemWorkersAiBillingMode = "postpaid";
export const ListResultItemWorkersAiBillingMode = /*@__PURE__*/ S.String;

export interface ListResultItem {
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number;
  collectLogs: boolean;
  createdAt: string;
  modifiedAt: string;
  rateLimitingInterval: number;
  rateLimitingLimit: number;
  authentication?: boolean | null;
  dlp?: ListResultItemDlp | null;
  guardrails?: ListResultItemGuardrails | null;
  isDefault?: boolean | null;
  logManagement?: number | null;
  logManagementStrategy?: ListResultItemLogManagementStrategy | null;
  logpush?: boolean | null;
  logpushPublicKey?: string | null;
  otel?: ListResultItemOtelList | null;
  rateLimitingTechnique?: ListResultItemRateLimitingTechnique | null;
  /** Backoff strategy for retry delays */
  retryBackoff?: ListResultItemRetryBackoff | null;
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number | null;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number | null;
  spendLimits?: ListResultItemSpendLimits | null;
  storeId?: string | null;
  stripe?: ListResultItemStripe | null;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: ListResultItemWorkersAiBillingMode | null;
  zdr?: boolean | null;
}
export const ListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.Number.pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    rateLimitingInterval: S.Number.pipe(T.Body("rate_limiting_interval")),
    rateLimitingLimit: S.Number.pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.NullOr(S.Boolean)),
    dlp: S.optional(S.NullOr(ListResultItemDlp)),
    guardrails: S.optional(S.NullOr(ListResultItemGuardrails)),
    isDefault: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_default"))),
    logManagement: S.optional(
      S.NullOr(S.Number).pipe(T.Body("log_management")),
    ),
    logManagementStrategy: S.optional(
      S.NullOr(ListResultItemLogManagementStrategy).pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.NullOr(S.Boolean)),
    logpushPublicKey: S.optional(
      S.NullOr(S.String).pipe(T.Body("logpush_public_key")),
    ),
    otel: S.optional(S.NullOr(ListResultItemOtelList)),
    rateLimitingTechnique: S.optional(
      S.NullOr(ListResultItemRateLimitingTechnique).pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      S.NullOr(ListResultItemRetryBackoff).pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(
      S.NullOr(S.Number).pipe(T.Body("retry_max_attempts")),
    ),
    spendLimits: S.optional(
      S.NullOr(ListResultItemSpendLimits).pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.NullOr(S.String).pipe(T.Body("store_id"))),
    stripe: S.optional(S.NullOr(ListResultItemStripe)),
    workersAiBillingMode: S.optional(
      S.NullOr(ListResultItemWorkersAiBillingMode).pipe(
        T.Body("workers_ai_billing_mode"),
      ),
    ),
    zdr: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({ identifier: "ListResultItem" }) as any as S.Schema<ListResultItem>;

export type ListResultList = Array<ListResultItem>;
export const ListResultList = /*@__PURE__*/ S.Array(
  ListResultItem,
) as any as S.Schema<ListResultList>;

export interface ListAiGatewaysResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListAiGatewaysResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAiGatewaysResponse",
}) as any as S.Schema<ListAiGatewaysResponse>;

export interface ListCustomProvidersRequest {
  accountId: string;
  beta?: boolean;
  enable?: boolean;
  page?: number;
  perPage?: number;
  /** Search by id, name, slug */
  search?: string;
}
export const ListCustomProvidersRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    beta: S.optional(S.Boolean.pipe(T.Query())),
    enable: S.optional(S.Boolean.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/custom-providers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListCustomProvidersRequest",
}) as any as S.Schema<ListCustomProvidersRequest>;

export interface CustomProvidersListResultItem {
  id: string;
  baseUrl: string;
  createdAt: string;
  modifiedAt: string;
  name: string;
  slug: string;
  beta?: boolean | null;
  curlExample?: string | null;
  description?: string | null;
  enable?: boolean | null;
  headers?: string | null;
  jsExample?: string | null;
  link?: string | null;
  logo?: string | null;
  position?: number | null;
}
export const CustomProvidersListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    baseUrl: S.String.pipe(T.Body("base_url")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    slug: S.String,
    beta: S.optional(S.NullOr(S.Boolean)),
    curlExample: S.optional(S.NullOr(S.String).pipe(T.Body("curl_example"))),
    description: S.optional(S.NullOr(S.String)),
    enable: S.optional(S.NullOr(S.Boolean)),
    headers: S.optional(S.NullOr(S.String)),
    jsExample: S.optional(S.NullOr(S.String).pipe(T.Body("js_example"))),
    link: S.optional(S.NullOr(S.String)),
    logo: S.optional(S.NullOr(S.String)),
    position: S.optional(S.NullOr(S.Number)),
  }),
).annotate({
  identifier: "CustomProvidersListResultItem",
}) as any as S.Schema<CustomProvidersListResultItem>;

export type CustomProvidersListResultList =
  Array<CustomProvidersListResultItem>;
export const CustomProvidersListResultList = /*@__PURE__*/ S.Array(
  CustomProvidersListResultItem,
) as any as S.Schema<CustomProvidersListResultList>;

export interface ListCustomProvidersResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: CustomProvidersListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListCustomProvidersResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: CustomProvidersListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListCustomProvidersResponse",
}) as any as S.Schema<ListCustomProvidersResponse>;

export interface ListDatasetsRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  enable?: boolean;
  name?: string;
  page?: number;
  perPage?: number;
  /** Search by id, name, filters */
  search?: string;
}
export const ListDatasetsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    enable: S.optional(S.Boolean.pipe(T.Query())),
    name: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/datasets",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDatasetsRequest",
}) as any as S.Schema<ListDatasetsRequest>;

export type DatasetsListResultItemFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsListResultItemFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsListResultItemFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsListResultItemFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsListResultItemFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsListResultItemFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsListResultItemFiltersItemValueList =
  Array<DatasetsListResultItemFiltersItemValueItem>;
export const DatasetsListResultItemFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsListResultItemFiltersItemValueItem,
) as any as S.Schema<DatasetsListResultItemFiltersItemValueList>;

export interface DatasetsListResultItemFiltersItem {
  key: DatasetsListResultItemFiltersItemKey;
  operator: DatasetsListResultItemFiltersItemOperator;
  value: DatasetsListResultItemFiltersItemValueList;
}
export const DatasetsListResultItemFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsListResultItemFiltersItemKey,
    operator: DatasetsListResultItemFiltersItemOperator,
    value: DatasetsListResultItemFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsListResultItemFiltersItem",
}) as any as S.Schema<DatasetsListResultItemFiltersItem>;

export type DatasetsListResultItemFiltersList =
  Array<DatasetsListResultItemFiltersItem>;
export const DatasetsListResultItemFiltersList = /*@__PURE__*/ S.Array(
  DatasetsListResultItemFiltersItem,
) as any as S.Schema<DatasetsListResultItemFiltersList>;

export interface DatasetsListResultItem {
  id: string;
  createdAt: string;
  enable: boolean;
  filters: DatasetsListResultItemFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const DatasetsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: DatasetsListResultItemFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }),
).annotate({
  identifier: "DatasetsListResultItem",
}) as any as S.Schema<DatasetsListResultItem>;

export type DatasetsListResultList = Array<DatasetsListResultItem>;
export const DatasetsListResultList = /*@__PURE__*/ S.Array(
  DatasetsListResultItem,
) as any as S.Schema<DatasetsListResultList>;

export interface ListDatasetsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: DatasetsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListDatasetsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: DatasetsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDatasetsResponse",
}) as any as S.Schema<ListDatasetsResponse>;

export interface ListDeploymentsDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
}
export const ListDeploymentsDynamicRoutingRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      gatewayId: S.String.pipe(T.Label("gateway_id")),
      id: S.String.pipe(T.Label()),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}/deployments",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDeploymentsDynamicRoutingRequest",
}) as any as S.Schema<ListDeploymentsDynamicRoutingRequest>;

export type DynamicRoutingListDeploymentsResponseDataDeploymentsItem =
  DynamicRoutingCreateResponseDeployment;
export const DynamicRoutingListDeploymentsResponseDataDeploymentsItem =
  DynamicRoutingCreateResponseDeployment;

export type DynamicRoutingListDeploymentsResponseDataDeploymentsList =
  Array<DynamicRoutingCreateResponseDeployment>;
export const DynamicRoutingListDeploymentsResponseDataDeploymentsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingCreateResponseDeployment,
  ) as any as S.Schema<DynamicRoutingListDeploymentsResponseDataDeploymentsList>;

export interface DynamicRoutingListDeploymentsResponseData {
  deployments: DynamicRoutingListDeploymentsResponseDataDeploymentsList;
  orderBy: string;
  orderByDirection: string;
  page: number;
  perPage: number;
}
export const DynamicRoutingListDeploymentsResponseData =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      deployments: DynamicRoutingListDeploymentsResponseDataDeploymentsList,
      orderBy: S.String.pipe(T.Body("order_by")),
      orderByDirection: S.String.pipe(T.Body("order_by_direction")),
      page: S.Number,
      perPage: S.Number.pipe(T.Body("per_page")),
    }),
  ).annotate({
    identifier: "DynamicRoutingListDeploymentsResponseData",
  }) as any as S.Schema<DynamicRoutingListDeploymentsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListDeploymentsDynamicRoutingResponse {
  data: DynamicRoutingListDeploymentsResponseData;
}
export const ListDeploymentsDynamicRoutingResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: DynamicRoutingListDeploymentsResponseData,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDeploymentsDynamicRoutingResponse",
}) as any as S.Schema<ListDeploymentsDynamicRoutingResponse>;

export interface ListDynamicRoutingsRequest {
  accountId: string;
  gatewayId: string;
  /** Page number */
  page?: number;
  /** Number of routes per page */
  perPage?: number;
}
export const ListDynamicRoutingsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDynamicRoutingsRequest",
}) as any as S.Schema<ListDynamicRoutingsRequest>;

export type DynamicRoutingListResponseDataRoutesItemDeployment =
  DynamicRoutingCreateResponseDeployment;
export const DynamicRoutingListResponseDataRoutesItemDeployment =
  DynamicRoutingCreateResponseDeployment;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase0Type =
  "start";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase0Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase0>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase1Type =
  "conditional";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase1Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase1>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase2OutputsMap =
  { [key: string]: unknown | undefined };
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase2OutputsMap>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase2Type =
  "percentage";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingListResponseDataRoutesItemElementsItemCase2OutputsMap;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase2Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs:
        DynamicRoutingListResponseDataRoutesItemElementsItemCase2OutputsMap,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase2>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingListResponseDataRoutesItemElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingListResponseDataRoutesItemElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier:
      "DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase3Type =
  "rate";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase3Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingListResponseDataRoutesItemElementsItemCase3Properties,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase3>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase4Type =
  "model";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase4Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase4>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase5OutputsMap =
  { [key: string]: unknown | undefined };
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase5OutputsMap>;

export type DynamicRoutingListResponseDataRoutesItemElementsItemCase5Type =
  "end";
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingListResponseDataRoutesItemElementsItemCase5OutputsMap;
  type: DynamicRoutingListResponseDataRoutesItemElementsItemCase5Type;
}
export const DynamicRoutingListResponseDataRoutesItemElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs:
        DynamicRoutingListResponseDataRoutesItemElementsItemCase5OutputsMap,
      type: DynamicRoutingListResponseDataRoutesItemElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsItemCase5>;

export type DynamicRoutingListResponseDataRoutesItemElementsItem =
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase0
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase1
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase2
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase3
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase4
  | DynamicRoutingListResponseDataRoutesItemElementsItemCase5;
export const DynamicRoutingListResponseDataRoutesItemElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingListResponseDataRoutesItemElementsList =
  Array<DynamicRoutingListResponseDataRoutesItemElementsItem>;
export const DynamicRoutingListResponseDataRoutesItemElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingListResponseDataRoutesItemElementsItem,
  ) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemElementsList>;

export type DynamicRoutingListResponseDataRoutesItemVersionActive =
  | "true"
  | "false";
export const DynamicRoutingListResponseDataRoutesItemVersionActive =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListResponseDataRoutesItemVersion {
  active: DynamicRoutingListResponseDataRoutesItemVersionActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  versionId: string;
  isValid?: boolean | null;
}
export const DynamicRoutingListResponseDataRoutesItemVersion =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      active: DynamicRoutingListResponseDataRoutesItemVersionActive,
      createdAt: S.String.pipe(T.Body("created_at")),
      data: DynamicRoutingCreateRequestElementsList,
      versionId: S.String.pipe(T.Body("version_id")),
      isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
    }),
  ).annotate({
    identifier: "DynamicRoutingListResponseDataRoutesItemVersion",
  }) as any as S.Schema<DynamicRoutingListResponseDataRoutesItemVersion>;

export interface DynamicRoutingListResponseDataRoutesItem {
  id: string;
  accountTag: string;
  createdAt: string;
  deployment: DynamicRoutingCreateResponseDeployment;
  elements: DynamicRoutingListResponseDataRoutesItemElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  version: DynamicRoutingListResponseDataRoutesItemVersion;
}
export const DynamicRoutingListResponseDataRoutesItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accountTag: S.String.pipe(T.Body("account_tag")),
      createdAt: S.String.pipe(T.Body("created_at")),
      deployment: DynamicRoutingCreateResponseDeployment,
      elements: DynamicRoutingListResponseDataRoutesItemElementsList,
      gatewayId: S.String.pipe(T.Body("gateway_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      name: S.String,
      version: DynamicRoutingListResponseDataRoutesItemVersion,
    }),
).annotate({
  identifier: "DynamicRoutingListResponseDataRoutesItem",
}) as any as S.Schema<DynamicRoutingListResponseDataRoutesItem>;

export type DynamicRoutingListResponseDataRoutesList =
  Array<DynamicRoutingListResponseDataRoutesItem>;
export const DynamicRoutingListResponseDataRoutesList = /*@__PURE__*/ S.Array(
  DynamicRoutingListResponseDataRoutesItem,
) as any as S.Schema<DynamicRoutingListResponseDataRoutesList>;

export interface DynamicRoutingListResponseData {
  orderBy: string;
  orderByDirection: string;
  page: number;
  perPage: number;
  routes: DynamicRoutingListResponseDataRoutesList;
}
export const DynamicRoutingListResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    orderBy: S.String.pipe(T.Body("order_by")),
    orderByDirection: S.String.pipe(T.Body("order_by_direction")),
    page: S.Number,
    perPage: S.Number.pipe(T.Body("per_page")),
    routes: DynamicRoutingListResponseDataRoutesList,
  }),
).annotate({
  identifier: "DynamicRoutingListResponseData",
}) as any as S.Schema<DynamicRoutingListResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListDynamicRoutingsResponse {
  data: DynamicRoutingListResponseData;
}
export const ListDynamicRoutingsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: DynamicRoutingListResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDynamicRoutingsResponse",
}) as any as S.Schema<ListDynamicRoutingsResponse>;

export interface ListEvaluationsRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  name?: string;
  page?: number;
  perPage?: number;
  processed?: boolean;
  /** Search by id, name */
  search?: string;
}
export const ListEvaluationsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    name: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    processed: S.optional(S.Boolean.pipe(T.Query())),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/evaluations",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListEvaluationsRequest",
}) as any as S.Schema<ListEvaluationsRequest>;

export type EvaluationsListResultItemDatasetsItemFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const EvaluationsListResultItemDatasetsItemFiltersItemKey =
  /*@__PURE__*/ S.String;

export type EvaluationsListResultItemDatasetsItemFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const EvaluationsListResultItemDatasetsItemFiltersItemOperator =
  /*@__PURE__*/ S.String;

export type EvaluationsListResultItemDatasetsItemFiltersItemValueItem =
  | string
  | number
  | boolean;
export const EvaluationsListResultItemDatasetsItemFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type EvaluationsListResultItemDatasetsItemFiltersItemValueList =
  Array<EvaluationsListResultItemDatasetsItemFiltersItemValueItem>;
export const EvaluationsListResultItemDatasetsItemFiltersItemValueList =
  /*@__PURE__*/ S.Array(
    EvaluationsListResultItemDatasetsItemFiltersItemValueItem,
  ) as any as S.Schema<EvaluationsListResultItemDatasetsItemFiltersItemValueList>;

export interface EvaluationsListResultItemDatasetsItemFiltersItem {
  key: EvaluationsListResultItemDatasetsItemFiltersItemKey;
  operator: EvaluationsListResultItemDatasetsItemFiltersItemOperator;
  value: EvaluationsListResultItemDatasetsItemFiltersItemValueList;
}
export const EvaluationsListResultItemDatasetsItemFiltersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: EvaluationsListResultItemDatasetsItemFiltersItemKey,
      operator: EvaluationsListResultItemDatasetsItemFiltersItemOperator,
      value: EvaluationsListResultItemDatasetsItemFiltersItemValueList,
    }),
  ).annotate({
    identifier: "EvaluationsListResultItemDatasetsItemFiltersItem",
  }) as any as S.Schema<EvaluationsListResultItemDatasetsItemFiltersItem>;

export type EvaluationsListResultItemDatasetsItemFiltersList =
  Array<EvaluationsListResultItemDatasetsItemFiltersItem>;
export const EvaluationsListResultItemDatasetsItemFiltersList =
  /*@__PURE__*/ S.Array(
    EvaluationsListResultItemDatasetsItemFiltersItem,
  ) as any as S.Schema<EvaluationsListResultItemDatasetsItemFiltersList>;

export interface EvaluationsListResultItemDatasetsItem {
  id: string;
  accountId: string;
  accountTag: string;
  createdAt: string;
  enable: boolean;
  filters: EvaluationsListResultItemDatasetsItemFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const EvaluationsListResultItemDatasetsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accountId: S.String.pipe(T.Body("account_id")),
      accountTag: S.String.pipe(T.Body("account_tag")),
      createdAt: S.String.pipe(T.Body("created_at")),
      enable: S.Boolean,
      filters: EvaluationsListResultItemDatasetsItemFiltersList,
      gatewayId: S.String.pipe(T.Body("gateway_id")),
      modifiedAt: S.String.pipe(T.Body("modified_at")),
      name: S.String,
    }),
).annotate({
  identifier: "EvaluationsListResultItemDatasetsItem",
}) as any as S.Schema<EvaluationsListResultItemDatasetsItem>;

export type EvaluationsListResultItemDatasetsList =
  Array<EvaluationsListResultItemDatasetsItem>;
export const EvaluationsListResultItemDatasetsList = /*@__PURE__*/ S.Array(
  EvaluationsListResultItemDatasetsItem,
) as any as S.Schema<EvaluationsListResultItemDatasetsList>;

export type EvaluationsListResultItemResultsItem =
  EvaluationsCreateResponseResultsItem;
export const EvaluationsListResultItemResultsItem =
  EvaluationsCreateResponseResultsItem;

export type EvaluationsListResultItemResultsList =
  Array<EvaluationsCreateResponseResultsItem>;
export const EvaluationsListResultItemResultsList = /*@__PURE__*/ S.Array(
  EvaluationsCreateResponseResultsItem,
) as any as S.Schema<EvaluationsListResultItemResultsList>;

export interface EvaluationsListResultItem {
  id: string;
  createdAt: string;
  datasets: EvaluationsListResultItemDatasetsList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
  processed: boolean;
  results: EvaluationsListResultItemResultsList;
  totalLogs: number;
}
export const EvaluationsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    datasets: EvaluationsListResultItemDatasetsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    processed: S.Boolean,
    results: EvaluationsListResultItemResultsList,
    totalLogs: S.Number.pipe(T.Body("total_logs")),
  }),
).annotate({
  identifier: "EvaluationsListResultItem",
}) as any as S.Schema<EvaluationsListResultItem>;

export type EvaluationsListResultList = Array<EvaluationsListResultItem>;
export const EvaluationsListResultList = /*@__PURE__*/ S.Array(
  EvaluationsListResultItem,
) as any as S.Schema<EvaluationsListResultList>;

export interface ListEvaluationsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: EvaluationsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListEvaluationsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: EvaluationsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListEvaluationsResponse",
}) as any as S.Schema<ListEvaluationsResponse>;

export type EvaluationTypesListRequestOrderByDirection = "asc" | "desc";
export const EvaluationTypesListRequestOrderByDirection =
  /*@__PURE__*/ S.String;

export interface ListEvaluationTypesRequest {
  accountId: string;
  orderBy?: string;
  orderByDirection?: EvaluationTypesListRequestOrderByDirection | (string & {});
  page?: number;
  perPage?: number;
}
export const ListEvaluationTypesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    orderBy: S.optional(S.String.pipe(T.Query("order_by"))),
    orderByDirection: S.optional(
      EvaluationTypesListRequestOrderByDirection.pipe(
        T.Query("order_by_direction"),
      ),
    ),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/evaluation-types",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListEvaluationTypesRequest",
}) as any as S.Schema<ListEvaluationTypesRequest>;

export interface EvaluationTypesListResultItem {
  id: string;
  createdAt: string;
  description: string;
  enable: boolean;
  mandatory: boolean;
  modifiedAt: string;
  name: string;
  type: string;
}
export const EvaluationTypesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    description: S.String,
    enable: S.Boolean,
    mandatory: S.Boolean,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    type: S.String,
  }),
).annotate({
  identifier: "EvaluationTypesListResultItem",
}) as any as S.Schema<EvaluationTypesListResultItem>;

export type EvaluationTypesListResultList =
  Array<EvaluationTypesListResultItem>;
export const EvaluationTypesListResultList = /*@__PURE__*/ S.Array(
  EvaluationTypesListResultItem,
) as any as S.Schema<EvaluationTypesListResultList>;

export interface ListEvaluationTypesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: EvaluationTypesListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListEvaluationTypesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: EvaluationTypesListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListEvaluationTypesResponse",
}) as any as S.Schema<ListEvaluationTypesResponse>;

export type LogsListRequestDirection = "asc" | "desc";
export const LogsListRequestDirection = /*@__PURE__*/ S.String;

export type LogsListRequestFiltersList = Array<string>;
export const LogsListRequestFiltersList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<LogsListRequestFiltersList>;

export type LogsListRequestOrderBy =
  | "created_at"
  | "provider"
  | "model"
  | "model_type"
  | "success"
  | "cached";
export const LogsListRequestOrderBy = /*@__PURE__*/ S.String;

export type LogsListRequestOrderByDirection = "asc" | "desc";
export const LogsListRequestOrderByDirection = /*@__PURE__*/ S.String;

export interface ListLogsRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  cached?: boolean;
  direction?: LogsListRequestDirection | (string & {});
  endDate?: string;
  feedback?: string;
  filters?: LogsListRequestFiltersList;
  maxCost?: number;
  maxDuration?: number;
  maxTokensIn?: number;
  maxTokensOut?: number;
  maxTotalTokens?: number;
  metaInfo?: boolean;
  minCost?: number;
  minDuration?: number;
  minTokensIn?: number;
  minTokensOut?: number;
  minTotalTokens?: number;
  model?: string;
  modelType?: string;
  orderBy?: LogsListRequestOrderBy | (string & {});
  orderByDirection?: LogsListRequestOrderByDirection | (string & {});
  page?: number;
  perPage?: number;
  provider?: string;
  requestContentType?: string;
  responseContentType?: string;
  search?: string;
  startDate?: string;
  success?: boolean;
}
export const ListLogsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    cached: S.optional(S.Boolean.pipe(T.Query())),
    direction: S.optional(LogsListRequestDirection.pipe(T.Query())),
    endDate: S.optional(S.String.pipe(T.Query("end_date"))),
    feedback: S.optional(S.String.pipe(T.Query())),
    filters: S.optional(LogsListRequestFiltersList.pipe(T.Query())),
    maxCost: S.optional(S.Number.pipe(T.Query("max_cost"))),
    maxDuration: S.optional(S.Number.pipe(T.Query("max_duration"))),
    maxTokensIn: S.optional(S.Number.pipe(T.Query("max_tokens_in"))),
    maxTokensOut: S.optional(S.Number.pipe(T.Query("max_tokens_out"))),
    maxTotalTokens: S.optional(S.Number.pipe(T.Query("max_total_tokens"))),
    metaInfo: S.optional(S.Boolean.pipe(T.Query("meta_info"))),
    minCost: S.optional(S.Number.pipe(T.Query("min_cost"))),
    minDuration: S.optional(S.Number.pipe(T.Query("min_duration"))),
    minTokensIn: S.optional(S.Number.pipe(T.Query("min_tokens_in"))),
    minTokensOut: S.optional(S.Number.pipe(T.Query("min_tokens_out"))),
    minTotalTokens: S.optional(S.Number.pipe(T.Query("min_total_tokens"))),
    model: S.optional(S.String.pipe(T.Query())),
    modelType: S.optional(S.String.pipe(T.Query("model_type"))),
    orderBy: S.optional(LogsListRequestOrderBy.pipe(T.Query("order_by"))),
    orderByDirection: S.optional(
      LogsListRequestOrderByDirection.pipe(T.Query("order_by_direction")),
    ),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    provider: S.optional(S.String.pipe(T.Query())),
    requestContentType: S.optional(
      S.String.pipe(T.Query("request_content_type")),
    ),
    responseContentType: S.optional(
      S.String.pipe(T.Query("response_content_type")),
    ),
    search: S.optional(S.String.pipe(T.Query())),
    startDate: S.optional(S.String.pipe(T.Query("start_date"))),
    success: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListLogsRequest",
}) as any as S.Schema<ListLogsRequest>;

export interface LogsListResultItem {
  id: string;
  cached: boolean;
  createdAt: string;
  duration: number;
  model: string;
  path: string;
  provider: string;
  success: boolean;
  tokensIn: number;
  tokensOut: number;
  cost?: number | null;
  customCost?: boolean | null;
  metadata?: string | null;
  modelType?: string | null;
  requestContentType?: string | null;
  requestType?: string | null;
  responseContentType?: string | null;
  statusCode?: number | null;
  step?: number | null;
}
export const LogsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cached: S.Boolean,
    createdAt: S.String.pipe(T.Body("created_at")),
    duration: S.Number,
    model: S.String,
    path: S.String,
    provider: S.String,
    success: S.Boolean,
    tokensIn: S.Number.pipe(T.Body("tokens_in")),
    tokensOut: S.Number.pipe(T.Body("tokens_out")),
    cost: S.optional(S.NullOr(S.Number)),
    customCost: S.optional(S.NullOr(S.Boolean).pipe(T.Body("custom_cost"))),
    metadata: S.optional(S.NullOr(S.String)),
    modelType: S.optional(S.NullOr(S.String).pipe(T.Body("model_type"))),
    requestContentType: S.optional(
      S.NullOr(S.String).pipe(T.Body("request_content_type")),
    ),
    requestType: S.optional(S.NullOr(S.String).pipe(T.Body("request_type"))),
    responseContentType: S.optional(
      S.NullOr(S.String).pipe(T.Body("response_content_type")),
    ),
    statusCode: S.optional(S.NullOr(S.Number).pipe(T.Body("status_code"))),
    step: S.optional(S.NullOr(S.Number)),
  }),
).annotate({
  identifier: "LogsListResultItem",
}) as any as S.Schema<LogsListResultItem>;

export type LogsListResultList = Array<LogsListResultItem>;
export const LogsListResultList = /*@__PURE__*/ S.Array(
  LogsListResultItem,
) as any as S.Schema<LogsListResultList>;

export interface ListLogsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: LogsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListLogsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: LogsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListLogsResponse",
}) as any as S.Schema<ListLogsResponse>;

export interface ListProviderConfigsRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  page?: number;
  perPage?: number;
}
export const ListProviderConfigsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/provider_configs",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListProviderConfigsRequest",
}) as any as S.Schema<ListProviderConfigsRequest>;

export interface ProviderConfigsListResultItem {
  id: string;
  alias: string;
  defaultConfig: boolean;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  providerSlug: string;
  secretId: string;
  secretPreview: string;
  rateLimit?: number | null;
  rateLimitPeriod?: number | null;
}
export const ProviderConfigsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    alias: S.String,
    defaultConfig: S.Boolean.pipe(T.Body("default_config")),
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    providerSlug: S.String.pipe(T.Body("provider_slug")),
    secretId: S.String.pipe(T.Body("secret_id")),
    secretPreview: S.String.pipe(T.Body("secret_preview")),
    rateLimit: S.optional(S.NullOr(S.Number).pipe(T.Body("rate_limit"))),
    rateLimitPeriod: S.optional(
      S.NullOr(S.Number).pipe(T.Body("rate_limit_period")),
    ),
  }),
).annotate({
  identifier: "ProviderConfigsListResultItem",
}) as any as S.Schema<ProviderConfigsListResultItem>;

export type ProviderConfigsListResultList =
  Array<ProviderConfigsListResultItem>;
export const ProviderConfigsListResultList = /*@__PURE__*/ S.Array(
  ProviderConfigsListResultItem,
) as any as S.Schema<ProviderConfigsListResultList>;

export interface ListProviderConfigsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ProviderConfigsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListProviderConfigsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ProviderConfigsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListProviderConfigsResponse",
}) as any as S.Schema<ListProviderConfigsResponse>;

export interface ListVersionsDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
}
export const ListVersionsDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}/versions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListVersionsDynamicRoutingRequest",
}) as any as S.Schema<ListVersionsDynamicRoutingRequest>;

export type DynamicRoutingListVersionsResponseDataVersionsItemActive =
  | "true"
  | "false";
export const DynamicRoutingListVersionsResponseDataVersionsItemActive =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingListVersionsResponseDataVersionsItem {
  active: DynamicRoutingListVersionsResponseDataVersionsItemActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  versionId: string;
  isValid?: boolean | null;
}
export const DynamicRoutingListVersionsResponseDataVersionsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      active: DynamicRoutingListVersionsResponseDataVersionsItemActive,
      createdAt: S.String.pipe(T.Body("created_at")),
      data: DynamicRoutingCreateRequestElementsList,
      versionId: S.String.pipe(T.Body("version_id")),
      isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
    }),
  ).annotate({
    identifier: "DynamicRoutingListVersionsResponseDataVersionsItem",
  }) as any as S.Schema<DynamicRoutingListVersionsResponseDataVersionsItem>;

export type DynamicRoutingListVersionsResponseDataVersionsList =
  Array<DynamicRoutingListVersionsResponseDataVersionsItem>;
export const DynamicRoutingListVersionsResponseDataVersionsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingListVersionsResponseDataVersionsItem,
  ) as any as S.Schema<DynamicRoutingListVersionsResponseDataVersionsList>;

export interface DynamicRoutingListVersionsResponseData {
  orderBy: string;
  orderByDirection: string;
  page: number;
  perPage: number;
  versions: DynamicRoutingListVersionsResponseDataVersionsList;
}
export const DynamicRoutingListVersionsResponseData = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      orderBy: S.String.pipe(T.Body("order_by")),
      orderByDirection: S.String.pipe(T.Body("order_by_direction")),
      page: S.Number,
      perPage: S.Number.pipe(T.Body("per_page")),
      versions: DynamicRoutingListVersionsResponseDataVersionsList,
    }),
).annotate({
  identifier: "DynamicRoutingListVersionsResponseData",
}) as any as S.Schema<DynamicRoutingListVersionsResponseData>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListVersionsDynamicRoutingResponse {
  data: DynamicRoutingListVersionsResponseData;
}
export const ListVersionsDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: DynamicRoutingListVersionsResponseData,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListVersionsDynamicRoutingResponse",
}) as any as S.Schema<ListVersionsDynamicRoutingResponse>;

export interface PatchDynamicRoutingRequest {
  accountId: string;
  gatewayId: string;
  id: string;
  name: string;
}
export const PatchDynamicRoutingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/routes/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchDynamicRoutingRequest",
}) as any as S.Schema<PatchDynamicRoutingRequest>;

export type DynamicRoutingUpdateResponseRouteDeployment =
  DynamicRoutingCreateResponseDeployment;
export const DynamicRoutingUpdateResponseRouteDeployment =
  DynamicRoutingCreateResponseDeployment;

export type DynamicRoutingUpdateResponseRouteElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase0OutputsNext =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
export const DynamicRoutingUpdateResponseRouteElementsItemCase0Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;

export type DynamicRoutingUpdateResponseRouteElementsItemCase0Type = "start";
export const DynamicRoutingUpdateResponseRouteElementsItemCase0Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase0 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase0Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase0 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase0Outputs,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase0Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase0",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase0>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase1OutputsFalse =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase1OutputsTrue =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
export const DynamicRoutingUpdateResponseRouteElementsItemCase1Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;

export type DynamicRoutingUpdateResponseRouteElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
export const DynamicRoutingUpdateResponseRouteElementsItemCase1Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;

export type DynamicRoutingUpdateResponseRouteElementsItemCase1Type =
  "conditional";
export const DynamicRoutingUpdateResponseRouteElementsItemCase1Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase1 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase1Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase1 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase1Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase1Properties,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase1Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase1",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase1>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase2OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingUpdateResponseRouteElementsItemCase2OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase2OutputsMap>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase2Type =
  "percentage";
export const DynamicRoutingUpdateResponseRouteElementsItemCase2Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase2 {
  id: string;
  outputs: DynamicRoutingUpdateResponseRouteElementsItemCase2OutputsMap;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase2Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingUpdateResponseRouteElementsItemCase2OutputsMap,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase2Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase2",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase2>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase3OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase3OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingUpdateResponseRouteElementsItemCase3Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingUpdateResponseRouteElementsItemCase3PropertiesLimitType =
  | "count"
  | "cost";
export const DynamicRoutingUpdateResponseRouteElementsItemCase3PropertiesLimitType =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase3Properties {
  key: string;
  limit: number;
  limitType: DynamicRoutingUpdateResponseRouteElementsItemCase3PropertiesLimitType;
  window: number;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase3Properties =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      limit: S.Number,
      limitType:
        DynamicRoutingUpdateResponseRouteElementsItemCase3PropertiesLimitType,
      window: S.Number,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase3Properties",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase3Properties>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase3Type = "rate";
export const DynamicRoutingUpdateResponseRouteElementsItemCase3Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase3 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingUpdateResponseRouteElementsItemCase3Properties;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase3Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase3 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties: DynamicRoutingUpdateResponseRouteElementsItemCase3Properties,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase3Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase3",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase3>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase4OutputsFallback =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;
export const DynamicRoutingUpdateResponseRouteElementsItemCase4OutputsSuccess =
  DynamicRoutingCreateDeploymentResponseElementsItemCase0OutputsNext;

export type DynamicRoutingUpdateResponseRouteElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
export const DynamicRoutingUpdateResponseRouteElementsItemCase4Outputs =
  DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;

export type DynamicRoutingUpdateResponseRouteElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
export const DynamicRoutingUpdateResponseRouteElementsItemCase4Properties =
  DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;

export type DynamicRoutingUpdateResponseRouteElementsItemCase4Type = "model";
export const DynamicRoutingUpdateResponseRouteElementsItemCase4Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase4 {
  id: string;
  outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs;
  properties: DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase4Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase4 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingCreateDeploymentResponseElementsItemCase3Outputs,
      properties:
        DynamicRoutingCreateDeploymentResponseElementsItemCase4Properties,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase4Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase4",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase4>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase5OutputsMap = {
  [key: string]: unknown | undefined;
};
export const DynamicRoutingUpdateResponseRouteElementsItemCase5OutputsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase5OutputsMap>;

export type DynamicRoutingUpdateResponseRouteElementsItemCase5Type = "end";
export const DynamicRoutingUpdateResponseRouteElementsItemCase5Type =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteElementsItemCase5 {
  id: string;
  outputs: DynamicRoutingUpdateResponseRouteElementsItemCase5OutputsMap;
  type: DynamicRoutingUpdateResponseRouteElementsItemCase5Type;
}
export const DynamicRoutingUpdateResponseRouteElementsItemCase5 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      outputs: DynamicRoutingUpdateResponseRouteElementsItemCase5OutputsMap,
      type: DynamicRoutingUpdateResponseRouteElementsItemCase5Type,
    }),
  ).annotate({
    identifier: "DynamicRoutingUpdateResponseRouteElementsItemCase5",
  }) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsItemCase5>;

export type DynamicRoutingUpdateResponseRouteElementsItem =
  | DynamicRoutingUpdateResponseRouteElementsItemCase0
  | DynamicRoutingUpdateResponseRouteElementsItemCase1
  | DynamicRoutingUpdateResponseRouteElementsItemCase2
  | DynamicRoutingUpdateResponseRouteElementsItemCase3
  | DynamicRoutingUpdateResponseRouteElementsItemCase4
  | DynamicRoutingUpdateResponseRouteElementsItemCase5;
export const DynamicRoutingUpdateResponseRouteElementsItem =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "properties", "type"],
      ["id", "outputs", "type"],
    ]),
  );

export type DynamicRoutingUpdateResponseRouteElementsList =
  Array<DynamicRoutingUpdateResponseRouteElementsItem>;
export const DynamicRoutingUpdateResponseRouteElementsList =
  /*@__PURE__*/ S.Array(
    DynamicRoutingUpdateResponseRouteElementsItem,
  ) as any as S.Schema<DynamicRoutingUpdateResponseRouteElementsList>;

export type DynamicRoutingUpdateResponseRouteVersionActive = "true" | "false";
export const DynamicRoutingUpdateResponseRouteVersionActive =
  /*@__PURE__*/ S.String;

export interface DynamicRoutingUpdateResponseRouteVersion {
  active: DynamicRoutingUpdateResponseRouteVersionActive;
  createdAt: string;
  data: DynamicRoutingCreateRequestElementsList;
  versionId: string;
  isValid?: boolean | null;
}
export const DynamicRoutingUpdateResponseRouteVersion = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      active: DynamicRoutingUpdateResponseRouteVersionActive,
      createdAt: S.String.pipe(T.Body("created_at")),
      data: DynamicRoutingCreateRequestElementsList,
      versionId: S.String.pipe(T.Body("version_id")),
      isValid: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_valid"))),
    }),
).annotate({
  identifier: "DynamicRoutingUpdateResponseRouteVersion",
}) as any as S.Schema<DynamicRoutingUpdateResponseRouteVersion>;

export interface DynamicRoutingUpdateResponseRoute {
  id: string;
  accountTag: string;
  createdAt: string;
  deployment: DynamicRoutingCreateResponseDeployment;
  elements: DynamicRoutingUpdateResponseRouteElementsList;
  gatewayId: string;
  modifiedAt: string;
  name: string;
  version: DynamicRoutingUpdateResponseRouteVersion;
}
export const DynamicRoutingUpdateResponseRoute = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountTag: S.String.pipe(T.Body("account_tag")),
    createdAt: S.String.pipe(T.Body("created_at")),
    deployment: DynamicRoutingCreateResponseDeployment,
    elements: DynamicRoutingUpdateResponseRouteElementsList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: DynamicRoutingUpdateResponseRouteVersion,
  }),
).annotate({
  identifier: "DynamicRoutingUpdateResponseRoute",
}) as any as S.Schema<DynamicRoutingUpdateResponseRoute>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PatchDynamicRoutingResponse {
  route: DynamicRoutingUpdateResponseRoute;
}
export const PatchDynamicRoutingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    route: DynamicRoutingUpdateResponseRoute,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchDynamicRoutingResponse",
}) as any as S.Schema<PatchDynamicRoutingResponse>;

export type LogsEditRequestMetadata = string | number | boolean;
export const LogsEditRequestMetadata = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], [], []]),
);

export interface PatchLogRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
  feedback?: number;
  metadata?: LogsEditRequestMetadata;
  score?: number;
}
export const PatchLogRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
    feedback: S.optional(S.Number),
    metadata: S.optional(LogsEditRequestMetadata),
    score: S.optional(S.Number),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchLogRequest",
}) as any as S.Schema<PatchLogRequest>;

export type PatchLogResponse = unknown;
export const PatchLogResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchLogResponse",
}) as any as S.Schema<PatchLogResponse>;

export interface RequestLogRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const RequestLogRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}/request",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RequestLogRequest",
}) as any as S.Schema<RequestLogRequest>;

export interface RequestLogResponse {}
export const RequestLogResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RequestLogResponse",
}) as any as S.Schema<RequestLogResponse>;

export interface ResponseLogRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
}
export const ResponseLogRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}/response",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ResponseLogRequest",
}) as any as S.Schema<ResponseLogRequest>;

export interface ResponseLogResponse {}
export const ResponseLogResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ResponseLogResponse",
}) as any as S.Schema<ResponseLogResponse>;

export interface StatusBillingTopupRequest {
  accountId: string;
  /** Stripe invoice ID to check status for. */
  paymentIntentId: string;
}
export const StatusBillingTopupRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    paymentIntentId: S.String.pipe(T.Body("payment_intent_id")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/ai-gateway/billing/topup/status",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusBillingTopupRequest",
}) as any as S.Schema<StatusBillingTopupRequest>;

export type BillingTopupStatusResponseStatus = "completed" | "pending";
export const BillingTopupStatusResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface StatusBillingTopupResponse {
  paymentIntentId: string;
  status: BillingTopupStatusResponseStatus;
}
export const StatusBillingTopupResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    paymentIntentId: S.String.pipe(T.Body("payment_intent_id")),
    status: BillingTopupStatusResponseStatus,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusBillingTopupResponse",
}) as any as S.Schema<StatusBillingTopupResponse>;

export type UpdateRequestDlpCase0Action = "BLOCK" | "FLAG";
export const UpdateRequestDlpCase0Action = /*@__PURE__*/ S.String;

export type UpdateRequestDlpCase0ProfilesList = Array<string>;
export const UpdateRequestDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<UpdateRequestDlpCase0ProfilesList>;

export interface UpdateRequestDlpCase0 {
  action: UpdateRequestDlpCase0Action | (string & {});
  enabled: boolean;
  profiles: UpdateRequestDlpCase0ProfilesList;
}
export const UpdateRequestDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: UpdateRequestDlpCase0Action,
    enabled: S.Boolean,
    profiles: UpdateRequestDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "UpdateRequestDlpCase0",
}) as any as S.Schema<UpdateRequestDlpCase0>;

export type UpdateRequestDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const UpdateRequestDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type UpdateRequestDlpCase1PoliciesItemCheckItem = "REQUEST" | "RESPONSE";
export const UpdateRequestDlpCase1PoliciesItemCheckItem =
  /*@__PURE__*/ S.String;

export type UpdateRequestDlpCase1PoliciesItemCheckList = Array<
  UpdateRequestDlpCase1PoliciesItemCheckItem | (string & {})
>;
export const UpdateRequestDlpCase1PoliciesItemCheckList = /*@__PURE__*/ S.Array(
  UpdateRequestDlpCase1PoliciesItemCheckItem,
) as any as S.Schema<UpdateRequestDlpCase1PoliciesItemCheckList>;

export type UpdateRequestDlpCase1PoliciesItemProfilesList = Array<string>;
export const UpdateRequestDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateRequestDlpCase1PoliciesItemProfilesList>;

export interface UpdateRequestDlpCase1PoliciesItem {
  id: string;
  action: UpdateRequestDlpCase1PoliciesItemAction | (string & {});
  check: UpdateRequestDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: UpdateRequestDlpCase1PoliciesItemProfilesList;
}
export const UpdateRequestDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: UpdateRequestDlpCase1PoliciesItemAction,
    check: UpdateRequestDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: UpdateRequestDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "UpdateRequestDlpCase1PoliciesItem",
}) as any as S.Schema<UpdateRequestDlpCase1PoliciesItem>;

export type UpdateRequestDlpCase1PoliciesList =
  Array<UpdateRequestDlpCase1PoliciesItem>;
export const UpdateRequestDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  UpdateRequestDlpCase1PoliciesItem,
) as any as S.Schema<UpdateRequestDlpCase1PoliciesList>;

export interface UpdateRequestDlpCase1 {
  enabled: boolean;
  policies: UpdateRequestDlpCase1PoliciesList;
}
export const UpdateRequestDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: UpdateRequestDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "UpdateRequestDlpCase1",
}) as any as S.Schema<UpdateRequestDlpCase1>;

export type UpdateRequestDlp = UpdateRequestDlpCase0 | UpdateRequestDlpCase1;
export const UpdateRequestDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type UpdateRequestGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface UpdateRequestGuardrailsPrompt {
  p1?: UpdateRequestGuardrailsPromptP1 | (string & {});
  s1?: UpdateRequestGuardrailsPromptS1 | (string & {});
  s10?: UpdateRequestGuardrailsPromptS10 | (string & {});
  s11?: UpdateRequestGuardrailsPromptS11 | (string & {});
  s12?: UpdateRequestGuardrailsPromptS12 | (string & {});
  s13?: UpdateRequestGuardrailsPromptS13 | (string & {});
  s2?: UpdateRequestGuardrailsPromptS2 | (string & {});
  s3?: UpdateRequestGuardrailsPromptS3 | (string & {});
  s4?: UpdateRequestGuardrailsPromptS4 | (string & {});
  s5?: UpdateRequestGuardrailsPromptS5 | (string & {});
  s6?: UpdateRequestGuardrailsPromptS6 | (string & {});
  s7?: UpdateRequestGuardrailsPromptS7 | (string & {});
  s8?: UpdateRequestGuardrailsPromptS8 | (string & {});
  s9?: UpdateRequestGuardrailsPromptS9 | (string & {});
}
export const UpdateRequestGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(UpdateRequestGuardrailsPromptP1.pipe(T.Body("P1"))),
    s1: S.optional(UpdateRequestGuardrailsPromptS1.pipe(T.Body("S1"))),
    s10: S.optional(UpdateRequestGuardrailsPromptS10.pipe(T.Body("S10"))),
    s11: S.optional(UpdateRequestGuardrailsPromptS11.pipe(T.Body("S11"))),
    s12: S.optional(UpdateRequestGuardrailsPromptS12.pipe(T.Body("S12"))),
    s13: S.optional(UpdateRequestGuardrailsPromptS13.pipe(T.Body("S13"))),
    s2: S.optional(UpdateRequestGuardrailsPromptS2.pipe(T.Body("S2"))),
    s3: S.optional(UpdateRequestGuardrailsPromptS3.pipe(T.Body("S3"))),
    s4: S.optional(UpdateRequestGuardrailsPromptS4.pipe(T.Body("S4"))),
    s5: S.optional(UpdateRequestGuardrailsPromptS5.pipe(T.Body("S5"))),
    s6: S.optional(UpdateRequestGuardrailsPromptS6.pipe(T.Body("S6"))),
    s7: S.optional(UpdateRequestGuardrailsPromptS7.pipe(T.Body("S7"))),
    s8: S.optional(UpdateRequestGuardrailsPromptS8.pipe(T.Body("S8"))),
    s9: S.optional(UpdateRequestGuardrailsPromptS9.pipe(T.Body("S9"))),
  }),
).annotate({
  identifier: "UpdateRequestGuardrailsPrompt",
}) as any as S.Schema<UpdateRequestGuardrailsPrompt>;

export type UpdateRequestGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type UpdateRequestGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const UpdateRequestGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface UpdateRequestGuardrailsResponse {
  p1?: UpdateRequestGuardrailsResponseP1 | (string & {});
  s1?: UpdateRequestGuardrailsResponseS1 | (string & {});
  s10?: UpdateRequestGuardrailsResponseS10 | (string & {});
  s11?: UpdateRequestGuardrailsResponseS11 | (string & {});
  s12?: UpdateRequestGuardrailsResponseS12 | (string & {});
  s13?: UpdateRequestGuardrailsResponseS13 | (string & {});
  s2?: UpdateRequestGuardrailsResponseS2 | (string & {});
  s3?: UpdateRequestGuardrailsResponseS3 | (string & {});
  s4?: UpdateRequestGuardrailsResponseS4 | (string & {});
  s5?: UpdateRequestGuardrailsResponseS5 | (string & {});
  s6?: UpdateRequestGuardrailsResponseS6 | (string & {});
  s7?: UpdateRequestGuardrailsResponseS7 | (string & {});
  s8?: UpdateRequestGuardrailsResponseS8 | (string & {});
  s9?: UpdateRequestGuardrailsResponseS9 | (string & {});
}
export const UpdateRequestGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(UpdateRequestGuardrailsResponseP1.pipe(T.Body("P1"))),
    s1: S.optional(UpdateRequestGuardrailsResponseS1.pipe(T.Body("S1"))),
    s10: S.optional(UpdateRequestGuardrailsResponseS10.pipe(T.Body("S10"))),
    s11: S.optional(UpdateRequestGuardrailsResponseS11.pipe(T.Body("S11"))),
    s12: S.optional(UpdateRequestGuardrailsResponseS12.pipe(T.Body("S12"))),
    s13: S.optional(UpdateRequestGuardrailsResponseS13.pipe(T.Body("S13"))),
    s2: S.optional(UpdateRequestGuardrailsResponseS2.pipe(T.Body("S2"))),
    s3: S.optional(UpdateRequestGuardrailsResponseS3.pipe(T.Body("S3"))),
    s4: S.optional(UpdateRequestGuardrailsResponseS4.pipe(T.Body("S4"))),
    s5: S.optional(UpdateRequestGuardrailsResponseS5.pipe(T.Body("S5"))),
    s6: S.optional(UpdateRequestGuardrailsResponseS6.pipe(T.Body("S6"))),
    s7: S.optional(UpdateRequestGuardrailsResponseS7.pipe(T.Body("S7"))),
    s8: S.optional(UpdateRequestGuardrailsResponseS8.pipe(T.Body("S8"))),
    s9: S.optional(UpdateRequestGuardrailsResponseS9.pipe(T.Body("S9"))),
  }),
).annotate({
  identifier: "UpdateRequestGuardrailsResponse",
}) as any as S.Schema<UpdateRequestGuardrailsResponse>;

export interface UpdateRequestGuardrails {
  prompt: UpdateRequestGuardrailsPrompt;
  response: UpdateRequestGuardrailsResponse;
}
export const UpdateRequestGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: UpdateRequestGuardrailsPrompt,
    response: UpdateRequestGuardrailsResponse,
  }),
).annotate({
  identifier: "UpdateRequestGuardrails",
}) as any as S.Schema<UpdateRequestGuardrails>;

export type UpdateRequestLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const UpdateRequestLogManagementStrategy = /*@__PURE__*/ S.String;

export type UpdateRequestOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const UpdateRequestOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<UpdateRequestOtelItemHeadersMap>;

export type UpdateRequestOtelItemContentType = "json" | "protobuf";
export const UpdateRequestOtelItemContentType = /*@__PURE__*/ S.String;

export interface UpdateRequestOtelItem {
  headers: UpdateRequestOtelItemHeadersMap;
  url: string;
  authorization?: string;
  contentType?: UpdateRequestOtelItemContentType | (string & {});
}
export const UpdateRequestOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: UpdateRequestOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.String),
    contentType: S.optional(
      UpdateRequestOtelItemContentType.pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "UpdateRequestOtelItem",
}) as any as S.Schema<UpdateRequestOtelItem>;

export type UpdateRequestOtelList = Array<UpdateRequestOtelItem>;
export const UpdateRequestOtelList = /*@__PURE__*/ S.Array(
  UpdateRequestOtelItem,
) as any as S.Schema<UpdateRequestOtelList>;

export type UpdateRequestRateLimitingTechnique = "fixed" | "sliding";
export const UpdateRequestRateLimitingTechnique = /*@__PURE__*/ S.String;

export type UpdateRequestRetryBackoff = "constant" | "linear" | "exponential";
export const UpdateRequestRetryBackoff = /*@__PURE__*/ S.String;

export type UpdateRequestSpendLimitsRulesItemLimitType = "cost";
export const UpdateRequestSpendLimitsRulesItemLimitType =
  /*@__PURE__*/ S.String;

export type UpdateRequestSpendLimitsRulesItemModelMode = "filter";
export const UpdateRequestSpendLimitsRulesItemModelMode =
  /*@__PURE__*/ S.String;

export type UpdateRequestSpendLimitsRulesItemModelValuesList = Array<string>;
export const UpdateRequestSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateRequestSpendLimitsRulesItemModelValuesList>;

export interface UpdateRequestSpendLimitsRulesItemModel {
  mode: UpdateRequestSpendLimitsRulesItemModelMode | (string & {});
  values: UpdateRequestSpendLimitsRulesItemModelValuesList;
}
export const UpdateRequestSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: UpdateRequestSpendLimitsRulesItemModelMode,
      values: UpdateRequestSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "UpdateRequestSpendLimitsRulesItemModel",
}) as any as S.Schema<UpdateRequestSpendLimitsRulesItemModel>;

export type UpdateRequestSpendLimitsRulesItemProviderMode = "filter";
export const UpdateRequestSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type UpdateRequestSpendLimitsRulesItemProviderValuesList = Array<string>;
export const UpdateRequestSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateRequestSpendLimitsRulesItemProviderValuesList>;

export interface UpdateRequestSpendLimitsRulesItemProvider {
  mode: UpdateRequestSpendLimitsRulesItemProviderMode | (string & {});
  values: UpdateRequestSpendLimitsRulesItemProviderValuesList;
}
export const UpdateRequestSpendLimitsRulesItemProvider =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mode: UpdateRequestSpendLimitsRulesItemProviderMode,
      values: UpdateRequestSpendLimitsRulesItemProviderValuesList,
    }),
  ).annotate({
    identifier: "UpdateRequestSpendLimitsRulesItemProvider",
  }) as any as S.Schema<UpdateRequestSpendLimitsRulesItemProvider>;

export type UpdateRequestSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const UpdateRequestSpendLimitsRulesItemTechnique =
  /*@__PURE__*/ S.String;

export interface UpdateRequestSpendLimitsRulesItem {
  limit: number;
  limitType: UpdateRequestSpendLimitsRulesItemLimitType | (string & {});
  window: number;
  id?: string;
  enabled?: boolean;
  metadata?: UntypedMetadataMap;
  model?: UpdateRequestSpendLimitsRulesItemModel;
  provider?: UpdateRequestSpendLimitsRulesItemProvider;
  technique?: UpdateRequestSpendLimitsRulesItemTechnique | (string & {});
}
export const UpdateRequestSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: UpdateRequestSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.String),
    enabled: S.optional(S.Boolean),
    metadata: S.optional(UntypedMetadataMap),
    model: S.optional(UpdateRequestSpendLimitsRulesItemModel),
    provider: S.optional(UpdateRequestSpendLimitsRulesItemProvider),
    technique: S.optional(UpdateRequestSpendLimitsRulesItemTechnique),
  }),
).annotate({
  identifier: "UpdateRequestSpendLimitsRulesItem",
}) as any as S.Schema<UpdateRequestSpendLimitsRulesItem>;

export type UpdateRequestSpendLimitsRulesList =
  Array<UpdateRequestSpendLimitsRulesItem>;
export const UpdateRequestSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  UpdateRequestSpendLimitsRulesItem,
) as any as S.Schema<UpdateRequestSpendLimitsRulesList>;

export interface UpdateRequestSpendLimits {
  enabled?: boolean;
  rules?: UpdateRequestSpendLimitsRulesList;
}
export const UpdateRequestSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.Boolean),
    rules: S.optional(UpdateRequestSpendLimitsRulesList),
  }),
).annotate({
  identifier: "UpdateRequestSpendLimits",
}) as any as S.Schema<UpdateRequestSpendLimits>;

export type UpdateRequestStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;
export const UpdateRequestStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;

export type UpdateRequestStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const UpdateRequestStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<UpdateRequestStripeUsageEventsList>;

export interface UpdateRequestStripe {
  authorization: string;
  usageEvents: UpdateRequestStripeUsageEventsList;
}
export const UpdateRequestStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: UpdateRequestStripeUsageEventsList.pipe(
      T.Body("usage_events"),
    ),
  }),
).annotate({
  identifier: "UpdateRequestStripe",
}) as any as S.Schema<UpdateRequestStripe>;

export type UpdateRequestWorkersAiBillingMode = "postpaid";
export const UpdateRequestWorkersAiBillingMode = /*@__PURE__*/ S.String;

export interface UpdateAiGatewayRequest {
  accountId: string;
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number | null;
  collectLogs: boolean;
  rateLimitingInterval: number | null;
  rateLimitingLimit: number | null;
  authentication?: boolean;
  dlp?: UpdateRequestDlp;
  guardrails?: UpdateRequestGuardrails;
  logManagement?: number;
  logManagementStrategy?: UpdateRequestLogManagementStrategy | (string & {});
  logpush?: boolean;
  logpushPublicKey?: string;
  otel?: UpdateRequestOtelList;
  rateLimitingTechnique?: UpdateRequestRateLimitingTechnique | (string & {});
  /** Backoff strategy for retry delays */
  retryBackoff?: UpdateRequestRetryBackoff | (string & {});
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number;
  spendLimits?: UpdateRequestSpendLimits;
  storeId?: string;
  stripe?: UpdateRequestStripe;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: UpdateRequestWorkersAiBillingMode | (string & {});
  zdr?: boolean;
}
export const UpdateAiGatewayRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.NullOr(S.Number).pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    rateLimitingInterval: S.NullOr(S.Number).pipe(
      T.Body("rate_limiting_interval"),
    ),
    rateLimitingLimit: S.NullOr(S.Number).pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.Boolean),
    dlp: S.optional(UpdateRequestDlp),
    guardrails: S.optional(UpdateRequestGuardrails),
    logManagement: S.optional(S.Number.pipe(T.Body("log_management"))),
    logManagementStrategy: S.optional(
      UpdateRequestLogManagementStrategy.pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.Boolean),
    logpushPublicKey: S.optional(S.String.pipe(T.Body("logpush_public_key"))),
    otel: S.optional(UpdateRequestOtelList),
    rateLimitingTechnique: S.optional(
      UpdateRequestRateLimitingTechnique.pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      UpdateRequestRetryBackoff.pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.Number.pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(S.Number.pipe(T.Body("retry_max_attempts"))),
    spendLimits: S.optional(
      UpdateRequestSpendLimits.pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.String.pipe(T.Body("store_id"))),
    stripe: S.optional(UpdateRequestStripe),
    workersAiBillingMode: S.optional(
      UpdateRequestWorkersAiBillingMode.pipe(T.Body("workers_ai_billing_mode")),
    ),
    zdr: S.optional(S.Boolean),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAiGatewayRequest",
}) as any as S.Schema<UpdateAiGatewayRequest>;

export type UpdateResponseDlpCase0Action = "BLOCK" | "FLAG";
export const UpdateResponseDlpCase0Action = /*@__PURE__*/ S.String;

export type UpdateResponseDlpCase0ProfilesList = Array<string>;
export const UpdateResponseDlpCase0ProfilesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<UpdateResponseDlpCase0ProfilesList>;

export interface UpdateResponseDlpCase0 {
  action: UpdateResponseDlpCase0Action;
  enabled: boolean;
  profiles: UpdateResponseDlpCase0ProfilesList;
}
export const UpdateResponseDlpCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: UpdateResponseDlpCase0Action,
    enabled: S.Boolean,
    profiles: UpdateResponseDlpCase0ProfilesList,
  }),
).annotate({
  identifier: "UpdateResponseDlpCase0",
}) as any as S.Schema<UpdateResponseDlpCase0>;

export type UpdateResponseDlpCase1PoliciesItemAction = "FLAG" | "BLOCK";
export const UpdateResponseDlpCase1PoliciesItemAction = /*@__PURE__*/ S.String;

export type UpdateResponseDlpCase1PoliciesItemCheckItem =
  | "REQUEST"
  | "RESPONSE";
export const UpdateResponseDlpCase1PoliciesItemCheckItem =
  /*@__PURE__*/ S.String;

export type UpdateResponseDlpCase1PoliciesItemCheckList =
  Array<UpdateResponseDlpCase1PoliciesItemCheckItem>;
export const UpdateResponseDlpCase1PoliciesItemCheckList =
  /*@__PURE__*/ S.Array(
    UpdateResponseDlpCase1PoliciesItemCheckItem,
  ) as any as S.Schema<UpdateResponseDlpCase1PoliciesItemCheckList>;

export type UpdateResponseDlpCase1PoliciesItemProfilesList = Array<string>;
export const UpdateResponseDlpCase1PoliciesItemProfilesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateResponseDlpCase1PoliciesItemProfilesList>;

export interface UpdateResponseDlpCase1PoliciesItem {
  id: string;
  action: UpdateResponseDlpCase1PoliciesItemAction;
  check: UpdateResponseDlpCase1PoliciesItemCheckList;
  enabled: boolean;
  profiles: UpdateResponseDlpCase1PoliciesItemProfilesList;
}
export const UpdateResponseDlpCase1PoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: UpdateResponseDlpCase1PoliciesItemAction,
    check: UpdateResponseDlpCase1PoliciesItemCheckList,
    enabled: S.Boolean,
    profiles: UpdateResponseDlpCase1PoliciesItemProfilesList,
  }),
).annotate({
  identifier: "UpdateResponseDlpCase1PoliciesItem",
}) as any as S.Schema<UpdateResponseDlpCase1PoliciesItem>;

export type UpdateResponseDlpCase1PoliciesList =
  Array<UpdateResponseDlpCase1PoliciesItem>;
export const UpdateResponseDlpCase1PoliciesList = /*@__PURE__*/ S.Array(
  UpdateResponseDlpCase1PoliciesItem,
) as any as S.Schema<UpdateResponseDlpCase1PoliciesList>;

export interface UpdateResponseDlpCase1 {
  enabled: boolean;
  policies: UpdateResponseDlpCase1PoliciesList;
}
export const UpdateResponseDlpCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
    policies: UpdateResponseDlpCase1PoliciesList,
  }),
).annotate({
  identifier: "UpdateResponseDlpCase1",
}) as any as S.Schema<UpdateResponseDlpCase1>;

export type UpdateResponseDlp = UpdateResponseDlpCase0 | UpdateResponseDlpCase1;
export const UpdateResponseDlp = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["action", "enabled", "profiles"],
    ["enabled", "policies"],
  ]),
);

export type UpdateResponseGuardrailsPromptP1 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptP1 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS1 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS1 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS10 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS10 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS11 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS11 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS12 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS12 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS13 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS13 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS2 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS2 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS3 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS3 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS4 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS4 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS5 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS5 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS6 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS6 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS7 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS7 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS8 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS8 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsPromptS9 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsPromptS9 = /*@__PURE__*/ S.String;

export interface UpdateResponseGuardrailsPrompt {
  p1?: UpdateResponseGuardrailsPromptP1 | null;
  s1?: UpdateResponseGuardrailsPromptS1 | null;
  s10?: UpdateResponseGuardrailsPromptS10 | null;
  s11?: UpdateResponseGuardrailsPromptS11 | null;
  s12?: UpdateResponseGuardrailsPromptS12 | null;
  s13?: UpdateResponseGuardrailsPromptS13 | null;
  s2?: UpdateResponseGuardrailsPromptS2 | null;
  s3?: UpdateResponseGuardrailsPromptS3 | null;
  s4?: UpdateResponseGuardrailsPromptS4 | null;
  s5?: UpdateResponseGuardrailsPromptS5 | null;
  s6?: UpdateResponseGuardrailsPromptS6 | null;
  s7?: UpdateResponseGuardrailsPromptS7 | null;
  s8?: UpdateResponseGuardrailsPromptS8 | null;
  s9?: UpdateResponseGuardrailsPromptS9 | null;
}
export const UpdateResponseGuardrailsPrompt = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(UpdateResponseGuardrailsPromptS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "UpdateResponseGuardrailsPrompt",
}) as any as S.Schema<UpdateResponseGuardrailsPrompt>;

export type UpdateResponseGuardrailsResponseP1 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseP1 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS1 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS1 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS10 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS10 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS11 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS11 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS12 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS12 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS13 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS13 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS2 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS2 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS3 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS3 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS4 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS4 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS5 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS5 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS6 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS6 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS7 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS7 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS8 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS8 = /*@__PURE__*/ S.String;

export type UpdateResponseGuardrailsResponseS9 = "FLAG" | "BLOCK";
export const UpdateResponseGuardrailsResponseS9 = /*@__PURE__*/ S.String;

export interface UpdateResponseGuardrailsResponse {
  p1?: UpdateResponseGuardrailsResponseP1 | null;
  s1?: UpdateResponseGuardrailsResponseS1 | null;
  s10?: UpdateResponseGuardrailsResponseS10 | null;
  s11?: UpdateResponseGuardrailsResponseS11 | null;
  s12?: UpdateResponseGuardrailsResponseS12 | null;
  s13?: UpdateResponseGuardrailsResponseS13 | null;
  s2?: UpdateResponseGuardrailsResponseS2 | null;
  s3?: UpdateResponseGuardrailsResponseS3 | null;
  s4?: UpdateResponseGuardrailsResponseS4 | null;
  s5?: UpdateResponseGuardrailsResponseS5 | null;
  s6?: UpdateResponseGuardrailsResponseS6 | null;
  s7?: UpdateResponseGuardrailsResponseS7 | null;
  s8?: UpdateResponseGuardrailsResponseS8 | null;
  s9?: UpdateResponseGuardrailsResponseS9 | null;
}
export const UpdateResponseGuardrailsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    p1: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseP1).pipe(T.Body("P1")),
    ),
    s1: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS1).pipe(T.Body("S1")),
    ),
    s10: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS10).pipe(T.Body("S10")),
    ),
    s11: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS11).pipe(T.Body("S11")),
    ),
    s12: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS12).pipe(T.Body("S12")),
    ),
    s13: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS13).pipe(T.Body("S13")),
    ),
    s2: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS2).pipe(T.Body("S2")),
    ),
    s3: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS3).pipe(T.Body("S3")),
    ),
    s4: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS4).pipe(T.Body("S4")),
    ),
    s5: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS5).pipe(T.Body("S5")),
    ),
    s6: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS6).pipe(T.Body("S6")),
    ),
    s7: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS7).pipe(T.Body("S7")),
    ),
    s8: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS8).pipe(T.Body("S8")),
    ),
    s9: S.optional(
      S.NullOr(UpdateResponseGuardrailsResponseS9).pipe(T.Body("S9")),
    ),
  }),
).annotate({
  identifier: "UpdateResponseGuardrailsResponse",
}) as any as S.Schema<UpdateResponseGuardrailsResponse>;

export interface UpdateResponseGuardrails {
  prompt: UpdateResponseGuardrailsPrompt;
  response: UpdateResponseGuardrailsResponse;
}
export const UpdateResponseGuardrails = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    prompt: UpdateResponseGuardrailsPrompt,
    response: UpdateResponseGuardrailsResponse,
  }),
).annotate({
  identifier: "UpdateResponseGuardrails",
}) as any as S.Schema<UpdateResponseGuardrails>;

export type UpdateResponseLogManagementStrategy =
  | "STOP_INSERTING"
  | "DELETE_OLDEST";
export const UpdateResponseLogManagementStrategy = /*@__PURE__*/ S.String;

export type UpdateResponseOtelItemHeadersMap = {
  [key: string]: unknown | undefined;
};
export const UpdateResponseOtelItemHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<UpdateResponseOtelItemHeadersMap>;

export type UpdateResponseOtelItemContentType = "json" | "protobuf";
export const UpdateResponseOtelItemContentType = /*@__PURE__*/ S.String;

export interface UpdateResponseOtelItem {
  headers: UpdateResponseOtelItemHeadersMap;
  url: string;
  authorization?: string | null;
  contentType?: UpdateResponseOtelItemContentType | null;
}
export const UpdateResponseOtelItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    headers: UpdateResponseOtelItemHeadersMap,
    url: S.String,
    authorization: S.optional(S.NullOr(S.String)),
    contentType: S.optional(
      S.NullOr(UpdateResponseOtelItemContentType).pipe(T.Body("content_type")),
    ),
  }),
).annotate({
  identifier: "UpdateResponseOtelItem",
}) as any as S.Schema<UpdateResponseOtelItem>;

export type UpdateResponseOtelList = Array<UpdateResponseOtelItem>;
export const UpdateResponseOtelList = /*@__PURE__*/ S.Array(
  UpdateResponseOtelItem,
) as any as S.Schema<UpdateResponseOtelList>;

export type UpdateResponseRateLimitingTechnique = "fixed" | "sliding";
export const UpdateResponseRateLimitingTechnique = /*@__PURE__*/ S.String;

export type UpdateResponseRetryBackoff = "constant" | "linear" | "exponential";
export const UpdateResponseRetryBackoff = /*@__PURE__*/ S.String;

export type UpdateResponseSpendLimitsRulesItemLimitType = "cost";
export const UpdateResponseSpendLimitsRulesItemLimitType =
  /*@__PURE__*/ S.String;

export type UpdateResponseSpendLimitsRulesItemModelMode = "filter";
export const UpdateResponseSpendLimitsRulesItemModelMode =
  /*@__PURE__*/ S.String;

export type UpdateResponseSpendLimitsRulesItemModelValuesList = Array<string>;
export const UpdateResponseSpendLimitsRulesItemModelValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateResponseSpendLimitsRulesItemModelValuesList>;

export interface UpdateResponseSpendLimitsRulesItemModel {
  mode: UpdateResponseSpendLimitsRulesItemModelMode;
  values: UpdateResponseSpendLimitsRulesItemModelValuesList;
}
export const UpdateResponseSpendLimitsRulesItemModel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mode: UpdateResponseSpendLimitsRulesItemModelMode,
      values: UpdateResponseSpendLimitsRulesItemModelValuesList,
    }),
).annotate({
  identifier: "UpdateResponseSpendLimitsRulesItemModel",
}) as any as S.Schema<UpdateResponseSpendLimitsRulesItemModel>;

export type UpdateResponseSpendLimitsRulesItemProviderMode = "filter";
export const UpdateResponseSpendLimitsRulesItemProviderMode =
  /*@__PURE__*/ S.String;

export type UpdateResponseSpendLimitsRulesItemProviderValuesList =
  Array<string>;
export const UpdateResponseSpendLimitsRulesItemProviderValuesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<UpdateResponseSpendLimitsRulesItemProviderValuesList>;

export interface UpdateResponseSpendLimitsRulesItemProvider {
  mode: UpdateResponseSpendLimitsRulesItemProviderMode;
  values: UpdateResponseSpendLimitsRulesItemProviderValuesList;
}
export const UpdateResponseSpendLimitsRulesItemProvider =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mode: UpdateResponseSpendLimitsRulesItemProviderMode,
      values: UpdateResponseSpendLimitsRulesItemProviderValuesList,
    }),
  ).annotate({
    identifier: "UpdateResponseSpendLimitsRulesItemProvider",
  }) as any as S.Schema<UpdateResponseSpendLimitsRulesItemProvider>;

export type UpdateResponseSpendLimitsRulesItemTechnique = "fixed" | "sliding";
export const UpdateResponseSpendLimitsRulesItemTechnique =
  /*@__PURE__*/ S.String;

export interface UpdateResponseSpendLimitsRulesItem {
  limit: number;
  limitType: UpdateResponseSpendLimitsRulesItemLimitType;
  window: number;
  id?: string | null;
  enabled?: boolean | null;
  metadata?: UntypedMetadataMap | null;
  model?: UpdateResponseSpendLimitsRulesItemModel | null;
  provider?: UpdateResponseSpendLimitsRulesItemProvider | null;
  technique?: UpdateResponseSpendLimitsRulesItemTechnique | null;
}
export const UpdateResponseSpendLimitsRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    limit: S.Number,
    limitType: UpdateResponseSpendLimitsRulesItemLimitType,
    window: S.Number,
    id: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    metadata: S.optional(S.NullOr(UntypedMetadataMap)),
    model: S.optional(S.NullOr(UpdateResponseSpendLimitsRulesItemModel)),
    provider: S.optional(S.NullOr(UpdateResponseSpendLimitsRulesItemProvider)),
    technique: S.optional(
      S.NullOr(UpdateResponseSpendLimitsRulesItemTechnique),
    ),
  }),
).annotate({
  identifier: "UpdateResponseSpendLimitsRulesItem",
}) as any as S.Schema<UpdateResponseSpendLimitsRulesItem>;

export type UpdateResponseSpendLimitsRulesList =
  Array<UpdateResponseSpendLimitsRulesItem>;
export const UpdateResponseSpendLimitsRulesList = /*@__PURE__*/ S.Array(
  UpdateResponseSpendLimitsRulesItem,
) as any as S.Schema<UpdateResponseSpendLimitsRulesList>;

export interface UpdateResponseSpendLimits {
  enabled?: boolean | null;
  rules?: UpdateResponseSpendLimitsRulesList | null;
}
export const UpdateResponseSpendLimits = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.NullOr(S.Boolean)),
    rules: S.optional(S.NullOr(UpdateResponseSpendLimitsRulesList)),
  }),
).annotate({
  identifier: "UpdateResponseSpendLimits",
}) as any as S.Schema<UpdateResponseSpendLimits>;

export type UpdateResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;
export const UpdateResponseStripeUsageEventsItem =
  CreateResponseStripeUsageEventsItem;

export type UpdateResponseStripeUsageEventsList =
  Array<CreateResponseStripeUsageEventsItem>;
export const UpdateResponseStripeUsageEventsList = /*@__PURE__*/ S.Array(
  CreateResponseStripeUsageEventsItem,
) as any as S.Schema<UpdateResponseStripeUsageEventsList>;

export interface UpdateResponseStripe {
  authorization: string;
  usageEvents: UpdateResponseStripeUsageEventsList;
}
export const UpdateResponseStripe = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authorization: S.String,
    usageEvents: UpdateResponseStripeUsageEventsList.pipe(
      T.Body("usage_events"),
    ),
  }),
).annotate({
  identifier: "UpdateResponseStripe",
}) as any as S.Schema<UpdateResponseStripe>;

export type UpdateResponseWorkersAiBillingMode = "postpaid";
export const UpdateResponseWorkersAiBillingMode = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateAiGatewayResponse {
  /** gateway id */
  id: string;
  cacheInvalidateOnUpdate: boolean;
  cacheTtl: number;
  collectLogs: boolean;
  createdAt: string;
  modifiedAt: string;
  rateLimitingInterval: number;
  rateLimitingLimit: number;
  authentication?: boolean | null;
  dlp?: UpdateResponseDlp | null;
  guardrails?: UpdateResponseGuardrails | null;
  isDefault?: boolean | null;
  logManagement?: number | null;
  logManagementStrategy?: UpdateResponseLogManagementStrategy | null;
  logpush?: boolean | null;
  logpushPublicKey?: string | null;
  otel?: UpdateResponseOtelList | null;
  rateLimitingTechnique?: UpdateResponseRateLimitingTechnique | null;
  /** Backoff strategy for retry delays */
  retryBackoff?: UpdateResponseRetryBackoff | null;
  /** Delay between retry attempts in milliseconds (0-5000) */
  retryDelay?: number | null;
  /** Maximum number of retry attempts for failed requests (1-5) */
  retryMaxAttempts?: number | null;
  spendLimits?: UpdateResponseSpendLimits | null;
  storeId?: string | null;
  stripe?: UpdateResponseStripe | null;
  /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
  workersAiBillingMode?: UpdateResponseWorkersAiBillingMode | null;
  zdr?: boolean | null;
}
export const UpdateAiGatewayResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    cacheInvalidateOnUpdate: S.Boolean.pipe(
      T.Body("cache_invalidate_on_update"),
    ),
    cacheTtl: S.Number.pipe(T.Body("cache_ttl")),
    collectLogs: S.Boolean.pipe(T.Body("collect_logs")),
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    rateLimitingInterval: S.Number.pipe(T.Body("rate_limiting_interval")),
    rateLimitingLimit: S.Number.pipe(T.Body("rate_limiting_limit")),
    authentication: S.optional(S.NullOr(S.Boolean)),
    dlp: S.optional(S.NullOr(UpdateResponseDlp)),
    guardrails: S.optional(S.NullOr(UpdateResponseGuardrails)),
    isDefault: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_default"))),
    logManagement: S.optional(
      S.NullOr(S.Number).pipe(T.Body("log_management")),
    ),
    logManagementStrategy: S.optional(
      S.NullOr(UpdateResponseLogManagementStrategy).pipe(
        T.Body("log_management_strategy"),
      ),
    ),
    logpush: S.optional(S.NullOr(S.Boolean)),
    logpushPublicKey: S.optional(
      S.NullOr(S.String).pipe(T.Body("logpush_public_key")),
    ),
    otel: S.optional(S.NullOr(UpdateResponseOtelList)),
    rateLimitingTechnique: S.optional(
      S.NullOr(UpdateResponseRateLimitingTechnique).pipe(
        T.Body("rate_limiting_technique"),
      ),
    ),
    retryBackoff: S.optional(
      S.NullOr(UpdateResponseRetryBackoff).pipe(T.Body("retry_backoff")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
    retryMaxAttempts: S.optional(
      S.NullOr(S.Number).pipe(T.Body("retry_max_attempts")),
    ),
    spendLimits: S.optional(
      S.NullOr(UpdateResponseSpendLimits).pipe(T.Body("spend_limits")),
    ),
    storeId: S.optional(S.NullOr(S.String).pipe(T.Body("store_id"))),
    stripe: S.optional(S.NullOr(UpdateResponseStripe)),
    workersAiBillingMode: S.optional(
      S.NullOr(UpdateResponseWorkersAiBillingMode).pipe(
        T.Body("workers_ai_billing_mode"),
      ),
    ),
    zdr: S.optional(S.NullOr(S.Boolean)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAiGatewayResponse",
}) as any as S.Schema<UpdateAiGatewayResponse>;

export type DatasetsUpdateRequestFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsUpdateRequestFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsUpdateRequestFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsUpdateRequestFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsUpdateRequestFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsUpdateRequestFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsUpdateRequestFiltersItemValueList =
  Array<DatasetsUpdateRequestFiltersItemValueItem>;
export const DatasetsUpdateRequestFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsUpdateRequestFiltersItemValueItem,
) as any as S.Schema<DatasetsUpdateRequestFiltersItemValueList>;

export interface DatasetsUpdateRequestFiltersItem {
  key: DatasetsUpdateRequestFiltersItemKey | (string & {});
  operator: DatasetsUpdateRequestFiltersItemOperator | (string & {});
  value: DatasetsUpdateRequestFiltersItemValueList;
}
export const DatasetsUpdateRequestFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsUpdateRequestFiltersItemKey,
    operator: DatasetsUpdateRequestFiltersItemOperator,
    value: DatasetsUpdateRequestFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsUpdateRequestFiltersItem",
}) as any as S.Schema<DatasetsUpdateRequestFiltersItem>;

export type DatasetsUpdateRequestFiltersList =
  Array<DatasetsUpdateRequestFiltersItem>;
export const DatasetsUpdateRequestFiltersList = /*@__PURE__*/ S.Array(
  DatasetsUpdateRequestFiltersItem,
) as any as S.Schema<DatasetsUpdateRequestFiltersList>;

export interface UpdateDatasetRequest {
  accountId: string;
  /** gateway id */
  gatewayId: string;
  id: string;
  enable: boolean;
  filters: DatasetsUpdateRequestFiltersList;
  name: string;
}
export const UpdateDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    gatewayId: S.String.pipe(T.Label("gateway_id")),
    id: S.String.pipe(T.Label()),
    enable: S.Boolean,
    filters: DatasetsUpdateRequestFiltersList,
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/datasets/{id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateDatasetRequest",
}) as any as S.Schema<UpdateDatasetRequest>;

export type DatasetsUpdateResponseFiltersItemKey =
  | "created_at"
  | "request_content_type"
  | "response_content_type"
  | "success"
  | "cached"
  | "provider"
  | "model"
  | "cost"
  | "tokens"
  | "tokens_in"
  | "tokens_out"
  | "duration"
  | "feedback";
export const DatasetsUpdateResponseFiltersItemKey = /*@__PURE__*/ S.String;

export type DatasetsUpdateResponseFiltersItemOperator =
  | "eq"
  | "contains"
  | "lt"
  | "gt";
export const DatasetsUpdateResponseFiltersItemOperator = /*@__PURE__*/ S.String;

export type DatasetsUpdateResponseFiltersItemValueItem =
  | string
  | number
  | boolean;
export const DatasetsUpdateResponseFiltersItemValueItem =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export type DatasetsUpdateResponseFiltersItemValueList =
  Array<DatasetsUpdateResponseFiltersItemValueItem>;
export const DatasetsUpdateResponseFiltersItemValueList = /*@__PURE__*/ S.Array(
  DatasetsUpdateResponseFiltersItemValueItem,
) as any as S.Schema<DatasetsUpdateResponseFiltersItemValueList>;

export interface DatasetsUpdateResponseFiltersItem {
  key: DatasetsUpdateResponseFiltersItemKey;
  operator: DatasetsUpdateResponseFiltersItemOperator;
  value: DatasetsUpdateResponseFiltersItemValueList;
}
export const DatasetsUpdateResponseFiltersItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: DatasetsUpdateResponseFiltersItemKey,
    operator: DatasetsUpdateResponseFiltersItemOperator,
    value: DatasetsUpdateResponseFiltersItemValueList,
  }),
).annotate({
  identifier: "DatasetsUpdateResponseFiltersItem",
}) as any as S.Schema<DatasetsUpdateResponseFiltersItem>;

export type DatasetsUpdateResponseFiltersList =
  Array<DatasetsUpdateResponseFiltersItem>;
export const DatasetsUpdateResponseFiltersList = /*@__PURE__*/ S.Array(
  DatasetsUpdateResponseFiltersItem,
) as any as S.Schema<DatasetsUpdateResponseFiltersList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateDatasetResponse {
  id: string;
  createdAt: string;
  enable: boolean;
  filters: DatasetsUpdateResponseFiltersList;
  /** gateway id */
  gatewayId: string;
  modifiedAt: string;
  name: string;
}
export const UpdateDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    enable: S.Boolean,
    filters: DatasetsUpdateResponseFiltersList,
    gatewayId: S.String.pipe(T.Body("gateway_id")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateDatasetResponse",
}) as any as S.Schema<UpdateDatasetResponse>;

export type BillingUsageHistoryRequestValueGroupingWindow = "day" | "hour";
export const BillingUsageHistoryRequestValueGroupingWindow =
  /*@__PURE__*/ S.String;

export interface UsageHistoryBillingRequest {
  accountId: string;
  /** Grouping window for usage data. */
  valueGroupingWindow:
    | BillingUsageHistoryRequestValueGroupingWindow
    | (string & {});
  /** End time as Unix timestamp in milliseconds. */
  endTime?: number;
  /** Start time as Unix timestamp in milliseconds. */
  startTime?: number;
}
export const UsageHistoryBillingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    valueGroupingWindow: BillingUsageHistoryRequestValueGroupingWindow.pipe(
      T.Query("value_grouping_window"),
    ),
    endTime: S.optional(S.Number.pipe(T.Query("end_time"))),
    startTime: S.optional(S.Number.pipe(T.Query("start_time"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/ai-gateway/billing/usage-history",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UsageHistoryBillingRequest",
}) as any as S.Schema<UsageHistoryBillingRequest>;

export interface BillingUsageHistoryResponseHistoryItem {
  id: string;
  aggregatedValue: number;
  endTime: number;
  startTime: number;
}
export const BillingUsageHistoryResponseHistoryItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      aggregatedValue: S.Number.pipe(T.Body("aggregated_value")),
      endTime: S.Number.pipe(T.Body("end_time")),
      startTime: S.Number.pipe(T.Body("start_time")),
    }),
).annotate({
  identifier: "BillingUsageHistoryResponseHistoryItem",
}) as any as S.Schema<BillingUsageHistoryResponseHistoryItem>;

export type BillingUsageHistoryResponseHistoryList =
  Array<BillingUsageHistoryResponseHistoryItem>;
export const BillingUsageHistoryResponseHistoryList = /*@__PURE__*/ S.Array(
  BillingUsageHistoryResponseHistoryItem,
) as any as S.Schema<BillingUsageHistoryResponseHistoryList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UsageHistoryBillingResponse {
  history: BillingUsageHistoryResponseHistoryList;
}
export const UsageHistoryBillingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    history: BillingUsageHistoryResponseHistoryList,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UsageHistoryBillingResponse",
}) as any as S.Schema<UsageHistoryBillingResponse>;

export type CreateAiGatewayError = GatewayAlreadyExists | CloudflareOpError;
/** Creates a new AI Gateway. */
export const createAiGateway: API.OperationMethod<
  CreateAiGatewayRequest,
  CreateAiGatewayResponse,
  CreateAiGatewayError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateAiGatewayRequest,
  output: CreateAiGatewayResponse,
  errors: [GatewayAlreadyExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateBillingSpendingLimitError =
  | NoManualTopup
  | AiGatewaySpendingLimitDeprecated
  | CloudflareOpError;
/** Deprecated: spending limits can no longer be created, enabled, or modified and this endpoint always responds 403. Use the new AI Gateway spend limits instead: https://developers.cloudflare.com/ai-gateway/features/spend-limits/. Existing limits can be removed via DELETE /spending-limit. */
export const createBillingSpendingLimit: API.OperationMethod<
  CreateBillingSpendingLimitRequest,
  CreateBillingSpendingLimitResponse,
  CreateBillingSpendingLimitError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateBillingSpendingLimitRequest,
  output: CreateBillingSpendingLimitResponse,
  errors: [
    NoManualTopup,
    AiGatewaySpendingLimitDeprecated,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateBillingTopupError = CloudflareOpError;
/** Create a credit top-up via Stripe PaymentIntent for the given account. */
export const createBillingTopup: API.OperationMethod<
  CreateBillingTopupRequest,
  CreateBillingTopupResponse,
  CreateBillingTopupError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateBillingTopupRequest,
  output: CreateBillingTopupResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateBillingTopupConfigError = CloudflareOpError;
/** Configure auto top-up with a balance threshold and top-up amount. */
export const createBillingTopupConfig: API.OperationMethod<
  CreateBillingTopupConfigRequest,
  CreateBillingTopupConfigResponse,
  CreateBillingTopupConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateBillingTopupConfigRequest,
  output: CreateBillingTopupConfigResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateCustomProviderError = CloudflareOpError;
/** Creates a new AI Gateway. */
export const createCustomProvider: API.OperationMethod<
  CreateCustomProviderRequest,
  CreateCustomProviderResponse,
  CreateCustomProviderError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateCustomProviderRequest,
  output: CreateCustomProviderResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateDatasetError =
  | GatewayNotFound
  | DatasetNameAlreadyExists
  | CloudflareOpError;
/** Creates a new AI Gateway. */
export const createDataset: API.OperationMethod<
  CreateDatasetRequest,
  CreateDatasetResponse,
  CreateDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDatasetRequest,
  output: CreateDatasetResponse,
  errors: [
    GatewayNotFound,
    DatasetNameAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateDeploymentDynamicRoutingError =
  | RouteNotFound
  | CloudflareOpError;
/** Create a new AI Gateway Dynamic Route Deployment. */
export const createDeploymentDynamicRouting: API.OperationMethod<
  CreateDeploymentDynamicRoutingRequest,
  CreateDeploymentDynamicRoutingResponse,
  CreateDeploymentDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDeploymentDynamicRoutingRequest,
  output: CreateDeploymentDynamicRoutingResponse,
  errors: [RouteNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateDynamicRoutingError =
  | RouteAlreadyExists
  | GatewayNotFound
  | CloudflareOpError;
/** Create a new AI Gateway Dynamic Route. */
export const createDynamicRouting: API.OperationMethod<
  CreateDynamicRoutingRequest,
  CreateDynamicRoutingResponse,
  CreateDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDynamicRoutingRequest,
  output: CreateDynamicRoutingResponse,
  errors: [
    RouteAlreadyExists,
    GatewayNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateEvaluationError =
  | GatewayNotFound
  | EvaluationNameAlreadyExists
  | CloudflareOpError;
/** Creates a new AI Gateway. */
export const createEvaluation: API.OperationMethod<
  CreateEvaluationRequest,
  CreateEvaluationResponse,
  CreateEvaluationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateEvaluationRequest,
  output: CreateEvaluationResponse,
  errors: [
    GatewayNotFound,
    EvaluationNameAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateProviderConfigError =
  | ProviderConfigSecretNotFound
  | ProviderConfigAlreadyExists
  | GatewayNotFound
  | CloudflareOpError;
/** Creates a new AI Gateway. */
export const createProviderConfig: API.OperationMethod<
  CreateProviderConfigRequest,
  CreateProviderConfigResponse,
  CreateProviderConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateProviderConfigRequest,
  output: CreateProviderConfigResponse,
  errors: [
    ProviderConfigSecretNotFound,
    ProviderConfigAlreadyExists,
    GatewayNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateVersionDynamicRoutingError =
  | RouteNotFound
  | CloudflareOpError;
/** Create a new AI Gateway Dynamic Route Version. */
export const createVersionDynamicRouting: API.OperationMethod<
  CreateVersionDynamicRoutingRequest,
  CreateVersionDynamicRoutingResponse,
  CreateVersionDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateVersionDynamicRoutingRequest,
  output: CreateVersionDynamicRoutingResponse,
  errors: [RouteNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreditBalanceBillingError = CloudflareOpError;
/** Retrieve the current credit balance, payment method info, and top-up configuration. */
export const creditBalanceBilling: API.OperationMethod<
  CreditBalanceBillingRequest,
  CreditBalanceBillingResponse,
  CreditBalanceBillingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreditBalanceBillingRequest,
  output: CreditBalanceBillingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteAiGatewayError = GatewayNotFound | CloudflareOpError;
/** Deletes an AI Gateway dataset. */
export const deleteAiGateway: API.OperationMethod<
  DeleteAiGatewayRequest,
  DeleteAiGatewayResponse,
  DeleteAiGatewayError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteAiGatewayRequest,
  output: DeleteAiGatewayResponse,
  errors: [GatewayNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteBillingSpendingLimitError = CloudflareOpError;
/** Remove the spending limit for the account. */
export const deleteBillingSpendingLimit: API.OperationMethod<
  DeleteBillingSpendingLimitRequest,
  DeleteBillingSpendingLimitResponse,
  DeleteBillingSpendingLimitError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteBillingSpendingLimitRequest,
  output: DeleteBillingSpendingLimitResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteBillingTopupConfigError = CloudflareOpError;
/** Remove the auto top-up configuration for the account. */
export const deleteBillingTopupConfig: API.OperationMethod<
  DeleteBillingTopupConfigRequest,
  DeleteBillingTopupConfigResponse,
  DeleteBillingTopupConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteBillingTopupConfigRequest,
  output: DeleteBillingTopupConfigResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteCustomProviderError = CloudflareOpError;
/** Deletes an AI Gateway dataset. */
export const deleteCustomProvider: API.OperationMethod<
  DeleteCustomProviderRequest,
  DeleteCustomProviderResponse,
  DeleteCustomProviderError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteCustomProviderRequest,
  output: DeleteCustomProviderResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteDatasetError = DatasetNotFound | CloudflareOpError;
/** Deletes an AI Gateway dataset. */
export const deleteDataset: API.OperationMethod<
  DeleteDatasetRequest,
  DeleteDatasetResponse,
  DeleteDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteDatasetRequest,
  output: DeleteDatasetResponse,
  errors: [DatasetNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteDynamicRoutingError =
  | RouteNotFound
  | GatewayNotFound
  | CloudflareOpError;
/** Delete an AI Gateway Dynamic Route. */
export const deleteDynamicRouting: API.OperationMethod<
  DeleteDynamicRoutingRequest,
  DeleteDynamicRoutingResponse,
  DeleteDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteDynamicRoutingRequest,
  output: DeleteDynamicRoutingResponse,
  errors: [
    RouteNotFound,
    GatewayNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteEvaluationError = EvaluationNotFound | CloudflareOpError;
/** Deletes an AI Gateway dataset. */
export const deleteEvaluation: API.OperationMethod<
  DeleteEvaluationRequest,
  DeleteEvaluationResponse,
  DeleteEvaluationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteEvaluationRequest,
  output: DeleteEvaluationResponse,
  errors: [EvaluationNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteLogError = CloudflareOpError;
/** Delete Gateway Logs */
export const deleteLog: API.OperationMethod<
  DeleteLogRequest,
  DeleteLogResponse,
  DeleteLogError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteLogRequest,
  output: DeleteLogResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteProviderConfigError =
  | ProviderConfigNotFound
  | CloudflareOpError;
export const deleteProviderConfig: API.OperationMethod<
  DeleteProviderConfigRequest,
  DeleteProviderConfigResponse,
  DeleteProviderConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteProviderConfigRequest,
  output: DeleteProviderConfigResponse,
  errors: [ProviderConfigNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAiGatewayError = GatewayNotFound | CloudflareOpError;
/** Retrieves details for a specific AI Gateway dataset. */
export const getAiGateway: API.OperationMethod<
  GetAiGatewayRequest,
  GetAiGatewayResponse,
  GetAiGatewayError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAiGatewayRequest,
  output: GetAiGatewayResponse,
  errors: [GatewayNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetBillingSpendingLimitError = CloudflareOpError;
/** Retrieve the current spending limit configuration for the account. */
export const getBillingSpendingLimit: API.OperationMethod<
  GetBillingSpendingLimitRequest,
  GetBillingSpendingLimitResponse,
  GetBillingSpendingLimitError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetBillingSpendingLimitRequest,
  output: GetBillingSpendingLimitResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetBillingTopupConfigError = CloudflareOpError;
/** Retrieve the current auto top-up threshold, amount, and any error state. */
export const getBillingTopupConfig: API.OperationMethod<
  GetBillingTopupConfigRequest,
  GetBillingTopupConfigResponse,
  GetBillingTopupConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetBillingTopupConfigRequest,
  output: GetBillingTopupConfigResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetCustomProviderError = CloudflareOpError;
/** Retrieves details for a specific AI Gateway dataset. */
export const getCustomProvider: API.OperationMethod<
  GetCustomProviderRequest,
  GetCustomProviderResponse,
  GetCustomProviderError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetCustomProviderRequest,
  output: GetCustomProviderResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDatasetError = DatasetNotFound | CloudflareOpError;
/** Retrieves details for a specific AI Gateway dataset. */
export const getDataset: API.OperationMethod<
  GetDatasetRequest,
  GetDatasetResponse,
  GetDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDatasetRequest,
  output: GetDatasetResponse,
  errors: [DatasetNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDynamicRoutingError =
  | RouteNotFound
  | GatewayNotFound
  | CloudflareOpError;
/** Get an AI Gateway Dynamic Route. */
export const getDynamicRouting: API.OperationMethod<
  GetDynamicRoutingRequest,
  GetDynamicRoutingResponse,
  GetDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDynamicRoutingRequest,
  output: GetDynamicRoutingResponse,
  errors: [
    RouteNotFound,
    GatewayNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetEvaluationError = EvaluationNotFound | CloudflareOpError;
/** Retrieves details for a specific AI Gateway dataset. */
export const getEvaluation: API.OperationMethod<
  GetEvaluationRequest,
  GetEvaluationResponse,
  GetEvaluationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetEvaluationRequest,
  output: GetEvaluationResponse,
  errors: [EvaluationNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetLogError = CloudflareOpError;
/** Retrieves detailed information for a specific AI Gateway log entry. */
export const getLog: API.OperationMethod<
  GetLogRequest,
  GetLogResponse,
  GetLogError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetLogRequest,
  output: GetLogResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetUrlError = CloudflareOpError;
/** Retrieves the endpoint URL for an AI Gateway. */
export const getUrl: API.OperationMethod<
  GetUrlRequest,
  GetUrlResponse,
  GetUrlError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetUrlRequest,
  output: GetUrlResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetVersionDynamicRoutingError = CloudflareOpError;
/** Get an AI Gateway Dynamic Route Version. */
export const getVersionDynamicRouting: API.OperationMethod<
  GetVersionDynamicRoutingRequest,
  GetVersionDynamicRoutingResponse,
  GetVersionDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetVersionDynamicRoutingRequest,
  output: GetVersionDynamicRoutingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type InvoiceHistoryBillingError = CloudflareOpError;
/** Retrieve a list of past invoices with pagination, optionally filtered by type. */
export const invoiceHistoryBilling: API.OperationMethod<
  InvoiceHistoryBillingRequest,
  InvoiceHistoryBillingResponse,
  InvoiceHistoryBillingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: InvoiceHistoryBillingRequest,
  output: InvoiceHistoryBillingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type InvoicePreviewBillingError = CloudflareOpError;
/** Retrieve a preview of the upcoming invoice including line items and tax. */
export const invoicePreviewBilling: API.OperationMethod<
  InvoicePreviewBillingRequest,
  InvoicePreviewBillingResponse,
  InvoicePreviewBillingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: InvoicePreviewBillingRequest,
  output: InvoicePreviewBillingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAiGatewaysError = CloudflareOpError;
/** Lists all AI Gateway evaluator types configured for the account. */
export const listAiGateways: API.PaginatedOperationMethod<
  ListAiGatewaysRequest,
  ListAiGatewaysResponse,
  ListAiGatewaysError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAiGatewaysRequest,
    output: ListAiGatewaysResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListCustomProvidersError = CloudflareOpError;
/** Lists all AI Gateway evaluator types configured for the account. */
export const listCustomProviders: API.PaginatedOperationMethod<
  ListCustomProvidersRequest,
  ListCustomProvidersResponse,
  ListCustomProvidersError,
  CloudflareOpContext,
  CustomProvidersListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListCustomProvidersRequest,
    output: ListCustomProvidersResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListDatasetsError = GatewayNotFound | CloudflareOpError;
/** Lists all AI Gateway evaluator types configured for the account. */
export const listDatasets: API.PaginatedOperationMethod<
  ListDatasetsRequest,
  ListDatasetsResponse,
  ListDatasetsError,
  CloudflareOpContext,
  DatasetsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListDatasetsRequest,
    output: ListDatasetsResponse,
    errors: [GatewayNotFound, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListDeploymentsDynamicRoutingError = CloudflareOpError;
/** List all AI Gateway Dynamic Route Deployments. */
export const listDeploymentsDynamicRouting: API.OperationMethod<
  ListDeploymentsDynamicRoutingRequest,
  ListDeploymentsDynamicRoutingResponse,
  ListDeploymentsDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListDeploymentsDynamicRoutingRequest,
  output: ListDeploymentsDynamicRoutingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListDynamicRoutingsError = GatewayNotFound | CloudflareOpError;
/** List all AI Gateway Dynamic Routes. */
export const listDynamicRoutings: API.OperationMethod<
  ListDynamicRoutingsRequest,
  ListDynamicRoutingsResponse,
  ListDynamicRoutingsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListDynamicRoutingsRequest,
  output: ListDynamicRoutingsResponse,
  errors: [GatewayNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListEvaluationsError = CloudflareOpError;
/** Lists all AI Gateway evaluator types configured for the account. */
export const listEvaluations: API.PaginatedOperationMethod<
  ListEvaluationsRequest,
  ListEvaluationsResponse,
  ListEvaluationsError,
  CloudflareOpContext,
  EvaluationsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListEvaluationsRequest,
    output: ListEvaluationsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListEvaluationTypesError = CloudflareOpError;
/** List Evaluators */
export const listEvaluationTypes: API.PaginatedOperationMethod<
  ListEvaluationTypesRequest,
  ListEvaluationTypesResponse,
  ListEvaluationTypesError,
  CloudflareOpContext,
  EvaluationTypesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListEvaluationTypesRequest,
    output: ListEvaluationTypesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListLogsError = CloudflareOpError;
/** List Gateway Logs */
export const listLogs: API.PaginatedOperationMethod<
  ListLogsRequest,
  ListLogsResponse,
  ListLogsError,
  CloudflareOpContext,
  LogsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListLogsRequest,
    output: ListLogsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListProviderConfigsError = CloudflareOpError;
/** Lists all AI Gateway evaluator types configured for the account. */
export const listProviderConfigs: API.PaginatedOperationMethod<
  ListProviderConfigsRequest,
  ListProviderConfigsResponse,
  ListProviderConfigsError,
  CloudflareOpContext,
  ProviderConfigsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListProviderConfigsRequest,
    output: ListProviderConfigsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListVersionsDynamicRoutingError = CloudflareOpError;
/** List all AI Gateway Dynamic Route Versions. */
export const listVersionsDynamicRouting: API.OperationMethod<
  ListVersionsDynamicRoutingRequest,
  ListVersionsDynamicRoutingResponse,
  ListVersionsDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListVersionsDynamicRoutingRequest,
  output: ListVersionsDynamicRoutingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchDynamicRoutingError =
  | RouteNotFound
  | RouteAlreadyExists
  | CloudflareOpError;
/** Update an AI Gateway Dynamic Route. */
export const patchDynamicRouting: API.OperationMethod<
  PatchDynamicRoutingRequest,
  PatchDynamicRoutingResponse,
  PatchDynamicRoutingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchDynamicRoutingRequest,
  output: PatchDynamicRoutingResponse,
  errors: [
    RouteNotFound,
    RouteAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchLogError = CloudflareOpError;
/** Updates metadata for an AI Gateway log entry. */
export const patchLog: API.OperationMethod<
  PatchLogRequest,
  PatchLogResponse,
  PatchLogError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchLogRequest,
  output: PatchLogResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RequestLogError = CloudflareOpError;
/** Retrieves the original request payload for an AI Gateway log entry. */
export const requestLog: API.OperationMethod<
  RequestLogRequest,
  RequestLogResponse,
  RequestLogError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RequestLogRequest,
  output: RequestLogResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ResponseLogError = CloudflareOpError;
/** Retrieves the response payload for an AI Gateway log entry. */
export const responseLog: API.OperationMethod<
  ResponseLogRequest,
  ResponseLogResponse,
  ResponseLogError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ResponseLogRequest,
  output: ResponseLogResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StatusBillingTopupError = CloudflareOpError;
/** Get the payment processing status of a top-up by its invoice ID. */
export const statusBillingTopup: API.OperationMethod<
  StatusBillingTopupRequest,
  StatusBillingTopupResponse,
  StatusBillingTopupError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StatusBillingTopupRequest,
  output: StatusBillingTopupResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateAiGatewayError = GatewayNotFound | CloudflareOpError;
/** Updates an existing AI Gateway dataset. */
export const updateAiGateway: API.OperationMethod<
  UpdateAiGatewayRequest,
  UpdateAiGatewayResponse,
  UpdateAiGatewayError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateAiGatewayRequest,
  output: UpdateAiGatewayResponse,
  errors: [GatewayNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateDatasetError = DatasetNotFound | CloudflareOpError;
/** Updates an existing AI Gateway dataset. */
export const updateDataset: API.OperationMethod<
  UpdateDatasetRequest,
  UpdateDatasetResponse,
  UpdateDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateDatasetRequest,
  output: UpdateDatasetResponse,
  errors: [DatasetNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UsageHistoryBillingError = CloudflareOpError;
/** Retrieve aggregated usage meter event summaries for the given time range. */
export const usageHistoryBilling: API.OperationMethod<
  UsageHistoryBillingRequest,
  UsageHistoryBillingResponse,
  UsageHistoryBillingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UsageHistoryBillingRequest,
  output: UsageHistoryBillingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));