/*
 * 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 GetDrainsRequest = {
  projectId?: string | undefined;
  includeMetadata?: boolean | undefined;
  /**
   * 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 GetDrainsDrainsStatus = {
  Disabled: "disabled",
  Enabled: "enabled",
  Errored: "errored",
} as const;
export type GetDrainsDrainsStatus = ClosedEnum<typeof GetDrainsDrainsStatus>;

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

export type GetDrainsDrainsLog = {};

export type GetDrainsDrainsTrace = {};

export type GetDrainsDrainsAnalytics = {};

export type GetDrainsDrainsSpeedInsights = {};

export type GetDrainsDrainsAiGateway = {};

export type GetDrainsDrainsAuditLog = {};

export type GetDrainsDrainsConnect = {};

export type GetDrainsDrainsSchemas = {
  log?: GetDrainsDrainsLog | undefined;
  trace?: GetDrainsDrainsTrace | undefined;
  analytics?: GetDrainsDrainsAnalytics | undefined;
  speedInsights?: GetDrainsDrainsSpeedInsights | undefined;
  aiGateway?: GetDrainsDrainsAiGateway | undefined;
  auditLog?: GetDrainsDrainsAuditLog | undefined;
  connect?: GetDrainsDrainsConnect | undefined;
};

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

export type GetDrainsDeliveryDrains5 = {
  type: "internal";
  target: GetDrainsDeliveryDrainsTarget;
};

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

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

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

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

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

export type GetDrainsDeliveryDrains4 = {
  type: "s3";
  endpoint: string;
  encoding:
    GetDrainsDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding;
  compression: GetDrainsDeliveryDrainsResponse200Compression;
  fileStructure: GetDrainsDeliveryDrainsFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?:
    | GetDrainsDeliveryDrainsServerSideEncryption
    | undefined;
  objectAcl?: GetDrainsDeliveryDrainsObjectAcl | undefined;
};

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

export type GetDrainsDeliveryDrainsEndpoint = {
  traces: string;
};

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

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

export type GetDrainsSecretDrainsResponse2002 = {
  kind: GetDrainsSecretDrainsResponse200Kind;
};

export type GetDrainsDeliveryDrainsResponse200Secret =
  | GetDrainsSecretDrainsResponse2002
  | string;

export type GetDrainsDeliveryDrains2 = {
  type: "otlphttp";
  endpoint: GetDrainsDeliveryDrainsEndpoint;
  encoding: GetDrainsDeliveryDrainsResponse200ApplicationJSONEncoding;
  headers: { [k: string]: string };
  secret?: GetDrainsSecretDrainsResponse2002 | string | undefined;
};

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

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

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

export type GetDrainsSecretDrainsResponse2 = {
  kind: GetDrainsSecretDrainsResponseKind;
};

export type GetDrainsDeliveryDrainsResponseSecret =
  | GetDrainsSecretDrainsResponse2
  | string;

export type GetDrainsDeliveryDrains1 = {
  type: "http";
  endpoint: string;
  encoding: GetDrainsDeliveryDrainsResponse200Encoding;
  compression?: GetDrainsDeliveryDrainsResponseCompression | undefined;
  headers: { [k: string]: string };
  secret?: GetDrainsSecretDrainsResponse2 | string | undefined;
};

export type GetDrainsDrainsDelivery =
  | GetDrainsDeliveryDrains1
  | GetDrainsDeliveryDrains2
  | GetDrainsDeliveryDrains3
  | GetDrainsDeliveryDrains4
  | GetDrainsDeliveryDrains5;

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

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

export type GetDrainsDrainsSampling = {
  type: GetDrainsDrainsType;
  rate: number;
  env?: GetDrainsDrainsEnv | undefined;
  requestPath?: string | undefined;
};

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

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

export type GetDrainsDrainsSource =
  | GetDrainsSourceDrains1
  | GetDrainsSourceDrains2;

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

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

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

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

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

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

export type GetDrainsFilterDrainsDeployment = {
  environments?: Array<GetDrainsFilterDrainsEnvironments> | undefined;
};

export type GetDrainsFilterDrains1 = {
  type: "basic";
  project?: GetDrainsFilterDrainsProject | undefined;
  log?: GetDrainsFilterDrainsLog | undefined;
  deployment?: GetDrainsFilterDrainsDeployment | undefined;
};

export type GetDrainsDrainsFilter =
  | GetDrainsFilterDrains1
  | GetDrainsFilterDrains2;

export type GetDrainsDrainsFilterV2 = {
  version: GetDrainsDrainsVersion;
  filter: GetDrainsFilterDrains1 | GetDrainsFilterDrains2;
};

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

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

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

export type GetDrainsProjectAccess1 = {
  access: "all";
  managedBy: GetDrainsProjectAccessManagedBy;
};

export type DrainsProjectAccess =
  | GetDrainsProjectAccess1
  | GetDrainsProjectAccess2;

export type Drains2 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: GetDrainsDrainsStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: GetDrainsDrainsDisabledReason | undefined;
  schemas: GetDrainsDrainsSchemas;
  delivery:
    | GetDrainsDeliveryDrains1
    | GetDrainsDeliveryDrains2
    | GetDrainsDeliveryDrains3
    | GetDrainsDeliveryDrains4
    | GetDrainsDeliveryDrains5;
  sampling?: Array<GetDrainsDrainsSampling> | undefined;
  source: GetDrainsSourceDrains1 | GetDrainsSourceDrains2;
  filterV2?: GetDrainsDrainsFilterV2 | undefined;
  integrationIcon?: string | undefined;
  integrationConfigurationUri?: string | undefined;
  integrationWebsite?: string | undefined;
  projectAccess?: GetDrainsProjectAccess1 | GetDrainsProjectAccess2 | undefined;
};

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

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

export type DrainsLog = {};

export type DrainsTrace = {};

export type DrainsAnalytics = {};

export type DrainsSpeedInsights = {};

export type DrainsAiGateway = {};

export type DrainsAuditLog = {};

export type DrainsConnect = {};

export type DrainsSchemas = {
  log?: DrainsLog | undefined;
  trace?: DrainsTrace | undefined;
  analytics?: DrainsAnalytics | undefined;
  speedInsights?: DrainsSpeedInsights | undefined;
  aiGateway?: DrainsAiGateway | undefined;
  auditLog?: DrainsAuditLog | undefined;
  connect?: DrainsConnect | undefined;
};

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

export type GetDrainsDelivery5 = {
  type: "internal";
  target: GetDrainsDeliveryTarget;
};

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

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

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

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

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

export type GetDrainsDelivery4 = {
  type: "s3";
  endpoint: string;
  encoding: GetDrainsDeliveryDrainsResponseEncoding;
  compression: GetDrainsDeliveryDrainsCompression;
  fileStructure: GetDrainsDeliveryFileStructure;
  roleArn: string;
  region: string;
  serverSideEncryption?: GetDrainsDeliveryServerSideEncryption | undefined;
  objectAcl?: GetDrainsDeliveryObjectAcl | undefined;
};

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

export type GetDrainsDeliveryEndpoint = {
  traces: string;
};

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

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

export type GetDrainsSecretDrains2 = {
  kind: GetDrainsSecretDrainsKind;
};

export type GetDrainsDeliveryDrainsSecret = GetDrainsSecretDrains2 | string;

export type GetDrainsDelivery2 = {
  type: "otlphttp";
  endpoint: GetDrainsDeliveryEndpoint;
  encoding: GetDrainsDeliveryDrainsEncoding;
  headers: { [k: string]: string };
  secret?: GetDrainsSecretDrains2 | string | undefined;
};

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

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

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

export type GetDrainsSecret2 = {
  kind: GetDrainsSecretKind;
};

export type GetDrainsDeliverySecret = GetDrainsSecret2 | string;

export type GetDrainsDelivery1 = {
  type: "http";
  endpoint: string;
  encoding: GetDrainsDeliveryEncoding;
  compression?: GetDrainsDeliveryCompression | undefined;
  headers: { [k: string]: string };
  secret?: GetDrainsSecret2 | string | undefined;
};

export type DrainsDelivery =
  | GetDrainsDelivery1
  | GetDrainsDelivery2
  | GetDrainsDelivery3
  | GetDrainsDelivery4
  | GetDrainsDelivery5;

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

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

export type DrainsSampling = {
  type: DrainsType;
  rate: number;
  env?: DrainsEnv | undefined;
  requestPath?: string | undefined;
};

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

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

export type DrainsSource = GetDrainsSource1 | GetDrainsSource2;

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

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

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

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

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

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

export type GetDrainsFilterDeployment = {
  environments?: Array<GetDrainsFilterEnvironments> | undefined;
};

export type GetDrainsFilter1 = {
  type: "basic";
  project?: GetDrainsFilterProject | undefined;
  log?: GetDrainsFilterLog | undefined;
  deployment?: GetDrainsFilterDeployment | undefined;
};

export type DrainsFilter = GetDrainsFilter1 | GetDrainsFilter2;

export type DrainsFilterV2 = {
  version: DrainsVersion;
  filter: GetDrainsFilter1 | GetDrainsFilter2;
};

export type Drains1 = {
  id: string;
  createdAt: number;
  updatedAt: number;
  projectIds?: Array<string> | undefined;
  name: string;
  teamId?: string | null | undefined;
  ownerId: string;
  status?: DrainsStatus | undefined;
  firstErrorTimestamp?: number | undefined;
  disabledAt?: number | undefined;
  disabledBy?: string | undefined;
  disabledReason?: DrainsDisabledReason | undefined;
  schemas: DrainsSchemas;
  delivery:
    | GetDrainsDelivery1
    | GetDrainsDelivery2
    | GetDrainsDelivery3
    | GetDrainsDelivery4
    | GetDrainsDelivery5;
  sampling?: Array<DrainsSampling> | undefined;
  source: GetDrainsSource1 | GetDrainsSource2;
  filterV2?: DrainsFilterV2 | undefined;
};

export type Drains = Array<Drains1> | Array<Drains2>;

export type GetDrainsResponseBody = {
  drains: Array<Drains1> | Array<Drains2>;
};

/** @internal */
export type GetDrainsRequest$Outbound = {
  projectId?: string | undefined;
  includeMetadata: boolean;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const GetDrainsRequest$outboundSchema: z.ZodType<
  GetDrainsRequest$Outbound,
  z.ZodTypeDef,
  GetDrainsRequest
> = z.object({
  projectId: z.string().optional(),
  includeMetadata: z.boolean().default(false),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function getDrainsRequestToJSON(
  getDrainsRequest: GetDrainsRequest,
): string {
  return JSON.stringify(
    GetDrainsRequest$outboundSchema.parse(getDrainsRequest),
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainsDrainsSchemas$inboundSchema: z.ZodType<
  GetDrainsDrainsSchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(z.lazy(() => GetDrainsDrainsLog$inboundSchema)),
  trace: types.optional(z.lazy(() => GetDrainsDrainsTrace$inboundSchema)),
  analytics: types.optional(
    z.lazy(() => GetDrainsDrainsAnalytics$inboundSchema),
  ),
  speed_insights: types.optional(
    z.lazy(() => GetDrainsDrainsSpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(
    z.lazy(() => GetDrainsDrainsAiGateway$inboundSchema),
  ),
  audit_log: types.optional(
    z.lazy(() => GetDrainsDrainsAuditLog$inboundSchema),
  ),
  connect: types.optional(z.lazy(() => GetDrainsDrainsConnect$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainsDeliveryDrains4$inboundSchema: z.ZodType<
  GetDrainsDeliveryDrains4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding:
    GetDrainsDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding$inboundSchema,
  compression: GetDrainsDeliveryDrainsResponse200Compression$inboundSchema,
  fileStructure: GetDrainsDeliveryDrainsFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    GetDrainsDeliveryDrainsServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(GetDrainsDeliveryDrainsObjectAcl$inboundSchema),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainsDrainsDelivery$inboundSchema: z.ZodType<
  GetDrainsDrainsDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetDrainsDeliveryDrains1$inboundSchema),
  z.lazy(() => GetDrainsDeliveryDrains2$inboundSchema),
  z.lazy(() => GetDrainsDeliveryDrains3$inboundSchema),
  z.lazy(() => GetDrainsDeliveryDrains4$inboundSchema),
  z.lazy(() => GetDrainsDeliveryDrains5$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainsDrainsFilterV2$inboundSchema: z.ZodType<
  GetDrainsDrainsFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: GetDrainsDrainsVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => GetDrainsFilterDrains1$inboundSchema),
    z.lazy(() => GetDrainsFilterDrains2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const Drains2$inboundSchema: z.ZodType<Drains2, 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(GetDrainsDrainsStatus$inboundSchema),
    firstErrorTimestamp: types.optional(types.number()),
    disabledAt: types.optional(types.number()),
    disabledBy: types.optional(types.string()),
    disabledReason: types.optional(GetDrainsDrainsDisabledReason$inboundSchema),
    schemas: z.lazy(() => GetDrainsDrainsSchemas$inboundSchema),
    delivery: z.union([
      z.lazy(() => GetDrainsDeliveryDrains1$inboundSchema),
      z.lazy(() => GetDrainsDeliveryDrains2$inboundSchema),
      z.lazy(() => GetDrainsDeliveryDrains3$inboundSchema),
      z.lazy(() => GetDrainsDeliveryDrains4$inboundSchema),
      z.lazy(() => GetDrainsDeliveryDrains5$inboundSchema),
    ]),
    sampling: types.optional(
      z.array(z.lazy(() => GetDrainsDrainsSampling$inboundSchema)),
    ),
    source: z.union([
      z.lazy(() => GetDrainsSourceDrains1$inboundSchema),
      z.lazy(() => GetDrainsSourceDrains2$inboundSchema),
    ]),
    filterV2: types.optional(
      z.lazy(() => GetDrainsDrainsFilterV2$inboundSchema),
    ),
    integrationIcon: types.optional(types.string()),
    integrationConfigurationUri: types.optional(types.string()),
    integrationWebsite: types.optional(types.string()),
    projectAccess: types.optional(
      z.union([
        z.lazy(() => GetDrainsProjectAccess1$inboundSchema),
        z.lazy(() => GetDrainsProjectAccess2$inboundSchema),
      ]),
    ),
  });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DrainsSchemas$inboundSchema: z.ZodType<
  DrainsSchemas,
  z.ZodTypeDef,
  unknown
> = z.object({
  log: types.optional(z.lazy(() => DrainsLog$inboundSchema)),
  trace: types.optional(z.lazy(() => DrainsTrace$inboundSchema)),
  analytics: types.optional(z.lazy(() => DrainsAnalytics$inboundSchema)),
  speed_insights: types.optional(
    z.lazy(() => DrainsSpeedInsights$inboundSchema),
  ),
  ai_gateway: types.optional(z.lazy(() => DrainsAiGateway$inboundSchema)),
  audit_log: types.optional(z.lazy(() => DrainsAuditLog$inboundSchema)),
  connect: types.optional(z.lazy(() => DrainsConnect$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "speed_insights": "speedInsights",
    "ai_gateway": "aiGateway",
    "audit_log": "auditLog",
  });
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetDrainsDelivery4$inboundSchema: z.ZodType<
  GetDrainsDelivery4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("s3"),
  endpoint: types.string(),
  encoding: GetDrainsDeliveryDrainsResponseEncoding$inboundSchema,
  compression: GetDrainsDeliveryDrainsCompression$inboundSchema,
  fileStructure: GetDrainsDeliveryFileStructure$inboundSchema,
  roleArn: types.string(),
  region: types.string(),
  serverSideEncryption: types.optional(
    GetDrainsDeliveryServerSideEncryption$inboundSchema,
  ),
  objectAcl: types.optional(GetDrainsDeliveryObjectAcl$inboundSchema),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DrainsDelivery$inboundSchema: z.ZodType<
  DrainsDelivery,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetDrainsDelivery1$inboundSchema),
  z.lazy(() => GetDrainsDelivery2$inboundSchema),
  z.lazy(() => GetDrainsDelivery3$inboundSchema),
  z.lazy(() => GetDrainsDelivery4$inboundSchema),
  z.lazy(() => GetDrainsDelivery5$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DrainsFilterV2$inboundSchema: z.ZodType<
  DrainsFilterV2,
  z.ZodTypeDef,
  unknown
> = z.object({
  version: DrainsVersion$inboundSchema,
  filter: z.union([
    z.lazy(() => GetDrainsFilter1$inboundSchema),
    z.lazy(() => GetDrainsFilter2$inboundSchema),
  ]),
});

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

/** @internal */
export const Drains1$inboundSchema: z.ZodType<Drains1, 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(DrainsStatus$inboundSchema),
    firstErrorTimestamp: types.optional(types.number()),
    disabledAt: types.optional(types.number()),
    disabledBy: types.optional(types.string()),
    disabledReason: types.optional(DrainsDisabledReason$inboundSchema),
    schemas: z.lazy(() => DrainsSchemas$inboundSchema),
    delivery: z.union([
      z.lazy(() => GetDrainsDelivery1$inboundSchema),
      z.lazy(() => GetDrainsDelivery2$inboundSchema),
      z.lazy(() => GetDrainsDelivery3$inboundSchema),
      z.lazy(() => GetDrainsDelivery4$inboundSchema),
      z.lazy(() => GetDrainsDelivery5$inboundSchema),
    ]),
    sampling: types.optional(
      z.array(z.lazy(() => DrainsSampling$inboundSchema)),
    ),
    source: z.union([
      z.lazy(() => GetDrainsSource1$inboundSchema),
      z.lazy(() => GetDrainsSource2$inboundSchema),
    ]),
    filterV2: types.optional(z.lazy(() => DrainsFilterV2$inboundSchema)),
  });

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

/** @internal */
export const Drains$inboundSchema: z.ZodType<Drains, z.ZodTypeDef, unknown> =
  smartUnion([
    z.array(z.lazy(() => Drains1$inboundSchema)),
    z.array(z.lazy(() => Drains2$inboundSchema)),
  ]);

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

/** @internal */
export const GetDrainsResponseBody$inboundSchema: z.ZodType<
  GetDrainsResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  drains: smartUnion([
    z.array(z.lazy(() => Drains1$inboundSchema)),
    z.array(z.lazy(() => Drains2$inboundSchema)),
  ]),
});

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