import * as z from "zod/v3";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
export declare const CreateDrainProjects: {
    readonly Some: "some";
    readonly All: "all";
};
export type CreateDrainProjects = ClosedEnum<typeof CreateDrainProjects>;
export type Filter2 = {
    type: string;
    text: string;
};
export type FilterProject = {
    ids?: Array<string> | undefined;
};
export declare const FilterSources: {
    readonly Build: "build";
    readonly Edge: "edge";
    readonly Lambda: "lambda";
    readonly Static: "static";
    readonly External: "external";
    readonly Firewall: "firewall";
    readonly Redirect: "redirect";
};
export type FilterSources = ClosedEnum<typeof FilterSources>;
export type Log = {
    sources?: Array<FilterSources> | undefined;
};
export declare const FilterEnvironments: {
    readonly Production: "production";
    readonly Preview: "preview";
};
export type FilterEnvironments = ClosedEnum<typeof FilterEnvironments>;
export type CreateDrainFilterDeployment = {
    environments?: Array<FilterEnvironments> | undefined;
};
export type Filter1 = {
    type: string;
    project?: FilterProject | undefined;
    log?: Log | undefined;
    deployment?: CreateDrainFilterDeployment | undefined;
};
export type CreateDrainFilter = Filter2 | Filter1;
export type Filter = {
    version: string;
    filter: Filter2 | Filter1;
};
export type Schemas = {
    version: string;
};
export declare const CreateDrainDeliveryDrainsEncoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type CreateDrainDeliveryDrainsEncoding = ClosedEnum<typeof CreateDrainDeliveryDrainsEncoding>;
export declare const DeliveryCompression: {
    readonly None: "none";
};
export type DeliveryCompression = ClosedEnum<typeof DeliveryCompression>;
export declare const FileStructure: {
    readonly Hive: "hive";
};
export type FileStructure = ClosedEnum<typeof FileStructure>;
export declare const ServerSideEncryption: {
    readonly Aes256: "AES256";
    readonly AwsKms: "aws:kms";
    readonly AwsKmsDsse: "aws:kms:dsse";
};
export type ServerSideEncryption = ClosedEnum<typeof ServerSideEncryption>;
export declare const ObjectAcl: {
    readonly Private: "private";
    readonly BucketOwnerRead: "bucket-owner-read";
    readonly BucketOwnerFullControl: "bucket-owner-full-control";
};
export type ObjectAcl = ClosedEnum<typeof ObjectAcl>;
export type Delivery3 = {
    type: string;
    endpoint: string;
    encoding: CreateDrainDeliveryDrainsEncoding;
    compression: DeliveryCompression;
    fileStructure: FileStructure;
    roleArn: string;
    region: string;
    serverSideEncryption?: ServerSideEncryption | undefined;
    objectAcl?: ObjectAcl | undefined;
};
export type Endpoint1 = {
    traces: string;
};
export type CreateDrainDeliveryEndpoint = Endpoint1;
export declare const CreateDrainDeliveryEncoding: {
    readonly Proto: "proto";
    readonly Json: "json";
};
export type CreateDrainDeliveryEncoding = ClosedEnum<typeof CreateDrainDeliveryEncoding>;
export type Delivery2 = {
    type: string;
    endpoint: Endpoint1;
    encoding: CreateDrainDeliveryEncoding;
    headers: {
        [k: string]: string;
    };
    secret?: string | undefined;
};
export declare const Compression: {
    readonly Gzip: "gzip";
    readonly None: "none";
};
export type Compression = ClosedEnum<typeof Compression>;
export declare const DeliveryEncoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type DeliveryEncoding = ClosedEnum<typeof DeliveryEncoding>;
export type Delivery1 = {
    type: string;
    endpoint: string;
    compression?: Compression | undefined;
    encoding: DeliveryEncoding;
    headers: {
        [k: string]: string;
    };
    secret?: string | undefined;
};
export type Delivery = Delivery3 | Delivery1 | Delivery2;
/**
 * Environment to apply sampling to
 */
export declare const CreateDrainEnv: {
    readonly Production: "production";
    readonly Preview: "preview";
};
/**
 * Environment to apply sampling to
 */
export type CreateDrainEnv = ClosedEnum<typeof CreateDrainEnv>;
export type CreateDrainSampling = {
    type: string;
    /**
     * Sampling rate from 0 to 1 (e.g., 0.1 for 10%)
     */
    rate: number;
    /**
     * Environment to apply sampling to
     */
    env?: CreateDrainEnv | undefined;
    /**
     * Request path prefix to apply the sampling rule to
     */
    requestPath?: string | undefined;
};
export type Transforms = {
    id: string;
};
export type CreateDrainSource2 = {
    kind?: string | undefined;
};
export type One3 = {
    kind?: string | undefined;
};
export type One2 = {
    kind?: string | undefined;
    resourceId: string;
};
export type CreateDrain11 = {
    kind?: string | undefined;
    externalResourceId: string;
};
export type CreateDrainSource1 = CreateDrain11 | One2 | One3;
export type CreateDrainSource = CreateDrain11 | One2 | One3 | CreateDrainSource2;
export type CreateDrainRequestBody = {
    name: string;
    projects: CreateDrainProjects;
    projectIds?: Array<string> | undefined;
    filter?: Filter | undefined;
    schemas: {
        [k: string]: Schemas;
    };
    delivery?: Delivery3 | Delivery1 | Delivery2 | undefined;
    sampling?: Array<CreateDrainSampling> | undefined;
    transforms?: Array<Transforms> | undefined;
    source?: CreateDrain11 | One2 | One3 | CreateDrainSource2 | undefined;
};
export type CreateDrainRequest = {
    /**
     * The Team identifier to perform the request on behalf of.
     */
    teamId?: string | undefined;
    /**
     * The Team slug to perform the request on behalf of.
     */
    slug?: string | undefined;
    requestBody?: CreateDrainRequestBody | undefined;
};
export declare const CreateDrainResponseBodyDrainsStatus: {
    readonly Disabled: "disabled";
    readonly Enabled: "enabled";
    readonly Errored: "errored";
};
export type CreateDrainResponseBodyDrainsStatus = ClosedEnum<typeof CreateDrainResponseBodyDrainsStatus>;
export declare const ResponseBodyDisabledReason: {
    readonly AccountPlanDowngrade: "account-plan-downgrade";
    readonly DisabledByAdmin: "disabled-by-admin";
    readonly DisabledByOwner: "disabled-by-owner";
    readonly FeatureNotAvailable: "feature-not-available";
    readonly LimitsExceeded: "limits-exceeded";
};
export type ResponseBodyDisabledReason = ClosedEnum<typeof ResponseBodyDisabledReason>;
export type CreateDrainResponseBodyLog = {};
export type ResponseBodyTrace = {};
export type CreateDrainResponseBodyDrainsAnalytics = {};
export type CreateDrainResponseBodyDrainsSpeedInsights = {};
export type ResponseBodyAiGateway = {};
export type ResponseBodyAuditLog = {};
export type ResponseBodyConnect = {};
export type CreateDrainResponseBodySchemas = {
    log?: CreateDrainResponseBodyLog | undefined;
    trace?: ResponseBodyTrace | undefined;
    analytics?: CreateDrainResponseBodyDrainsAnalytics | undefined;
    speedInsights?: CreateDrainResponseBodyDrainsSpeedInsights | undefined;
    aiGateway?: ResponseBodyAiGateway | undefined;
    auditLog?: ResponseBodyAuditLog | undefined;
    connect?: ResponseBodyConnect | undefined;
};
export declare const CreateDrainDeliveryTarget: {
    readonly VercelOtelTracesDb: "vercel-otel-traces-db";
};
export type CreateDrainDeliveryTarget = ClosedEnum<typeof CreateDrainDeliveryTarget>;
export type CreateDrainDelivery5 = {
    type: "internal";
    target: CreateDrainDeliveryTarget;
};
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding>;
export declare const CreateDrainDeliveryDrainsResponse200Compression: {
    readonly None: "none";
};
export type CreateDrainDeliveryDrainsResponse200Compression = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200Compression>;
export declare const CreateDrainDeliveryFileStructure: {
    readonly Hive: "hive";
};
export type CreateDrainDeliveryFileStructure = ClosedEnum<typeof CreateDrainDeliveryFileStructure>;
export declare const CreateDrainDeliveryServerSideEncryption: {
    readonly Aes256: "AES256";
    readonly AwsKms: "aws:kms";
    readonly AwsKmsDsse: "aws:kms:dsse";
};
export type CreateDrainDeliveryServerSideEncryption = ClosedEnum<typeof CreateDrainDeliveryServerSideEncryption>;
export declare const CreateDrainDeliveryObjectAcl: {
    readonly AuthenticatedRead: "authenticated-read";
    readonly AwsExecRead: "aws-exec-read";
    readonly BucketOwnerFullControl: "bucket-owner-full-control";
    readonly BucketOwnerRead: "bucket-owner-read";
    readonly Private: "private";
    readonly PublicRead: "public-read";
    readonly PublicReadWrite: "public-read-write";
};
export type CreateDrainDeliveryObjectAcl = ClosedEnum<typeof CreateDrainDeliveryObjectAcl>;
export type CreateDrainDelivery4 = {
    type: "s3";
    endpoint: string;
    encoding: CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding;
    compression: CreateDrainDeliveryDrainsResponse200Compression;
    fileStructure: CreateDrainDeliveryFileStructure;
    roleArn: string;
    region: string;
    serverSideEncryption?: CreateDrainDeliveryServerSideEncryption | undefined;
    objectAcl?: CreateDrainDeliveryObjectAcl | undefined;
};
export type CreateDrainDeliveryDrains3 = {
    type: "clickhouse";
    endpoint: string;
    table: string;
};
export type CreateDrainDeliveryDrainsResponseEndpoint = {
    traces: string;
};
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding: {
    readonly Json: "json";
    readonly Proto: "proto";
};
export type CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding>;
export declare const CreateDrainSecretDrainsResponseKind: {
    readonly IntegrationSecret: "INTEGRATION_SECRET";
};
export type CreateDrainSecretDrainsResponseKind = ClosedEnum<typeof CreateDrainSecretDrainsResponseKind>;
export type CreateDrainSecretDrainsResponse2 = {
    kind: CreateDrainSecretDrainsResponseKind;
};
export type CreateDrainDeliveryDrainsSecret = CreateDrainSecretDrainsResponse2 | string;
export type CreateDrainDeliveryDrains2 = {
    type: "otlphttp";
    endpoint: CreateDrainDeliveryDrainsResponseEndpoint;
    encoding: CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding;
    headers: {
        [k: string]: string;
    };
    secret?: CreateDrainSecretDrainsResponse2 | string | undefined;
};
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding>;
export declare const CreateDrainDeliveryDrainsResponseCompression: {
    readonly Gzip: "gzip";
    readonly None: "none";
};
export type CreateDrainDeliveryDrainsResponseCompression = ClosedEnum<typeof CreateDrainDeliveryDrainsResponseCompression>;
export declare const CreateDrainSecretDrainsKind: {
    readonly IntegrationSecret: "INTEGRATION_SECRET";
};
export type CreateDrainSecretDrainsKind = ClosedEnum<typeof CreateDrainSecretDrainsKind>;
export type CreateDrainSecretDrains2 = {
    kind: CreateDrainSecretDrainsKind;
};
export type CreateDrainDeliverySecret = CreateDrainSecretDrains2 | string;
export type CreateDrainDeliveryDrains1 = {
    type: "http";
    endpoint: string;
    encoding: CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding;
    compression?: CreateDrainDeliveryDrainsResponseCompression | undefined;
    headers: {
        [k: string]: string;
    };
    secret?: CreateDrainSecretDrains2 | string | undefined;
};
export type CreateDrainResponseBodyDelivery = CreateDrainDeliveryDrains1 | CreateDrainDeliveryDrains2 | CreateDrainDeliveryDrains3 | CreateDrainDelivery4 | CreateDrainDelivery5;
export declare const CreateDrainResponseBodyDrainsType: {
    readonly HeadSampling: "head_sampling";
};
export type CreateDrainResponseBodyDrainsType = ClosedEnum<typeof CreateDrainResponseBodyDrainsType>;
export declare const CreateDrainResponseBodyEnv: {
    readonly Preview: "preview";
    readonly Production: "production";
};
export type CreateDrainResponseBodyEnv = ClosedEnum<typeof CreateDrainResponseBodyEnv>;
export type CreateDrainResponseBodySampling = {
    type: CreateDrainResponseBodyDrainsType;
    rate: number;
    env?: CreateDrainResponseBodyEnv | undefined;
    requestPath?: string | undefined;
};
export type CreateDrainSourceDrainsResponse2 = {
    kind: "integration";
    resourceId?: string | undefined;
    externalResourceId?: string | undefined;
    integrationId: string;
    integrationConfigurationId: string;
};
export type CreateDrainSourceDrainsResponse1 = {
    kind: "self-served";
};
export type CreateDrainResponseBodyDrainsSource = CreateDrainSourceDrainsResponse1 | CreateDrainSourceDrainsResponse2;
export declare const CreateDrainResponseBodyDrainsVersion: {
    readonly V2: "v2";
};
export type CreateDrainResponseBodyDrainsVersion = ClosedEnum<typeof CreateDrainResponseBodyDrainsVersion>;
export type CreateDrainFilterDrains2 = {
    type: "odata";
    text: string;
};
export type CreateDrainFilterDrainsProject = {
    ids?: Array<string> | undefined;
};
export declare const CreateDrainFilterDrainsSources: {
    readonly Build: "build";
    readonly Edge: "edge";
    readonly External: "external";
    readonly Firewall: "firewall";
    readonly Lambda: "lambda";
    readonly Redirect: "redirect";
    readonly Static: "static";
};
export type CreateDrainFilterDrainsSources = ClosedEnum<typeof CreateDrainFilterDrainsSources>;
export type CreateDrainFilterLog = {
    sources?: Array<CreateDrainFilterDrainsSources> | undefined;
    legacyExcludeCachedStaticAssetLogs?: boolean | undefined;
};
export declare const CreateDrainFilterDrainsEnvironments: {
    readonly Preview: "preview";
    readonly Production: "production";
};
export type CreateDrainFilterDrainsEnvironments = ClosedEnum<typeof CreateDrainFilterDrainsEnvironments>;
export type CreateDrainFilterDrainsResponseDeployment = {
    environments?: Array<CreateDrainFilterDrainsEnvironments> | undefined;
};
export type CreateDrainFilterDrains1 = {
    type: "basic";
    project?: CreateDrainFilterDrainsProject | undefined;
    log?: CreateDrainFilterLog | undefined;
    deployment?: CreateDrainFilterDrainsResponseDeployment | undefined;
};
export type CreateDrainResponseBodyFilter = CreateDrainFilterDrains1 | CreateDrainFilterDrains2;
export type ResponseBodyFilterV2 = {
    version: CreateDrainResponseBodyDrainsVersion;
    filter: CreateDrainFilterDrains1 | CreateDrainFilterDrains2;
};
export declare const ProjectAccessManagedBy: {
    readonly Drain: "drain";
    readonly Integration: "integration";
};
export type ProjectAccessManagedBy = ClosedEnum<typeof ProjectAccessManagedBy>;
export type ProjectAccess2 = {
    access: "some";
    projectIds: Array<string>;
    managedBy: ProjectAccessManagedBy;
};
export declare const ManagedBy: {
    readonly Drain: "drain";
    readonly Integration: "integration";
};
export type ManagedBy = ClosedEnum<typeof ManagedBy>;
export type ProjectAccess1 = {
    access: "all";
    managedBy: ManagedBy;
};
export type ProjectAccess = ProjectAccess1 | ProjectAccess2;
export type CreateDrainResponseBody2 = {
    id: string;
    createdAt: number;
    updatedAt: number;
    projectIds?: Array<string> | undefined;
    name: string;
    teamId?: string | null | undefined;
    ownerId: string;
    status?: CreateDrainResponseBodyDrainsStatus | undefined;
    firstErrorTimestamp?: number | undefined;
    disabledAt?: number | undefined;
    disabledBy?: string | undefined;
    disabledReason?: ResponseBodyDisabledReason | undefined;
    schemas: CreateDrainResponseBodySchemas;
    delivery: CreateDrainDeliveryDrains1 | CreateDrainDeliveryDrains2 | CreateDrainDeliveryDrains3 | CreateDrainDelivery4 | CreateDrainDelivery5;
    sampling?: Array<CreateDrainResponseBodySampling> | undefined;
    source: CreateDrainSourceDrainsResponse1 | CreateDrainSourceDrainsResponse2;
    filterV2?: ResponseBodyFilterV2 | undefined;
    integrationIcon?: string | undefined;
    integrationConfigurationUri?: string | undefined;
    integrationWebsite?: string | undefined;
    projectAccess?: ProjectAccess1 | ProjectAccess2 | undefined;
};
export declare const CreateDrainResponseBodyStatus: {
    readonly Disabled: "disabled";
    readonly Enabled: "enabled";
    readonly Errored: "errored";
};
export type CreateDrainResponseBodyStatus = ClosedEnum<typeof CreateDrainResponseBodyStatus>;
export declare const DisabledReason: {
    readonly AccountPlanDowngrade: "account-plan-downgrade";
    readonly DisabledByAdmin: "disabled-by-admin";
    readonly DisabledByOwner: "disabled-by-owner";
    readonly FeatureNotAvailable: "feature-not-available";
    readonly LimitsExceeded: "limits-exceeded";
};
export type DisabledReason = ClosedEnum<typeof DisabledReason>;
export type ResponseBodyLog = {};
export type CreateDrainResponseBodyTrace = {};
export type CreateDrainResponseBodyAnalytics = {};
export type CreateDrainResponseBodySpeedInsights = {};
export type AiGateway = {};
export type AuditLog = {};
export type CreateDrainResponseBodyConnect = {};
export type ResponseBodySchemas = {
    log?: ResponseBodyLog | undefined;
    trace?: CreateDrainResponseBodyTrace | undefined;
    analytics?: CreateDrainResponseBodyAnalytics | undefined;
    speedInsights?: CreateDrainResponseBodySpeedInsights | undefined;
    aiGateway?: AiGateway | undefined;
    auditLog?: AuditLog | undefined;
    connect?: CreateDrainResponseBodyConnect | undefined;
};
export declare const DeliveryTarget: {
    readonly VercelOtelTracesDb: "vercel-otel-traces-db";
};
export type DeliveryTarget = ClosedEnum<typeof DeliveryTarget>;
export type Delivery5 = {
    type: "internal";
    target: DeliveryTarget;
};
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding>;
export declare const CreateDrainDeliveryDrainsCompression: {
    readonly None: "none";
};
export type CreateDrainDeliveryDrainsCompression = ClosedEnum<typeof CreateDrainDeliveryDrainsCompression>;
export declare const CreateDrainDeliveryDrainsFileStructure: {
    readonly Hive: "hive";
};
export type CreateDrainDeliveryDrainsFileStructure = ClosedEnum<typeof CreateDrainDeliveryDrainsFileStructure>;
export declare const CreateDrainDeliveryDrainsServerSideEncryption: {
    readonly Aes256: "AES256";
    readonly AwsKms: "aws:kms";
    readonly AwsKmsDsse: "aws:kms:dsse";
};
export type CreateDrainDeliveryDrainsServerSideEncryption = ClosedEnum<typeof CreateDrainDeliveryDrainsServerSideEncryption>;
export declare const CreateDrainDeliveryDrainsObjectAcl: {
    readonly AuthenticatedRead: "authenticated-read";
    readonly AwsExecRead: "aws-exec-read";
    readonly BucketOwnerFullControl: "bucket-owner-full-control";
    readonly BucketOwnerRead: "bucket-owner-read";
    readonly Private: "private";
    readonly PublicRead: "public-read";
    readonly PublicReadWrite: "public-read-write";
};
export type CreateDrainDeliveryDrainsObjectAcl = ClosedEnum<typeof CreateDrainDeliveryDrainsObjectAcl>;
export type Delivery4 = {
    type: "s3";
    endpoint: string;
    encoding: CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding;
    compression: CreateDrainDeliveryDrainsCompression;
    fileStructure: CreateDrainDeliveryDrainsFileStructure;
    roleArn: string;
    region: string;
    serverSideEncryption?: CreateDrainDeliveryDrainsServerSideEncryption | undefined;
    objectAcl?: CreateDrainDeliveryDrainsObjectAcl | undefined;
};
export type CreateDrainDelivery3 = {
    type: "clickhouse";
    endpoint: string;
    table: string;
};
export type CreateDrainDeliveryDrainsEndpoint = {
    traces: string;
};
export declare const CreateDrainDeliveryDrainsResponse200Encoding: {
    readonly Json: "json";
    readonly Proto: "proto";
};
export type CreateDrainDeliveryDrainsResponse200Encoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponse200Encoding>;
export declare const CreateDrainSecretKind: {
    readonly IntegrationSecret: "INTEGRATION_SECRET";
};
export type CreateDrainSecretKind = ClosedEnum<typeof CreateDrainSecretKind>;
export type CreateDrainSecret2 = {
    kind: CreateDrainSecretKind;
};
export type DeliverySecret = CreateDrainSecret2 | string;
export type CreateDrainDelivery2 = {
    type: "otlphttp";
    endpoint: CreateDrainDeliveryDrainsEndpoint;
    encoding: CreateDrainDeliveryDrainsResponse200Encoding;
    headers: {
        [k: string]: string;
    };
    secret?: CreateDrainSecret2 | string | undefined;
};
export declare const CreateDrainDeliveryDrainsResponseEncoding: {
    readonly Json: "json";
    readonly Ndjson: "ndjson";
};
export type CreateDrainDeliveryDrainsResponseEncoding = ClosedEnum<typeof CreateDrainDeliveryDrainsResponseEncoding>;
export declare const CreateDrainDeliveryCompression: {
    readonly Gzip: "gzip";
    readonly None: "none";
};
export type CreateDrainDeliveryCompression = ClosedEnum<typeof CreateDrainDeliveryCompression>;
export declare const SecretKind: {
    readonly IntegrationSecret: "INTEGRATION_SECRET";
};
export type SecretKind = ClosedEnum<typeof SecretKind>;
export type Secret2 = {
    kind: SecretKind;
};
export type Secret = Secret2 | string;
export type CreateDrainDelivery1 = {
    type: "http";
    endpoint: string;
    encoding: CreateDrainDeliveryDrainsResponseEncoding;
    compression?: CreateDrainDeliveryCompression | undefined;
    headers: {
        [k: string]: string;
    };
    secret?: Secret2 | string | undefined;
};
export type ResponseBodyDelivery = CreateDrainDelivery1 | CreateDrainDelivery2 | CreateDrainDelivery3 | Delivery4 | Delivery5;
export declare const CreateDrainResponseBodyType: {
    readonly HeadSampling: "head_sampling";
};
export type CreateDrainResponseBodyType = ClosedEnum<typeof CreateDrainResponseBodyType>;
export declare const CreateDrainResponseBodyDrainsEnv: {
    readonly Preview: "preview";
    readonly Production: "production";
};
export type CreateDrainResponseBodyDrainsEnv = ClosedEnum<typeof CreateDrainResponseBodyDrainsEnv>;
export type ResponseBodySampling = {
    type: CreateDrainResponseBodyType;
    rate: number;
    env?: CreateDrainResponseBodyDrainsEnv | undefined;
    requestPath?: string | undefined;
};
export type CreateDrainSourceDrains2 = {
    kind: "integration";
    resourceId?: string | undefined;
    externalResourceId?: string | undefined;
    integrationId: string;
    integrationConfigurationId: string;
};
export type CreateDrainSourceDrains1 = {
    kind: "self-served";
};
export type CreateDrainResponseBodySource = CreateDrainSourceDrains1 | CreateDrainSourceDrains2;
export declare const CreateDrainResponseBodyVersion: {
    readonly V2: "v2";
};
export type CreateDrainResponseBodyVersion = ClosedEnum<typeof CreateDrainResponseBodyVersion>;
export type CreateDrainFilter2 = {
    type: "odata";
    text: string;
};
export type CreateDrainFilterProject = {
    ids?: Array<string> | undefined;
};
export declare const CreateDrainFilterSources: {
    readonly Build: "build";
    readonly Edge: "edge";
    readonly External: "external";
    readonly Firewall: "firewall";
    readonly Lambda: "lambda";
    readonly Redirect: "redirect";
    readonly Static: "static";
};
export type CreateDrainFilterSources = ClosedEnum<typeof CreateDrainFilterSources>;
export type CreateDrainFilterDrainsLog = {
    sources?: Array<CreateDrainFilterSources> | undefined;
    legacyExcludeCachedStaticAssetLogs?: boolean | undefined;
};
export declare const CreateDrainFilterEnvironments: {
    readonly Preview: "preview";
    readonly Production: "production";
};
export type CreateDrainFilterEnvironments = ClosedEnum<typeof CreateDrainFilterEnvironments>;
export type CreateDrainFilterDrainsDeployment = {
    environments?: Array<CreateDrainFilterEnvironments> | undefined;
};
export type CreateDrainFilter1 = {
    type: "basic";
    project?: CreateDrainFilterProject | undefined;
    log?: CreateDrainFilterDrainsLog | undefined;
    deployment?: CreateDrainFilterDrainsDeployment | undefined;
};
export type ResponseBodyFilter = CreateDrainFilter1 | CreateDrainFilter2;
export type FilterV2 = {
    version: CreateDrainResponseBodyVersion;
    filter: CreateDrainFilter1 | CreateDrainFilter2;
};
export type CreateDrainResponseBody1 = {
    id: string;
    createdAt: number;
    updatedAt: number;
    projectIds?: Array<string> | undefined;
    name: string;
    teamId?: string | null | undefined;
    ownerId: string;
    status?: CreateDrainResponseBodyStatus | undefined;
    firstErrorTimestamp?: number | undefined;
    disabledAt?: number | undefined;
    disabledBy?: string | undefined;
    disabledReason?: DisabledReason | undefined;
    schemas: ResponseBodySchemas;
    delivery: CreateDrainDelivery1 | CreateDrainDelivery2 | CreateDrainDelivery3 | Delivery4 | Delivery5;
    sampling?: Array<ResponseBodySampling> | undefined;
    source: CreateDrainSourceDrains1 | CreateDrainSourceDrains2;
    filterV2?: FilterV2 | undefined;
};
export type CreateDrainResponseBody = CreateDrainResponseBody1 | CreateDrainResponseBody2;
/** @internal */
export declare const CreateDrainProjects$outboundSchema: z.ZodNativeEnum<typeof CreateDrainProjects>;
/** @internal */
export type Filter2$Outbound = {
    type: string;
    text: string;
};
/** @internal */
export declare const Filter2$outboundSchema: z.ZodType<Filter2$Outbound, z.ZodTypeDef, Filter2>;
export declare function filter2ToJSON(filter2: Filter2): string;
/** @internal */
export type FilterProject$Outbound = {
    ids?: Array<string> | undefined;
};
/** @internal */
export declare const FilterProject$outboundSchema: z.ZodType<FilterProject$Outbound, z.ZodTypeDef, FilterProject>;
export declare function filterProjectToJSON(filterProject: FilterProject): string;
/** @internal */
export declare const FilterSources$outboundSchema: z.ZodNativeEnum<typeof FilterSources>;
/** @internal */
export type Log$Outbound = {
    sources?: Array<string> | undefined;
};
/** @internal */
export declare const Log$outboundSchema: z.ZodType<Log$Outbound, z.ZodTypeDef, Log>;
export declare function logToJSON(log: Log): string;
/** @internal */
export declare const FilterEnvironments$outboundSchema: z.ZodNativeEnum<typeof FilterEnvironments>;
/** @internal */
export type CreateDrainFilterDeployment$Outbound = {
    environments?: Array<string> | undefined;
};
/** @internal */
export declare const CreateDrainFilterDeployment$outboundSchema: z.ZodType<CreateDrainFilterDeployment$Outbound, z.ZodTypeDef, CreateDrainFilterDeployment>;
export declare function createDrainFilterDeploymentToJSON(createDrainFilterDeployment: CreateDrainFilterDeployment): string;
/** @internal */
export type Filter1$Outbound = {
    type: string;
    project?: FilterProject$Outbound | undefined;
    log?: Log$Outbound | undefined;
    deployment?: CreateDrainFilterDeployment$Outbound | undefined;
};
/** @internal */
export declare const Filter1$outboundSchema: z.ZodType<Filter1$Outbound, z.ZodTypeDef, Filter1>;
export declare function filter1ToJSON(filter1: Filter1): string;
/** @internal */
export type CreateDrainFilter$Outbound = Filter2$Outbound | Filter1$Outbound;
/** @internal */
export declare const CreateDrainFilter$outboundSchema: z.ZodType<CreateDrainFilter$Outbound, z.ZodTypeDef, CreateDrainFilter>;
export declare function createDrainFilterToJSON(createDrainFilter: CreateDrainFilter): string;
/** @internal */
export type Filter$Outbound = {
    version: string;
    filter: Filter2$Outbound | Filter1$Outbound;
};
/** @internal */
export declare const Filter$outboundSchema: z.ZodType<Filter$Outbound, z.ZodTypeDef, Filter>;
export declare function filterToJSON(filter: Filter): string;
/** @internal */
export type Schemas$Outbound = {
    version: string;
};
/** @internal */
export declare const Schemas$outboundSchema: z.ZodType<Schemas$Outbound, z.ZodTypeDef, Schemas>;
export declare function schemasToJSON(schemas: Schemas): string;
/** @internal */
export declare const CreateDrainDeliveryDrainsEncoding$outboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsEncoding>;
/** @internal */
export declare const DeliveryCompression$outboundSchema: z.ZodNativeEnum<typeof DeliveryCompression>;
/** @internal */
export declare const FileStructure$outboundSchema: z.ZodNativeEnum<typeof FileStructure>;
/** @internal */
export declare const ServerSideEncryption$outboundSchema: z.ZodNativeEnum<typeof ServerSideEncryption>;
/** @internal */
export declare const ObjectAcl$outboundSchema: z.ZodNativeEnum<typeof ObjectAcl>;
/** @internal */
export type Delivery3$Outbound = {
    type: string;
    endpoint: string;
    encoding: string;
    compression: string;
    fileStructure: string;
    roleArn: string;
    region: string;
    serverSideEncryption: string;
    objectAcl?: string | undefined;
};
/** @internal */
export declare const Delivery3$outboundSchema: z.ZodType<Delivery3$Outbound, z.ZodTypeDef, Delivery3>;
export declare function delivery3ToJSON(delivery3: Delivery3): string;
/** @internal */
export type Endpoint1$Outbound = {
    traces: string;
};
/** @internal */
export declare const Endpoint1$outboundSchema: z.ZodType<Endpoint1$Outbound, z.ZodTypeDef, Endpoint1>;
export declare function endpoint1ToJSON(endpoint1: Endpoint1): string;
/** @internal */
export type CreateDrainDeliveryEndpoint$Outbound = Endpoint1$Outbound;
/** @internal */
export declare const CreateDrainDeliveryEndpoint$outboundSchema: z.ZodType<CreateDrainDeliveryEndpoint$Outbound, z.ZodTypeDef, CreateDrainDeliveryEndpoint>;
export declare function createDrainDeliveryEndpointToJSON(createDrainDeliveryEndpoint: CreateDrainDeliveryEndpoint): string;
/** @internal */
export declare const CreateDrainDeliveryEncoding$outboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryEncoding>;
/** @internal */
export type Delivery2$Outbound = {
    type: string;
    endpoint: Endpoint1$Outbound;
    encoding: string;
    headers: {
        [k: string]: string;
    };
    secret?: string | undefined;
};
/** @internal */
export declare const Delivery2$outboundSchema: z.ZodType<Delivery2$Outbound, z.ZodTypeDef, Delivery2>;
export declare function delivery2ToJSON(delivery2: Delivery2): string;
/** @internal */
export declare const Compression$outboundSchema: z.ZodNativeEnum<typeof Compression>;
/** @internal */
export declare const DeliveryEncoding$outboundSchema: z.ZodNativeEnum<typeof DeliveryEncoding>;
/** @internal */
export type Delivery1$Outbound = {
    type: string;
    endpoint: string;
    compression?: string | undefined;
    encoding: string;
    headers: {
        [k: string]: string;
    };
    secret?: string | undefined;
};
/** @internal */
export declare const Delivery1$outboundSchema: z.ZodType<Delivery1$Outbound, z.ZodTypeDef, Delivery1>;
export declare function delivery1ToJSON(delivery1: Delivery1): string;
/** @internal */
export type Delivery$Outbound = Delivery3$Outbound | Delivery1$Outbound | Delivery2$Outbound;
/** @internal */
export declare const Delivery$outboundSchema: z.ZodType<Delivery$Outbound, z.ZodTypeDef, Delivery>;
export declare function deliveryToJSON(delivery: Delivery): string;
/** @internal */
export declare const CreateDrainEnv$outboundSchema: z.ZodNativeEnum<typeof CreateDrainEnv>;
/** @internal */
export type CreateDrainSampling$Outbound = {
    type: string;
    rate: number;
    env?: string | undefined;
    requestPath?: string | undefined;
};
/** @internal */
export declare const CreateDrainSampling$outboundSchema: z.ZodType<CreateDrainSampling$Outbound, z.ZodTypeDef, CreateDrainSampling>;
export declare function createDrainSamplingToJSON(createDrainSampling: CreateDrainSampling): string;
/** @internal */
export type Transforms$Outbound = {
    id: string;
};
/** @internal */
export declare const Transforms$outboundSchema: z.ZodType<Transforms$Outbound, z.ZodTypeDef, Transforms>;
export declare function transformsToJSON(transforms: Transforms): string;
/** @internal */
export type CreateDrainSource2$Outbound = {
    kind: string;
};
/** @internal */
export declare const CreateDrainSource2$outboundSchema: z.ZodType<CreateDrainSource2$Outbound, z.ZodTypeDef, CreateDrainSource2>;
export declare function createDrainSource2ToJSON(createDrainSource2: CreateDrainSource2): string;
/** @internal */
export type One3$Outbound = {
    kind: string;
};
/** @internal */
export declare const One3$outboundSchema: z.ZodType<One3$Outbound, z.ZodTypeDef, One3>;
export declare function one3ToJSON(one3: One3): string;
/** @internal */
export type One2$Outbound = {
    kind: string;
    resourceId: string;
};
/** @internal */
export declare const One2$outboundSchema: z.ZodType<One2$Outbound, z.ZodTypeDef, One2>;
export declare function one2ToJSON(one2: One2): string;
/** @internal */
export type CreateDrain11$Outbound = {
    kind: string;
    externalResourceId: string;
};
/** @internal */
export declare const CreateDrain11$outboundSchema: z.ZodType<CreateDrain11$Outbound, z.ZodTypeDef, CreateDrain11>;
export declare function createDrain11ToJSON(createDrain11: CreateDrain11): string;
/** @internal */
export type CreateDrainSource1$Outbound = CreateDrain11$Outbound | One2$Outbound | One3$Outbound;
/** @internal */
export declare const CreateDrainSource1$outboundSchema: z.ZodType<CreateDrainSource1$Outbound, z.ZodTypeDef, CreateDrainSource1>;
export declare function createDrainSource1ToJSON(createDrainSource1: CreateDrainSource1): string;
/** @internal */
export type CreateDrainSource$Outbound = CreateDrain11$Outbound | One2$Outbound | One3$Outbound | CreateDrainSource2$Outbound;
/** @internal */
export declare const CreateDrainSource$outboundSchema: z.ZodType<CreateDrainSource$Outbound, z.ZodTypeDef, CreateDrainSource>;
export declare function createDrainSourceToJSON(createDrainSource: CreateDrainSource): string;
/** @internal */
export type CreateDrainRequestBody$Outbound = {
    name: string;
    projects: string;
    projectIds?: Array<string> | undefined;
    filter?: Filter$Outbound | undefined;
    schemas: {
        [k: string]: Schemas$Outbound;
    };
    delivery?: Delivery3$Outbound | Delivery1$Outbound | Delivery2$Outbound | undefined;
    sampling?: Array<CreateDrainSampling$Outbound> | undefined;
    transforms?: Array<Transforms$Outbound> | undefined;
    source?: CreateDrain11$Outbound | One2$Outbound | One3$Outbound | CreateDrainSource2$Outbound | undefined;
};
/** @internal */
export declare const CreateDrainRequestBody$outboundSchema: z.ZodType<CreateDrainRequestBody$Outbound, z.ZodTypeDef, CreateDrainRequestBody>;
export declare function createDrainRequestBodyToJSON(createDrainRequestBody: CreateDrainRequestBody): string;
/** @internal */
export type CreateDrainRequest$Outbound = {
    teamId?: string | undefined;
    slug?: string | undefined;
    RequestBody?: CreateDrainRequestBody$Outbound | undefined;
};
/** @internal */
export declare const CreateDrainRequest$outboundSchema: z.ZodType<CreateDrainRequest$Outbound, z.ZodTypeDef, CreateDrainRequest>;
export declare function createDrainRequestToJSON(createDrainRequest: CreateDrainRequest): string;
/** @internal */
export declare const CreateDrainResponseBodyDrainsStatus$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyDrainsStatus>;
/** @internal */
export declare const ResponseBodyDisabledReason$inboundSchema: z.ZodNativeEnum<typeof ResponseBodyDisabledReason>;
/** @internal */
export declare const CreateDrainResponseBodyLog$inboundSchema: z.ZodType<CreateDrainResponseBodyLog, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyLogFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyLog, SDKValidationError>;
/** @internal */
export declare const ResponseBodyTrace$inboundSchema: z.ZodType<ResponseBodyTrace, z.ZodTypeDef, unknown>;
export declare function responseBodyTraceFromJSON(jsonString: string): SafeParseResult<ResponseBodyTrace, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsAnalytics$inboundSchema: z.ZodType<CreateDrainResponseBodyDrainsAnalytics, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyDrainsAnalyticsFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyDrainsAnalytics, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsSpeedInsights$inboundSchema: z.ZodType<CreateDrainResponseBodyDrainsSpeedInsights, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyDrainsSpeedInsightsFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyDrainsSpeedInsights, SDKValidationError>;
/** @internal */
export declare const ResponseBodyAiGateway$inboundSchema: z.ZodType<ResponseBodyAiGateway, z.ZodTypeDef, unknown>;
export declare function responseBodyAiGatewayFromJSON(jsonString: string): SafeParseResult<ResponseBodyAiGateway, SDKValidationError>;
/** @internal */
export declare const ResponseBodyAuditLog$inboundSchema: z.ZodType<ResponseBodyAuditLog, z.ZodTypeDef, unknown>;
export declare function responseBodyAuditLogFromJSON(jsonString: string): SafeParseResult<ResponseBodyAuditLog, SDKValidationError>;
/** @internal */
export declare const ResponseBodyConnect$inboundSchema: z.ZodType<ResponseBodyConnect, z.ZodTypeDef, unknown>;
export declare function responseBodyConnectFromJSON(jsonString: string): SafeParseResult<ResponseBodyConnect, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodySchemas$inboundSchema: z.ZodType<CreateDrainResponseBodySchemas, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodySchemasFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodySchemas, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryTarget$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryTarget>;
/** @internal */
export declare const CreateDrainDelivery5$inboundSchema: z.ZodType<CreateDrainDelivery5, z.ZodTypeDef, unknown>;
export declare function createDrainDelivery5FromJSON(jsonString: string): SafeParseResult<CreateDrainDelivery5, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody24Encoding>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200Compression$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200Compression>;
/** @internal */
export declare const CreateDrainDeliveryFileStructure$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryFileStructure>;
/** @internal */
export declare const CreateDrainDeliveryServerSideEncryption$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryServerSideEncryption>;
/** @internal */
export declare const CreateDrainDeliveryObjectAcl$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryObjectAcl>;
/** @internal */
export declare const CreateDrainDelivery4$inboundSchema: z.ZodType<CreateDrainDelivery4, z.ZodTypeDef, unknown>;
export declare function createDrainDelivery4FromJSON(jsonString: string): SafeParseResult<CreateDrainDelivery4, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrains3$inboundSchema: z.ZodType<CreateDrainDeliveryDrains3, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrains3FromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrains3, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponseEndpoint$inboundSchema: z.ZodType<CreateDrainDeliveryDrainsResponseEndpoint, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrainsResponseEndpointFromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrainsResponseEndpoint, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBody2Encoding>;
/** @internal */
export declare const CreateDrainSecretDrainsResponseKind$inboundSchema: z.ZodNativeEnum<typeof CreateDrainSecretDrainsResponseKind>;
/** @internal */
export declare const CreateDrainSecretDrainsResponse2$inboundSchema: z.ZodType<CreateDrainSecretDrainsResponse2, z.ZodTypeDef, unknown>;
export declare function createDrainSecretDrainsResponse2FromJSON(jsonString: string): SafeParseResult<CreateDrainSecretDrainsResponse2, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsSecret$inboundSchema: z.ZodType<CreateDrainDeliveryDrainsSecret, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrainsSecretFromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrainsSecret, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrains2$inboundSchema: z.ZodType<CreateDrainDeliveryDrains2, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrains2FromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrains2, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONResponseBodyEncoding>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponseCompression$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponseCompression>;
/** @internal */
export declare const CreateDrainSecretDrainsKind$inboundSchema: z.ZodNativeEnum<typeof CreateDrainSecretDrainsKind>;
/** @internal */
export declare const CreateDrainSecretDrains2$inboundSchema: z.ZodType<CreateDrainSecretDrains2, z.ZodTypeDef, unknown>;
export declare function createDrainSecretDrains2FromJSON(jsonString: string): SafeParseResult<CreateDrainSecretDrains2, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliverySecret$inboundSchema: z.ZodType<CreateDrainDeliverySecret, z.ZodTypeDef, unknown>;
export declare function createDrainDeliverySecretFromJSON(jsonString: string): SafeParseResult<CreateDrainDeliverySecret, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrains1$inboundSchema: z.ZodType<CreateDrainDeliveryDrains1, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrains1FromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrains1, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDelivery$inboundSchema: z.ZodType<CreateDrainResponseBodyDelivery, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyDeliveryFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyDelivery, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsType$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyDrainsType>;
/** @internal */
export declare const CreateDrainResponseBodyEnv$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyEnv>;
/** @internal */
export declare const CreateDrainResponseBodySampling$inboundSchema: z.ZodType<CreateDrainResponseBodySampling, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodySamplingFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodySampling, SDKValidationError>;
/** @internal */
export declare const CreateDrainSourceDrainsResponse2$inboundSchema: z.ZodType<CreateDrainSourceDrainsResponse2, z.ZodTypeDef, unknown>;
export declare function createDrainSourceDrainsResponse2FromJSON(jsonString: string): SafeParseResult<CreateDrainSourceDrainsResponse2, SDKValidationError>;
/** @internal */
export declare const CreateDrainSourceDrainsResponse1$inboundSchema: z.ZodType<CreateDrainSourceDrainsResponse1, z.ZodTypeDef, unknown>;
export declare function createDrainSourceDrainsResponse1FromJSON(jsonString: string): SafeParseResult<CreateDrainSourceDrainsResponse1, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsSource$inboundSchema: z.ZodType<CreateDrainResponseBodyDrainsSource, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyDrainsSourceFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyDrainsSource, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsVersion$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyDrainsVersion>;
/** @internal */
export declare const CreateDrainFilterDrains2$inboundSchema: z.ZodType<CreateDrainFilterDrains2, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrains2FromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrains2, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterDrainsProject$inboundSchema: z.ZodType<CreateDrainFilterDrainsProject, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrainsProjectFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrainsProject, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterDrainsSources$inboundSchema: z.ZodNativeEnum<typeof CreateDrainFilterDrainsSources>;
/** @internal */
export declare const CreateDrainFilterLog$inboundSchema: z.ZodType<CreateDrainFilterLog, z.ZodTypeDef, unknown>;
export declare function createDrainFilterLogFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterLog, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterDrainsEnvironments$inboundSchema: z.ZodNativeEnum<typeof CreateDrainFilterDrainsEnvironments>;
/** @internal */
export declare const CreateDrainFilterDrainsResponseDeployment$inboundSchema: z.ZodType<CreateDrainFilterDrainsResponseDeployment, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrainsResponseDeploymentFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrainsResponseDeployment, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterDrains1$inboundSchema: z.ZodType<CreateDrainFilterDrains1, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrains1FromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrains1, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyFilter$inboundSchema: z.ZodType<CreateDrainResponseBodyFilter, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyFilterFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyFilter, SDKValidationError>;
/** @internal */
export declare const ResponseBodyFilterV2$inboundSchema: z.ZodType<ResponseBodyFilterV2, z.ZodTypeDef, unknown>;
export declare function responseBodyFilterV2FromJSON(jsonString: string): SafeParseResult<ResponseBodyFilterV2, SDKValidationError>;
/** @internal */
export declare const ProjectAccessManagedBy$inboundSchema: z.ZodNativeEnum<typeof ProjectAccessManagedBy>;
/** @internal */
export declare const ProjectAccess2$inboundSchema: z.ZodType<ProjectAccess2, z.ZodTypeDef, unknown>;
export declare function projectAccess2FromJSON(jsonString: string): SafeParseResult<ProjectAccess2, SDKValidationError>;
/** @internal */
export declare const ManagedBy$inboundSchema: z.ZodNativeEnum<typeof ManagedBy>;
/** @internal */
export declare const ProjectAccess1$inboundSchema: z.ZodType<ProjectAccess1, z.ZodTypeDef, unknown>;
export declare function projectAccess1FromJSON(jsonString: string): SafeParseResult<ProjectAccess1, SDKValidationError>;
/** @internal */
export declare const ProjectAccess$inboundSchema: z.ZodType<ProjectAccess, z.ZodTypeDef, unknown>;
export declare function projectAccessFromJSON(jsonString: string): SafeParseResult<ProjectAccess, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBody2$inboundSchema: z.ZodType<CreateDrainResponseBody2, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBody2FromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBody2, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyStatus$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyStatus>;
/** @internal */
export declare const DisabledReason$inboundSchema: z.ZodNativeEnum<typeof DisabledReason>;
/** @internal */
export declare const ResponseBodyLog$inboundSchema: z.ZodType<ResponseBodyLog, z.ZodTypeDef, unknown>;
export declare function responseBodyLogFromJSON(jsonString: string): SafeParseResult<ResponseBodyLog, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyTrace$inboundSchema: z.ZodType<CreateDrainResponseBodyTrace, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyTraceFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyTrace, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyAnalytics$inboundSchema: z.ZodType<CreateDrainResponseBodyAnalytics, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyAnalyticsFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyAnalytics, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodySpeedInsights$inboundSchema: z.ZodType<CreateDrainResponseBodySpeedInsights, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodySpeedInsightsFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodySpeedInsights, SDKValidationError>;
/** @internal */
export declare const AiGateway$inboundSchema: z.ZodType<AiGateway, z.ZodTypeDef, unknown>;
export declare function aiGatewayFromJSON(jsonString: string): SafeParseResult<AiGateway, SDKValidationError>;
/** @internal */
export declare const AuditLog$inboundSchema: z.ZodType<AuditLog, z.ZodTypeDef, unknown>;
export declare function auditLogFromJSON(jsonString: string): SafeParseResult<AuditLog, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyConnect$inboundSchema: z.ZodType<CreateDrainResponseBodyConnect, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyConnectFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodyConnect, SDKValidationError>;
/** @internal */
export declare const ResponseBodySchemas$inboundSchema: z.ZodType<ResponseBodySchemas, z.ZodTypeDef, unknown>;
export declare function responseBodySchemasFromJSON(jsonString: string): SafeParseResult<ResponseBodySchemas, SDKValidationError>;
/** @internal */
export declare const DeliveryTarget$inboundSchema: z.ZodNativeEnum<typeof DeliveryTarget>;
/** @internal */
export declare const Delivery5$inboundSchema: z.ZodType<Delivery5, z.ZodTypeDef, unknown>;
export declare function delivery5FromJSON(jsonString: string): SafeParseResult<Delivery5, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200ApplicationJSONEncoding>;
/** @internal */
export declare const CreateDrainDeliveryDrainsCompression$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsCompression>;
/** @internal */
export declare const CreateDrainDeliveryDrainsFileStructure$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsFileStructure>;
/** @internal */
export declare const CreateDrainDeliveryDrainsServerSideEncryption$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsServerSideEncryption>;
/** @internal */
export declare const CreateDrainDeliveryDrainsObjectAcl$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsObjectAcl>;
/** @internal */
export declare const Delivery4$inboundSchema: z.ZodType<Delivery4, z.ZodTypeDef, unknown>;
export declare function delivery4FromJSON(jsonString: string): SafeParseResult<Delivery4, SDKValidationError>;
/** @internal */
export declare const CreateDrainDelivery3$inboundSchema: z.ZodType<CreateDrainDelivery3, z.ZodTypeDef, unknown>;
export declare function createDrainDelivery3FromJSON(jsonString: string): SafeParseResult<CreateDrainDelivery3, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsEndpoint$inboundSchema: z.ZodType<CreateDrainDeliveryDrainsEndpoint, z.ZodTypeDef, unknown>;
export declare function createDrainDeliveryDrainsEndpointFromJSON(jsonString: string): SafeParseResult<CreateDrainDeliveryDrainsEndpoint, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponse200Encoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponse200Encoding>;
/** @internal */
export declare const CreateDrainSecretKind$inboundSchema: z.ZodNativeEnum<typeof CreateDrainSecretKind>;
/** @internal */
export declare const CreateDrainSecret2$inboundSchema: z.ZodType<CreateDrainSecret2, z.ZodTypeDef, unknown>;
export declare function createDrainSecret2FromJSON(jsonString: string): SafeParseResult<CreateDrainSecret2, SDKValidationError>;
/** @internal */
export declare const DeliverySecret$inboundSchema: z.ZodType<DeliverySecret, z.ZodTypeDef, unknown>;
export declare function deliverySecretFromJSON(jsonString: string): SafeParseResult<DeliverySecret, SDKValidationError>;
/** @internal */
export declare const CreateDrainDelivery2$inboundSchema: z.ZodType<CreateDrainDelivery2, z.ZodTypeDef, unknown>;
export declare function createDrainDelivery2FromJSON(jsonString: string): SafeParseResult<CreateDrainDelivery2, SDKValidationError>;
/** @internal */
export declare const CreateDrainDeliveryDrainsResponseEncoding$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryDrainsResponseEncoding>;
/** @internal */
export declare const CreateDrainDeliveryCompression$inboundSchema: z.ZodNativeEnum<typeof CreateDrainDeliveryCompression>;
/** @internal */
export declare const SecretKind$inboundSchema: z.ZodNativeEnum<typeof SecretKind>;
/** @internal */
export declare const Secret2$inboundSchema: z.ZodType<Secret2, z.ZodTypeDef, unknown>;
export declare function secret2FromJSON(jsonString: string): SafeParseResult<Secret2, SDKValidationError>;
/** @internal */
export declare const Secret$inboundSchema: z.ZodType<Secret, z.ZodTypeDef, unknown>;
export declare function secretFromJSON(jsonString: string): SafeParseResult<Secret, SDKValidationError>;
/** @internal */
export declare const CreateDrainDelivery1$inboundSchema: z.ZodType<CreateDrainDelivery1, z.ZodTypeDef, unknown>;
export declare function createDrainDelivery1FromJSON(jsonString: string): SafeParseResult<CreateDrainDelivery1, SDKValidationError>;
/** @internal */
export declare const ResponseBodyDelivery$inboundSchema: z.ZodType<ResponseBodyDelivery, z.ZodTypeDef, unknown>;
export declare function responseBodyDeliveryFromJSON(jsonString: string): SafeParseResult<ResponseBodyDelivery, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyType>;
/** @internal */
export declare const CreateDrainResponseBodyDrainsEnv$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyDrainsEnv>;
/** @internal */
export declare const ResponseBodySampling$inboundSchema: z.ZodType<ResponseBodySampling, z.ZodTypeDef, unknown>;
export declare function responseBodySamplingFromJSON(jsonString: string): SafeParseResult<ResponseBodySampling, SDKValidationError>;
/** @internal */
export declare const CreateDrainSourceDrains2$inboundSchema: z.ZodType<CreateDrainSourceDrains2, z.ZodTypeDef, unknown>;
export declare function createDrainSourceDrains2FromJSON(jsonString: string): SafeParseResult<CreateDrainSourceDrains2, SDKValidationError>;
/** @internal */
export declare const CreateDrainSourceDrains1$inboundSchema: z.ZodType<CreateDrainSourceDrains1, z.ZodTypeDef, unknown>;
export declare function createDrainSourceDrains1FromJSON(jsonString: string): SafeParseResult<CreateDrainSourceDrains1, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodySource$inboundSchema: z.ZodType<CreateDrainResponseBodySource, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodySourceFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBodySource, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBodyVersion$inboundSchema: z.ZodNativeEnum<typeof CreateDrainResponseBodyVersion>;
/** @internal */
export declare const CreateDrainFilter2$inboundSchema: z.ZodType<CreateDrainFilter2, z.ZodTypeDef, unknown>;
export declare function createDrainFilter2FromJSON(jsonString: string): SafeParseResult<CreateDrainFilter2, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterProject$inboundSchema: z.ZodType<CreateDrainFilterProject, z.ZodTypeDef, unknown>;
export declare function createDrainFilterProjectFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterProject, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterSources$inboundSchema: z.ZodNativeEnum<typeof CreateDrainFilterSources>;
/** @internal */
export declare const CreateDrainFilterDrainsLog$inboundSchema: z.ZodType<CreateDrainFilterDrainsLog, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrainsLogFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrainsLog, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilterEnvironments$inboundSchema: z.ZodNativeEnum<typeof CreateDrainFilterEnvironments>;
/** @internal */
export declare const CreateDrainFilterDrainsDeployment$inboundSchema: z.ZodType<CreateDrainFilterDrainsDeployment, z.ZodTypeDef, unknown>;
export declare function createDrainFilterDrainsDeploymentFromJSON(jsonString: string): SafeParseResult<CreateDrainFilterDrainsDeployment, SDKValidationError>;
/** @internal */
export declare const CreateDrainFilter1$inboundSchema: z.ZodType<CreateDrainFilter1, z.ZodTypeDef, unknown>;
export declare function createDrainFilter1FromJSON(jsonString: string): SafeParseResult<CreateDrainFilter1, SDKValidationError>;
/** @internal */
export declare const ResponseBodyFilter$inboundSchema: z.ZodType<ResponseBodyFilter, z.ZodTypeDef, unknown>;
export declare function responseBodyFilterFromJSON(jsonString: string): SafeParseResult<ResponseBodyFilter, SDKValidationError>;
/** @internal */
export declare const FilterV2$inboundSchema: z.ZodType<FilterV2, z.ZodTypeDef, unknown>;
export declare function filterV2FromJSON(jsonString: string): SafeParseResult<FilterV2, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBody1$inboundSchema: z.ZodType<CreateDrainResponseBody1, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBody1FromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBody1, SDKValidationError>;
/** @internal */
export declare const CreateDrainResponseBody$inboundSchema: z.ZodType<CreateDrainResponseBody, z.ZodTypeDef, unknown>;
export declare function createDrainResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateDrainResponseBody, SDKValidationError>;
//# sourceMappingURL=createdrainop.d.ts.map