/*
 * 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 type GetDrainRequest = {
  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;
};

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

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

export type GetDrainResponseBodyDrainsLog = {};

export type GetDrainResponseBodyDrainsTrace = {};

export type GetDrainResponseBodyDrainsAnalytics = {};

export type GetDrainResponseBodyDrainsSpeedInsights = {};

export type GetDrainResponseBodyDrainsAiGateway = {};

export type GetDrainResponseBodyDrainsAuditLog = {};

export type GetDrainResponseBodyDrainsSchemas = {
  log?: GetDrainResponseBodyDrainsLog | undefined;
  trace?: GetDrainResponseBodyDrainsTrace | undefined;
  analytics?: GetDrainResponseBodyDrainsAnalytics | undefined;
  speedInsights?: GetDrainResponseBodyDrainsSpeedInsights | undefined;
  aiGateway?: GetDrainResponseBodyDrainsAiGateway | undefined;
  auditLog?: GetDrainResponseBodyDrainsAuditLog | undefined;
};

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

export type GetDrainDeliveryDrains5 = {
  type: "internal";
  target: GetDrainDeliveryDrainsTarget;
};

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

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

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

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

export const GetDrainDeliveryDrainsObjectAcl = {
  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 GetDrainDeliveryDrainsObjectAcl = ClosedEnum<
  typeof GetDrainDeliveryDrainsObjectAcl
>;

export type GetDrainDeliveryDrains4 = {
  type: "s3";
  endpoint: string;
  encoding:
    GetDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding;
  compression: GetDrainDeliveryDrainsResponse200Compression;
  fileStructure: GetDrainDeliveryDrainsFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?: GetDrainDeliveryDrainsServerSideEncryption | undefined;
  objectAcl?: GetDrainDeliveryDrainsObjectAcl | undefined;
};

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

export type GetDrainDeliveryDrainsEndpoint = {
  traces: string;
};

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

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

export type GetDrainSecretDrainsResponse2002 = {
  kind: GetDrainSecretDrainsResponse200Kind;
};

export type GetDrainDeliveryDrainsResponse200Secret =
  | GetDrainSecretDrainsResponse2002
  | string;

export type GetDrainDeliveryDrains2 = {
  type: "otlphttp";
  endpoint: GetDrainDeliveryDrainsEndpoint;
  encoding: GetDrainDeliveryDrainsResponse200ApplicationJSONEncoding;
  headers: { [k: string]: string };
  secret?: GetDrainSecretDrainsResponse2002 | string | undefined;
};

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

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

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

export type GetDrainSecretDrainsResponse2 = {
  kind: GetDrainSecretDrainsResponseKind;
};

export type GetDrainDeliveryDrainsResponseSecret =
  | GetDrainSecretDrainsResponse2
  | string;

export type GetDrainDeliveryDrains1 = {
  type: "http";
  endpoint: string;
  encoding: GetDrainDeliveryDrainsResponse200Encoding;
  compression?: GetDrainDeliveryDrainsResponseCompression | undefined;
  headers: { [k: string]: string };
  secret?: GetDrainSecretDrainsResponse2 | string | undefined;
};

export type GetDrainResponseBodyDrainsDelivery =
  | GetDrainDeliveryDrains1
  | GetDrainDeliveryDrains2
  | GetDrainDeliveryDrains3
  | GetDrainDeliveryDrains4
  | GetDrainDeliveryDrains5;

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

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

export type GetDrainResponseBodyDrainsSampling = {
  type: GetDrainResponseBodyDrainsType;
  rate: number;
  env?: GetDrainResponseBodyDrainsEnv | undefined;
  requestPath?: string | undefined;
};

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

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

export type GetDrainResponseBodyDrainsSource =
  | GetDrainSourceDrains1
  | GetDrainSourceDrains2;

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

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

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

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

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

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

export type GetDrainFilterDrainsDeployment = {
  environments?: Array<GetDrainFilterDrainsEnvironments> | undefined;
};

export type GetDrainFilterDrains1 = {
  type: "basic";
  project?: GetDrainFilterDrainsProject | undefined;
  log?: GetDrainFilterDrainsLog | undefined;
  deployment?: GetDrainFilterDrainsDeployment | undefined;
};

export type GetDrainResponseBodyDrainsFilter =
  | GetDrainFilterDrains1
  | GetDrainFilterDrains2;

export type GetDrainResponseBodyDrainsFilterV2 = {
  version: GetDrainResponseBodyDrainsVersion;
  filter: GetDrainFilterDrains1 | GetDrainFilterDrains2;
};

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

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

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

export type GetDrainProjectAccess1 = {
  access: "all";
  managedBy: GetDrainProjectAccessManagedBy;
};

export type ResponseBodyProjectAccess =
  | GetDrainProjectAccess1
  | GetDrainProjectAccess2;

export type GetDrainResponseBody2 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: GetDrainResponseBodyDrainsStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: GetDrainResponseBodyDrainsDisabledReason | undefined;
  schemas: GetDrainResponseBodyDrainsSchemas;
  delivery:
    | GetDrainDeliveryDrains1
    | GetDrainDeliveryDrains2
    | GetDrainDeliveryDrains3
    | GetDrainDeliveryDrains4
    | GetDrainDeliveryDrains5;
  sampling?: Array<GetDrainResponseBodyDrainsSampling> | undefined;
  source: GetDrainSourceDrains1 | GetDrainSourceDrains2;
  filterV2?: GetDrainResponseBodyDrainsFilterV2 | undefined;
  integrationIcon?: string | undefined;
  integrationConfigurationUri?: string | undefined;
  integrationWebsite?: string | undefined;
  projectAccess?: GetDrainProjectAccess1 | GetDrainProjectAccess2 | undefined;
};

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

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

export type GetDrainResponseBodyLog = {};

export type GetDrainResponseBodyTrace = {};

export type GetDrainResponseBodyAnalytics = {};

export type GetDrainResponseBodySpeedInsights = {};

export type GetDrainResponseBodyAiGateway = {};

export type GetDrainResponseBodyAuditLog = {};

export type GetDrainResponseBodySchemas = {
  log?: GetDrainResponseBodyLog | undefined;
  trace?: GetDrainResponseBodyTrace | undefined;
  analytics?: GetDrainResponseBodyAnalytics | undefined;
  speedInsights?: GetDrainResponseBodySpeedInsights | undefined;
  aiGateway?: GetDrainResponseBodyAiGateway | undefined;
  auditLog?: GetDrainResponseBodyAuditLog | undefined;
};

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

export type GetDrainDelivery5 = {
  type: "internal";
  target: GetDrainDeliveryTarget;
};

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

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

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

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

export const GetDrainDeliveryObjectAcl = {
  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 GetDrainDeliveryObjectAcl = ClosedEnum<
  typeof GetDrainDeliveryObjectAcl
>;

export type GetDrainDelivery4 = {
  type: "s3";
  endpoint: string;
  encoding: GetDrainDeliveryDrainsResponseEncoding;
  compression: GetDrainDeliveryDrainsCompression;
  fileStructure: GetDrainDeliveryFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?: GetDrainDeliveryServerSideEncryption | undefined;
  objectAcl?: GetDrainDeliveryObjectAcl | undefined;
};

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

export type GetDrainDeliveryEndpoint = {
  traces: string;
};

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

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

export type GetDrainSecretDrains2 = {
  kind: GetDrainSecretDrainsKind;
};

export type GetDrainDeliveryDrainsSecret = GetDrainSecretDrains2 | string;

export type GetDrainDelivery2 = {
  type: "otlphttp";
  endpoint: GetDrainDeliveryEndpoint;
  encoding: GetDrainDeliveryDrainsEncoding;
  headers: { [k: string]: string };
  secret?: GetDrainSecretDrains2 | string | undefined;
};

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

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

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

export type GetDrainSecret2 = {
  kind: GetDrainSecretKind;
};

export type GetDrainDeliverySecret = GetDrainSecret2 | string;

export type GetDrainDelivery1 = {
  type: "http";
  endpoint: string;
  encoding: GetDrainDeliveryEncoding;
  compression?: GetDrainDeliveryCompression | undefined;
  headers: { [k: string]: string };
  secret?: GetDrainSecret2 | string | undefined;
};

export type GetDrainResponseBodyDelivery =
  | GetDrainDelivery1
  | GetDrainDelivery2
  | GetDrainDelivery3
  | GetDrainDelivery4
  | GetDrainDelivery5;

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

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

export type GetDrainResponseBodySampling = {
  type: GetDrainResponseBodyType;
  rate: number;
  env?: GetDrainResponseBodyEnv | undefined;
  requestPath?: string | undefined;
};

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

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

export type GetDrainResponseBodySource = GetDrainSource1 | GetDrainSource2;

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

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

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

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

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

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

export type GetDrainFilterDeployment = {
  environments?: Array<GetDrainFilterEnvironments> | undefined;
};

export type GetDrainFilter1 = {
  type: "basic";
  project?: GetDrainFilterProject | undefined;
  log?: GetDrainFilterLog | undefined;
  deployment?: GetDrainFilterDeployment | undefined;
};

export type GetDrainResponseBodyFilter = GetDrainFilter1 | GetDrainFilter2;

export type GetDrainResponseBodyFilterV2 = {
  version: GetDrainResponseBodyVersion;
  filter: GetDrainFilter1 | GetDrainFilter2;
};

export type GetDrainResponseBody1 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: GetDrainResponseBodyStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: GetDrainResponseBodyDisabledReason | undefined;
  schemas: GetDrainResponseBodySchemas;
  delivery:
    | GetDrainDelivery1
    | GetDrainDelivery2
    | GetDrainDelivery3
    | GetDrainDelivery4
    | GetDrainDelivery5;
  sampling?: Array<GetDrainResponseBodySampling> | undefined;
  source: GetDrainSource1 | GetDrainSource2;
  filterV2?: GetDrainResponseBodyFilterV2 | undefined;
};

export type GetDrainResponseBody =
  | GetDrainResponseBody1
  | GetDrainResponseBody2;

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

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

export function getDrainRequestToJSON(
  getDrainRequest: GetDrainRequest,
): string {
  return JSON.stringify(GetDrainRequest$outboundSchema.parse(getDrainRequest));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodyDrainsSchemas$inboundSchema: z.ZodType<
  GetDrainResponseBodyDrainsSchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsLog$inboundSchema),
  ),
  trace: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsTrace$inboundSchema),
  ),
  analytics: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsAnalytics$inboundSchema),
  ),
  speed_insights: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsSpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsAiGateway$inboundSchema),
  ),
  audit_log: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsAuditLog$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainDeliveryDrains4$inboundSchema: z.ZodType<
  GetDrainDeliveryDrains4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding:
    GetDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding$inboundSchema,
  compression: GetDrainDeliveryDrainsResponse200Compression$inboundSchema,
  fileStructure: GetDrainDeliveryDrainsFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    GetDrainDeliveryDrainsServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(GetDrainDeliveryDrainsObjectAcl$inboundSchema),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodyDrainsDelivery$inboundSchema: z.ZodType<
  GetDrainResponseBodyDrainsDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetDrainDeliveryDrains1$inboundSchema),
  z.lazy(() => GetDrainDeliveryDrains2$inboundSchema),
  z.lazy(() => GetDrainDeliveryDrains3$inboundSchema),
  z.lazy(() => GetDrainDeliveryDrains4$inboundSchema),
  z.lazy(() => GetDrainDeliveryDrains5$inboundSchema),
]);

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

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

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

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

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

/** @internal */
export const GetDrainSourceDrains2$inboundSchema: z.ZodType<
  GetDrainSourceDrains2,
  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 getDrainSourceDrains2FromJSON(
  jsonString: string,
): SafeParseResult<GetDrainSourceDrains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => GetDrainSourceDrains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetDrainSourceDrains2' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodyDrainsFilterV2$inboundSchema: z.ZodType<
  GetDrainResponseBodyDrainsFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: GetDrainResponseBodyDrainsVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => GetDrainFilterDrains1$inboundSchema),
    z.lazy(() => GetDrainFilterDrains2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBody2$inboundSchema: z.ZodType<
  GetDrainResponseBody2,
  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(GetDrainResponseBodyDrainsStatus$inboundSchema),
  firstErrorTimestamp: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  disabledBy: types.optional(types.string()),
  disabledReason: types.optional(
    GetDrainResponseBodyDrainsDisabledReason$inboundSchema,
  ),
  schemas: z.lazy(() => GetDrainResponseBodyDrainsSchemas$inboundSchema),
  delivery: z.union([
    z.lazy(() => GetDrainDeliveryDrains1$inboundSchema),
    z.lazy(() => GetDrainDeliveryDrains2$inboundSchema),
    z.lazy(() => GetDrainDeliveryDrains3$inboundSchema),
    z.lazy(() => GetDrainDeliveryDrains4$inboundSchema),
    z.lazy(() => GetDrainDeliveryDrains5$inboundSchema),
  ]),
  sampling: types.optional(
    z.array(z.lazy(() => GetDrainResponseBodyDrainsSampling$inboundSchema)),
  ),
  source: z.union([
    z.lazy(() => GetDrainSourceDrains1$inboundSchema),
    z.lazy(() => GetDrainSourceDrains2$inboundSchema),
  ]),
  filterV2: types.optional(
    z.lazy(() => GetDrainResponseBodyDrainsFilterV2$inboundSchema),
  ),
  integrationIcon: types.optional(types.string()),
  integrationConfigurationUri: types.optional(types.string()),
  integrationWebsite: types.optional(types.string()),
  projectAccess: types.optional(
    z.union([
      z.lazy(() => GetDrainProjectAccess1$inboundSchema),
      z.lazy(() => GetDrainProjectAccess2$inboundSchema),
    ]),
  ),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodySchemas$inboundSchema: z.ZodType<
  GetDrainResponseBodySchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(z.lazy(() => GetDrainResponseBodyLog$inboundSchema)),
  trace: types.optional(z.lazy(() => GetDrainResponseBodyTrace$inboundSchema)),
  analytics: types.optional(
    z.lazy(() => GetDrainResponseBodyAnalytics$inboundSchema),
  ),
  speed_insights: types.optional(
    z.lazy(() => GetDrainResponseBodySpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(
    z.lazy(() => GetDrainResponseBodyAiGateway$inboundSchema),
  ),
  audit_log: types.optional(
    z.lazy(() => GetDrainResponseBodyAuditLog$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainDelivery4$inboundSchema: z.ZodType<
  GetDrainDelivery4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding: GetDrainDeliveryDrainsResponseEncoding$inboundSchema,
  compression: GetDrainDeliveryDrainsCompression$inboundSchema,
  fileStructure: GetDrainDeliveryFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    GetDrainDeliveryServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(GetDrainDeliveryObjectAcl$inboundSchema),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodyDelivery$inboundSchema: z.ZodType<
  GetDrainResponseBodyDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetDrainDelivery1$inboundSchema),
  z.lazy(() => GetDrainDelivery2$inboundSchema),
  z.lazy(() => GetDrainDelivery3$inboundSchema),
  z.lazy(() => GetDrainDelivery4$inboundSchema),
  z.lazy(() => GetDrainDelivery5$inboundSchema),
]);

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

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

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

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

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

/** @internal */
export const GetDrainSource2$inboundSchema: z.ZodType<
  GetDrainSource2,
  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 getDrainSource2FromJSON(
  jsonString: string,
): SafeParseResult<GetDrainSource2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => GetDrainSource2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetDrainSource2' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainResponseBodyFilterV2$inboundSchema: z.ZodType<
  GetDrainResponseBodyFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: GetDrainResponseBodyVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => GetDrainFilter1$inboundSchema),
    z.lazy(() => GetDrainFilter2$inboundSchema),
  ]),
});

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

/** @internal */
export const GetDrainResponseBody1$inboundSchema: z.ZodType<
  GetDrainResponseBody1,
  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(GetDrainResponseBodyStatus$inboundSchema),
  firstErrorTimestamp: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  disabledBy: types.optional(types.string()),
  disabledReason: types.optional(
    GetDrainResponseBodyDisabledReason$inboundSchema,
  ),
  schemas: z.lazy(() => GetDrainResponseBodySchemas$inboundSchema),
  delivery: z.union([
    z.lazy(() => GetDrainDelivery1$inboundSchema),
    z.lazy(() => GetDrainDelivery2$inboundSchema),
    z.lazy(() => GetDrainDelivery3$inboundSchema),
    z.lazy(() => GetDrainDelivery4$inboundSchema),
    z.lazy(() => GetDrainDelivery5$inboundSchema),
  ]),
  sampling: types.optional(
    z.array(z.lazy(() => GetDrainResponseBodySampling$inboundSchema)),
  ),
  source: z.union([
    z.lazy(() => GetDrainSource1$inboundSchema),
    z.lazy(() => GetDrainSource2$inboundSchema),
  ]),
  filterV2: types.optional(
    z.lazy(() => GetDrainResponseBodyFilterV2$inboundSchema),
  ),
});

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

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

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