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

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  accessKeyId: "access_key_id",
  accountId: "account_id",
  createdAt: "created_at",
  decimalEncoding: "decimal_encoding",
  destId: "dest_id",
  edgeType: "edge_type",
  failureReason: "failure_reason",
  fileNaming: "file_naming",
  fileSizeBytes: "file_size_bytes",
  inactivitySeconds: "inactivity_seconds",
  intervalSeconds: "interval_seconds",
  keyType: "key_type",
  maxBytes: "max_bytes",
  maxDurationS: "max_duration_s",
  maxRows: "max_rows",
  metadataKey: "metadata_key",
  modifiedAt: "modified_at",
  nodeId: "node_id",
  perPage: "per_page",
  resultInfo: "result_info",
  results: "result",
  rollingPolicy: "rolling_policy",
  rowGroupBytes: "row_group_bytes",
  secretAccessKey: "secret_access_key",
  sqlName: "sql_name",
  srcId: "src_id",
  tableName: "table_name",
  timePattern: "time_pattern",
  timestampFormat: "timestamp_format",
  totalCount: "total_count",
  valueType: "value_type",
  workerBinding: "worker_binding",
};

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

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

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

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

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

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

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

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

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

export class SinkInUse
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<SinkInUse>()("SinkInUse", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 422, message: { includes: "in use" } }],
  ) {}

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

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

export class StreamInUse
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<StreamInUse>()("StreamInUse", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 422, message: { includes: "in use" } }],
  ) {}

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

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

export interface CreateRequestDestinationBatch {
  /** Specifies rough maximum size of files. */
  maxBytes?: number;
  /** Specifies duration to wait to aggregate batches files. */
  maxDurationS?: number;
  /** Specifies rough maximum number of rows per file. */
  maxRows?: number;
}
export const CreateRequestDestinationBatch = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxBytes: S.optional(S.Number.pipe(T.Body("max_bytes"))),
    maxDurationS: S.optional(S.Number.pipe(T.Body("max_duration_s"))),
    maxRows: S.optional(S.Number.pipe(T.Body("max_rows"))),
  }),
).annotate({
  identifier: "CreateRequestDestinationBatch",
}) as any as S.Schema<CreateRequestDestinationBatch>;

export type CreateRequestDestinationCompressionType =
  | "none"
  | "gzip"
  | "deflate";
export const CreateRequestDestinationCompressionType = /*@__PURE__*/ S.String;

export interface CreateRequestDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type?: CreateRequestDestinationCompressionType | (string & {});
}
export const CreateRequestDestinationCompression = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: S.optional(CreateRequestDestinationCompressionType),
  }),
).annotate({
  identifier: "CreateRequestDestinationCompression",
}) as any as S.Schema<CreateRequestDestinationCompression>;

export interface CreateRequestDestinationCredentials {
  /** Specifies the R2 Bucket Access Key Id. */
  accessKeyId: string;
  /** Specifies the R2 Endpoint. */
  endpoint: string;
  /** Specifies the R2 Bucket Secret Access Key. */
  secretAccessKey: string;
}
export const CreateRequestDestinationCredentials = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accessKeyId: S.String.pipe(T.Body("access_key_id")),
    endpoint: S.String,
    secretAccessKey: S.String.pipe(T.Body("secret_access_key")),
  }),
).annotate({
  identifier: "CreateRequestDestinationCredentials",
}) as any as S.Schema<CreateRequestDestinationCredentials>;

export type CreateRequestDestinationFormat = "json";
export const CreateRequestDestinationFormat = /*@__PURE__*/ S.String;

export interface CreateRequestDestinationPath {
  /** Specifies the R2 Bucket to store files. */
  bucket: string;
  /** Specifies the name pattern to for individual data files. */
  filename?: string;
  /** Specifies the name pattern for directory. */
  filepath?: string;
  /** Specifies the base directory within the bucket. */
  prefix?: string;
}
export const CreateRequestDestinationPath = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    bucket: S.String,
    filename: S.optional(S.String),
    filepath: S.optional(S.String),
    prefix: S.optional(S.String),
  }),
).annotate({
  identifier: "CreateRequestDestinationPath",
}) as any as S.Schema<CreateRequestDestinationPath>;

export type CreateRequestDestinationType = "r2";
export const CreateRequestDestinationType = /*@__PURE__*/ S.String;

export interface CreateRequestDestination {
  batch: CreateRequestDestinationBatch;
  compression: CreateRequestDestinationCompression;
  credentials: CreateRequestDestinationCredentials;
  /** Specifies the format of data to deliver. */
  format: CreateRequestDestinationFormat | (string & {});
  path: CreateRequestDestinationPath;
  /** Specifies the type of destination. */
  type: CreateRequestDestinationType | (string & {});
}
export const CreateRequestDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateRequestDestinationBatch,
    compression: CreateRequestDestinationCompression,
    credentials: CreateRequestDestinationCredentials,
    format: CreateRequestDestinationFormat,
    path: CreateRequestDestinationPath,
    type: CreateRequestDestinationType,
  }),
).annotate({
  identifier: "CreateRequestDestination",
}) as any as S.Schema<CreateRequestDestination>;

export type CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList;
}
export const CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
      ),
    }),
  ).annotate({
    identifier:
      "CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean;
  cors?: CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors;
}
export const CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.Boolean),
      cors: S.optional(
        CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
      ),
    }),
  ).annotate({
    identifier:
      "CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type CreateRequestSourceItem =
  | CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | CreateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const CreateRequestSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

export interface CreatePipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  destination: CreateRequestDestination;
  /** Defines the name of the pipeline. */
  name: string;
  source: CreateRequestSourceList;
}
export const CreatePipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    destination: CreateRequestDestination,
    name: S.String,
    source: CreateRequestSourceList,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/pipelines",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePipelineRequest",
}) as any as S.Schema<CreatePipelineRequest>;

export interface CreateResponseDestinationBatch {
  /** Specifies rough maximum size of files. */
  maxBytes: number;
  /** Specifies duration to wait to aggregate batches files. */
  maxDurationS: number;
  /** Specifies rough maximum number of rows per file. */
  maxRows: number;
}
export const CreateResponseDestinationBatch = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    maxBytes: S.Number.pipe(T.Body("max_bytes")),
    maxDurationS: S.Number.pipe(T.Body("max_duration_s")),
    maxRows: S.Number.pipe(T.Body("max_rows")),
  }),
).annotate({
  identifier: "CreateResponseDestinationBatch",
}) as any as S.Schema<CreateResponseDestinationBatch>;

export type CreateResponseDestinationCompressionType =
  | "none"
  | "gzip"
  | "deflate";
export const CreateResponseDestinationCompressionType = /*@__PURE__*/ S.String;

export interface CreateResponseDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type: CreateResponseDestinationCompressionType;
}
export const CreateResponseDestinationCompression = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: CreateResponseDestinationCompressionType,
    }),
).annotate({
  identifier: "CreateResponseDestinationCompression",
}) as any as S.Schema<CreateResponseDestinationCompression>;

export type CreateResponseDestinationFormat = "json";
export const CreateResponseDestinationFormat = /*@__PURE__*/ S.String;

export interface CreateResponseDestinationPath {
  /** Specifies the R2 Bucket to store files. */
  bucket: string;
  /** Specifies the name pattern to for individual data files. */
  filename?: string | null;
  /** Specifies the name pattern for directory. */
  filepath?: string | null;
  /** Specifies the base directory within the bucket. */
  prefix?: string | null;
}
export const CreateResponseDestinationPath = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    bucket: S.String,
    filename: S.optional(S.NullOr(S.String)),
    filepath: S.optional(S.NullOr(S.String)),
    prefix: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "CreateResponseDestinationPath",
}) as any as S.Schema<CreateResponseDestinationPath>;

export type CreateResponseDestinationType = "r2";
export const CreateResponseDestinationType = /*@__PURE__*/ S.String;

export interface CreateResponseDestination {
  batch: CreateResponseDestinationBatch;
  compression: CreateResponseDestinationCompression;
  /** Specifies the format of data to deliver. */
  format: CreateResponseDestinationFormat;
  path: CreateResponseDestinationPath;
  /** Specifies the type of destination. */
  type: CreateResponseDestinationType;
}
export const CreateResponseDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateResponseDestinationBatch,
    compression: CreateResponseDestinationCompression,
    format: CreateResponseDestinationFormat,
    path: CreateResponseDestinationPath,
    type: CreateResponseDestinationType,
  }),
).annotate({
  identifier: "CreateResponseDestination",
}) as any as S.Schema<CreateResponseDestination>;

export type CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList | null;
}
export const CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        S.NullOr(
          CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean | null;
  cors?: CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors | null;
}
export const CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.NullOr(S.Boolean)),
      cors: S.optional(
        S.NullOr(
          CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type CreateResponseSourceItem =
  | CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | CreateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const CreateResponseSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreatePipelineResponse {
  /** Specifies the pipeline identifier. */
  id: string;
  destination: CreateResponseDestination;
  /** Indicates the endpoint URL to send traffic. */
  endpoint: string;
  /** Defines the name of the pipeline. */
  name: string;
  source: CreateResponseSourceList;
  /** Indicates the version number of last saved configuration. */
  version: number;
}
export const CreatePipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    destination: CreateResponseDestination,
    endpoint: S.String,
    name: S.String,
    source: CreateResponseSourceList,
    version: S.Number,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePipelineResponse",
}) as any as S.Schema<CreatePipelineResponse>;

export type SinksCreateRequestType = "r2" | "r2_data_catalog";
export const SinksCreateRequestType = /*@__PURE__*/ S.String;

export interface SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials {
  /** Cloudflare Account ID for the bucket */
  accessKeyId: string;
  /** Cloudflare Account ID for the bucket */
  secretAccessKey: string;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accessKeyId: S.String.pipe(T.Body("access_key_id")),
      secretAccessKey: S.String.pipe(T.Body("secret_access_key")),
    }),
  ).annotate({
    identifier: "SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials>;

export type SinksCreateRequestConfigCloudflarePipelinesR2TableFileNamingStrategy =
  | "serial"
  | "uuid"
  | "uuid_v7"
  | "ulid";
export const SinksCreateRequestConfigCloudflarePipelinesR2TableFileNamingStrategy =
  /*@__PURE__*/ S.String;

export interface SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming {
  /** The prefix to use in file name. i.e prefix-<uuid>.parquet */
  prefix?: string;
  /** Filename generation strategy. */
  strategy?:
    | SinksCreateRequestConfigCloudflarePipelinesR2TableFileNamingStrategy
    | (string & {});
  /** This will overwrite the default file suffix. i.e .parquet, use with caution */
  suffix?: string;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      prefix: S.optional(S.String),
      strategy: S.optional(
        SinksCreateRequestConfigCloudflarePipelinesR2TableFileNamingStrategy,
      ),
      suffix: S.optional(S.String),
    }),
  ).annotate({
    identifier: "SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming>;

export interface SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning {
  /** The pattern of the date string */
  timePattern?: string;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      timePattern: S.optional(S.String.pipe(T.Body("time_pattern"))),
    }),
  ).annotate({
    identifier:
      "SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning>;

export interface SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy {
  /** Files will be rolled after reaching this number of bytes */
  fileSizeBytes?: number;
  /** Number of seconds of inactivity to wait before rolling over to a new file */
  inactivitySeconds?: number;
  /** Number of seconds to wait before rolling over to a new file */
  intervalSeconds?: number;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      fileSizeBytes: S.optional(S.Number.pipe(T.Body("file_size_bytes"))),
      inactivitySeconds: S.optional(
        S.Number.pipe(T.Body("inactivity_seconds")),
      ),
      intervalSeconds: S.optional(S.Number.pipe(T.Body("interval_seconds"))),
    }),
  ).annotate({
    identifier:
      "SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy>;

export interface SinksCreateRequestConfigCloudflarePipelinesR2Table {
  /** Cloudflare Account ID for the bucket */
  accountId: string;
  /** R2 Bucket to write to */
  bucket: string;
  credentials: SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials;
  /** Controls filename prefix/suffix and strategy. */
  fileNaming?: SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming;
  /** Jurisdiction this bucket is hosted in */
  jurisdiction?: string;
  /** Data-layout partitioning for sinks. */
  partitioning?: SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning;
  /** Subpath within the bucket to write to */
  path?: string;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2Table =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      credentials:
        SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials,
      fileNaming: S.optional(
        SinksCreateRequestConfigCloudflarePipelinesR2TableFileNaming.pipe(
          T.Body("file_naming"),
        ),
      ),
      jurisdiction: S.optional(S.String),
      partitioning: S.optional(
        SinksCreateRequestConfigCloudflarePipelinesR2TablePartitioning,
      ),
      path: S.optional(S.String),
      rollingPolicy: S.optional(
        SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy.pipe(
          T.Body("rolling_policy"),
        ),
      ),
    }),
  ).annotate({
    identifier: "SinksCreateRequestConfigCloudflarePipelinesR2Table",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2Table>;

export type SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTableRollingPolicy =
  SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTableRollingPolicy =
  SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy;

export interface SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTable {
  /** Authentication token */
  token: string;
  /** Cloudflare Account ID */
  accountId: string;
  /** The R2 Bucket that hosts this catalog */
  bucket: string;
  /** Table name */
  tableName: string;
  /** Table namespace */
  namespace?: string;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy;
}
export const SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTable =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      token: S.String,
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      tableName: S.String.pipe(T.Body("table_name")),
      namespace: S.optional(S.String),
      rollingPolicy: S.optional(
        SinksCreateRequestConfigCloudflarePipelinesR2TableRollingPolicy.pipe(
          T.Body("rolling_policy"),
        ),
      ),
    }),
  ).annotate({
    identifier: "SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTable",
  }) as any as S.Schema<SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTable>;

export type SinksCreateRequestConfig =
  | SinksCreateRequestConfigCloudflarePipelinesR2Table
  | SinksCreateRequestConfigCloudflarePipelinesR2DataCatalogTable;
export const SinksCreateRequestConfig = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "accountId",
      "bucket",
      "credentials",
      "fileNaming",
      "jurisdiction",
      "partitioning",
      "path",
      "rollingPolicy",
    ],
    ["token", "accountId", "bucket", "tableName", "namespace", "rollingPolicy"],
  ]),
);

export type SinksCreateRequestFormatJsonType = "json";
export const SinksCreateRequestFormatJsonType = /*@__PURE__*/ S.String;

export type SinksCreateRequestFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksCreateRequestFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksCreateRequestFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksCreateRequestFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksCreateRequestFormatJson {
  type: SinksCreateRequestFormatJsonType;
  decimalEncoding?: SinksCreateRequestFormatJsonDecimalEncoding | (string & {});
  timestampFormat?: SinksCreateRequestFormatJsonTimestampFormat | (string & {});
  unstructured?: boolean;
}
export const SinksCreateRequestFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateRequestFormatJsonType,
    decimalEncoding: S.optional(
      SinksCreateRequestFormatJsonDecimalEncoding.pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      SinksCreateRequestFormatJsonTimestampFormat.pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "SinksCreateRequestFormatJson",
}) as any as S.Schema<SinksCreateRequestFormatJson>;

export type SinksCreateRequestFormatParquetType = "parquet";
export const SinksCreateRequestFormatParquetType = /*@__PURE__*/ S.String;

export type SinksCreateRequestFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksCreateRequestFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksCreateRequestFormatParquet {
  type: SinksCreateRequestFormatParquetType;
  compression?: SinksCreateRequestFormatParquetCompression | (string & {});
  rowGroupBytes?: number;
}
export const SinksCreateRequestFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateRequestFormatParquetType,
    compression: S.optional(SinksCreateRequestFormatParquetCompression),
    rowGroupBytes: S.optional(S.Number.pipe(T.Body("row_group_bytes"))),
  }),
).annotate({
  identifier: "SinksCreateRequestFormatParquet",
}) as any as S.Schema<SinksCreateRequestFormatParquet>;

export type SinksCreateRequestFormat =
  | SinksCreateRequestFormatJson
  | SinksCreateRequestFormatParquet;
export const SinksCreateRequestFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type SinksCreateRequestSchemaFormatJsonType = "json";
export const SinksCreateRequestSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type SinksCreateRequestSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksCreateRequestSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksCreateRequestSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksCreateRequestSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksCreateRequestSchemaFormatJson {
  type: SinksCreateRequestSchemaFormatJsonType;
  decimalEncoding?:
    | SinksCreateRequestSchemaFormatJsonDecimalEncoding
    | (string & {});
  timestampFormat?:
    | SinksCreateRequestSchemaFormatJsonTimestampFormat
    | (string & {});
  unstructured?: boolean;
}
export const SinksCreateRequestSchemaFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateRequestSchemaFormatJsonType,
    decimalEncoding: S.optional(
      SinksCreateRequestSchemaFormatJsonDecimalEncoding.pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      SinksCreateRequestSchemaFormatJsonTimestampFormat.pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "SinksCreateRequestSchemaFormatJson",
}) as any as S.Schema<SinksCreateRequestSchemaFormatJson>;

export type SinksCreateRequestSchemaFormatParquetType = "parquet";
export const SinksCreateRequestSchemaFormatParquetType = /*@__PURE__*/ S.String;

export type SinksCreateRequestSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksCreateRequestSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksCreateRequestSchemaFormatParquet {
  type: SinksCreateRequestSchemaFormatParquetType;
  compression?:
    | SinksCreateRequestSchemaFormatParquetCompression
    | (string & {});
  rowGroupBytes?: number;
}
export const SinksCreateRequestSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: SinksCreateRequestSchemaFormatParquetType,
      compression: S.optional(SinksCreateRequestSchemaFormatParquetCompression),
      rowGroupBytes: S.optional(S.Number.pipe(T.Body("row_group_bytes"))),
    }),
).annotate({
  identifier: "SinksCreateRequestSchemaFormatParquet",
}) as any as S.Schema<SinksCreateRequestSchemaFormatParquet>;

export type SinksCreateRequestSchemaFormat =
  | SinksCreateRequestSchemaFormatJson
  | SinksCreateRequestSchemaFormatParquet;
export const SinksCreateRequestSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface SinksCreateRequestSchema {
  fields?: SinksCreateRequestSchemaFieldsList;
  format?: SinksCreateRequestSchemaFormat;
  inferred?: boolean;
}
export const SinksCreateRequestSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(SinksCreateRequestSchemaFieldsList),
    format: S.optional(SinksCreateRequestSchemaFormat),
    inferred: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "SinksCreateRequestSchema",
}) as any as S.Schema<SinksCreateRequestSchema>;

export interface CreateSinkRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Defines the name of the Sink. */
  name: string;
  /** Specifies the type of sink. */
  type: SinksCreateRequestType | (string & {});
  /** Defines the configuration of the R2 Sink. */
  config?: SinksCreateRequestConfig;
  format?: SinksCreateRequestFormat;
  schema?: SinksCreateRequestSchema;
}
export const CreateSinkRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.String,
    type: SinksCreateRequestType,
    config: S.optional(SinksCreateRequestConfig),
    format: S.optional(SinksCreateRequestFormat),
    schema: S.optional(SinksCreateRequestSchema),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/pipelines/v1/sinks",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSinkRequest",
}) as any as S.Schema<CreateSinkRequest>;

export type SinksCreateResponseType = "r2" | "r2_data_catalog";
export const SinksCreateResponseType = /*@__PURE__*/ S.String;

export type SinksCreateResponseConfigCloudflarePipelinesR2TableCredentials =
  SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials;
export const SinksCreateResponseConfigCloudflarePipelinesR2TableCredentials =
  SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials;

export type SinksCreateResponseConfigCloudflarePipelinesR2TableFileNamingStrategy =
  | "serial"
  | "uuid"
  | "uuid_v7"
  | "ulid";
export const SinksCreateResponseConfigCloudflarePipelinesR2TableFileNamingStrategy =
  /*@__PURE__*/ S.String;

export interface SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming {
  /** The prefix to use in file name. i.e prefix-<uuid>.parquet */
  prefix?: string | null;
  /** Filename generation strategy. */
  strategy?: SinksCreateResponseConfigCloudflarePipelinesR2TableFileNamingStrategy | null;
  /** This will overwrite the default file suffix. i.e .parquet, use with caution */
  suffix?: string | null;
}
export const SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      prefix: S.optional(S.NullOr(S.String)),
      strategy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableFileNamingStrategy,
        ),
      ),
      suffix: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming",
  }) as any as S.Schema<SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming>;

export interface SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning {
  /** The pattern of the date string */
  timePattern?: string | null;
}
export const SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      timePattern: S.optional(S.NullOr(S.String).pipe(T.Body("time_pattern"))),
    }),
  ).annotate({
    identifier:
      "SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning",
  }) as any as S.Schema<SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning>;

export interface SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy {
  /** Files will be rolled after reaching this number of bytes */
  fileSizeBytes?: number | null;
  /** Number of seconds of inactivity to wait before rolling over to a new file */
  inactivitySeconds?: number | null;
  /** Number of seconds to wait before rolling over to a new file */
  intervalSeconds?: number | null;
}
export const SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      fileSizeBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("file_size_bytes")),
      ),
      inactivitySeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("inactivity_seconds")),
      ),
      intervalSeconds: S.optional(
        S.NullOr(S.Number).pipe(T.Body("interval_seconds")),
      ),
    }),
  ).annotate({
    identifier:
      "SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy",
  }) as any as S.Schema<SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy>;

export interface SinksCreateResponseConfigCloudflarePipelinesR2Table {
  /** Cloudflare Account ID for the bucket */
  accountId: string;
  /** R2 Bucket to write to */
  bucket: string;
  credentials: SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials;
  /** Controls filename prefix/suffix and strategy. */
  fileNaming?: SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming | null;
  /** Jurisdiction this bucket is hosted in */
  jurisdiction?: string | null;
  /** Data-layout partitioning for sinks. */
  partitioning?: SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning | null;
  /** Subpath within the bucket to write to */
  path?: string | null;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy | null;
}
export const SinksCreateResponseConfigCloudflarePipelinesR2Table =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      credentials:
        SinksCreateRequestConfigCloudflarePipelinesR2TableCredentials,
      fileNaming: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableFileNaming,
        ).pipe(T.Body("file_naming")),
      ),
      jurisdiction: S.optional(S.NullOr(S.String)),
      partitioning: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning,
        ),
      ),
      path: S.optional(S.NullOr(S.String)),
      rollingPolicy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy,
        ).pipe(T.Body("rolling_policy")),
      ),
    }),
  ).annotate({
    identifier: "SinksCreateResponseConfigCloudflarePipelinesR2Table",
  }) as any as S.Schema<SinksCreateResponseConfigCloudflarePipelinesR2Table>;

export type SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTableRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTableRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;

export interface SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTable {
  /** Authentication token */
  token: string;
  /** Cloudflare Account ID */
  accountId: string;
  /** The R2 Bucket that hosts this catalog */
  bucket: string;
  /** Table name */
  tableName: string;
  /** Table namespace */
  namespace?: string | null;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy | null;
}
export const SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTable =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      token: S.String,
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      tableName: S.String.pipe(T.Body("table_name")),
      namespace: S.optional(S.NullOr(S.String)),
      rollingPolicy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy,
        ).pipe(T.Body("rolling_policy")),
      ),
    }),
  ).annotate({
    identifier:
      "SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTable",
  }) as any as S.Schema<SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTable>;

export type SinksCreateResponseConfig =
  | SinksCreateResponseConfigCloudflarePipelinesR2Table
  | SinksCreateResponseConfigCloudflarePipelinesR2DataCatalogTable;
export const SinksCreateResponseConfig = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "accountId",
      "bucket",
      "credentials",
      "fileNaming",
      "jurisdiction",
      "partitioning",
      "path",
      "rollingPolicy",
    ],
    ["token", "accountId", "bucket", "tableName", "namespace", "rollingPolicy"],
  ]),
);

export type SinksCreateResponseFormatJsonType = "json";
export const SinksCreateResponseFormatJsonType = /*@__PURE__*/ S.String;

export type SinksCreateResponseFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksCreateResponseFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksCreateResponseFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksCreateResponseFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksCreateResponseFormatJson {
  type: SinksCreateResponseFormatJsonType;
  decimalEncoding?: SinksCreateResponseFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksCreateResponseFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksCreateResponseFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateResponseFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksCreateResponseFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksCreateResponseFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksCreateResponseFormatJson",
}) as any as S.Schema<SinksCreateResponseFormatJson>;

export type SinksCreateResponseFormatParquetType = "parquet";
export const SinksCreateResponseFormatParquetType = /*@__PURE__*/ S.String;

export type SinksCreateResponseFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksCreateResponseFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksCreateResponseFormatParquet {
  type: SinksCreateResponseFormatParquetType;
  compression?: SinksCreateResponseFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksCreateResponseFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateResponseFormatParquetType,
    compression: S.optional(
      S.NullOr(SinksCreateResponseFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "SinksCreateResponseFormatParquet",
}) as any as S.Schema<SinksCreateResponseFormatParquet>;

export type SinksCreateResponseFormat =
  | SinksCreateResponseFormatJson
  | SinksCreateResponseFormatParquet;
export const SinksCreateResponseFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type SinksCreateResponseSchemaFormatJsonType = "json";
export const SinksCreateResponseSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type SinksCreateResponseSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksCreateResponseSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksCreateResponseSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksCreateResponseSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksCreateResponseSchemaFormatJson {
  type: SinksCreateResponseSchemaFormatJsonType;
  decimalEncoding?: SinksCreateResponseSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksCreateResponseSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksCreateResponseSchemaFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksCreateResponseSchemaFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksCreateResponseSchemaFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksCreateResponseSchemaFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksCreateResponseSchemaFormatJson",
}) as any as S.Schema<SinksCreateResponseSchemaFormatJson>;

export type SinksCreateResponseSchemaFormatParquetType = "parquet";
export const SinksCreateResponseSchemaFormatParquetType =
  /*@__PURE__*/ S.String;

export type SinksCreateResponseSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksCreateResponseSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksCreateResponseSchemaFormatParquet {
  type: SinksCreateResponseSchemaFormatParquetType;
  compression?: SinksCreateResponseSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksCreateResponseSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: SinksCreateResponseSchemaFormatParquetType,
      compression: S.optional(
        S.NullOr(SinksCreateResponseSchemaFormatParquetCompression),
      ),
      rowGroupBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
      ),
    }),
).annotate({
  identifier: "SinksCreateResponseSchemaFormatParquet",
}) as any as S.Schema<SinksCreateResponseSchemaFormatParquet>;

export type SinksCreateResponseSchemaFormat =
  | SinksCreateResponseSchemaFormatJson
  | SinksCreateResponseSchemaFormatParquet;
export const SinksCreateResponseSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface SinksCreateResponseSchema {
  fields?: SinksCreateResponseSchemaFieldsList | null;
  format?: SinksCreateResponseSchemaFormat | null;
  inferred?: boolean | null;
}
export const SinksCreateResponseSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(SinksCreateResponseSchemaFieldsList)),
    format: S.optional(S.NullOr(SinksCreateResponseSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksCreateResponseSchema",
}) as any as S.Schema<SinksCreateResponseSchema>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSinkResponse {
  /** Indicates a unique identifier for this sink. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Defines the name of the Sink. */
  name: string;
  /** Specifies the type of sink. */
  type: SinksCreateResponseType;
  /** R2 Data Catalog Sink */
  config?: SinksCreateResponseConfig | null;
  format?: SinksCreateResponseFormat | null;
  schema?: SinksCreateResponseSchema | null;
}
export const CreateSinkResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    type: SinksCreateResponseType,
    config: S.optional(S.NullOr(SinksCreateResponseConfig)),
    format: S.optional(S.NullOr(SinksCreateResponseFormat)),
    schema: S.optional(S.NullOr(SinksCreateResponseSchema)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSinkResponse",
}) as any as S.Schema<CreateSinkResponse>;

export type StreamsCreateRequestFormatJsonType = "json";
export const StreamsCreateRequestFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsCreateRequestFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsCreateRequestFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsCreateRequestFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsCreateRequestFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsCreateRequestFormatJson {
  type: StreamsCreateRequestFormatJsonType;
  decimalEncoding?:
    | StreamsCreateRequestFormatJsonDecimalEncoding
    | (string & {});
  timestampFormat?:
    | StreamsCreateRequestFormatJsonTimestampFormat
    | (string & {});
  unstructured?: boolean;
}
export const StreamsCreateRequestFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsCreateRequestFormatJsonType,
    decimalEncoding: S.optional(
      StreamsCreateRequestFormatJsonDecimalEncoding.pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      StreamsCreateRequestFormatJsonTimestampFormat.pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "StreamsCreateRequestFormatJson",
}) as any as S.Schema<StreamsCreateRequestFormatJson>;

export type StreamsCreateRequestFormatParquetType = "parquet";
export const StreamsCreateRequestFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsCreateRequestFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsCreateRequestFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsCreateRequestFormatParquet {
  type: StreamsCreateRequestFormatParquetType;
  compression?: StreamsCreateRequestFormatParquetCompression | (string & {});
  rowGroupBytes?: number;
}
export const StreamsCreateRequestFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsCreateRequestFormatParquetType,
    compression: S.optional(StreamsCreateRequestFormatParquetCompression),
    rowGroupBytes: S.optional(S.Number.pipe(T.Body("row_group_bytes"))),
  }),
).annotate({
  identifier: "StreamsCreateRequestFormatParquet",
}) as any as S.Schema<StreamsCreateRequestFormatParquet>;

export type StreamsCreateRequestFormat =
  | StreamsCreateRequestFormatJson
  | StreamsCreateRequestFormatParquet;
export const StreamsCreateRequestFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

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

export interface StreamsCreateRequestHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsCreateRequestHttpCors;
}
export const StreamsCreateRequestHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(StreamsCreateRequestHttpCors),
  }),
).annotate({
  identifier: "StreamsCreateRequestHttp",
}) as any as S.Schema<StreamsCreateRequestHttp>;

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

export type StreamsCreateRequestSchemaFormatJsonType = "json";
export const StreamsCreateRequestSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsCreateRequestSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsCreateRequestSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsCreateRequestSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsCreateRequestSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsCreateRequestSchemaFormatJson {
  type: StreamsCreateRequestSchemaFormatJsonType;
  decimalEncoding?:
    | StreamsCreateRequestSchemaFormatJsonDecimalEncoding
    | (string & {});
  timestampFormat?:
    | StreamsCreateRequestSchemaFormatJsonTimestampFormat
    | (string & {});
  unstructured?: boolean;
}
export const StreamsCreateRequestSchemaFormatJson = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsCreateRequestSchemaFormatJsonType,
      decimalEncoding: S.optional(
        StreamsCreateRequestSchemaFormatJsonDecimalEncoding.pipe(
          T.Body("decimal_encoding"),
        ),
      ),
      timestampFormat: S.optional(
        StreamsCreateRequestSchemaFormatJsonTimestampFormat.pipe(
          T.Body("timestamp_format"),
        ),
      ),
      unstructured: S.optional(S.Boolean),
    }),
).annotate({
  identifier: "StreamsCreateRequestSchemaFormatJson",
}) as any as S.Schema<StreamsCreateRequestSchemaFormatJson>;

export type StreamsCreateRequestSchemaFormatParquetType = "parquet";
export const StreamsCreateRequestSchemaFormatParquetType =
  /*@__PURE__*/ S.String;

export type StreamsCreateRequestSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsCreateRequestSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsCreateRequestSchemaFormatParquet {
  type: StreamsCreateRequestSchemaFormatParquetType;
  compression?:
    | StreamsCreateRequestSchemaFormatParquetCompression
    | (string & {});
  rowGroupBytes?: number;
}
export const StreamsCreateRequestSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsCreateRequestSchemaFormatParquetType,
      compression: S.optional(
        StreamsCreateRequestSchemaFormatParquetCompression,
      ),
      rowGroupBytes: S.optional(S.Number.pipe(T.Body("row_group_bytes"))),
    }),
).annotate({
  identifier: "StreamsCreateRequestSchemaFormatParquet",
}) as any as S.Schema<StreamsCreateRequestSchemaFormatParquet>;

export type StreamsCreateRequestSchemaFormat =
  | StreamsCreateRequestSchemaFormatJson
  | StreamsCreateRequestSchemaFormatParquet;
export const StreamsCreateRequestSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface StreamsCreateRequestSchema {
  fields?: StreamsCreateRequestSchemaFieldsList;
  format?: StreamsCreateRequestSchemaFormat;
  inferred?: boolean;
}
export const StreamsCreateRequestSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(StreamsCreateRequestSchemaFieldsList),
    format: S.optional(StreamsCreateRequestSchemaFormat),
    inferred: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "StreamsCreateRequestSchema",
}) as any as S.Schema<StreamsCreateRequestSchema>;

export interface StreamsCreateRequestWorkerBinding {
  /** Indicates that the worker binding is enabled. */
  enabled: boolean;
}
export const StreamsCreateRequestWorkerBinding = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.Boolean,
  }),
).annotate({
  identifier: "StreamsCreateRequestWorkerBinding",
}) as any as S.Schema<StreamsCreateRequestWorkerBinding>;

export interface CreateStreamRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the name of the Stream. */
  name: string;
  format?: StreamsCreateRequestFormat;
  http?: StreamsCreateRequestHttp;
  schema?: StreamsCreateRequestSchema;
  workerBinding?: StreamsCreateRequestWorkerBinding;
}
export const CreateStreamRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.String,
    format: S.optional(StreamsCreateRequestFormat),
    http: S.optional(StreamsCreateRequestHttp),
    schema: S.optional(StreamsCreateRequestSchema),
    workerBinding: S.optional(
      StreamsCreateRequestWorkerBinding.pipe(T.Body("worker_binding")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/pipelines/v1/streams",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateStreamRequest",
}) as any as S.Schema<CreateStreamRequest>;

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

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

export interface StreamsCreateResponseHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsCreateResponseHttpCors | null;
}
export const StreamsCreateResponseHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(S.NullOr(StreamsCreateResponseHttpCors)),
  }),
).annotate({
  identifier: "StreamsCreateResponseHttp",
}) as any as S.Schema<StreamsCreateResponseHttp>;

export type StreamsCreateResponseWorkerBinding =
  StreamsCreateRequestWorkerBinding;
export const StreamsCreateResponseWorkerBinding =
  StreamsCreateRequestWorkerBinding;

export type StreamsCreateResponseFormatJsonType = "json";
export const StreamsCreateResponseFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsCreateResponseFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsCreateResponseFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsCreateResponseFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsCreateResponseFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsCreateResponseFormatJson {
  type: StreamsCreateResponseFormatJsonType;
  decimalEncoding?: StreamsCreateResponseFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsCreateResponseFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsCreateResponseFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsCreateResponseFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(StreamsCreateResponseFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(StreamsCreateResponseFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsCreateResponseFormatJson",
}) as any as S.Schema<StreamsCreateResponseFormatJson>;

export type StreamsCreateResponseFormatParquetType = "parquet";
export const StreamsCreateResponseFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsCreateResponseFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsCreateResponseFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsCreateResponseFormatParquet {
  type: StreamsCreateResponseFormatParquetType;
  compression?: StreamsCreateResponseFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsCreateResponseFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsCreateResponseFormatParquetType,
    compression: S.optional(
      S.NullOr(StreamsCreateResponseFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "StreamsCreateResponseFormatParquet",
}) as any as S.Schema<StreamsCreateResponseFormatParquet>;

export type StreamsCreateResponseFormat =
  | StreamsCreateResponseFormatJson
  | StreamsCreateResponseFormatParquet;
export const StreamsCreateResponseFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type StreamsCreateResponseSchemaFormatJsonType = "json";
export const StreamsCreateResponseSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsCreateResponseSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsCreateResponseSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsCreateResponseSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsCreateResponseSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsCreateResponseSchemaFormatJson {
  type: StreamsCreateResponseSchemaFormatJsonType;
  decimalEncoding?: StreamsCreateResponseSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsCreateResponseSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsCreateResponseSchemaFormatJson = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsCreateResponseSchemaFormatJsonType,
      decimalEncoding: S.optional(
        S.NullOr(StreamsCreateResponseSchemaFormatJsonDecimalEncoding).pipe(
          T.Body("decimal_encoding"),
        ),
      ),
      timestampFormat: S.optional(
        S.NullOr(StreamsCreateResponseSchemaFormatJsonTimestampFormat).pipe(
          T.Body("timestamp_format"),
        ),
      ),
      unstructured: S.optional(S.NullOr(S.Boolean)),
    }),
).annotate({
  identifier: "StreamsCreateResponseSchemaFormatJson",
}) as any as S.Schema<StreamsCreateResponseSchemaFormatJson>;

export type StreamsCreateResponseSchemaFormatParquetType = "parquet";
export const StreamsCreateResponseSchemaFormatParquetType =
  /*@__PURE__*/ S.String;

export type StreamsCreateResponseSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsCreateResponseSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsCreateResponseSchemaFormatParquet {
  type: StreamsCreateResponseSchemaFormatParquetType;
  compression?: StreamsCreateResponseSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsCreateResponseSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsCreateResponseSchemaFormatParquetType,
      compression: S.optional(
        S.NullOr(StreamsCreateResponseSchemaFormatParquetCompression),
      ),
      rowGroupBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
      ),
    }),
).annotate({
  identifier: "StreamsCreateResponseSchemaFormatParquet",
}) as any as S.Schema<StreamsCreateResponseSchemaFormatParquet>;

export type StreamsCreateResponseSchemaFormat =
  | StreamsCreateResponseSchemaFormatJson
  | StreamsCreateResponseSchemaFormatParquet;
export const StreamsCreateResponseSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface StreamsCreateResponseSchema {
  fields?: StreamsCreateResponseSchemaFieldsList | null;
  format?: StreamsCreateResponseSchemaFormat | null;
  inferred?: boolean | null;
}
export const StreamsCreateResponseSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(StreamsCreateResponseSchemaFieldsList)),
    format: S.optional(S.NullOr(StreamsCreateResponseSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsCreateResponseSchema",
}) as any as S.Schema<StreamsCreateResponseSchema>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateStreamResponse {
  /** Indicates a unique identifier for this stream. */
  id: string;
  createdAt: string;
  http: StreamsCreateResponseHttp;
  modifiedAt: string;
  /** Indicates the name of the Stream. */
  name: string;
  /** Indicates the current version of this stream. */
  version: number;
  workerBinding: StreamsCreateRequestWorkerBinding;
  /** Indicates the endpoint URL of this stream. */
  endpoint?: string | null;
  format?: StreamsCreateResponseFormat | null;
  schema?: StreamsCreateResponseSchema | null;
}
export const CreateStreamResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    http: StreamsCreateResponseHttp,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: S.Number,
    workerBinding: StreamsCreateRequestWorkerBinding.pipe(
      T.Body("worker_binding"),
    ),
    endpoint: S.optional(S.NullOr(S.String)),
    format: S.optional(S.NullOr(StreamsCreateResponseFormat)),
    schema: S.optional(S.NullOr(StreamsCreateResponseSchema)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateStreamResponse",
}) as any as S.Schema<CreateStreamResponse>;

export interface CreateV1PipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the name of the Pipeline. */
  name: string;
  /** Specifies SQL for the Pipeline processing flow. */
  sql: string;
}
export const CreateV1PipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.String,
    sql: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/pipelines/v1/pipelines",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateV1PipelineRequest",
}) as any as S.Schema<CreateV1PipelineRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateV1PipelineResponse {
  /** Indicates a unique identifier for this pipeline. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Indicates the name of the Pipeline. */
  name: string;
  /** Specifies SQL for the Pipeline processing flow. */
  sql: string;
  /** Indicates the current status of the Pipeline. */
  status: string;
}
export const CreateV1PipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    sql: S.String,
    status: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateV1PipelineResponse",
}) as any as S.Schema<CreateV1PipelineResponse>;

export interface DeletePipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Defines the name of the pipeline. */
  pipelineName: string;
}
export const DeletePipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pipelineName: S.String.pipe(T.Label("pipeline_name")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/pipelines/{pipeline_name}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeletePipelineRequest",
}) as any as S.Schema<DeletePipelineRequest>;

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

export interface DeleteSinkRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the publid ID of the sink. */
  sinkId: string;
  /** Deprecated: Delete sink forcefully, including deleting any dependent pipelines. */
  force?: string;
}
export const DeleteSinkRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sinkId: S.String.pipe(T.Label("sink_id")),
    force: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/pipelines/v1/sinks/{sink_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSinkRequest",
}) as any as S.Schema<DeleteSinkRequest>;

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

export interface DeleteStreamRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the public ID of the stream. */
  streamId: string;
  /** Deprecated: Delete stream forcefully, including deleting any dependent pipelines. */
  force?: string;
}
export const DeleteStreamRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    streamId: S.String.pipe(T.Label("stream_id")),
    force: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/pipelines/v1/streams/{stream_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteStreamRequest",
}) as any as S.Schema<DeleteStreamRequest>;

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

export interface DeleteV1PipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the public ID of the pipeline. */
  pipelineId: string;
}
export const DeleteV1PipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pipelineId: S.String.pipe(T.Label("pipeline_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/pipelines/v1/pipelines/{pipeline_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteV1PipelineRequest",
}) as any as S.Schema<DeleteV1PipelineRequest>;

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

export interface GetPipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Defines the name of the pipeline. */
  pipelineName: string;
}
export const GetPipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pipelineName: S.String.pipe(T.Label("pipeline_name")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/{pipeline_name}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPipelineRequest",
}) as any as S.Schema<GetPipelineRequest>;

export type GetResponseDestinationBatch = CreateResponseDestinationBatch;
export const GetResponseDestinationBatch = CreateResponseDestinationBatch;

export type GetResponseDestinationCompressionType = "none" | "gzip" | "deflate";
export const GetResponseDestinationCompressionType = /*@__PURE__*/ S.String;

export interface GetResponseDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type: GetResponseDestinationCompressionType;
}
export const GetResponseDestinationCompression = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: GetResponseDestinationCompressionType,
  }),
).annotate({
  identifier: "GetResponseDestinationCompression",
}) as any as S.Schema<GetResponseDestinationCompression>;

export type GetResponseDestinationFormat = "json";
export const GetResponseDestinationFormat = /*@__PURE__*/ S.String;

export type GetResponseDestinationPath = CreateResponseDestinationPath;
export const GetResponseDestinationPath = CreateResponseDestinationPath;

export type GetResponseDestinationType = "r2";
export const GetResponseDestinationType = /*@__PURE__*/ S.String;

export interface GetResponseDestination {
  batch: CreateResponseDestinationBatch;
  compression: GetResponseDestinationCompression;
  /** Specifies the format of data to deliver. */
  format: GetResponseDestinationFormat;
  path: CreateResponseDestinationPath;
  /** Specifies the type of destination. */
  type: GetResponseDestinationType;
}
export const GetResponseDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateResponseDestinationBatch,
    compression: GetResponseDestinationCompression,
    format: GetResponseDestinationFormat,
    path: CreateResponseDestinationPath,
    type: GetResponseDestinationType,
  }),
).annotate({
  identifier: "GetResponseDestination",
}) as any as S.Schema<GetResponseDestination>;

export type GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList | null;
}
export const GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        S.NullOr(
          GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean | null;
  cors?: GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors | null;
}
export const GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.NullOr(S.Boolean)),
      cors: S.optional(
        S.NullOr(
          GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type GetResponseSourceItem =
  | GetResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | GetResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const GetResponseSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetPipelineResponse {
  /** Specifies the pipeline identifier. */
  id: string;
  destination: GetResponseDestination;
  /** Indicates the endpoint URL to send traffic. */
  endpoint: string;
  /** Defines the name of the pipeline. */
  name: string;
  source: GetResponseSourceList;
  /** Indicates the version number of last saved configuration. */
  version: number;
}
export const GetPipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    destination: GetResponseDestination,
    endpoint: S.String,
    name: S.String,
    source: GetResponseSourceList,
    version: S.Number,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPipelineResponse",
}) as any as S.Schema<GetPipelineResponse>;

export interface GetSinkRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the publid ID of the sink. */
  sinkId: string;
}
export const GetSinkRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sinkId: S.String.pipe(T.Label("sink_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/sinks/{sink_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetSinkRequest" }) as any as S.Schema<GetSinkRequest>;

export type SinksGetResponseType = "r2" | "r2_data_catalog";
export const SinksGetResponseType = /*@__PURE__*/ S.String;

export type SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNamingStrategy =
  | "serial"
  | "uuid"
  | "uuid_v7"
  | "ulid";
export const SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNamingStrategy =
  /*@__PURE__*/ S.String;

export interface SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming {
  /** The prefix to use in file name. i.e prefix-<uuid>.parquet */
  prefix?: string | null;
  /** Filename generation strategy. */
  strategy?: SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNamingStrategy | null;
  /** This will overwrite the default file suffix. i.e .parquet, use with caution */
  suffix?: string | null;
}
export const SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      prefix: S.optional(S.NullOr(S.String)),
      strategy: S.optional(
        S.NullOr(
          SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNamingStrategy,
        ),
      ),
      suffix: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming",
  }) as any as S.Schema<SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming>;

export type SinksGetResponseConfigCloudflarePipelinesR2TablePublicPartitioning =
  SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning;
export const SinksGetResponseConfigCloudflarePipelinesR2TablePublicPartitioning =
  SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning;

export type SinksGetResponseConfigCloudflarePipelinesR2TablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksGetResponseConfigCloudflarePipelinesR2TablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;

export interface SinksGetResponseConfigCloudflarePipelinesR2TablePublic {
  /** Cloudflare Account ID for the bucket */
  accountId: string;
  /** R2 Bucket to write to */
  bucket: string;
  /** Controls filename prefix/suffix and strategy. */
  fileNaming?: SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming | null;
  /** Jurisdiction this bucket is hosted in */
  jurisdiction?: string | null;
  /** Data-layout partitioning for sinks. */
  partitioning?: SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning | null;
  /** Subpath within the bucket to write to */
  path?: string | null;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy | null;
}
export const SinksGetResponseConfigCloudflarePipelinesR2TablePublic =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      fileNaming: S.optional(
        S.NullOr(
          SinksGetResponseConfigCloudflarePipelinesR2TablePublicFileNaming,
        ).pipe(T.Body("file_naming")),
      ),
      jurisdiction: S.optional(S.NullOr(S.String)),
      partitioning: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning,
        ),
      ),
      path: S.optional(S.NullOr(S.String)),
      rollingPolicy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy,
        ).pipe(T.Body("rolling_policy")),
      ),
    }),
  ).annotate({
    identifier: "SinksGetResponseConfigCloudflarePipelinesR2TablePublic",
  }) as any as S.Schema<SinksGetResponseConfigCloudflarePipelinesR2TablePublic>;

export type SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;

export interface SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic {
  /** Cloudflare Account ID */
  accountId: string;
  /** The R2 Bucket that hosts this catalog */
  bucket: string;
  /** Table name */
  tableName: string;
  /** Table namespace */
  namespace?: string | null;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy | null;
}
export const SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      tableName: S.String.pipe(T.Body("table_name")),
      namespace: S.optional(S.NullOr(S.String)),
      rollingPolicy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy,
        ).pipe(T.Body("rolling_policy")),
      ),
    }),
  ).annotate({
    identifier:
      "SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic",
  }) as any as S.Schema<SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic>;

export type SinksGetResponseConfig =
  | SinksGetResponseConfigCloudflarePipelinesR2TablePublic
  | SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic;
export const SinksGetResponseConfig = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "accountId",
      "bucket",
      "fileNaming",
      "jurisdiction",
      "partitioning",
      "path",
      "rollingPolicy",
    ],
    ["accountId", "bucket", "tableName", "namespace", "rollingPolicy"],
  ]),
);

export type SinksGetResponseFormatJsonType = "json";
export const SinksGetResponseFormatJsonType = /*@__PURE__*/ S.String;

export type SinksGetResponseFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksGetResponseFormatJsonDecimalEncoding = /*@__PURE__*/ S.String;

export type SinksGetResponseFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksGetResponseFormatJsonTimestampFormat = /*@__PURE__*/ S.String;

export interface SinksGetResponseFormatJson {
  type: SinksGetResponseFormatJsonType;
  decimalEncoding?: SinksGetResponseFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksGetResponseFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksGetResponseFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksGetResponseFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksGetResponseFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksGetResponseFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksGetResponseFormatJson",
}) as any as S.Schema<SinksGetResponseFormatJson>;

export type SinksGetResponseFormatParquetType = "parquet";
export const SinksGetResponseFormatParquetType = /*@__PURE__*/ S.String;

export type SinksGetResponseFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksGetResponseFormatParquetCompression = /*@__PURE__*/ S.String;

export interface SinksGetResponseFormatParquet {
  type: SinksGetResponseFormatParquetType;
  compression?: SinksGetResponseFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksGetResponseFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksGetResponseFormatParquetType,
    compression: S.optional(S.NullOr(SinksGetResponseFormatParquetCompression)),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "SinksGetResponseFormatParquet",
}) as any as S.Schema<SinksGetResponseFormatParquet>;

export type SinksGetResponseFormat =
  | SinksGetResponseFormatJson
  | SinksGetResponseFormatParquet;
export const SinksGetResponseFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type SinksGetResponseSchemaFormatJsonType = "json";
export const SinksGetResponseSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type SinksGetResponseSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksGetResponseSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksGetResponseSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksGetResponseSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksGetResponseSchemaFormatJson {
  type: SinksGetResponseSchemaFormatJsonType;
  decimalEncoding?: SinksGetResponseSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksGetResponseSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksGetResponseSchemaFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksGetResponseSchemaFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksGetResponseSchemaFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksGetResponseSchemaFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksGetResponseSchemaFormatJson",
}) as any as S.Schema<SinksGetResponseSchemaFormatJson>;

export type SinksGetResponseSchemaFormatParquetType = "parquet";
export const SinksGetResponseSchemaFormatParquetType = /*@__PURE__*/ S.String;

export type SinksGetResponseSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksGetResponseSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksGetResponseSchemaFormatParquet {
  type: SinksGetResponseSchemaFormatParquetType;
  compression?: SinksGetResponseSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksGetResponseSchemaFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksGetResponseSchemaFormatParquetType,
    compression: S.optional(
      S.NullOr(SinksGetResponseSchemaFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "SinksGetResponseSchemaFormatParquet",
}) as any as S.Schema<SinksGetResponseSchemaFormatParquet>;

export type SinksGetResponseSchemaFormat =
  | SinksGetResponseSchemaFormatJson
  | SinksGetResponseSchemaFormatParquet;
export const SinksGetResponseSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface SinksGetResponseSchema {
  fields?: SinksGetResponseSchemaFieldsList | null;
  format?: SinksGetResponseSchemaFormat | null;
  inferred?: boolean | null;
}
export const SinksGetResponseSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(SinksGetResponseSchemaFieldsList)),
    format: S.optional(S.NullOr(SinksGetResponseSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksGetResponseSchema",
}) as any as S.Schema<SinksGetResponseSchema>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSinkResponse {
  /** Indicates a unique identifier for this sink. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Defines the name of the Sink. */
  name: string;
  /** Specifies the type of sink. */
  type: SinksGetResponseType;
  /** Defines the configuration of the R2 Sink. */
  config?: SinksGetResponseConfig | null;
  format?: SinksGetResponseFormat | null;
  schema?: SinksGetResponseSchema | null;
}
export const GetSinkResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    type: SinksGetResponseType,
    config: S.optional(S.NullOr(SinksGetResponseConfig)),
    format: S.optional(S.NullOr(SinksGetResponseFormat)),
    schema: S.optional(S.NullOr(SinksGetResponseSchema)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSinkResponse",
}) as any as S.Schema<GetSinkResponse>;

export interface GetStreamRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the public ID of the stream. */
  streamId: string;
}
export const GetStreamRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    streamId: S.String.pipe(T.Label("stream_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/streams/{stream_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetStreamRequest",
}) as any as S.Schema<GetStreamRequest>;

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

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

export interface StreamsGetResponseHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsGetResponseHttpCors | null;
}
export const StreamsGetResponseHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(S.NullOr(StreamsGetResponseHttpCors)),
  }),
).annotate({
  identifier: "StreamsGetResponseHttp",
}) as any as S.Schema<StreamsGetResponseHttp>;

export type StreamsGetResponseWorkerBinding = StreamsCreateRequestWorkerBinding;
export const StreamsGetResponseWorkerBinding =
  StreamsCreateRequestWorkerBinding;

export type StreamsGetResponseFormatJsonType = "json";
export const StreamsGetResponseFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsGetResponseFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsGetResponseFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsGetResponseFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsGetResponseFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsGetResponseFormatJson {
  type: StreamsGetResponseFormatJsonType;
  decimalEncoding?: StreamsGetResponseFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsGetResponseFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsGetResponseFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsGetResponseFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(StreamsGetResponseFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(StreamsGetResponseFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsGetResponseFormatJson",
}) as any as S.Schema<StreamsGetResponseFormatJson>;

export type StreamsGetResponseFormatParquetType = "parquet";
export const StreamsGetResponseFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsGetResponseFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsGetResponseFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsGetResponseFormatParquet {
  type: StreamsGetResponseFormatParquetType;
  compression?: StreamsGetResponseFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsGetResponseFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsGetResponseFormatParquetType,
    compression: S.optional(
      S.NullOr(StreamsGetResponseFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "StreamsGetResponseFormatParquet",
}) as any as S.Schema<StreamsGetResponseFormatParquet>;

export type StreamsGetResponseFormat =
  | StreamsGetResponseFormatJson
  | StreamsGetResponseFormatParquet;
export const StreamsGetResponseFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type StreamsGetResponseSchemaFormatJsonType = "json";
export const StreamsGetResponseSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsGetResponseSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsGetResponseSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsGetResponseSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsGetResponseSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsGetResponseSchemaFormatJson {
  type: StreamsGetResponseSchemaFormatJsonType;
  decimalEncoding?: StreamsGetResponseSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsGetResponseSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsGetResponseSchemaFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsGetResponseSchemaFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(StreamsGetResponseSchemaFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(StreamsGetResponseSchemaFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsGetResponseSchemaFormatJson",
}) as any as S.Schema<StreamsGetResponseSchemaFormatJson>;

export type StreamsGetResponseSchemaFormatParquetType = "parquet";
export const StreamsGetResponseSchemaFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsGetResponseSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsGetResponseSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsGetResponseSchemaFormatParquet {
  type: StreamsGetResponseSchemaFormatParquetType;
  compression?: StreamsGetResponseSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsGetResponseSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsGetResponseSchemaFormatParquetType,
      compression: S.optional(
        S.NullOr(StreamsGetResponseSchemaFormatParquetCompression),
      ),
      rowGroupBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
      ),
    }),
).annotate({
  identifier: "StreamsGetResponseSchemaFormatParquet",
}) as any as S.Schema<StreamsGetResponseSchemaFormatParquet>;

export type StreamsGetResponseSchemaFormat =
  | StreamsGetResponseSchemaFormatJson
  | StreamsGetResponseSchemaFormatParquet;
export const StreamsGetResponseSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface StreamsGetResponseSchema {
  fields?: StreamsGetResponseSchemaFieldsList | null;
  format?: StreamsGetResponseSchemaFormat | null;
  inferred?: boolean | null;
}
export const StreamsGetResponseSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(StreamsGetResponseSchemaFieldsList)),
    format: S.optional(S.NullOr(StreamsGetResponseSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsGetResponseSchema",
}) as any as S.Schema<StreamsGetResponseSchema>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetStreamResponse {
  /** Indicates a unique identifier for this stream. */
  id: string;
  createdAt: string;
  http: StreamsGetResponseHttp;
  modifiedAt: string;
  /** Indicates the name of the Stream. */
  name: string;
  /** Indicates the current version of this stream. */
  version: number;
  workerBinding: StreamsCreateRequestWorkerBinding;
  /** Indicates the endpoint URL of this stream. */
  endpoint?: string | null;
  format?: StreamsGetResponseFormat | null;
  schema?: StreamsGetResponseSchema | null;
}
export const GetStreamResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    http: StreamsGetResponseHttp,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: S.Number,
    workerBinding: StreamsCreateRequestWorkerBinding.pipe(
      T.Body("worker_binding"),
    ),
    endpoint: S.optional(S.NullOr(S.String)),
    format: S.optional(S.NullOr(StreamsGetResponseFormat)),
    schema: S.optional(S.NullOr(StreamsGetResponseSchema)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetStreamResponse",
}) as any as S.Schema<GetStreamResponse>;

export interface GetV1PipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the public ID of the pipeline. */
  pipelineId: string;
}
export const GetV1PipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pipelineId: S.String.pipe(T.Label("pipeline_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/pipelines/{pipeline_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetV1PipelineRequest",
}) as any as S.Schema<GetV1PipelineRequest>;

export type GetV1ResponseTablesItemType = "stream" | "sink";
export const GetV1ResponseTablesItemType = /*@__PURE__*/ S.String;

export interface GetV1ResponseTablesItem {
  /** Unique identifier for the connection (stream or sink). */
  id: string;
  /** Latest available version of the connection. */
  latest: number;
  /** Name of the connection. */
  name: string;
  /** Type of the connection. */
  type: GetV1ResponseTablesItemType;
  /** Current version of the connection used by this pipeline. */
  version: number;
}
export const GetV1ResponseTablesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    latest: S.Number,
    name: S.String,
    type: GetV1ResponseTablesItemType,
    version: S.Number,
  }),
).annotate({
  identifier: "GetV1ResponseTablesItem",
}) as any as S.Schema<GetV1ResponseTablesItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetV1PipelineResponse {
  /** Indicates a unique identifier for this pipeline. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Indicates the name of the Pipeline. */
  name: string;
  /** Specifies SQL for the Pipeline processing flow. */
  sql: string;
  /** Indicates the current status of the Pipeline. */
  status: string;
  /** List of streams and sinks used by this pipeline. */
  tables: GetV1ResponseTablesList;
  /** Indicates the reason for the failure of the Pipeline. */
  failureReason?: string | null;
}
export const GetV1PipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    sql: S.String,
    status: S.String,
    tables: GetV1ResponseTablesList,
    failureReason: S.optional(
      S.NullOr(S.String).pipe(T.Body("failure_reason")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetV1PipelineResponse",
}) as any as S.Schema<GetV1PipelineResponse>;

export interface ListPipelinesRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies which page to retrieve. */
  page?: string;
  /** Specifies the number of pipelines per page. */
  perPage?: string;
  /** Specifies the prefix of pipeline name to search. */
  search?: string;
}
export const ListPipelinesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    page: S.optional(S.String.pipe(T.Query())),
    perPage: S.optional(S.String.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPipelinesRequest",
}) as any as S.Schema<ListPipelinesRequest>;

export type ListResponseResultsItemDestinationBatch =
  CreateResponseDestinationBatch;
export const ListResponseResultsItemDestinationBatch =
  CreateResponseDestinationBatch;

export type ListResponseResultsItemDestinationCompressionType =
  | "none"
  | "gzip"
  | "deflate";
export const ListResponseResultsItemDestinationCompressionType =
  /*@__PURE__*/ S.String;

export interface ListResponseResultsItemDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type: ListResponseResultsItemDestinationCompressionType;
}
export const ListResponseResultsItemDestinationCompression =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: ListResponseResultsItemDestinationCompressionType,
    }),
  ).annotate({
    identifier: "ListResponseResultsItemDestinationCompression",
  }) as any as S.Schema<ListResponseResultsItemDestinationCompression>;

export type ListResponseResultsItemDestinationFormat = "json";
export const ListResponseResultsItemDestinationFormat = /*@__PURE__*/ S.String;

export type ListResponseResultsItemDestinationPath =
  CreateResponseDestinationPath;
export const ListResponseResultsItemDestinationPath =
  CreateResponseDestinationPath;

export type ListResponseResultsItemDestinationType = "r2";
export const ListResponseResultsItemDestinationType = /*@__PURE__*/ S.String;

export interface ListResponseResultsItemDestination {
  batch: CreateResponseDestinationBatch;
  compression: ListResponseResultsItemDestinationCompression;
  /** Specifies the format of data to deliver. */
  format: ListResponseResultsItemDestinationFormat;
  path: CreateResponseDestinationPath;
  /** Specifies the type of destination. */
  type: ListResponseResultsItemDestinationType;
}
export const ListResponseResultsItemDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateResponseDestinationBatch,
    compression: ListResponseResultsItemDestinationCompression,
    format: ListResponseResultsItemDestinationFormat,
    path: CreateResponseDestinationPath,
    type: ListResponseResultsItemDestinationType,
  }),
).annotate({
  identifier: "ListResponseResultsItemDestination",
}) as any as S.Schema<ListResponseResultsItemDestination>;

export type ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList | null;
}
export const ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        S.NullOr(
          ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean | null;
  cors?: ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors | null;
}
export const ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.NullOr(S.Boolean)),
      cors: S.optional(
        S.NullOr(
          ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type ListResponseResultsItemSourceItem =
  | ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | ListResponseResultsItemSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const ListResponseResultsItemSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

export interface ListResponseResultsItem {
  /** Specifies the pipeline identifier. */
  id: string;
  destination: ListResponseResultsItemDestination;
  /** Indicates the endpoint URL to send traffic. */
  endpoint: string;
  /** Defines the name of the pipeline. */
  name: string;
  source: ListResponseResultsItemSourceList;
  /** Indicates the version number of last saved configuration. */
  version: number;
}
export const ListResponseResultsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    destination: ListResponseResultsItemDestination,
    endpoint: S.String,
    name: S.String,
    source: ListResponseResultsItemSourceList,
    version: S.Number,
  }),
).annotate({
  identifier: "ListResponseResultsItem",
}) as any as S.Schema<ListResponseResultsItem>;

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListPipelinesResponse {
  results: ListResponseResultsList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListPipelinesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    results: ListResponseResultsList,
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPipelinesResponse",
}) as any as S.Schema<ListPipelinesResponse>;

export interface ListSinksRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Filters sinks by name (case-insensitive substring). */
  name?: string;
  page?: number;
  perPage?: number;
  pipelineId?: string;
}
export const ListSinksRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    pipelineId: S.optional(S.String.pipe(T.Query("pipeline_id"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/sinks",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSinksRequest",
}) as any as S.Schema<ListSinksRequest>;

export type SinksListResultItemType = "r2" | "r2_data_catalog";
export const SinksListResultItemType = /*@__PURE__*/ S.String;

export type SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNamingStrategy =
  | "serial"
  | "uuid"
  | "uuid_v7"
  | "ulid";
export const SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNamingStrategy =
  /*@__PURE__*/ S.String;

export interface SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming {
  /** The prefix to use in file name. i.e prefix-<uuid>.parquet */
  prefix?: string | null;
  /** Filename generation strategy. */
  strategy?: SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNamingStrategy | null;
  /** This will overwrite the default file suffix. i.e .parquet, use with caution */
  suffix?: string | null;
}
export const SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      prefix: S.optional(S.NullOr(S.String)),
      strategy: S.optional(
        S.NullOr(
          SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNamingStrategy,
        ),
      ),
      suffix: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming",
  }) as any as S.Schema<SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming>;

export type SinksListResultItemConfigCloudflarePipelinesR2TablePublicPartitioning =
  SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning;
export const SinksListResultItemConfigCloudflarePipelinesR2TablePublicPartitioning =
  SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning;

export type SinksListResultItemConfigCloudflarePipelinesR2TablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksListResultItemConfigCloudflarePipelinesR2TablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;

export interface SinksListResultItemConfigCloudflarePipelinesR2TablePublic {
  /** Cloudflare Account ID for the bucket */
  accountId: string;
  /** R2 Bucket to write to */
  bucket: string;
  /** Controls filename prefix/suffix and strategy. */
  fileNaming?: SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming | null;
  /** Jurisdiction this bucket is hosted in */
  jurisdiction?: string | null;
  /** Data-layout partitioning for sinks. */
  partitioning?: SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning | null;
  /** Subpath within the bucket to write to */
  path?: string | null;
  /** Rolling policy for file sinks (when & why to close a file and open a new one). */
  rollingPolicy?: SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy | null;
}
export const SinksListResultItemConfigCloudflarePipelinesR2TablePublic =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      accountId: S.String.pipe(T.Body("account_id")),
      bucket: S.String,
      fileNaming: S.optional(
        S.NullOr(
          SinksListResultItemConfigCloudflarePipelinesR2TablePublicFileNaming,
        ).pipe(T.Body("file_naming")),
      ),
      jurisdiction: S.optional(S.NullOr(S.String)),
      partitioning: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TablePartitioning,
        ),
      ),
      path: S.optional(S.NullOr(S.String)),
      rollingPolicy: S.optional(
        S.NullOr(
          SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy,
        ).pipe(T.Body("rolling_policy")),
      ),
    }),
  ).annotate({
    identifier: "SinksListResultItemConfigCloudflarePipelinesR2TablePublic",
  }) as any as S.Schema<SinksListResultItemConfigCloudflarePipelinesR2TablePublic>;

export type SinksListResultItemConfigCloudflarePipelinesR2DataCatalogTablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;
export const SinksListResultItemConfigCloudflarePipelinesR2DataCatalogTablePublicRollingPolicy =
  SinksCreateResponseConfigCloudflarePipelinesR2TableRollingPolicy;

export type SinksListResultItemConfigCloudflarePipelinesR2DataCatalogTablePublic =
  SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic;
export const SinksListResultItemConfigCloudflarePipelinesR2DataCatalogTablePublic =
  SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic;

export type SinksListResultItemConfig =
  | SinksListResultItemConfigCloudflarePipelinesR2TablePublic
  | SinksGetResponseConfigCloudflarePipelinesR2DataCatalogTablePublic;
export const SinksListResultItemConfig = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "accountId",
      "bucket",
      "fileNaming",
      "jurisdiction",
      "partitioning",
      "path",
      "rollingPolicy",
    ],
    ["accountId", "bucket", "tableName", "namespace", "rollingPolicy"],
  ]),
);

export type SinksListResultItemFormatJsonType = "json";
export const SinksListResultItemFormatJsonType = /*@__PURE__*/ S.String;

export type SinksListResultItemFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksListResultItemFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksListResultItemFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksListResultItemFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksListResultItemFormatJson {
  type: SinksListResultItemFormatJsonType;
  decimalEncoding?: SinksListResultItemFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksListResultItemFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksListResultItemFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksListResultItemFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksListResultItemFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksListResultItemFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksListResultItemFormatJson",
}) as any as S.Schema<SinksListResultItemFormatJson>;

export type SinksListResultItemFormatParquetType = "parquet";
export const SinksListResultItemFormatParquetType = /*@__PURE__*/ S.String;

export type SinksListResultItemFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksListResultItemFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksListResultItemFormatParquet {
  type: SinksListResultItemFormatParquetType;
  compression?: SinksListResultItemFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksListResultItemFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksListResultItemFormatParquetType,
    compression: S.optional(
      S.NullOr(SinksListResultItemFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "SinksListResultItemFormatParquet",
}) as any as S.Schema<SinksListResultItemFormatParquet>;

export type SinksListResultItemFormat =
  | SinksListResultItemFormatJson
  | SinksListResultItemFormatParquet;
export const SinksListResultItemFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type SinksListResultItemSchemaFormatJsonType = "json";
export const SinksListResultItemSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type SinksListResultItemSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const SinksListResultItemSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type SinksListResultItemSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const SinksListResultItemSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface SinksListResultItemSchemaFormatJson {
  type: SinksListResultItemSchemaFormatJsonType;
  decimalEncoding?: SinksListResultItemSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: SinksListResultItemSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const SinksListResultItemSchemaFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: SinksListResultItemSchemaFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(SinksListResultItemSchemaFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(SinksListResultItemSchemaFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksListResultItemSchemaFormatJson",
}) as any as S.Schema<SinksListResultItemSchemaFormatJson>;

export type SinksListResultItemSchemaFormatParquetType = "parquet";
export const SinksListResultItemSchemaFormatParquetType =
  /*@__PURE__*/ S.String;

export type SinksListResultItemSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const SinksListResultItemSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface SinksListResultItemSchemaFormatParquet {
  type: SinksListResultItemSchemaFormatParquetType;
  compression?: SinksListResultItemSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const SinksListResultItemSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: SinksListResultItemSchemaFormatParquetType,
      compression: S.optional(
        S.NullOr(SinksListResultItemSchemaFormatParquetCompression),
      ),
      rowGroupBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
      ),
    }),
).annotate({
  identifier: "SinksListResultItemSchemaFormatParquet",
}) as any as S.Schema<SinksListResultItemSchemaFormatParquet>;

export type SinksListResultItemSchemaFormat =
  | SinksListResultItemSchemaFormatJson
  | SinksListResultItemSchemaFormatParquet;
export const SinksListResultItemSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface SinksListResultItemSchema {
  fields?: SinksListResultItemSchemaFieldsList | null;
  format?: SinksListResultItemSchemaFormat | null;
  inferred?: boolean | null;
}
export const SinksListResultItemSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(SinksListResultItemSchemaFieldsList)),
    format: S.optional(S.NullOr(SinksListResultItemSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "SinksListResultItemSchema",
}) as any as S.Schema<SinksListResultItemSchema>;

export interface SinksListResultItem {
  /** Indicates a unique identifier for this sink. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Defines the name of the Sink. */
  name: string;
  /** Specifies the type of sink. */
  type: SinksListResultItemType;
  /** Defines the configuration of the R2 Sink. */
  config?: SinksListResultItemConfig | null;
  format?: SinksListResultItemFormat | null;
  schema?: SinksListResultItemSchema | null;
}
export const SinksListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    type: SinksListResultItemType,
    config: S.optional(S.NullOr(SinksListResultItemConfig)),
    format: S.optional(S.NullOr(SinksListResultItemFormat)),
    schema: S.optional(S.NullOr(SinksListResultItemSchema)),
  }),
).annotate({
  identifier: "SinksListResultItem",
}) as any as S.Schema<SinksListResultItem>;

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

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

export interface ListStreamsRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Filters streams by name (case-insensitive substring). */
  name?: string;
  page?: number;
  perPage?: number;
  /** Specifies the public ID of the pipeline. */
  pipelineId?: string;
}
export const ListStreamsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    pipelineId: S.optional(S.String.pipe(T.Query("pipeline_id"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/streams",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListStreamsRequest",
}) as any as S.Schema<ListStreamsRequest>;

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

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

export interface StreamsListResultItemHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsListResultItemHttpCors | null;
}
export const StreamsListResultItemHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(S.NullOr(StreamsListResultItemHttpCors)),
  }),
).annotate({
  identifier: "StreamsListResultItemHttp",
}) as any as S.Schema<StreamsListResultItemHttp>;

export type StreamsListResultItemWorkerBinding =
  StreamsCreateRequestWorkerBinding;
export const StreamsListResultItemWorkerBinding =
  StreamsCreateRequestWorkerBinding;

export type StreamsListResultItemFormatJsonType = "json";
export const StreamsListResultItemFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsListResultItemFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsListResultItemFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsListResultItemFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsListResultItemFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsListResultItemFormatJson {
  type: StreamsListResultItemFormatJsonType;
  decimalEncoding?: StreamsListResultItemFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsListResultItemFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsListResultItemFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsListResultItemFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(StreamsListResultItemFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(StreamsListResultItemFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsListResultItemFormatJson",
}) as any as S.Schema<StreamsListResultItemFormatJson>;

export type StreamsListResultItemFormatParquetType = "parquet";
export const StreamsListResultItemFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsListResultItemFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsListResultItemFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsListResultItemFormatParquet {
  type: StreamsListResultItemFormatParquetType;
  compression?: StreamsListResultItemFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsListResultItemFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsListResultItemFormatParquetType,
    compression: S.optional(
      S.NullOr(StreamsListResultItemFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "StreamsListResultItemFormatParquet",
}) as any as S.Schema<StreamsListResultItemFormatParquet>;

export type StreamsListResultItemFormat =
  | StreamsListResultItemFormatJson
  | StreamsListResultItemFormatParquet;
export const StreamsListResultItemFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

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

export type StreamsListResultItemSchemaFormatJsonType = "json";
export const StreamsListResultItemSchemaFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsListResultItemSchemaFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsListResultItemSchemaFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsListResultItemSchemaFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsListResultItemSchemaFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsListResultItemSchemaFormatJson {
  type: StreamsListResultItemSchemaFormatJsonType;
  decimalEncoding?: StreamsListResultItemSchemaFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsListResultItemSchemaFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsListResultItemSchemaFormatJson = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsListResultItemSchemaFormatJsonType,
      decimalEncoding: S.optional(
        S.NullOr(StreamsListResultItemSchemaFormatJsonDecimalEncoding).pipe(
          T.Body("decimal_encoding"),
        ),
      ),
      timestampFormat: S.optional(
        S.NullOr(StreamsListResultItemSchemaFormatJsonTimestampFormat).pipe(
          T.Body("timestamp_format"),
        ),
      ),
      unstructured: S.optional(S.NullOr(S.Boolean)),
    }),
).annotate({
  identifier: "StreamsListResultItemSchemaFormatJson",
}) as any as S.Schema<StreamsListResultItemSchemaFormatJson>;

export type StreamsListResultItemSchemaFormatParquetType = "parquet";
export const StreamsListResultItemSchemaFormatParquetType =
  /*@__PURE__*/ S.String;

export type StreamsListResultItemSchemaFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsListResultItemSchemaFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsListResultItemSchemaFormatParquet {
  type: StreamsListResultItemSchemaFormatParquetType;
  compression?: StreamsListResultItemSchemaFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsListResultItemSchemaFormatParquet = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: StreamsListResultItemSchemaFormatParquetType,
      compression: S.optional(
        S.NullOr(StreamsListResultItemSchemaFormatParquetCompression),
      ),
      rowGroupBytes: S.optional(
        S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
      ),
    }),
).annotate({
  identifier: "StreamsListResultItemSchemaFormatParquet",
}) as any as S.Schema<StreamsListResultItemSchemaFormatParquet>;

export type StreamsListResultItemSchemaFormat =
  | StreamsListResultItemSchemaFormatJson
  | StreamsListResultItemSchemaFormatParquet;
export const StreamsListResultItemSchemaFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

export interface StreamsListResultItemSchema {
  fields?: StreamsListResultItemSchemaFieldsList | null;
  format?: StreamsListResultItemSchemaFormat | null;
  inferred?: boolean | null;
}
export const StreamsListResultItemSchema = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fields: S.optional(S.NullOr(StreamsListResultItemSchemaFieldsList)),
    format: S.optional(S.NullOr(StreamsListResultItemSchemaFormat)),
    inferred: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsListResultItemSchema",
}) as any as S.Schema<StreamsListResultItemSchema>;

export interface StreamsListResultItem {
  /** Indicates a unique identifier for this stream. */
  id: string;
  createdAt: string;
  http: StreamsListResultItemHttp;
  modifiedAt: string;
  /** Indicates the name of the Stream. */
  name: string;
  /** Indicates the current version of this stream. */
  version: number;
  workerBinding: StreamsCreateRequestWorkerBinding;
  /** Indicates the endpoint URL of this stream. */
  endpoint?: string | null;
  format?: StreamsListResultItemFormat | null;
  schema?: StreamsListResultItemSchema | null;
}
export const StreamsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    http: StreamsListResultItemHttp,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: S.Number,
    workerBinding: StreamsCreateRequestWorkerBinding.pipe(
      T.Body("worker_binding"),
    ),
    endpoint: S.optional(S.NullOr(S.String)),
    format: S.optional(S.NullOr(StreamsListResultItemFormat)),
    schema: S.optional(S.NullOr(StreamsListResultItemSchema)),
  }),
).annotate({
  identifier: "StreamsListResultItem",
}) as any as S.Schema<StreamsListResultItem>;

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

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

export interface ListV1PipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Filters pipelines by name (case-insensitive substring). */
  name?: string;
  page?: number;
  perPage?: number;
}
export const ListV1PipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/pipelines/v1/pipelines",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListV1PipelineRequest",
}) as any as S.Schema<ListV1PipelineRequest>;

export interface ListV1ResultItem {
  /** Indicates a unique identifier for this pipeline. */
  id: string;
  createdAt: string;
  modifiedAt: string;
  /** Indicates the name of the Pipeline. */
  name: string;
  /** Specifies SQL for the Pipeline processing flow. */
  sql: string;
  /** Indicates the current status of the Pipeline. */
  status: string;
}
export const ListV1ResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    sql: S.String,
    status: S.String,
  }),
).annotate({
  identifier: "ListV1ResultItem",
}) as any as S.Schema<ListV1ResultItem>;

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

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

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

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

export interface StreamsUpdateRequestHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsUpdateRequestHttpCors;
}
export const StreamsUpdateRequestHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(StreamsUpdateRequestHttpCors),
  }),
).annotate({
  identifier: "StreamsUpdateRequestHttp",
}) as any as S.Schema<StreamsUpdateRequestHttp>;

export type StreamsUpdateRequestWorkerBinding =
  StreamsCreateRequestWorkerBinding;
export const StreamsUpdateRequestWorkerBinding =
  StreamsCreateRequestWorkerBinding;

export interface PatchStreamRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies the public ID of the stream. */
  streamId: string;
  http?: StreamsUpdateRequestHttp;
  workerBinding?: StreamsCreateRequestWorkerBinding;
}
export const PatchStreamRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    streamId: S.String.pipe(T.Label("stream_id")),
    http: S.optional(StreamsUpdateRequestHttp),
    workerBinding: S.optional(
      StreamsCreateRequestWorkerBinding.pipe(T.Body("worker_binding")),
    ),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/pipelines/v1/streams/{stream_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchStreamRequest",
}) as any as S.Schema<PatchStreamRequest>;

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

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

export interface StreamsUpdateResponseHttp {
  /** Indicates that authentication is required for the HTTP endpoint. */
  authentication: boolean;
  /** Indicates that the HTTP endpoint is enabled. */
  enabled: boolean;
  /** Specifies the CORS options for the HTTP endpoint. */
  cors?: StreamsUpdateResponseHttpCors | null;
}
export const StreamsUpdateResponseHttp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    authentication: S.Boolean,
    enabled: S.Boolean,
    cors: S.optional(S.NullOr(StreamsUpdateResponseHttpCors)),
  }),
).annotate({
  identifier: "StreamsUpdateResponseHttp",
}) as any as S.Schema<StreamsUpdateResponseHttp>;

export type StreamsUpdateResponseWorkerBinding =
  StreamsCreateRequestWorkerBinding;
export const StreamsUpdateResponseWorkerBinding =
  StreamsCreateRequestWorkerBinding;

export type StreamsUpdateResponseFormatJsonType = "json";
export const StreamsUpdateResponseFormatJsonType = /*@__PURE__*/ S.String;

export type StreamsUpdateResponseFormatJsonDecimalEncoding =
  | "number"
  | "string"
  | "bytes";
export const StreamsUpdateResponseFormatJsonDecimalEncoding =
  /*@__PURE__*/ S.String;

export type StreamsUpdateResponseFormatJsonTimestampFormat =
  | "rfc3339"
  | "unix_millis";
export const StreamsUpdateResponseFormatJsonTimestampFormat =
  /*@__PURE__*/ S.String;

export interface StreamsUpdateResponseFormatJson {
  type: StreamsUpdateResponseFormatJsonType;
  decimalEncoding?: StreamsUpdateResponseFormatJsonDecimalEncoding | null;
  timestampFormat?: StreamsUpdateResponseFormatJsonTimestampFormat | null;
  unstructured?: boolean | null;
}
export const StreamsUpdateResponseFormatJson = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsUpdateResponseFormatJsonType,
    decimalEncoding: S.optional(
      S.NullOr(StreamsUpdateResponseFormatJsonDecimalEncoding).pipe(
        T.Body("decimal_encoding"),
      ),
    ),
    timestampFormat: S.optional(
      S.NullOr(StreamsUpdateResponseFormatJsonTimestampFormat).pipe(
        T.Body("timestamp_format"),
      ),
    ),
    unstructured: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "StreamsUpdateResponseFormatJson",
}) as any as S.Schema<StreamsUpdateResponseFormatJson>;

export type StreamsUpdateResponseFormatParquetType = "parquet";
export const StreamsUpdateResponseFormatParquetType = /*@__PURE__*/ S.String;

export type StreamsUpdateResponseFormatParquetCompression =
  | "uncompressed"
  | "snappy"
  | "gzip"
  | "zstd"
  | "lz4";
export const StreamsUpdateResponseFormatParquetCompression =
  /*@__PURE__*/ S.String;

export interface StreamsUpdateResponseFormatParquet {
  type: StreamsUpdateResponseFormatParquetType;
  compression?: StreamsUpdateResponseFormatParquetCompression | null;
  rowGroupBytes?: number | null;
}
export const StreamsUpdateResponseFormatParquet = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: StreamsUpdateResponseFormatParquetType,
    compression: S.optional(
      S.NullOr(StreamsUpdateResponseFormatParquetCompression),
    ),
    rowGroupBytes: S.optional(
      S.NullOr(S.Number).pipe(T.Body("row_group_bytes")),
    ),
  }),
).annotate({
  identifier: "StreamsUpdateResponseFormatParquet",
}) as any as S.Schema<StreamsUpdateResponseFormatParquet>;

export type StreamsUpdateResponseFormat =
  | StreamsUpdateResponseFormatJson
  | StreamsUpdateResponseFormatParquet;
export const StreamsUpdateResponseFormat = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "decimalEncoding", "timestampFormat", "unstructured"],
    ["type", "compression", "rowGroupBytes"],
  ]),
);

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchStreamResponse {
  /** Indicates a unique identifier for this stream. */
  id: string;
  createdAt: string;
  http: StreamsUpdateResponseHttp;
  modifiedAt: string;
  /** Indicates the name of the Stream. */
  name: string;
  /** Indicates the current version of this stream. */
  version: number;
  workerBinding: StreamsCreateRequestWorkerBinding;
  /** Indicates the endpoint URL of this stream. */
  endpoint?: string | null;
  format?: StreamsUpdateResponseFormat | null;
}
export const PatchStreamResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    http: StreamsUpdateResponseHttp,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    version: S.Number,
    workerBinding: StreamsCreateRequestWorkerBinding.pipe(
      T.Body("worker_binding"),
    ),
    endpoint: S.optional(S.NullOr(S.String)),
    format: S.optional(S.NullOr(StreamsUpdateResponseFormat)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchStreamResponse",
}) as any as S.Schema<PatchStreamResponse>;

export type UpdateRequestDestinationBatch = CreateRequestDestinationBatch;
export const UpdateRequestDestinationBatch = CreateRequestDestinationBatch;

export type UpdateRequestDestinationCompressionType =
  | "none"
  | "gzip"
  | "deflate";
export const UpdateRequestDestinationCompressionType = /*@__PURE__*/ S.String;

export interface UpdateRequestDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type?: UpdateRequestDestinationCompressionType | (string & {});
}
export const UpdateRequestDestinationCompression = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: S.optional(UpdateRequestDestinationCompressionType),
  }),
).annotate({
  identifier: "UpdateRequestDestinationCompression",
}) as any as S.Schema<UpdateRequestDestinationCompression>;

export type UpdateRequestDestinationFormat = "json";
export const UpdateRequestDestinationFormat = /*@__PURE__*/ S.String;

export type UpdateRequestDestinationPath = CreateRequestDestinationPath;
export const UpdateRequestDestinationPath = CreateRequestDestinationPath;

export type UpdateRequestDestinationType = "r2";
export const UpdateRequestDestinationType = /*@__PURE__*/ S.String;

export type UpdateRequestDestinationCredentials =
  CreateRequestDestinationCredentials;
export const UpdateRequestDestinationCredentials =
  CreateRequestDestinationCredentials;

export interface UpdateRequestDestination {
  batch: CreateRequestDestinationBatch;
  compression: UpdateRequestDestinationCompression;
  /** Specifies the format of data to deliver. */
  format: UpdateRequestDestinationFormat | (string & {});
  path: CreateRequestDestinationPath;
  /** Specifies the type of destination. */
  type: UpdateRequestDestinationType | (string & {});
  credentials?: CreateRequestDestinationCredentials;
}
export const UpdateRequestDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateRequestDestinationBatch,
    compression: UpdateRequestDestinationCompression,
    format: UpdateRequestDestinationFormat,
    path: CreateRequestDestinationPath,
    type: UpdateRequestDestinationType,
    credentials: S.optional(CreateRequestDestinationCredentials),
  }),
).annotate({
  identifier: "UpdateRequestDestination",
}) as any as S.Schema<UpdateRequestDestination>;

export type UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList;
}
export const UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
      ),
    }),
  ).annotate({
    identifier:
      "UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean;
  cors?: UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors;
}
export const UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.Boolean),
      cors: S.optional(
        UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
      ),
    }),
  ).annotate({
    identifier:
      "UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type UpdateRequestSourceItem =
  | UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | UpdateRequestSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const UpdateRequestSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

export interface UpdatePipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Defines the name of the pipeline. */
  pipelineName: string;
  destination: UpdateRequestDestination;
  /** Defines the name of the pipeline. */
  name: string;
  source: UpdateRequestSourceList;
}
export const UpdatePipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    pipelineName: S.String.pipe(T.Label("pipeline_name")),
    destination: UpdateRequestDestination,
    name: S.String,
    source: UpdateRequestSourceList,
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/pipelines/{pipeline_name}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdatePipelineRequest",
}) as any as S.Schema<UpdatePipelineRequest>;

export type UpdateResponseDestinationBatch = CreateResponseDestinationBatch;
export const UpdateResponseDestinationBatch = CreateResponseDestinationBatch;

export type UpdateResponseDestinationCompressionType =
  | "none"
  | "gzip"
  | "deflate";
export const UpdateResponseDestinationCompressionType = /*@__PURE__*/ S.String;

export interface UpdateResponseDestinationCompression {
  /** Specifies the desired compression algorithm and format. */
  type: UpdateResponseDestinationCompressionType;
}
export const UpdateResponseDestinationCompression = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: UpdateResponseDestinationCompressionType,
    }),
).annotate({
  identifier: "UpdateResponseDestinationCompression",
}) as any as S.Schema<UpdateResponseDestinationCompression>;

export type UpdateResponseDestinationFormat = "json";
export const UpdateResponseDestinationFormat = /*@__PURE__*/ S.String;

export type UpdateResponseDestinationPath = CreateResponseDestinationPath;
export const UpdateResponseDestinationPath = CreateResponseDestinationPath;

export type UpdateResponseDestinationType = "r2";
export const UpdateResponseDestinationType = /*@__PURE__*/ S.String;

export interface UpdateResponseDestination {
  batch: CreateResponseDestinationBatch;
  compression: UpdateResponseDestinationCompression;
  /** Specifies the format of data to deliver. */
  format: UpdateResponseDestinationFormat;
  path: CreateResponseDestinationPath;
  /** Specifies the type of destination. */
  type: UpdateResponseDestinationType;
}
export const UpdateResponseDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batch: CreateResponseDestinationBatch,
    compression: UpdateResponseDestinationCompression,
    format: UpdateResponseDestinationFormat,
    path: CreateResponseDestinationPath,
    type: UpdateResponseDestinationType,
  }),
).annotate({
  identifier: "UpdateResponseDestination",
}) as any as S.Schema<UpdateResponseDestination>;

export type UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  "json";
export const UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat =
  /*@__PURE__*/ S.String;

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

export interface UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors {
  /** Specifies allowed origins to allow Cross Origin HTTP Requests. */
  origins?: UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList | null;
}
export const UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      origins: S.optional(
        S.NullOr(
          UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCorsOriginsList,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors",
  }) as any as S.Schema<UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors>;

export interface UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource {
  /** Specifies the format of source data. */
  format: UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat;
  type: string;
  /** Specifies whether authentication is required to send to this pipeline via HTTP. */
  authentication?: boolean | null;
  cors?: UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors | null;
}
export const UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceFormat,
      type: S.String,
      authentication: S.optional(S.NullOr(S.Boolean)),
      cors: S.optional(
        S.NullOr(
          UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSourceCors,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource",
  }) as any as S.Schema<UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource>;

export type UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  "json";
export const UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat =
  /*@__PURE__*/ S.String;

export interface UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource {
  /** Specifies the format of source data. */
  format: UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat;
  type: string;
}
export const UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      format:
        UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSourceFormat,
      type: S.String,
    }),
  ).annotate({
    identifier:
      "UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource",
  }) as any as S.Schema<UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource>;

export type UpdateResponseSourceItem =
  | UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesHTTPSource
  | UpdateResponseSourceItemCloudflarePipelinesWorkersPipelinesBindingSource;
export const UpdateResponseSourceItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["format", "type", "authentication", "cors"],
    ["format", "type"],
  ]),
);

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdatePipelineResponse {
  /** Specifies the pipeline identifier. */
  id: string;
  destination: UpdateResponseDestination;
  /** Indicates the endpoint URL to send traffic. */
  endpoint: string;
  /** Defines the name of the pipeline. */
  name: string;
  source: UpdateResponseSourceList;
  /** Indicates the version number of last saved configuration. */
  version: number;
}
export const UpdatePipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    destination: UpdateResponseDestination,
    endpoint: S.String,
    name: S.String,
    source: UpdateResponseSourceList,
    version: S.Number,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdatePipelineResponse",
}) as any as S.Schema<UpdatePipelineResponse>;

export interface ValidateSqlPipelineRequest {
  /** Specifies the public ID of the account. */
  accountId: string;
  /** Specifies SQL to validate. */
  sql: string;
}
export const ValidateSqlPipelineRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sql: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/pipelines/v1/validate_sql",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ValidateSqlPipelineRequest",
}) as any as S.Schema<ValidateSqlPipelineRequest>;

export interface ValidateSqlResponseTablesValue {
  id: string;
  name: string;
  type: string;
  version: number;
}
export const ValidateSqlResponseTablesValue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
    type: S.String,
    version: S.Number,
  }),
).annotate({
  identifier: "ValidateSqlResponseTablesValue",
}) as any as S.Schema<ValidateSqlResponseTablesValue>;

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

export interface ValidateSqlResponseGraphEdgesItem {
  destId: number;
  edgeType: string;
  keyType: string;
  srcId: number;
  valueType: string;
}
export const ValidateSqlResponseGraphEdgesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    destId: S.Number.pipe(T.Body("dest_id")),
    edgeType: S.String.pipe(T.Body("edge_type")),
    keyType: S.String.pipe(T.Body("key_type")),
    srcId: S.Number.pipe(T.Body("src_id")),
    valueType: S.String.pipe(T.Body("value_type")),
  }),
).annotate({
  identifier: "ValidateSqlResponseGraphEdgesItem",
}) as any as S.Schema<ValidateSqlResponseGraphEdgesItem>;

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

export interface ValidateSqlResponseGraphNodesItem {
  description: string;
  nodeId: number;
  operator: string;
  parallelism: number;
}
export const ValidateSqlResponseGraphNodesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    description: S.String,
    nodeId: S.Number.pipe(T.Body("node_id")),
    operator: S.String,
    parallelism: S.Number,
  }),
).annotate({
  identifier: "ValidateSqlResponseGraphNodesItem",
}) as any as S.Schema<ValidateSqlResponseGraphNodesItem>;

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

export interface ValidateSqlResponseGraph {
  edges: ValidateSqlResponseGraphEdgesList;
  nodes: ValidateSqlResponseGraphNodesList;
}
export const ValidateSqlResponseGraph = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    edges: ValidateSqlResponseGraphEdgesList,
    nodes: ValidateSqlResponseGraphNodesList,
  }),
).annotate({
  identifier: "ValidateSqlResponseGraph",
}) as any as S.Schema<ValidateSqlResponseGraph>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ValidateSqlPipelineResponse {
  /** Indicates tables involved in the processing. */
  tables: ValidateSqlResponseTablesMap;
  graph?: ValidateSqlResponseGraph | null;
}
export const ValidateSqlPipelineResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    tables: ValidateSqlResponseTablesMap,
    graph: S.optional(S.NullOr(ValidateSqlResponseGraph)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ValidateSqlPipelineResponse",
}) as any as S.Schema<ValidateSqlPipelineResponse>;

export type CreatePipelineError = CloudflareOpError;
/** [DEPRECATED] Create a new pipeline. Use the new /pipelines/v1/pipelines endpoint instead. */
export const createPipeline: API.OperationMethod<
  CreatePipelineRequest,
  CreatePipelineResponse,
  CreatePipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreatePipelineRequest,
  output: CreatePipelineResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSinkError =
  | SinkAuthFailed
  | InvalidSinkConfig
  | SinkAlreadyExists
  | CloudflareOpError;
/** Create a new Sink. */
export const createSink: API.OperationMethod<
  CreateSinkRequest,
  CreateSinkResponse,
  CreateSinkError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSinkRequest,
  output: CreateSinkResponse,
  errors: [
    SinkAuthFailed,
    InvalidSinkConfig,
    SinkAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateStreamError =
  | InvalidStreamName
  | StreamAlreadyExists
  | CloudflareOpError;
/** Create a new Stream. */
export const createStream: API.OperationMethod<
  CreateStreamRequest,
  CreateStreamResponse,
  CreateStreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateStreamRequest,
  output: CreateStreamResponse,
  errors: [
    InvalidStreamName,
    StreamAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateV1PipelineError =
  | TableNotFound
  | InvalidSql
  | PipelineAlreadyExists
  | CloudflareOpError;
/** Create a new Pipeline. */
export const createV1Pipeline: API.OperationMethod<
  CreateV1PipelineRequest,
  CreateV1PipelineResponse,
  CreateV1PipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateV1PipelineRequest,
  output: CreateV1PipelineResponse,
  errors: [
    TableNotFound,
    InvalidSql,
    PipelineAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeletePipelineError = PipelineNotExists | CloudflareOpError;
/** [DEPRECATED] Delete a pipeline. Use the new /pipelines/v1/pipelines endpoint instead. */
export const deletePipeline: API.OperationMethod<
  DeletePipelineRequest,
  DeletePipelineResponse,
  DeletePipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeletePipelineRequest,
  output: DeletePipelineResponse,
  errors: [PipelineNotExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSinkError =
  | SinkNotFound
  | InvalidSinkId
  | SinkInUse
  | CloudflareOpError;
/** Delete Pipeline in Account. */
export const deleteSink: API.OperationMethod<
  DeleteSinkRequest,
  DeleteSinkResponse,
  DeleteSinkError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSinkRequest,
  output: DeleteSinkResponse,
  errors: [
    SinkNotFound,
    InvalidSinkId,
    SinkInUse,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteStreamError =
  | PipelineNotExists
  | StreamNotFound
  | InvalidStreamId
  | StreamInUse
  | CloudflareOpError;
/** Delete Stream in Account. */
export const deleteStream: API.OperationMethod<
  DeleteStreamRequest,
  DeleteStreamResponse,
  DeleteStreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteStreamRequest,
  output: DeleteStreamResponse,
  errors: [
    PipelineNotExists,
    StreamNotFound,
    InvalidStreamId,
    StreamInUse,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteV1PipelineError = PipelineNotExists | CloudflareOpError;
/** Delete Pipeline in Account. */
export const deleteV1Pipeline: API.OperationMethod<
  DeleteV1PipelineRequest,
  DeleteV1PipelineResponse,
  DeleteV1PipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteV1PipelineRequest,
  output: DeleteV1PipelineResponse,
  errors: [PipelineNotExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetPipelineError = PipelineNotExists | CloudflareOpError;
/** [DEPRECATED] Get configuration of a pipeline. Use the new /pipelines/v1/pipelines endpoint instead. */
export const getPipeline: API.OperationMethod<
  GetPipelineRequest,
  GetPipelineResponse,
  GetPipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetPipelineRequest,
  output: GetPipelineResponse,
  errors: [PipelineNotExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSinkError = SinkNotFound | InvalidSinkId | CloudflareOpError;
/** Get Sink Details. */
export const getSink: API.OperationMethod<
  GetSinkRequest,
  GetSinkResponse,
  GetSinkError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSinkRequest,
  output: GetSinkResponse,
  errors: [SinkNotFound, InvalidSinkId, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetStreamError =
  | StreamNotFound
  | InvalidStreamId
  | CloudflareOpError;
/** Get Stream Details. */
export const getStream: API.OperationMethod<
  GetStreamRequest,
  GetStreamResponse,
  GetStreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetStreamRequest,
  output: GetStreamResponse,
  errors: [
    StreamNotFound,
    InvalidStreamId,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetV1PipelineError = PipelineNotExists | CloudflareOpError;
/** Get Pipelines Details. */
export const getV1Pipeline: API.OperationMethod<
  GetV1PipelineRequest,
  GetV1PipelineResponse,
  GetV1PipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetV1PipelineRequest,
  output: GetV1PipelineResponse,
  errors: [PipelineNotExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListPipelinesError = CloudflareOpError;
/** [DEPRECATED] List, filter, and paginate pipelines in an account. Use the new /pipelines/v1/pipelines endpoint instead. */
export const listPipelines: API.PaginatedOperationMethod<
  ListPipelinesRequest,
  ListPipelinesResponse,
  ListPipelinesError,
  CloudflareOpContext,
  ListResponseResultsItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListPipelinesRequest,
    output: ListPipelinesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      inputToken: "page",
      pageSize: "per_page",
      items: "results",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListSinksError = CloudflareOpError;
/** List/Filter Sinks in Account. */
export const listSinks: API.PaginatedOperationMethod<
  ListSinksRequest,
  ListSinksResponse,
  ListSinksError,
  CloudflareOpContext,
  SinksListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListSinksRequest,
    output: ListSinksResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListStreamsError = CloudflareOpError;
/** List/Filter Streams in Account. */
export const listStreams: API.PaginatedOperationMethod<
  ListStreamsRequest,
  ListStreamsResponse,
  ListStreamsError,
  CloudflareOpContext,
  StreamsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListStreamsRequest,
    output: ListStreamsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListV1PipelineError = CloudflareOpError;
/** List/Filter Pipelines in Account. */
export const listV1Pipeline: API.PaginatedOperationMethod<
  ListV1PipelineRequest,
  ListV1PipelineResponse,
  ListV1PipelineError,
  CloudflareOpContext,
  ListV1ResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListV1PipelineRequest,
    output: ListV1PipelineResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type PatchStreamError = StreamNotFound | CloudflareOpError;
/** Update a Stream. */
export const patchStream: API.OperationMethod<
  PatchStreamRequest,
  PatchStreamResponse,
  PatchStreamError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchStreamRequest,
  output: PatchStreamResponse,
  errors: [StreamNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdatePipelineError = PipelineNotExists | CloudflareOpError;
/** [DEPRECATED] Update an existing pipeline. Use the new /pipelines/v1/pipelines endpoint instead. */
export const updatePipeline: API.OperationMethod<
  UpdatePipelineRequest,
  UpdatePipelineResponse,
  UpdatePipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdatePipelineRequest,
  output: UpdatePipelineResponse,
  errors: [PipelineNotExists, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ValidateSqlPipelineError =
  | TableNotFound
  | InvalidSql
  | CloudflareOpError;
/** Validate Arroyo SQL. */
export const validateSqlPipeline: API.OperationMethod<
  ValidateSqlPipelineRequest,
  ValidateSqlPipelineResponse,
  ValidateSqlPipelineError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ValidateSqlPipelineRequest,
  output: ValidateSqlPipelineResponse,
  errors: [TableNotFound, InvalidSql, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));