/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { remap as remap$ } from "../lib/primitives.js";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export const UpdateDrainProjects = {
  Some: "some",
  All: "all",
} as const;
export type UpdateDrainProjects = ClosedEnum<typeof UpdateDrainProjects>;

export type UpdateDrainFilterDrains2 = {
  type: string;
  text: string;
};

export type UpdateDrainFilterProject = {
  ids?: Array<string> | undefined;
};

export const UpdateDrainFilterSources = {
  Build: "build",
  Edge: "edge",
  Lambda: "lambda",
  Static: "static",
  External: "external",
  Firewall: "firewall",
  Redirect: "redirect",
} as const;
export type UpdateDrainFilterSources = ClosedEnum<
  typeof UpdateDrainFilterSources
>;

export type FilterLog = {
  sources?: Array<UpdateDrainFilterSources> | undefined;
};

export const UpdateDrainFilterEnvironments = {
  Production: "production",
  Preview: "preview",
} as const;
export type UpdateDrainFilterEnvironments = ClosedEnum<
  typeof UpdateDrainFilterEnvironments
>;

export type FilterDeployment = {
  environments?: Array<UpdateDrainFilterEnvironments> | undefined;
};

export type UpdateDrainFilter1 = {
  type: string;
  project?: UpdateDrainFilterProject | undefined;
  log?: FilterLog | undefined;
  deployment?: FilterDeployment | undefined;
};

export type FilterFilter = UpdateDrainFilterDrains2 | UpdateDrainFilter1;

export type UpdateDrainFilter2 = {
  version: string;
  filter: UpdateDrainFilterDrains2 | UpdateDrainFilter1;
};

export type UpdateDrainFilter = UpdateDrainFilter2 | string;

export type UpdateDrainSchemas = {
  version: string;
};

export const UpdateDrainDeliveryDrainsRequestEncoding = {
  Json: "json",
  Ndjson: "ndjson",
} as const;
export type UpdateDrainDeliveryDrainsRequestEncoding = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsRequestEncoding
>;

export const UpdateDrainDeliveryDrainsCompression = {
  None: "none",
} as const;
export type UpdateDrainDeliveryDrainsCompression = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsCompression
>;

export const DeliveryFileStructure = {
  Hive: "hive",
} as const;
export type DeliveryFileStructure = ClosedEnum<typeof DeliveryFileStructure>;

export const DeliveryServerSideEncryption = {
  Aes256: "AES256",
  AwsKms: "aws:kms",
  AwsKmsDsse: "aws:kms:dsse",
} as const;
export type DeliveryServerSideEncryption = ClosedEnum<
  typeof DeliveryServerSideEncryption
>;

export const DeliveryObjectAcl = {
  Private: "private",
  BucketOwnerRead: "bucket-owner-read",
  BucketOwnerFullControl: "bucket-owner-full-control",
} as const;
export type DeliveryObjectAcl = ClosedEnum<typeof DeliveryObjectAcl>;

export type UpdateDrainDelivery3 = {
  type: string;
  endpoint: string;
  encoding: UpdateDrainDeliveryDrainsRequestEncoding;
  compression: UpdateDrainDeliveryDrainsCompression;
  fileStructure: DeliveryFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?: DeliveryServerSideEncryption | undefined;
  objectAcl?: DeliveryObjectAcl | undefined;
};

export type UpdateDrainEndpoint1 = {
  traces: string;
};

export type DeliveryEndpoint = UpdateDrainEndpoint1;

export const UpdateDrainDeliveryDrainsEncoding = {
  Proto: "proto",
  Json: "json",
} as const;
export type UpdateDrainDeliveryDrainsEncoding = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsEncoding
>;

export type UpdateDrainDelivery2 = {
  type: string;
  endpoint: UpdateDrainEndpoint1;
  encoding: UpdateDrainDeliveryDrainsEncoding;
  headers: { [k: string]: string };
  secret?: string | undefined;
};

export const UpdateDrainDeliveryCompression = {
  Gzip: "gzip",
  None: "none",
} as const;
export type UpdateDrainDeliveryCompression = ClosedEnum<
  typeof UpdateDrainDeliveryCompression
>;

export const UpdateDrainDeliveryEncoding = {
  Json: "json",
  Ndjson: "ndjson",
} as const;
export type UpdateDrainDeliveryEncoding = ClosedEnum<
  typeof UpdateDrainDeliveryEncoding
>;

export type UpdateDrainDelivery1 = {
  type: string;
  endpoint: string;
  compression?: UpdateDrainDeliveryCompression | undefined;
  encoding: UpdateDrainDeliveryEncoding;
  headers: { [k: string]: string };
  secret?: string | undefined;
};

export type UpdateDrainDelivery =
  | UpdateDrainDelivery3
  | UpdateDrainDelivery1
  | UpdateDrainDelivery2;

/**
 * Environment to apply sampling to
 */
export const UpdateDrainEnv = {
  Production: "production",
  Preview: "preview",
} as const;
/**
 * Environment to apply sampling to
 */
export type UpdateDrainEnv = ClosedEnum<typeof UpdateDrainEnv>;

export type UpdateDrainSampling = {
  type: string;
  /**
   * Sampling rate from 0 to 1 (e.g., 0.1 for 10%)
   */
  rate: number;
  /**
   * Environment to apply sampling to
   */
  env?: UpdateDrainEnv | undefined;
  /**
   * Request path prefix to apply the sampling rule to
   */
  requestPath?: string | undefined;
};

export type UpdateDrainTransforms = {
  id: string;
};

export const UpdateDrainStatus = {
  Enabled: "enabled",
  Disabled: "disabled",
} as const;
export type UpdateDrainStatus = ClosedEnum<typeof UpdateDrainStatus>;

export type UpdateDrainSource2 = {
  kind?: string | undefined;
};

export type UpdateDrain13 = {
  kind?: string | undefined;
};

export type UpdateDrain12 = {
  kind?: string | undefined;
  resourceId: string;
};

export type UpdateDrain11 = {
  kind?: string | undefined;
  externalResourceId: string;
};

export type UpdateDrainSource1 = UpdateDrain11 | UpdateDrain12 | UpdateDrain13;

export type UpdateDrainSource =
  | UpdateDrain11
  | UpdateDrain12
  | UpdateDrain13
  | UpdateDrainSource2;

export type UpdateDrainRequestBody = {
  name?: string | undefined;
  projects?: UpdateDrainProjects | undefined;
  projectIds?: Array<string> | null | undefined;
  filter?: UpdateDrainFilter2 | string | undefined;
  schemas?: { [k: string]: UpdateDrainSchemas } | undefined;
  delivery?:
    | UpdateDrainDelivery3
    | UpdateDrainDelivery1
    | UpdateDrainDelivery2
    | undefined;
  sampling?: Array<UpdateDrainSampling> | null | undefined;
  transforms?: Array<UpdateDrainTransforms> | null | undefined;
  status?: UpdateDrainStatus | undefined;
  source?:
    | UpdateDrain11
    | UpdateDrain12
    | UpdateDrain13
    | UpdateDrainSource2
    | undefined;
};

export type UpdateDrainRequest = {
  id: string;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
  requestBody?: UpdateDrainRequestBody | undefined;
};

export const UpdateDrainResponseBodyDrainsStatus = {
  Disabled: "disabled",
  Enabled: "enabled",
  Errored: "errored",
} as const;
export type UpdateDrainResponseBodyDrainsStatus = ClosedEnum<
  typeof UpdateDrainResponseBodyDrainsStatus
>;

export const UpdateDrainResponseBodyDrainsDisabledReason = {
  AccountPlanDowngrade: "account-plan-downgrade",
  DisabledByAdmin: "disabled-by-admin",
  DisabledByOwner: "disabled-by-owner",
  FeatureNotAvailable: "feature-not-available",
  LimitsExceeded: "limits-exceeded",
} as const;
export type UpdateDrainResponseBodyDrainsDisabledReason = ClosedEnum<
  typeof UpdateDrainResponseBodyDrainsDisabledReason
>;

export type UpdateDrainResponseBodyDrainsLog = {};

export type UpdateDrainResponseBodyDrainsTrace = {};

export type UpdateDrainResponseBodyDrainsAnalytics = {};

export type UpdateDrainResponseBodyDrainsSpeedInsights = {};

export type UpdateDrainResponseBodyDrainsAiGateway = {};

export type UpdateDrainResponseBodyDrainsAuditLog = {};

export type UpdateDrainResponseBodyDrainsConnect = {};

export type UpdateDrainResponseBodyDrainsSchemas = {
  log?: UpdateDrainResponseBodyDrainsLog | undefined;
  trace?: UpdateDrainResponseBodyDrainsTrace | undefined;
  analytics?: UpdateDrainResponseBodyDrainsAnalytics | undefined;
  speedInsights?: UpdateDrainResponseBodyDrainsSpeedInsights | undefined;
  aiGateway?: UpdateDrainResponseBodyDrainsAiGateway | undefined;
  auditLog?: UpdateDrainResponseBodyDrainsAuditLog | undefined;
  connect?: UpdateDrainResponseBodyDrainsConnect | undefined;
};

export const UpdateDrainDeliveryDrainsTarget = {
  VercelOtelTracesDb: "vercel-otel-traces-db",
} as const;
export type UpdateDrainDeliveryDrainsTarget = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsTarget
>;

export type UpdateDrainDeliveryDrains5 = {
  type: "internal";
  target: UpdateDrainDeliveryDrainsTarget;
};

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding =
  {
    Json: "json",
    Ndjson: "ndjson",
  } as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding
  >;

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression =
  {
    None: "none",
  } as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression
  >;

export const UpdateDrainDeliveryDrainsFileStructure = {
  Hive: "hive",
} as const;
export type UpdateDrainDeliveryDrainsFileStructure = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsFileStructure
>;

export const UpdateDrainDeliveryDrainsServerSideEncryption = {
  Aes256: "AES256",
  AwsKms: "aws:kms",
  AwsKmsDsse: "aws:kms:dsse",
} as const;
export type UpdateDrainDeliveryDrainsServerSideEncryption = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsServerSideEncryption
>;

export const UpdateDrainDeliveryDrainsObjectAcl = {
  AuthenticatedRead: "authenticated-read",
  AwsExecRead: "aws-exec-read",
  BucketOwnerFullControl: "bucket-owner-full-control",
  BucketOwnerRead: "bucket-owner-read",
  Private: "private",
  PublicRead: "public-read",
  PublicReadWrite: "public-read-write",
} as const;
export type UpdateDrainDeliveryDrainsObjectAcl = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsObjectAcl
>;

export type UpdateDrainDeliveryDrains4 = {
  type: "s3";
  endpoint: string;
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding;
  compression:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression;
  fileStructure: UpdateDrainDeliveryDrainsFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?:
    | UpdateDrainDeliveryDrainsServerSideEncryption
    | undefined;
  objectAcl?: UpdateDrainDeliveryDrainsObjectAcl | undefined;
};

export type UpdateDrainDeliveryDrainsResponse3 = {
  type: "clickhouse";
  endpoint: string;
  table: string;
};

export type UpdateDrainDeliveryDrainsEndpoint = {
  traces: string;
};

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding =
  {
    Json: "json",
    Proto: "proto",
  } as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding
  >;

export const UpdateDrainSecretDrainsResponse200Kind = {
  IntegrationSecret: "INTEGRATION_SECRET",
} as const;
export type UpdateDrainSecretDrainsResponse200Kind = ClosedEnum<
  typeof UpdateDrainSecretDrainsResponse200Kind
>;

export type UpdateDrainSecretDrainsResponse2002 = {
  kind: UpdateDrainSecretDrainsResponse200Kind;
};

export type UpdateDrainDeliveryDrainsResponse200Secret =
  | UpdateDrainSecretDrainsResponse2002
  | string;

export type UpdateDrainDeliveryDrainsResponse2 = {
  type: "otlphttp";
  endpoint: UpdateDrainDeliveryDrainsEndpoint;
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding;
  headers: { [k: string]: string };
  secret?: UpdateDrainSecretDrainsResponse2002 | string | undefined;
};

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding =
  {
    Json: "json",
    Ndjson: "ndjson",
  } as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding
  >;

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression = {
  Gzip: "gzip",
  None: "none",
} as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression
  >;

export const UpdateDrainSecretDrainsResponseKind = {
  IntegrationSecret: "INTEGRATION_SECRET",
} as const;
export type UpdateDrainSecretDrainsResponseKind = ClosedEnum<
  typeof UpdateDrainSecretDrainsResponseKind
>;

export type UpdateDrainSecretDrainsResponse2 = {
  kind: UpdateDrainSecretDrainsResponseKind;
};

export type UpdateDrainDeliveryDrainsResponseSecret =
  | UpdateDrainSecretDrainsResponse2
  | string;

export type UpdateDrainDeliveryDrainsResponse1 = {
  type: "http";
  endpoint: string;
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding;
  compression?:
    | UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression
    | undefined;
  headers: { [k: string]: string };
  secret?: UpdateDrainSecretDrainsResponse2 | string | undefined;
};

export type UpdateDrainResponseBodyDrainsDelivery =
  | UpdateDrainDeliveryDrainsResponse1
  | UpdateDrainDeliveryDrainsResponse2
  | UpdateDrainDeliveryDrainsResponse3
  | UpdateDrainDeliveryDrains4
  | UpdateDrainDeliveryDrains5;

export const UpdateDrainResponseBodyDrainsType = {
  HeadSampling: "head_sampling",
} as const;
export type UpdateDrainResponseBodyDrainsType = ClosedEnum<
  typeof UpdateDrainResponseBodyDrainsType
>;

export const UpdateDrainResponseBodyDrainsEnv = {
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateDrainResponseBodyDrainsEnv = ClosedEnum<
  typeof UpdateDrainResponseBodyDrainsEnv
>;

export type UpdateDrainResponseBodyDrainsSampling = {
  type: UpdateDrainResponseBodyDrainsType;
  rate: number;
  env?: UpdateDrainResponseBodyDrainsEnv | undefined;
  requestPath?: string | undefined;
};

export type UpdateDrainSourceDrainsResponse2 = {
  kind: "integration";
  resourceId?: string | undefined;
  externalResourceId?: string | undefined;
  integrationId: string;
  integrationConfigurationId: string;
};

export type UpdateDrainSourceDrainsResponse1 = {
  kind: "self-served";
};

export type UpdateDrainResponseBodyDrainsSource =
  | UpdateDrainSourceDrainsResponse1
  | UpdateDrainSourceDrainsResponse2;

export const UpdateDrainResponseBodyDrainsVersion = {
  V2: "v2",
} as const;
export type UpdateDrainResponseBodyDrainsVersion = ClosedEnum<
  typeof UpdateDrainResponseBodyDrainsVersion
>;

export type UpdateDrainFilterDrainsResponse2002 = {
  type: "odata";
  text: string;
};

export type UpdateDrainFilterDrainsResponseProject = {
  ids?: Array<string> | undefined;
};

export const UpdateDrainFilterDrainsResponseSources = {
  Build: "build",
  Edge: "edge",
  External: "external",
  Firewall: "firewall",
  Lambda: "lambda",
  Redirect: "redirect",
  Static: "static",
} as const;
export type UpdateDrainFilterDrainsResponseSources = ClosedEnum<
  typeof UpdateDrainFilterDrainsResponseSources
>;

export type UpdateDrainFilterDrainsLog = {
  sources?: Array<UpdateDrainFilterDrainsResponseSources> | undefined;
  legacyExcludeCachedStaticAssetLogs?: boolean | undefined;
};

export const UpdateDrainFilterDrainsResponseEnvironments = {
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateDrainFilterDrainsResponseEnvironments = ClosedEnum<
  typeof UpdateDrainFilterDrainsResponseEnvironments
>;

export type UpdateDrainFilterDrainsDeployment = {
  environments?: Array<UpdateDrainFilterDrainsResponseEnvironments> | undefined;
};

export type UpdateDrainFilterDrainsResponse1 = {
  type: "basic";
  project?: UpdateDrainFilterDrainsResponseProject | undefined;
  log?: UpdateDrainFilterDrainsLog | undefined;
  deployment?: UpdateDrainFilterDrainsDeployment | undefined;
};

export type UpdateDrainResponseBodyDrainsFilter =
  | UpdateDrainFilterDrainsResponse1
  | UpdateDrainFilterDrainsResponse2002;

export type UpdateDrainResponseBodyDrainsFilterV2 = {
  version: UpdateDrainResponseBodyDrainsVersion;
  filter:
    | UpdateDrainFilterDrainsResponse1
    | UpdateDrainFilterDrainsResponse2002;
};

export const UpdateDrainProjectAccessDrainsManagedBy = {
  Drain: "drain",
  Integration: "integration",
} as const;
export type UpdateDrainProjectAccessDrainsManagedBy = ClosedEnum<
  typeof UpdateDrainProjectAccessDrainsManagedBy
>;

export type UpdateDrainProjectAccess2 = {
  access: "some";
  projectIds: Array<string>;
  managedBy: UpdateDrainProjectAccessDrainsManagedBy;
};

export const UpdateDrainProjectAccessManagedBy = {
  Drain: "drain",
  Integration: "integration",
} as const;
export type UpdateDrainProjectAccessManagedBy = ClosedEnum<
  typeof UpdateDrainProjectAccessManagedBy
>;

export type UpdateDrainProjectAccess1 = {
  access: "all";
  managedBy: UpdateDrainProjectAccessManagedBy;
};

export type UpdateDrainResponseBodyProjectAccess =
  | UpdateDrainProjectAccess1
  | UpdateDrainProjectAccess2;

export type UpdateDrainResponseBody2 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: UpdateDrainResponseBodyDrainsStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: UpdateDrainResponseBodyDrainsDisabledReason | undefined;
  schemas: UpdateDrainResponseBodyDrainsSchemas;
  delivery:
    | UpdateDrainDeliveryDrainsResponse1
    | UpdateDrainDeliveryDrainsResponse2
    | UpdateDrainDeliveryDrainsResponse3
    | UpdateDrainDeliveryDrains4
    | UpdateDrainDeliveryDrains5;
  sampling?: Array<UpdateDrainResponseBodyDrainsSampling> | undefined;
  source: UpdateDrainSourceDrainsResponse1 | UpdateDrainSourceDrainsResponse2;
  filterV2?: UpdateDrainResponseBodyDrainsFilterV2 | undefined;
  integrationIcon?: string | undefined;
  integrationConfigurationUri?: string | undefined;
  integrationWebsite?: string | undefined;
  projectAccess?:
    | UpdateDrainProjectAccess1
    | UpdateDrainProjectAccess2
    | undefined;
};

export const UpdateDrainResponseBodyStatus = {
  Disabled: "disabled",
  Enabled: "enabled",
  Errored: "errored",
} as const;
export type UpdateDrainResponseBodyStatus = ClosedEnum<
  typeof UpdateDrainResponseBodyStatus
>;

export const UpdateDrainResponseBodyDisabledReason = {
  AccountPlanDowngrade: "account-plan-downgrade",
  DisabledByAdmin: "disabled-by-admin",
  DisabledByOwner: "disabled-by-owner",
  FeatureNotAvailable: "feature-not-available",
  LimitsExceeded: "limits-exceeded",
} as const;
export type UpdateDrainResponseBodyDisabledReason = ClosedEnum<
  typeof UpdateDrainResponseBodyDisabledReason
>;

export type UpdateDrainResponseBodyLog = {};

export type UpdateDrainResponseBodyTrace = {};

export type UpdateDrainResponseBodyAnalytics = {};

export type UpdateDrainResponseBodySpeedInsights = {};

export type UpdateDrainResponseBodyAiGateway = {};

export type UpdateDrainResponseBodyAuditLog = {};

export type UpdateDrainResponseBodyConnect = {};

export type UpdateDrainResponseBodySchemas = {
  log?: UpdateDrainResponseBodyLog | undefined;
  trace?: UpdateDrainResponseBodyTrace | undefined;
  analytics?: UpdateDrainResponseBodyAnalytics | undefined;
  speedInsights?: UpdateDrainResponseBodySpeedInsights | undefined;
  aiGateway?: UpdateDrainResponseBodyAiGateway | undefined;
  auditLog?: UpdateDrainResponseBodyAuditLog | undefined;
  connect?: UpdateDrainResponseBodyConnect | undefined;
};

export const UpdateDrainDeliveryTarget = {
  VercelOtelTracesDb: "vercel-otel-traces-db",
} as const;
export type UpdateDrainDeliveryTarget = ClosedEnum<
  typeof UpdateDrainDeliveryTarget
>;

export type UpdateDrainDelivery5 = {
  type: "internal";
  target: UpdateDrainDeliveryTarget;
};

export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding = {
  Json: "json",
  Ndjson: "ndjson",
} as const;
export type UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding =
  ClosedEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding
  >;

export const UpdateDrainDeliveryDrainsResponse200Compression = {
  None: "none",
} as const;
export type UpdateDrainDeliveryDrainsResponse200Compression = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsResponse200Compression
>;

export const UpdateDrainDeliveryFileStructure = {
  Hive: "hive",
} as const;
export type UpdateDrainDeliveryFileStructure = ClosedEnum<
  typeof UpdateDrainDeliveryFileStructure
>;

export const UpdateDrainDeliveryServerSideEncryption = {
  Aes256: "AES256",
  AwsKms: "aws:kms",
  AwsKmsDsse: "aws:kms:dsse",
} as const;
export type UpdateDrainDeliveryServerSideEncryption = ClosedEnum<
  typeof UpdateDrainDeliveryServerSideEncryption
>;

export const UpdateDrainDeliveryObjectAcl = {
  AuthenticatedRead: "authenticated-read",
  AwsExecRead: "aws-exec-read",
  BucketOwnerFullControl: "bucket-owner-full-control",
  BucketOwnerRead: "bucket-owner-read",
  Private: "private",
  PublicRead: "public-read",
  PublicReadWrite: "public-read-write",
} as const;
export type UpdateDrainDeliveryObjectAcl = ClosedEnum<
  typeof UpdateDrainDeliveryObjectAcl
>;

export type UpdateDrainDelivery4 = {
  type: "s3";
  endpoint: string;
  encoding: UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding;
  compression: UpdateDrainDeliveryDrainsResponse200Compression;
  fileStructure: UpdateDrainDeliveryFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?: UpdateDrainDeliveryServerSideEncryption | undefined;
  objectAcl?: UpdateDrainDeliveryObjectAcl | undefined;
};

export type UpdateDrainDeliveryDrains3 = {
  type: "clickhouse";
  endpoint: string;
  table: string;
};

export type UpdateDrainDeliveryEndpoint = {
  traces: string;
};

export const UpdateDrainDeliveryDrainsResponse200Encoding = {
  Json: "json",
  Proto: "proto",
} as const;
export type UpdateDrainDeliveryDrainsResponse200Encoding = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsResponse200Encoding
>;

export const UpdateDrainSecretDrainsKind = {
  IntegrationSecret: "INTEGRATION_SECRET",
} as const;
export type UpdateDrainSecretDrainsKind = ClosedEnum<
  typeof UpdateDrainSecretDrainsKind
>;

export type UpdateDrainSecretDrains2 = {
  kind: UpdateDrainSecretDrainsKind;
};

export type UpdateDrainDeliveryDrainsSecret = UpdateDrainSecretDrains2 | string;

export type UpdateDrainDeliveryDrains2 = {
  type: "otlphttp";
  endpoint: UpdateDrainDeliveryEndpoint;
  encoding: UpdateDrainDeliveryDrainsResponse200Encoding;
  headers: { [k: string]: string };
  secret?: UpdateDrainSecretDrains2 | string | undefined;
};

export const UpdateDrainDeliveryDrainsResponseEncoding = {
  Json: "json",
  Ndjson: "ndjson",
} as const;
export type UpdateDrainDeliveryDrainsResponseEncoding = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsResponseEncoding
>;

export const UpdateDrainDeliveryDrainsResponseCompression = {
  Gzip: "gzip",
  None: "none",
} as const;
export type UpdateDrainDeliveryDrainsResponseCompression = ClosedEnum<
  typeof UpdateDrainDeliveryDrainsResponseCompression
>;

export const UpdateDrainSecretKind = {
  IntegrationSecret: "INTEGRATION_SECRET",
} as const;
export type UpdateDrainSecretKind = ClosedEnum<typeof UpdateDrainSecretKind>;

export type UpdateDrainSecret2 = {
  kind: UpdateDrainSecretKind;
};

export type UpdateDrainDeliverySecret = UpdateDrainSecret2 | string;

export type UpdateDrainDeliveryDrains1 = {
  type: "http";
  endpoint: string;
  encoding: UpdateDrainDeliveryDrainsResponseEncoding;
  compression?: UpdateDrainDeliveryDrainsResponseCompression | undefined;
  headers: { [k: string]: string };
  secret?: UpdateDrainSecret2 | string | undefined;
};

export type UpdateDrainResponseBodyDelivery =
  | UpdateDrainDeliveryDrains1
  | UpdateDrainDeliveryDrains2
  | UpdateDrainDeliveryDrains3
  | UpdateDrainDelivery4
  | UpdateDrainDelivery5;

export const UpdateDrainResponseBodyType = {
  HeadSampling: "head_sampling",
} as const;
export type UpdateDrainResponseBodyType = ClosedEnum<
  typeof UpdateDrainResponseBodyType
>;

export const UpdateDrainResponseBodyEnv = {
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateDrainResponseBodyEnv = ClosedEnum<
  typeof UpdateDrainResponseBodyEnv
>;

export type UpdateDrainResponseBodySampling = {
  type: UpdateDrainResponseBodyType;
  rate: number;
  env?: UpdateDrainResponseBodyEnv | undefined;
  requestPath?: string | undefined;
};

export type UpdateDrainSourceDrains2 = {
  kind: "integration";
  resourceId?: string | undefined;
  externalResourceId?: string | undefined;
  integrationId: string;
  integrationConfigurationId: string;
};

export type UpdateDrainSourceDrains1 = {
  kind: "self-served";
};

export type UpdateDrainResponseBodySource =
  | UpdateDrainSourceDrains1
  | UpdateDrainSourceDrains2;

export const UpdateDrainResponseBodyVersion = {
  V2: "v2",
} as const;
export type UpdateDrainResponseBodyVersion = ClosedEnum<
  typeof UpdateDrainResponseBodyVersion
>;

export type UpdateDrainFilterDrainsResponse2 = {
  type: "odata";
  text: string;
};

export type UpdateDrainFilterDrainsProject = {
  ids?: Array<string> | undefined;
};

export const UpdateDrainFilterDrainsSources = {
  Build: "build",
  Edge: "edge",
  External: "external",
  Firewall: "firewall",
  Lambda: "lambda",
  Redirect: "redirect",
  Static: "static",
} as const;
export type UpdateDrainFilterDrainsSources = ClosedEnum<
  typeof UpdateDrainFilterDrainsSources
>;

export type UpdateDrainFilterLog = {
  sources?: Array<UpdateDrainFilterDrainsSources> | undefined;
  legacyExcludeCachedStaticAssetLogs?: boolean | undefined;
};

export const UpdateDrainFilterDrainsEnvironments = {
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateDrainFilterDrainsEnvironments = ClosedEnum<
  typeof UpdateDrainFilterDrainsEnvironments
>;

export type UpdateDrainFilterDeployment = {
  environments?: Array<UpdateDrainFilterDrainsEnvironments> | undefined;
};

export type UpdateDrainFilterDrains1 = {
  type: "basic";
  project?: UpdateDrainFilterDrainsProject | undefined;
  log?: UpdateDrainFilterLog | undefined;
  deployment?: UpdateDrainFilterDeployment | undefined;
};

export type UpdateDrainResponseBodyFilter =
  | UpdateDrainFilterDrains1
  | UpdateDrainFilterDrainsResponse2;

export type UpdateDrainResponseBodyFilterV2 = {
  version: UpdateDrainResponseBodyVersion;
  filter: UpdateDrainFilterDrains1 | UpdateDrainFilterDrainsResponse2;
};

export type UpdateDrainResponseBody1 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: UpdateDrainResponseBodyStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: UpdateDrainResponseBodyDisabledReason | undefined;
  schemas: UpdateDrainResponseBodySchemas;
  delivery:
    | UpdateDrainDeliveryDrains1
    | UpdateDrainDeliveryDrains2
    | UpdateDrainDeliveryDrains3
    | UpdateDrainDelivery4
    | UpdateDrainDelivery5;
  sampling?: Array<UpdateDrainResponseBodySampling> | undefined;
  source: UpdateDrainSourceDrains1 | UpdateDrainSourceDrains2;
  filterV2?: UpdateDrainResponseBodyFilterV2 | undefined;
};

export type UpdateDrainResponseBody =
  | UpdateDrainResponseBody1
  | UpdateDrainResponseBody2;

/** @internal */
export const UpdateDrainProjects$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainProjects
> = z.nativeEnum(UpdateDrainProjects);

/** @internal */
export type UpdateDrainFilterDrains2$Outbound = {
  type: string;
  text: string;
};

/** @internal */
export const UpdateDrainFilterDrains2$outboundSchema: z.ZodType<
  UpdateDrainFilterDrains2$Outbound,
  z.ZodTypeDef,
  UpdateDrainFilterDrains2
> = z.object({
  type: z.string(),
  text: z.string(),
});

export function updateDrainFilterDrains2ToJSON(
  updateDrainFilterDrains2: UpdateDrainFilterDrains2,
): string {
  return JSON.stringify(
    UpdateDrainFilterDrains2$outboundSchema.parse(updateDrainFilterDrains2),
  );
}

/** @internal */
export type UpdateDrainFilterProject$Outbound = {
  ids?: Array<string> | undefined;
};

/** @internal */
export const UpdateDrainFilterProject$outboundSchema: z.ZodType<
  UpdateDrainFilterProject$Outbound,
  z.ZodTypeDef,
  UpdateDrainFilterProject
> = z.object({
  ids: z.array(z.string()).optional(),
});

export function updateDrainFilterProjectToJSON(
  updateDrainFilterProject: UpdateDrainFilterProject,
): string {
  return JSON.stringify(
    UpdateDrainFilterProject$outboundSchema.parse(updateDrainFilterProject),
  );
}

/** @internal */
export const UpdateDrainFilterSources$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainFilterSources
> = z.nativeEnum(UpdateDrainFilterSources);

/** @internal */
export type FilterLog$Outbound = {
  sources?: Array<string> | undefined;
};

/** @internal */
export const FilterLog$outboundSchema: z.ZodType<
  FilterLog$Outbound,
  z.ZodTypeDef,
  FilterLog
> = z.object({
  sources: z.array(UpdateDrainFilterSources$outboundSchema).optional(),
});

export function filterLogToJSON(filterLog: FilterLog): string {
  return JSON.stringify(FilterLog$outboundSchema.parse(filterLog));
}

/** @internal */
export const UpdateDrainFilterEnvironments$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainFilterEnvironments
> = z.nativeEnum(UpdateDrainFilterEnvironments);

/** @internal */
export type FilterDeployment$Outbound = {
  environments?: Array<string> | undefined;
};

/** @internal */
export const FilterDeployment$outboundSchema: z.ZodType<
  FilterDeployment$Outbound,
  z.ZodTypeDef,
  FilterDeployment
> = z.object({
  environments: z.array(UpdateDrainFilterEnvironments$outboundSchema)
    .optional(),
});

export function filterDeploymentToJSON(
  filterDeployment: FilterDeployment,
): string {
  return JSON.stringify(
    FilterDeployment$outboundSchema.parse(filterDeployment),
  );
}

/** @internal */
export type UpdateDrainFilter1$Outbound = {
  type: string;
  project?: UpdateDrainFilterProject$Outbound | undefined;
  log?: FilterLog$Outbound | undefined;
  deployment?: FilterDeployment$Outbound | undefined;
};

/** @internal */
export const UpdateDrainFilter1$outboundSchema: z.ZodType<
  UpdateDrainFilter1$Outbound,
  z.ZodTypeDef,
  UpdateDrainFilter1
> = z.object({
  type: z.string(),
  project: z.lazy(() => UpdateDrainFilterProject$outboundSchema).optional(),
  log: z.lazy(() => FilterLog$outboundSchema).optional(),
  deployment: z.lazy(() => FilterDeployment$outboundSchema).optional(),
});

export function updateDrainFilter1ToJSON(
  updateDrainFilter1: UpdateDrainFilter1,
): string {
  return JSON.stringify(
    UpdateDrainFilter1$outboundSchema.parse(updateDrainFilter1),
  );
}

/** @internal */
export type FilterFilter$Outbound =
  | UpdateDrainFilterDrains2$Outbound
  | UpdateDrainFilter1$Outbound;

/** @internal */
export const FilterFilter$outboundSchema: z.ZodType<
  FilterFilter$Outbound,
  z.ZodTypeDef,
  FilterFilter
> = smartUnion([
  z.lazy(() => UpdateDrainFilterDrains2$outboundSchema),
  z.lazy(() => UpdateDrainFilter1$outboundSchema),
]);

export function filterFilterToJSON(filterFilter: FilterFilter): string {
  return JSON.stringify(FilterFilter$outboundSchema.parse(filterFilter));
}

/** @internal */
export type UpdateDrainFilter2$Outbound = {
  version: string;
  filter: UpdateDrainFilterDrains2$Outbound | UpdateDrainFilter1$Outbound;
};

/** @internal */
export const UpdateDrainFilter2$outboundSchema: z.ZodType<
  UpdateDrainFilter2$Outbound,
  z.ZodTypeDef,
  UpdateDrainFilter2
> = z.object({
  version: z.string(),
  filter: smartUnion([
    z.lazy(() => UpdateDrainFilterDrains2$outboundSchema),
    z.lazy(() => UpdateDrainFilter1$outboundSchema),
  ]),
});

export function updateDrainFilter2ToJSON(
  updateDrainFilter2: UpdateDrainFilter2,
): string {
  return JSON.stringify(
    UpdateDrainFilter2$outboundSchema.parse(updateDrainFilter2),
  );
}

/** @internal */
export type UpdateDrainFilter$Outbound = UpdateDrainFilter2$Outbound | string;

/** @internal */
export const UpdateDrainFilter$outboundSchema: z.ZodType<
  UpdateDrainFilter$Outbound,
  z.ZodTypeDef,
  UpdateDrainFilter
> = smartUnion([z.lazy(() => UpdateDrainFilter2$outboundSchema), z.string()]);

export function updateDrainFilterToJSON(
  updateDrainFilter: UpdateDrainFilter,
): string {
  return JSON.stringify(
    UpdateDrainFilter$outboundSchema.parse(updateDrainFilter),
  );
}

/** @internal */
export type UpdateDrainSchemas$Outbound = {
  version: string;
};

/** @internal */
export const UpdateDrainSchemas$outboundSchema: z.ZodType<
  UpdateDrainSchemas$Outbound,
  z.ZodTypeDef,
  UpdateDrainSchemas
> = z.object({
  version: z.string(),
});

export function updateDrainSchemasToJSON(
  updateDrainSchemas: UpdateDrainSchemas,
): string {
  return JSON.stringify(
    UpdateDrainSchemas$outboundSchema.parse(updateDrainSchemas),
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsRequestEncoding$outboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsRequestEncoding> = z
    .nativeEnum(UpdateDrainDeliveryDrainsRequestEncoding);

/** @internal */
export const UpdateDrainDeliveryDrainsCompression$outboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsCompression> = z.nativeEnum(
    UpdateDrainDeliveryDrainsCompression,
  );

/** @internal */
export const DeliveryFileStructure$outboundSchema: z.ZodNativeEnum<
  typeof DeliveryFileStructure
> = z.nativeEnum(DeliveryFileStructure);

/** @internal */
export const DeliveryServerSideEncryption$outboundSchema: z.ZodNativeEnum<
  typeof DeliveryServerSideEncryption
> = z.nativeEnum(DeliveryServerSideEncryption);

/** @internal */
export const DeliveryObjectAcl$outboundSchema: z.ZodNativeEnum<
  typeof DeliveryObjectAcl
> = z.nativeEnum(DeliveryObjectAcl);

/** @internal */
export type UpdateDrainDelivery3$Outbound = {
  type: string;
  endpoint: string;
  encoding: string;
  compression: string;
  fileStructure: string;
  roleArn: string;
  region: string;
  serverSideEncryption: string;
  objectAcl?: string | undefined;
};

/** @internal */
export const UpdateDrainDelivery3$outboundSchema: z.ZodType<
  UpdateDrainDelivery3$Outbound,
  z.ZodTypeDef,
  UpdateDrainDelivery3
> = z.object({
  type: z.string(),
  endpoint: z.string(),
  encoding: UpdateDrainDeliveryDrainsRequestEncoding$outboundSchema,
  compression: UpdateDrainDeliveryDrainsCompression$outboundSchema,
  fileStructure: DeliveryFileStructure$outboundSchema,
  roleArn: z.string(),
  region: z.string(),
  serverSideEncryption: DeliveryServerSideEncryption$outboundSchema.default(
    "AES256",
  ),
  objectAcl: DeliveryObjectAcl$outboundSchema.optional(),
});

export function updateDrainDelivery3ToJSON(
  updateDrainDelivery3: UpdateDrainDelivery3,
): string {
  return JSON.stringify(
    UpdateDrainDelivery3$outboundSchema.parse(updateDrainDelivery3),
  );
}

/** @internal */
export type UpdateDrainEndpoint1$Outbound = {
  traces: string;
};

/** @internal */
export const UpdateDrainEndpoint1$outboundSchema: z.ZodType<
  UpdateDrainEndpoint1$Outbound,
  z.ZodTypeDef,
  UpdateDrainEndpoint1
> = z.object({
  traces: z.string(),
});

export function updateDrainEndpoint1ToJSON(
  updateDrainEndpoint1: UpdateDrainEndpoint1,
): string {
  return JSON.stringify(
    UpdateDrainEndpoint1$outboundSchema.parse(updateDrainEndpoint1),
  );
}

/** @internal */
export type DeliveryEndpoint$Outbound = UpdateDrainEndpoint1$Outbound;

/** @internal */
export const DeliveryEndpoint$outboundSchema: z.ZodType<
  DeliveryEndpoint$Outbound,
  z.ZodTypeDef,
  DeliveryEndpoint
> = z.lazy(() => UpdateDrainEndpoint1$outboundSchema);

export function deliveryEndpointToJSON(
  deliveryEndpoint: DeliveryEndpoint,
): string {
  return JSON.stringify(
    DeliveryEndpoint$outboundSchema.parse(deliveryEndpoint),
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsEncoding$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryDrainsEncoding
> = z.nativeEnum(UpdateDrainDeliveryDrainsEncoding);

/** @internal */
export type UpdateDrainDelivery2$Outbound = {
  type: string;
  endpoint: UpdateDrainEndpoint1$Outbound;
  encoding: string;
  headers: { [k: string]: string };
  secret?: string | undefined;
};

/** @internal */
export const UpdateDrainDelivery2$outboundSchema: z.ZodType<
  UpdateDrainDelivery2$Outbound,
  z.ZodTypeDef,
  UpdateDrainDelivery2
> = z.object({
  type: z.string(),
  endpoint: z.lazy(() => UpdateDrainEndpoint1$outboundSchema),
  encoding: UpdateDrainDeliveryDrainsEncoding$outboundSchema,
  headers: z.record(z.string()),
  secret: z.string().optional(),
});

export function updateDrainDelivery2ToJSON(
  updateDrainDelivery2: UpdateDrainDelivery2,
): string {
  return JSON.stringify(
    UpdateDrainDelivery2$outboundSchema.parse(updateDrainDelivery2),
  );
}

/** @internal */
export const UpdateDrainDeliveryCompression$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryCompression
> = z.nativeEnum(UpdateDrainDeliveryCompression);

/** @internal */
export const UpdateDrainDeliveryEncoding$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryEncoding
> = z.nativeEnum(UpdateDrainDeliveryEncoding);

/** @internal */
export type UpdateDrainDelivery1$Outbound = {
  type: string;
  endpoint: string;
  compression?: string | undefined;
  encoding: string;
  headers: { [k: string]: string };
  secret?: string | undefined;
};

/** @internal */
export const UpdateDrainDelivery1$outboundSchema: z.ZodType<
  UpdateDrainDelivery1$Outbound,
  z.ZodTypeDef,
  UpdateDrainDelivery1
> = z.object({
  type: z.string(),
  endpoint: z.string(),
  compression: UpdateDrainDeliveryCompression$outboundSchema.optional(),
  encoding: UpdateDrainDeliveryEncoding$outboundSchema,
  headers: z.record(z.string()),
  secret: z.string().optional(),
});

export function updateDrainDelivery1ToJSON(
  updateDrainDelivery1: UpdateDrainDelivery1,
): string {
  return JSON.stringify(
    UpdateDrainDelivery1$outboundSchema.parse(updateDrainDelivery1),
  );
}

/** @internal */
export type UpdateDrainDelivery$Outbound =
  | UpdateDrainDelivery3$Outbound
  | UpdateDrainDelivery1$Outbound
  | UpdateDrainDelivery2$Outbound;

/** @internal */
export const UpdateDrainDelivery$outboundSchema: z.ZodType<
  UpdateDrainDelivery$Outbound,
  z.ZodTypeDef,
  UpdateDrainDelivery
> = smartUnion([
  z.lazy(() => UpdateDrainDelivery3$outboundSchema),
  z.lazy(() => UpdateDrainDelivery1$outboundSchema),
  z.lazy(() => UpdateDrainDelivery2$outboundSchema),
]);

export function updateDrainDeliveryToJSON(
  updateDrainDelivery: UpdateDrainDelivery,
): string {
  return JSON.stringify(
    UpdateDrainDelivery$outboundSchema.parse(updateDrainDelivery),
  );
}

/** @internal */
export const UpdateDrainEnv$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainEnv
> = z.nativeEnum(UpdateDrainEnv);

/** @internal */
export type UpdateDrainSampling$Outbound = {
  type: string;
  rate: number;
  env?: string | undefined;
  requestPath?: string | undefined;
};

/** @internal */
export const UpdateDrainSampling$outboundSchema: z.ZodType<
  UpdateDrainSampling$Outbound,
  z.ZodTypeDef,
  UpdateDrainSampling
> = z.object({
  type: z.string(),
  rate: z.number(),
  env: UpdateDrainEnv$outboundSchema.optional(),
  requestPath: z.string().optional(),
});

export function updateDrainSamplingToJSON(
  updateDrainSampling: UpdateDrainSampling,
): string {
  return JSON.stringify(
    UpdateDrainSampling$outboundSchema.parse(updateDrainSampling),
  );
}

/** @internal */
export type UpdateDrainTransforms$Outbound = {
  id: string;
};

/** @internal */
export const UpdateDrainTransforms$outboundSchema: z.ZodType<
  UpdateDrainTransforms$Outbound,
  z.ZodTypeDef,
  UpdateDrainTransforms
> = z.object({
  id: z.string(),
});

export function updateDrainTransformsToJSON(
  updateDrainTransforms: UpdateDrainTransforms,
): string {
  return JSON.stringify(
    UpdateDrainTransforms$outboundSchema.parse(updateDrainTransforms),
  );
}

/** @internal */
export const UpdateDrainStatus$outboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainStatus
> = z.nativeEnum(UpdateDrainStatus);

/** @internal */
export type UpdateDrainSource2$Outbound = {
  kind: string;
};

/** @internal */
export const UpdateDrainSource2$outboundSchema: z.ZodType<
  UpdateDrainSource2$Outbound,
  z.ZodTypeDef,
  UpdateDrainSource2
> = z.object({
  kind: z.string().default("self-served"),
});

export function updateDrainSource2ToJSON(
  updateDrainSource2: UpdateDrainSource2,
): string {
  return JSON.stringify(
    UpdateDrainSource2$outboundSchema.parse(updateDrainSource2),
  );
}

/** @internal */
export type UpdateDrain13$Outbound = {
  kind: string;
};

/** @internal */
export const UpdateDrain13$outboundSchema: z.ZodType<
  UpdateDrain13$Outbound,
  z.ZodTypeDef,
  UpdateDrain13
> = z.object({
  kind: z.string().default("integration"),
});

export function updateDrain13ToJSON(updateDrain13: UpdateDrain13): string {
  return JSON.stringify(UpdateDrain13$outboundSchema.parse(updateDrain13));
}

/** @internal */
export type UpdateDrain12$Outbound = {
  kind: string;
  resourceId: string;
};

/** @internal */
export const UpdateDrain12$outboundSchema: z.ZodType<
  UpdateDrain12$Outbound,
  z.ZodTypeDef,
  UpdateDrain12
> = z.object({
  kind: z.string().default("integration"),
  resourceId: z.string(),
});

export function updateDrain12ToJSON(updateDrain12: UpdateDrain12): string {
  return JSON.stringify(UpdateDrain12$outboundSchema.parse(updateDrain12));
}

/** @internal */
export type UpdateDrain11$Outbound = {
  kind: string;
  externalResourceId: string;
};

/** @internal */
export const UpdateDrain11$outboundSchema: z.ZodType<
  UpdateDrain11$Outbound,
  z.ZodTypeDef,
  UpdateDrain11
> = z.object({
  kind: z.string().default("integration"),
  externalResourceId: z.string(),
});

export function updateDrain11ToJSON(updateDrain11: UpdateDrain11): string {
  return JSON.stringify(UpdateDrain11$outboundSchema.parse(updateDrain11));
}

/** @internal */
export type UpdateDrainSource1$Outbound =
  | UpdateDrain11$Outbound
  | UpdateDrain12$Outbound
  | UpdateDrain13$Outbound;

/** @internal */
export const UpdateDrainSource1$outboundSchema: z.ZodType<
  UpdateDrainSource1$Outbound,
  z.ZodTypeDef,
  UpdateDrainSource1
> = smartUnion([
  z.lazy(() => UpdateDrain11$outboundSchema),
  z.lazy(() => UpdateDrain12$outboundSchema),
  z.lazy(() => UpdateDrain13$outboundSchema),
]);

export function updateDrainSource1ToJSON(
  updateDrainSource1: UpdateDrainSource1,
): string {
  return JSON.stringify(
    UpdateDrainSource1$outboundSchema.parse(updateDrainSource1),
  );
}

/** @internal */
export type UpdateDrainSource$Outbound =
  | UpdateDrain11$Outbound
  | UpdateDrain12$Outbound
  | UpdateDrain13$Outbound
  | UpdateDrainSource2$Outbound;

/** @internal */
export const UpdateDrainSource$outboundSchema: z.ZodType<
  UpdateDrainSource$Outbound,
  z.ZodTypeDef,
  UpdateDrainSource
> = smartUnion([
  smartUnion([
    z.lazy(() => UpdateDrain11$outboundSchema),
    z.lazy(() => UpdateDrain12$outboundSchema),
    z.lazy(() => UpdateDrain13$outboundSchema),
  ]),
  z.lazy(() => UpdateDrainSource2$outboundSchema),
]);

export function updateDrainSourceToJSON(
  updateDrainSource: UpdateDrainSource,
): string {
  return JSON.stringify(
    UpdateDrainSource$outboundSchema.parse(updateDrainSource),
  );
}

/** @internal */
export type UpdateDrainRequestBody$Outbound = {
  name?: string | undefined;
  projects?: string | undefined;
  projectIds?: Array<string> | null | undefined;
  filter?: UpdateDrainFilter2$Outbound | string | undefined;
  schemas?: { [k: string]: UpdateDrainSchemas$Outbound } | undefined;
  delivery?:
    | UpdateDrainDelivery3$Outbound
    | UpdateDrainDelivery1$Outbound
    | UpdateDrainDelivery2$Outbound
    | undefined;
  sampling?: Array<UpdateDrainSampling$Outbound> | null | undefined;
  transforms?: Array<UpdateDrainTransforms$Outbound> | null | undefined;
  status?: string | undefined;
  source?:
    | UpdateDrain11$Outbound
    | UpdateDrain12$Outbound
    | UpdateDrain13$Outbound
    | UpdateDrainSource2$Outbound
    | undefined;
};

/** @internal */
export const UpdateDrainRequestBody$outboundSchema: z.ZodType<
  UpdateDrainRequestBody$Outbound,
  z.ZodTypeDef,
  UpdateDrainRequestBody
> = z.object({
  name: z.string().optional(),
  projects: UpdateDrainProjects$outboundSchema.optional(),
  projectIds: z.nullable(z.array(z.string())).optional(),
  filter: smartUnion([
    z.lazy(() => UpdateDrainFilter2$outboundSchema),
    z.string(),
  ]).optional(),
  schemas: z.record(z.lazy(() => UpdateDrainSchemas$outboundSchema)).optional(),
  delivery: smartUnion([
    z.lazy(() => UpdateDrainDelivery3$outboundSchema),
    z.lazy(() => UpdateDrainDelivery1$outboundSchema),
    z.lazy(() => UpdateDrainDelivery2$outboundSchema),
  ]).optional(),
  sampling: z.nullable(
    z.array(z.lazy(() => UpdateDrainSampling$outboundSchema)),
  ).optional(),
  transforms: z.nullable(
    z.array(z.lazy(() => UpdateDrainTransforms$outboundSchema)),
  ).optional(),
  status: UpdateDrainStatus$outboundSchema.optional(),
  source: smartUnion([
    smartUnion([
      z.lazy(() => UpdateDrain11$outboundSchema),
      z.lazy(() => UpdateDrain12$outboundSchema),
      z.lazy(() => UpdateDrain13$outboundSchema),
    ]),
    z.lazy(() => UpdateDrainSource2$outboundSchema),
  ]).optional(),
});

export function updateDrainRequestBodyToJSON(
  updateDrainRequestBody: UpdateDrainRequestBody,
): string {
  return JSON.stringify(
    UpdateDrainRequestBody$outboundSchema.parse(updateDrainRequestBody),
  );
}

/** @internal */
export type UpdateDrainRequest$Outbound = {
  id: string;
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody?: UpdateDrainRequestBody$Outbound | undefined;
};

/** @internal */
export const UpdateDrainRequest$outboundSchema: z.ZodType<
  UpdateDrainRequest$Outbound,
  z.ZodTypeDef,
  UpdateDrainRequest
> = z.object({
  id: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.lazy(() => UpdateDrainRequestBody$outboundSchema).optional(),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function updateDrainRequestToJSON(
  updateDrainRequest: UpdateDrainRequest,
): string {
  return JSON.stringify(
    UpdateDrainRequest$outboundSchema.parse(updateDrainRequest),
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsStatus$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyDrainsStatus
> = z.nativeEnum(UpdateDrainResponseBodyDrainsStatus);

/** @internal */
export const UpdateDrainResponseBodyDrainsDisabledReason$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainResponseBodyDrainsDisabledReason> = z
    .nativeEnum(UpdateDrainResponseBodyDrainsDisabledReason);

/** @internal */
export const UpdateDrainResponseBodyDrainsLog$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsLog,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyDrainsLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsTrace$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsTrace,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsTraceFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsTrace, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsTrace$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsTrace' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsAnalytics$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsAnalytics,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsAnalyticsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsAnalytics, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsAnalytics$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsAnalytics' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsSpeedInsights$inboundSchema:
  z.ZodType<UpdateDrainResponseBodyDrainsSpeedInsights, z.ZodTypeDef, unknown> =
    z.object({});

export function updateDrainResponseBodyDrainsSpeedInsightsFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateDrainResponseBodyDrainsSpeedInsights,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsSpeedInsights$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateDrainResponseBodyDrainsSpeedInsights' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsAiGateway$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsAiGateway,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsAiGatewayFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsAiGateway, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsAiGateway$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsAiGateway' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsAuditLog$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsAuditLog,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsAuditLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsAuditLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsAuditLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsAuditLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsConnect$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsConnect,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyDrainsConnectFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsConnect, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsConnect$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsConnect' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsSchemas$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsSchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsLog$inboundSchema),
  ),
  trace: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsTrace$inboundSchema),
  ),
  analytics: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsAnalytics$inboundSchema),
  ),
  speed_insights: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsSpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsAiGateway$inboundSchema),
  ),
  audit_log: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsAuditLog$inboundSchema),
  ),
  connect: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsConnect$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

export function updateDrainResponseBodyDrainsSchemasFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsSchemas, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsSchemas$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsSchemas' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsTarget$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryDrainsTarget
> = z.nativeEnum(UpdateDrainDeliveryDrainsTarget);

/** @internal */
export const UpdateDrainDeliveryDrains5$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrains5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("internal"),
  target: UpdateDrainDeliveryDrainsTarget$inboundSchema,
});

export function updateDrainDeliveryDrains5FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrains5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrains5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrains5' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding
  > = z.nativeEnum(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding,
  );

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression
  > = z.nativeEnum(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression,
  );

/** @internal */
export const UpdateDrainDeliveryDrainsFileStructure$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsFileStructure> = z.nativeEnum(
    UpdateDrainDeliveryDrainsFileStructure,
  );

/** @internal */
export const UpdateDrainDeliveryDrainsServerSideEncryption$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsServerSideEncryption> = z
    .nativeEnum(UpdateDrainDeliveryDrainsServerSideEncryption);

/** @internal */
export const UpdateDrainDeliveryDrainsObjectAcl$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryDrainsObjectAcl
> = z.nativeEnum(UpdateDrainDeliveryDrainsObjectAcl);

/** @internal */
export const UpdateDrainDeliveryDrains4$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrains4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding$inboundSchema,
  compression:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyCompression$inboundSchema,
  fileStructure: UpdateDrainDeliveryDrainsFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    UpdateDrainDeliveryDrainsServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(UpdateDrainDeliveryDrainsObjectAcl$inboundSchema),
});

export function updateDrainDeliveryDrains4FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrains4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrains4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrains4' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse3$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsResponse3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("clickhouse"),
  endpoint: types.string(),
  table: types.string(),
});

export function updateDrainDeliveryDrainsResponse3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrainsResponse3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainDeliveryDrainsResponse3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrainsResponse3' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsEndpoint$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsEndpoint,
  z.ZodTypeDef,
  unknown
> = z.object({
  traces: types.string(),
});

export function updateDrainDeliveryDrainsEndpointFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrainsEndpoint, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrainsEndpoint$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrainsEndpoint' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding
  > = z.nativeEnum(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding,
  );

/** @internal */
export const UpdateDrainSecretDrainsResponse200Kind$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainSecretDrainsResponse200Kind> = z.nativeEnum(
    UpdateDrainSecretDrainsResponse200Kind,
  );

/** @internal */
export const UpdateDrainSecretDrainsResponse2002$inboundSchema: z.ZodType<
  UpdateDrainSecretDrainsResponse2002,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: UpdateDrainSecretDrainsResponse200Kind$inboundSchema,
});

export function updateDrainSecretDrainsResponse2002FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSecretDrainsResponse2002, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainSecretDrainsResponse2002$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSecretDrainsResponse2002' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200Secret$inboundSchema:
  z.ZodType<UpdateDrainDeliveryDrainsResponse200Secret, z.ZodTypeDef, unknown> =
    smartUnion([
      z.lazy(() => UpdateDrainSecretDrainsResponse2002$inboundSchema),
      types.string(),
    ]);

export function updateDrainDeliveryDrainsResponse200SecretFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateDrainDeliveryDrainsResponse200Secret,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainDeliveryDrainsResponse200Secret$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateDrainDeliveryDrainsResponse200Secret' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse2$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("otlphttp"),
  endpoint: z.lazy(() => UpdateDrainDeliveryDrainsEndpoint$inboundSchema),
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding$inboundSchema,
  headers: z.record(types.string()),
  secret: types.optional(
    smartUnion([
      z.lazy(() => UpdateDrainSecretDrainsResponse2002$inboundSchema),
      types.string(),
    ]),
  ),
});

export function updateDrainDeliveryDrainsResponse2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrainsResponse2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainDeliveryDrainsResponse2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrainsResponse2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding
  > = z.nativeEnum(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding,
  );

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression
  > = z.nativeEnum(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression,
  );

/** @internal */
export const UpdateDrainSecretDrainsResponseKind$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainSecretDrainsResponseKind
> = z.nativeEnum(UpdateDrainSecretDrainsResponseKind);

/** @internal */
export const UpdateDrainSecretDrainsResponse2$inboundSchema: z.ZodType<
  UpdateDrainSecretDrainsResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: UpdateDrainSecretDrainsResponseKind$inboundSchema,
});

export function updateDrainSecretDrainsResponse2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSecretDrainsResponse2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSecretDrainsResponse2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSecretDrainsResponse2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponseSecret$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsResponseSecret,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateDrainSecretDrainsResponse2$inboundSchema),
  types.string(),
]);

export function updateDrainDeliveryDrainsResponseSecretFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateDrainDeliveryDrainsResponseSecret,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainDeliveryDrainsResponseSecret$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateDrainDeliveryDrainsResponseSecret' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse1$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsResponse1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("http"),
  endpoint: types.string(),
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding$inboundSchema,
  compression: types.optional(
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONCompression$inboundSchema,
  ),
  headers: z.record(types.string()),
  secret: types.optional(
    smartUnion([
      z.lazy(() => UpdateDrainSecretDrainsResponse2$inboundSchema),
      types.string(),
    ]),
  ),
});

export function updateDrainDeliveryDrainsResponse1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrainsResponse1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainDeliveryDrainsResponse1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrainsResponse1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsDelivery$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainDeliveryDrainsResponse1$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrainsResponse2$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrainsResponse3$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrains4$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrains5$inboundSchema),
]);

export function updateDrainResponseBodyDrainsDeliveryFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsDelivery, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsDelivery$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsDelivery' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsType$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyDrainsType
> = z.nativeEnum(UpdateDrainResponseBodyDrainsType);

/** @internal */
export const UpdateDrainResponseBodyDrainsEnv$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyDrainsEnv
> = z.nativeEnum(UpdateDrainResponseBodyDrainsEnv);

/** @internal */
export const UpdateDrainResponseBodyDrainsSampling$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsSampling,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: UpdateDrainResponseBodyDrainsType$inboundSchema,
  rate: types.number(),
  env: types.optional(UpdateDrainResponseBodyDrainsEnv$inboundSchema),
  requestPath: types.optional(types.string()),
});

export function updateDrainResponseBodyDrainsSamplingFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsSampling, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsSampling$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsSampling' from JSON`,
  );
}

/** @internal */
export const UpdateDrainSourceDrainsResponse2$inboundSchema: z.ZodType<
  UpdateDrainSourceDrainsResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: types.literal("integration"),
  resourceId: types.optional(types.string()),
  externalResourceId: types.optional(types.string()),
  integrationId: types.string(),
  integrationConfigurationId: types.string(),
});

export function updateDrainSourceDrainsResponse2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSourceDrainsResponse2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSourceDrainsResponse2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSourceDrainsResponse2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainSourceDrainsResponse1$inboundSchema: z.ZodType<
  UpdateDrainSourceDrainsResponse1,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: types.literal("self-served"),
});

export function updateDrainSourceDrainsResponse1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSourceDrainsResponse1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSourceDrainsResponse1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSourceDrainsResponse1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsSource$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsSource,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainSourceDrainsResponse1$inboundSchema),
  z.lazy(() => UpdateDrainSourceDrainsResponse2$inboundSchema),
]);

export function updateDrainResponseBodyDrainsSourceFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsSource, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsSource$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsSource' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsVersion$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainResponseBodyDrainsVersion> = z.nativeEnum(
    UpdateDrainResponseBodyDrainsVersion,
  );

/** @internal */
export const UpdateDrainFilterDrainsResponse2002$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsResponse2002,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("odata"),
  text: types.string(),
});

export function updateDrainFilterDrainsResponse2002FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsResponse2002, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainFilterDrainsResponse2002$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsResponse2002' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsResponseProject$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsResponseProject,
  z.ZodTypeDef,
  unknown
> = z.object({
  ids: types.optional(z.array(types.string())),
});

export function updateDrainFilterDrainsResponseProjectFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsResponseProject, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainFilterDrainsResponseProject$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsResponseProject' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsResponseSources$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainFilterDrainsResponseSources> = z.nativeEnum(
    UpdateDrainFilterDrainsResponseSources,
  );

/** @internal */
export const UpdateDrainFilterDrainsLog$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsLog,
  z.ZodTypeDef,
  unknown
> = z.object({
  sources: types.optional(
    z.array(UpdateDrainFilterDrainsResponseSources$inboundSchema),
  ),
  legacy_excludeCachedStaticAssetLogs: types.optional(types.boolean()),
}).transform((v) => {
  return remap$(v, {
    "legacy_excludeCachedStaticAssetLogs": "legacyExcludeCachedStaticAssetLogs",
  });
});

export function updateDrainFilterDrainsLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrainsLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsResponseEnvironments$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainFilterDrainsResponseEnvironments> = z
    .nativeEnum(UpdateDrainFilterDrainsResponseEnvironments);

/** @internal */
export const UpdateDrainFilterDrainsDeployment$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsDeployment,
  z.ZodTypeDef,
  unknown
> = z.object({
  environments: types.optional(
    z.array(UpdateDrainFilterDrainsResponseEnvironments$inboundSchema),
  ),
});

export function updateDrainFilterDrainsDeploymentFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsDeployment, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrainsDeployment$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsDeployment' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsResponse1$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsResponse1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("basic"),
  project: types.optional(
    z.lazy(() => UpdateDrainFilterDrainsResponseProject$inboundSchema),
  ),
  log: types.optional(z.lazy(() => UpdateDrainFilterDrainsLog$inboundSchema)),
  deployment: types.optional(
    z.lazy(() => UpdateDrainFilterDrainsDeployment$inboundSchema),
  ),
});

export function updateDrainFilterDrainsResponse1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsResponse1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrainsResponse1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsResponse1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsFilter$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsFilter,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainFilterDrainsResponse1$inboundSchema),
  z.lazy(() => UpdateDrainFilterDrainsResponse2002$inboundSchema),
]);

export function updateDrainResponseBodyDrainsFilterFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsFilter, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsFilter$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsFilter' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDrainsFilterV2$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDrainsFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: UpdateDrainResponseBodyDrainsVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => UpdateDrainFilterDrainsResponse1$inboundSchema),
    z.lazy(() => UpdateDrainFilterDrainsResponse2002$inboundSchema),
  ]),
});

export function updateDrainResponseBodyDrainsFilterV2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDrainsFilterV2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyDrainsFilterV2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDrainsFilterV2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainProjectAccessDrainsManagedBy$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainProjectAccessDrainsManagedBy> = z
    .nativeEnum(UpdateDrainProjectAccessDrainsManagedBy);

/** @internal */
export const UpdateDrainProjectAccess2$inboundSchema: z.ZodType<
  UpdateDrainProjectAccess2,
  z.ZodTypeDef,
  unknown
> = z.object({
  access: types.literal("some"),
  projectIds: z.array(types.string()),
  managedBy: UpdateDrainProjectAccessDrainsManagedBy$inboundSchema,
});

export function updateDrainProjectAccess2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainProjectAccess2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainProjectAccess2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainProjectAccess2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainProjectAccessManagedBy$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainProjectAccessManagedBy
> = z.nativeEnum(UpdateDrainProjectAccessManagedBy);

/** @internal */
export const UpdateDrainProjectAccess1$inboundSchema: z.ZodType<
  UpdateDrainProjectAccess1,
  z.ZodTypeDef,
  unknown
> = z.object({
  access: types.literal("all"),
  managedBy: UpdateDrainProjectAccessManagedBy$inboundSchema,
});

export function updateDrainProjectAccess1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainProjectAccess1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainProjectAccess1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainProjectAccess1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyProjectAccess$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyProjectAccess,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainProjectAccess1$inboundSchema),
  z.lazy(() => UpdateDrainProjectAccess2$inboundSchema),
]);

export function updateDrainResponseBodyProjectAccessFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyProjectAccess, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodyProjectAccess$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyProjectAccess' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBody2$inboundSchema: z.ZodType<
  UpdateDrainResponseBody2,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  createdAt: types.number(),
  updatedAt: types.number(),
  projectIds: types.optional(z.array(types.string())),
  name: types.string(),
  teamId: z.nullable(types.string()).optional(),
  ownerId: types.string(),
  status: types.optional(UpdateDrainResponseBodyDrainsStatus$inboundSchema),
  firstErrorTimestamp: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  disabledBy: types.optional(types.string()),
  disabledReason: types.optional(
    UpdateDrainResponseBodyDrainsDisabledReason$inboundSchema,
  ),
  schemas: z.lazy(() => UpdateDrainResponseBodyDrainsSchemas$inboundSchema),
  delivery: z.union([
    z.lazy(() => UpdateDrainDeliveryDrainsResponse1$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrainsResponse2$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrainsResponse3$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrains4$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrains5$inboundSchema),
  ]),
  sampling: types.optional(
    z.array(z.lazy(() => UpdateDrainResponseBodyDrainsSampling$inboundSchema)),
  ),
  source: z.union([
    z.lazy(() => UpdateDrainSourceDrainsResponse1$inboundSchema),
    z.lazy(() => UpdateDrainSourceDrainsResponse2$inboundSchema),
  ]),
  filterV2: types.optional(
    z.lazy(() => UpdateDrainResponseBodyDrainsFilterV2$inboundSchema),
  ),
  integrationIcon: types.optional(types.string()),
  integrationConfigurationUri: types.optional(types.string()),
  integrationWebsite: types.optional(types.string()),
  projectAccess: types.optional(
    z.union([
      z.lazy(() => UpdateDrainProjectAccess1$inboundSchema),
      z.lazy(() => UpdateDrainProjectAccess2$inboundSchema),
    ]),
  ),
});

export function updateDrainResponseBody2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBody2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBody2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBody2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyStatus$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyStatus
> = z.nativeEnum(UpdateDrainResponseBodyStatus);

/** @internal */
export const UpdateDrainResponseBodyDisabledReason$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainResponseBodyDisabledReason> = z.nativeEnum(
    UpdateDrainResponseBodyDisabledReason,
  );

/** @internal */
export const UpdateDrainResponseBodyLog$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyLog,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyTrace$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyTrace,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyTraceFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyTrace, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyTrace$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyTrace' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyAnalytics$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyAnalytics,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyAnalyticsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyAnalytics, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyAnalytics$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyAnalytics' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodySpeedInsights$inboundSchema: z.ZodType<
  UpdateDrainResponseBodySpeedInsights,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodySpeedInsightsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodySpeedInsights, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateDrainResponseBodySpeedInsights$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodySpeedInsights' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyAiGateway$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyAiGateway,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyAiGatewayFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyAiGateway, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyAiGateway$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyAiGateway' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyAuditLog$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyAuditLog,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyAuditLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyAuditLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyAuditLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyAuditLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyConnect$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyConnect,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function updateDrainResponseBodyConnectFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyConnect, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyConnect$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyConnect' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodySchemas$inboundSchema: z.ZodType<
  UpdateDrainResponseBodySchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(z.lazy(() => UpdateDrainResponseBodyLog$inboundSchema)),
  trace: types.optional(
    z.lazy(() => UpdateDrainResponseBodyTrace$inboundSchema),
  ),
  analytics: types.optional(
    z.lazy(() => UpdateDrainResponseBodyAnalytics$inboundSchema),
  ),
  speed_insights: types.optional(
    z.lazy(() => UpdateDrainResponseBodySpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(
    z.lazy(() => UpdateDrainResponseBodyAiGateway$inboundSchema),
  ),
  audit_log: types.optional(
    z.lazy(() => UpdateDrainResponseBodyAuditLog$inboundSchema),
  ),
  connect: types.optional(
    z.lazy(() => UpdateDrainResponseBodyConnect$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

export function updateDrainResponseBodySchemasFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodySchemas, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodySchemas$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodySchemas' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryTarget$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryTarget
> = z.nativeEnum(UpdateDrainDeliveryTarget);

/** @internal */
export const UpdateDrainDelivery5$inboundSchema: z.ZodType<
  UpdateDrainDelivery5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("internal"),
  target: UpdateDrainDeliveryTarget$inboundSchema,
});

export function updateDrainDelivery5FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDelivery5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDelivery5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDelivery5' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding
  > = z.nativeEnum(UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding);

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200Compression$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsResponse200Compression> = z
    .nativeEnum(UpdateDrainDeliveryDrainsResponse200Compression);

/** @internal */
export const UpdateDrainDeliveryFileStructure$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryFileStructure
> = z.nativeEnum(UpdateDrainDeliveryFileStructure);

/** @internal */
export const UpdateDrainDeliveryServerSideEncryption$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryServerSideEncryption> = z
    .nativeEnum(UpdateDrainDeliveryServerSideEncryption);

/** @internal */
export const UpdateDrainDeliveryObjectAcl$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainDeliveryObjectAcl
> = z.nativeEnum(UpdateDrainDeliveryObjectAcl);

/** @internal */
export const UpdateDrainDelivery4$inboundSchema: z.ZodType<
  UpdateDrainDelivery4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding:
    UpdateDrainDeliveryDrainsResponse200ApplicationJSONEncoding$inboundSchema,
  compression: UpdateDrainDeliveryDrainsResponse200Compression$inboundSchema,
  fileStructure: UpdateDrainDeliveryFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    UpdateDrainDeliveryServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(UpdateDrainDeliveryObjectAcl$inboundSchema),
});

export function updateDrainDelivery4FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDelivery4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDelivery4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDelivery4' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrains3$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrains3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("clickhouse"),
  endpoint: types.string(),
  table: types.string(),
});

export function updateDrainDeliveryDrains3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrains3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrains3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrains3' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryEndpoint$inboundSchema: z.ZodType<
  UpdateDrainDeliveryEndpoint,
  z.ZodTypeDef,
  unknown
> = z.object({
  traces: types.string(),
});

export function updateDrainDeliveryEndpointFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryEndpoint, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryEndpoint$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryEndpoint' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponse200Encoding$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsResponse200Encoding> = z
    .nativeEnum(UpdateDrainDeliveryDrainsResponse200Encoding);

/** @internal */
export const UpdateDrainSecretDrainsKind$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainSecretDrainsKind
> = z.nativeEnum(UpdateDrainSecretDrainsKind);

/** @internal */
export const UpdateDrainSecretDrains2$inboundSchema: z.ZodType<
  UpdateDrainSecretDrains2,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: UpdateDrainSecretDrainsKind$inboundSchema,
});

export function updateDrainSecretDrains2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSecretDrains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSecretDrains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSecretDrains2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsSecret$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrainsSecret,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateDrainSecretDrains2$inboundSchema),
  types.string(),
]);

export function updateDrainDeliveryDrainsSecretFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrainsSecret, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrainsSecret$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrainsSecret' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrains2$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrains2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("otlphttp"),
  endpoint: z.lazy(() => UpdateDrainDeliveryEndpoint$inboundSchema),
  encoding: UpdateDrainDeliveryDrainsResponse200Encoding$inboundSchema,
  headers: z.record(types.string()),
  secret: types.optional(
    smartUnion([
      z.lazy(() => UpdateDrainSecretDrains2$inboundSchema),
      types.string(),
    ]),
  ),
});

export function updateDrainDeliveryDrains2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrains2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrainsResponseEncoding$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsResponseEncoding> = z
    .nativeEnum(UpdateDrainDeliveryDrainsResponseEncoding);

/** @internal */
export const UpdateDrainDeliveryDrainsResponseCompression$inboundSchema:
  z.ZodNativeEnum<typeof UpdateDrainDeliveryDrainsResponseCompression> = z
    .nativeEnum(UpdateDrainDeliveryDrainsResponseCompression);

/** @internal */
export const UpdateDrainSecretKind$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainSecretKind
> = z.nativeEnum(UpdateDrainSecretKind);

/** @internal */
export const UpdateDrainSecret2$inboundSchema: z.ZodType<
  UpdateDrainSecret2,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: UpdateDrainSecretKind$inboundSchema,
});

export function updateDrainSecret2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSecret2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSecret2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSecret2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliverySecret$inboundSchema: z.ZodType<
  UpdateDrainDeliverySecret,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateDrainSecret2$inboundSchema),
  types.string(),
]);

export function updateDrainDeliverySecretFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliverySecret, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliverySecret$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliverySecret' from JSON`,
  );
}

/** @internal */
export const UpdateDrainDeliveryDrains1$inboundSchema: z.ZodType<
  UpdateDrainDeliveryDrains1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("http"),
  endpoint: types.string(),
  encoding: UpdateDrainDeliveryDrainsResponseEncoding$inboundSchema,
  compression: types.optional(
    UpdateDrainDeliveryDrainsResponseCompression$inboundSchema,
  ),
  headers: z.record(types.string()),
  secret: types.optional(
    smartUnion([
      z.lazy(() => UpdateDrainSecret2$inboundSchema),
      types.string(),
    ]),
  ),
});

export function updateDrainDeliveryDrains1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainDeliveryDrains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainDeliveryDrains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainDeliveryDrains1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyDelivery$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainDeliveryDrains1$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrains2$inboundSchema),
  z.lazy(() => UpdateDrainDeliveryDrains3$inboundSchema),
  z.lazy(() => UpdateDrainDelivery4$inboundSchema),
  z.lazy(() => UpdateDrainDelivery5$inboundSchema),
]);

export function updateDrainResponseBodyDeliveryFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyDelivery, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyDelivery$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyDelivery' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyType$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyType
> = z.nativeEnum(UpdateDrainResponseBodyType);

/** @internal */
export const UpdateDrainResponseBodyEnv$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyEnv
> = z.nativeEnum(UpdateDrainResponseBodyEnv);

/** @internal */
export const UpdateDrainResponseBodySampling$inboundSchema: z.ZodType<
  UpdateDrainResponseBodySampling,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: UpdateDrainResponseBodyType$inboundSchema,
  rate: types.number(),
  env: types.optional(UpdateDrainResponseBodyEnv$inboundSchema),
  requestPath: types.optional(types.string()),
});

export function updateDrainResponseBodySamplingFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodySampling, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodySampling$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodySampling' from JSON`,
  );
}

/** @internal */
export const UpdateDrainSourceDrains2$inboundSchema: z.ZodType<
  UpdateDrainSourceDrains2,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: types.literal("integration"),
  resourceId: types.optional(types.string()),
  externalResourceId: types.optional(types.string()),
  integrationId: types.string(),
  integrationConfigurationId: types.string(),
});

export function updateDrainSourceDrains2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSourceDrains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSourceDrains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSourceDrains2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainSourceDrains1$inboundSchema: z.ZodType<
  UpdateDrainSourceDrains1,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: types.literal("self-served"),
});

export function updateDrainSourceDrains1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainSourceDrains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainSourceDrains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainSourceDrains1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodySource$inboundSchema: z.ZodType<
  UpdateDrainResponseBodySource,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainSourceDrains1$inboundSchema),
  z.lazy(() => UpdateDrainSourceDrains2$inboundSchema),
]);

export function updateDrainResponseBodySourceFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodySource, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodySource$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodySource' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyVersion$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainResponseBodyVersion
> = z.nativeEnum(UpdateDrainResponseBodyVersion);

/** @internal */
export const UpdateDrainFilterDrainsResponse2$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("odata"),
  text: types.string(),
});

export function updateDrainFilterDrainsResponse2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsResponse2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrainsResponse2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsResponse2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsProject$inboundSchema: z.ZodType<
  UpdateDrainFilterDrainsProject,
  z.ZodTypeDef,
  unknown
> = z.object({
  ids: types.optional(z.array(types.string())),
});

export function updateDrainFilterDrainsProjectFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrainsProject, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrainsProject$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrainsProject' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsSources$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainFilterDrainsSources
> = z.nativeEnum(UpdateDrainFilterDrainsSources);

/** @internal */
export const UpdateDrainFilterLog$inboundSchema: z.ZodType<
  UpdateDrainFilterLog,
  z.ZodTypeDef,
  unknown
> = z.object({
  sources: types.optional(
    z.array(UpdateDrainFilterDrainsSources$inboundSchema),
  ),
  legacy_excludeCachedStaticAssetLogs: types.optional(types.boolean()),
}).transform((v) => {
  return remap$(v, {
    "legacy_excludeCachedStaticAssetLogs": "legacyExcludeCachedStaticAssetLogs",
  });
});

export function updateDrainFilterLogFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterLog, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterLog$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterLog' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrainsEnvironments$inboundSchema: z.ZodNativeEnum<
  typeof UpdateDrainFilterDrainsEnvironments
> = z.nativeEnum(UpdateDrainFilterDrainsEnvironments);

/** @internal */
export const UpdateDrainFilterDeployment$inboundSchema: z.ZodType<
  UpdateDrainFilterDeployment,
  z.ZodTypeDef,
  unknown
> = z.object({
  environments: types.optional(
    z.array(UpdateDrainFilterDrainsEnvironments$inboundSchema),
  ),
});

export function updateDrainFilterDeploymentFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDeployment, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDeployment$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDeployment' from JSON`,
  );
}

/** @internal */
export const UpdateDrainFilterDrains1$inboundSchema: z.ZodType<
  UpdateDrainFilterDrains1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("basic"),
  project: types.optional(
    z.lazy(() => UpdateDrainFilterDrainsProject$inboundSchema),
  ),
  log: types.optional(z.lazy(() => UpdateDrainFilterLog$inboundSchema)),
  deployment: types.optional(
    z.lazy(() => UpdateDrainFilterDeployment$inboundSchema),
  ),
});

export function updateDrainFilterDrains1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainFilterDrains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainFilterDrains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainFilterDrains1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyFilter$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyFilter,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateDrainFilterDrains1$inboundSchema),
  z.lazy(() => UpdateDrainFilterDrainsResponse2$inboundSchema),
]);

export function updateDrainResponseBodyFilterFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyFilter, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyFilter$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyFilter' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBodyFilterV2$inboundSchema: z.ZodType<
  UpdateDrainResponseBodyFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: UpdateDrainResponseBodyVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => UpdateDrainFilterDrains1$inboundSchema),
    z.lazy(() => UpdateDrainFilterDrainsResponse2$inboundSchema),
  ]),
});

export function updateDrainResponseBodyFilterV2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBodyFilterV2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBodyFilterV2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBodyFilterV2' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBody1$inboundSchema: z.ZodType<
  UpdateDrainResponseBody1,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  createdAt: types.number(),
  updatedAt: types.number(),
  projectIds: types.optional(z.array(types.string())),
  name: types.string(),
  teamId: z.nullable(types.string()).optional(),
  ownerId: types.string(),
  status: types.optional(UpdateDrainResponseBodyStatus$inboundSchema),
  firstErrorTimestamp: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  disabledBy: types.optional(types.string()),
  disabledReason: types.optional(
    UpdateDrainResponseBodyDisabledReason$inboundSchema,
  ),
  schemas: z.lazy(() => UpdateDrainResponseBodySchemas$inboundSchema),
  delivery: z.union([
    z.lazy(() => UpdateDrainDeliveryDrains1$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrains2$inboundSchema),
    z.lazy(() => UpdateDrainDeliveryDrains3$inboundSchema),
    z.lazy(() => UpdateDrainDelivery4$inboundSchema),
    z.lazy(() => UpdateDrainDelivery5$inboundSchema),
  ]),
  sampling: types.optional(
    z.array(z.lazy(() => UpdateDrainResponseBodySampling$inboundSchema)),
  ),
  source: z.union([
    z.lazy(() => UpdateDrainSourceDrains1$inboundSchema),
    z.lazy(() => UpdateDrainSourceDrains2$inboundSchema),
  ]),
  filterV2: types.optional(
    z.lazy(() => UpdateDrainResponseBodyFilterV2$inboundSchema),
  ),
});

export function updateDrainResponseBody1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBody1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBody1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBody1' from JSON`,
  );
}

/** @internal */
export const UpdateDrainResponseBody$inboundSchema: z.ZodType<
  UpdateDrainResponseBody,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateDrainResponseBody1$inboundSchema),
  z.lazy(() => UpdateDrainResponseBody2$inboundSchema),
]);

export function updateDrainResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<UpdateDrainResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateDrainResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateDrainResponseBody' from JSON`,
  );
}