/**
 * Cloudflare PIPELINES API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service pipelines
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
declare const InvalidSinkConfig_base: Schema.Class<InvalidSinkConfig, Schema.TaggedStruct<"InvalidSinkConfig", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidSinkConfig extends InvalidSinkConfig_base {
}
declare const InvalidSinkId_base: Schema.Class<InvalidSinkId, Schema.TaggedStruct<"InvalidSinkId", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidSinkId extends InvalidSinkId_base {
}
declare const InvalidSql_base: Schema.Class<InvalidSql, Schema.TaggedStruct<"InvalidSql", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidSql extends InvalidSql_base {
}
declare const InvalidStreamId_base: Schema.Class<InvalidStreamId, Schema.TaggedStruct<"InvalidStreamId", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidStreamId extends InvalidStreamId_base {
}
declare const InvalidStreamName_base: Schema.Class<InvalidStreamName, Schema.TaggedStruct<"InvalidStreamName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidStreamName extends InvalidStreamName_base {
}
declare const PipelineAlreadyExists_base: Schema.Class<PipelineAlreadyExists, Schema.TaggedStruct<"PipelineAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class PipelineAlreadyExists extends PipelineAlreadyExists_base {
}
declare const PipelineNotExists_base: Schema.Class<PipelineNotExists, Schema.TaggedStruct<"PipelineNotExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class PipelineNotExists extends PipelineNotExists_base {
}
declare const SinkAlreadyExists_base: Schema.Class<SinkAlreadyExists, Schema.TaggedStruct<"SinkAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SinkAlreadyExists extends SinkAlreadyExists_base {
}
declare const SinkAuthFailed_base: Schema.Class<SinkAuthFailed, Schema.TaggedStruct<"SinkAuthFailed", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SinkAuthFailed extends SinkAuthFailed_base {
}
declare const SinkNotFound_base: Schema.Class<SinkNotFound, Schema.TaggedStruct<"SinkNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SinkNotFound extends SinkNotFound_base {
}
declare const StreamAlreadyExists_base: Schema.Class<StreamAlreadyExists, Schema.TaggedStruct<"StreamAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class StreamAlreadyExists extends StreamAlreadyExists_base {
}
declare const StreamNotFound_base: Schema.Class<StreamNotFound, Schema.TaggedStruct<"StreamNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class StreamNotFound extends StreamNotFound_base {
}
declare const TableNotFound_base: Schema.Class<TableNotFound, Schema.TaggedStruct<"TableNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class TableNotFound extends TableNotFound_base {
}
export interface GetPipelineRequest {
    pipelineName: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const GetPipelineRequest: Schema.Schema<GetPipelineRequest>;
export interface GetPipelineResponse {
    /** Specifies the pipeline identifier. */
    id: string;
    destination: {
        batch: {
            maxBytes: number;
            maxDurationS: number;
            maxRows: number;
        };
        compression: {
            type: "none" | "gzip" | "deflate";
        };
        format: "json";
        path: {
            bucket: string;
            filename?: string | null;
            filepath?: string | null;
            prefix?: string | null;
        };
        type: "r2";
    };
    /** Indicates the endpoint URL to send traffic. */
    endpoint: string;
    /** Defines the name of the pipeline. */
    name: string;
    source: ({
        format: "json";
        type: string;
        authentication?: boolean | null;
        cors?: {
            origins?: string[] | null;
        } | null;
    } | {
        format: "json";
        type: string;
    })[];
    /** Indicates the version number of last saved configuration. */
    version: number;
}
export declare const GetPipelineResponse: Schema.Schema<GetPipelineResponse>;
export type GetPipelineError = DefaultErrors | PipelineNotExists;
export declare const getPipeline: API.OperationMethod<GetPipelineRequest, GetPipelineResponse, GetPipelineError, Credentials | HttpClient.HttpClient>;
export interface ListPipelinesRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Query param: Specifies which page to retrieve. */
    page?: string;
    /** Query param: Specifies the number of pipelines per page. */
    perPage?: string;
    /** Query param: Specifies the prefix of pipeline name to search. */
    search?: string;
}
export declare const ListPipelinesRequest: Schema.Schema<ListPipelinesRequest>;
export interface ListPipelinesResponse {
    resultInfo?: {
        count: number;
        page: number;
        perPage: number;
        totalCount: number;
    } | null;
    results: {
        id: string;
        destination: {
            batch: {
                maxBytes: number;
                maxDurationS: number;
                maxRows: number;
            };
            compression: {
                type: "none" | "gzip" | "deflate";
            };
            format: "json";
            path: {
                bucket: string;
                filename?: string | null;
                filepath?: string | null;
                prefix?: string | null;
            };
            type: "r2";
        };
        endpoint: string;
        name: string;
        source: ({
            format: "json";
            type: string;
            authentication?: boolean | null;
            cors?: {
                origins?: string[] | null;
            } | null;
        } | {
            format: "json";
            type: string;
        })[];
        version: number;
    }[];
    /** Indicates whether the API call was successful. */
    success: boolean;
}
export declare const ListPipelinesResponse: Schema.Schema<ListPipelinesResponse>;
export type ListPipelinesError = DefaultErrors;
export declare const listPipelines: API.OperationMethod<ListPipelinesRequest, ListPipelinesResponse, ListPipelinesError, Credentials | HttpClient.HttpClient>;
export interface CreatePipelineRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: */
    destination: {
        batch: {
            maxBytes?: number;
            maxDurationS?: number;
            maxRows?: number;
        };
        compression: {
            type?: "none" | "gzip" | "deflate";
        };
        credentials: {
            accessKeyId: string;
            endpoint: string;
            secretAccessKey: string;
        };
        format: "json";
        path: {
            bucket: string;
            filename?: string;
            filepath?: string;
            prefix?: string;
        };
        type: "r2";
    };
    /** Body param: Defines the name of the pipeline. */
    name: string;
    /** Body param: */
    source: ({
        format: "json";
        type: string;
        authentication?: boolean;
        cors?: {
            origins?: string[];
        };
    } | {
        format: "json";
        type: string;
    })[];
}
export declare const CreatePipelineRequest: Schema.Schema<CreatePipelineRequest>;
export interface CreatePipelineResponse {
    /** Specifies the pipeline identifier. */
    id: string;
    destination: {
        batch: {
            maxBytes: number;
            maxDurationS: number;
            maxRows: number;
        };
        compression: {
            type: "none" | "gzip" | "deflate";
        };
        format: "json";
        path: {
            bucket: string;
            filename?: string | null;
            filepath?: string | null;
            prefix?: string | null;
        };
        type: "r2";
    };
    /** Indicates the endpoint URL to send traffic. */
    endpoint: string;
    /** Defines the name of the pipeline. */
    name: string;
    source: ({
        format: "json";
        type: string;
        authentication?: boolean | null;
        cors?: {
            origins?: string[] | null;
        } | null;
    } | {
        format: "json";
        type: string;
    })[];
    /** Indicates the version number of last saved configuration. */
    version: number;
}
export declare const CreatePipelineResponse: Schema.Schema<CreatePipelineResponse>;
export type CreatePipelineError = DefaultErrors;
export declare const createPipeline: API.OperationMethod<CreatePipelineRequest, CreatePipelineResponse, CreatePipelineError, Credentials | HttpClient.HttpClient>;
export interface UpdatePipelineRequest {
    pipelineName: string;
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: */
    destination: {
        batch: {
            maxBytes?: number;
            maxDurationS?: number;
            maxRows?: number;
        };
        compression: {
            type?: "none" | "gzip" | "deflate";
        };
        format: "json";
        path: {
            bucket: string;
            filename?: string;
            filepath?: string;
            prefix?: string;
        };
        type: "r2";
        credentials?: {
            accessKeyId: string;
            endpoint: string;
            secretAccessKey: string;
        };
    };
    /** Body param: Defines the name of the pipeline. */
    name: string;
    /** Body param: */
    source: ({
        format: "json";
        type: string;
        authentication?: boolean;
        cors?: {
            origins?: string[];
        };
    } | {
        format: "json";
        type: string;
    })[];
}
export declare const UpdatePipelineRequest: Schema.Schema<UpdatePipelineRequest>;
export interface UpdatePipelineResponse {
    /** Specifies the pipeline identifier. */
    id: string;
    destination: {
        batch: {
            maxBytes: number;
            maxDurationS: number;
            maxRows: number;
        };
        compression: {
            type: "none" | "gzip" | "deflate";
        };
        format: "json";
        path: {
            bucket: string;
            filename?: string | null;
            filepath?: string | null;
            prefix?: string | null;
        };
        type: "r2";
    };
    /** Indicates the endpoint URL to send traffic. */
    endpoint: string;
    /** Defines the name of the pipeline. */
    name: string;
    source: ({
        format: "json";
        type: string;
        authentication?: boolean | null;
        cors?: {
            origins?: string[] | null;
        } | null;
    } | {
        format: "json";
        type: string;
    })[];
    /** Indicates the version number of last saved configuration. */
    version: number;
}
export declare const UpdatePipelineResponse: Schema.Schema<UpdatePipelineResponse>;
export type UpdatePipelineError = DefaultErrors | PipelineNotExists;
export declare const updatePipeline: API.OperationMethod<UpdatePipelineRequest, UpdatePipelineResponse, UpdatePipelineError, Credentials | HttpClient.HttpClient>;
export interface DeletePipelineRequest {
    pipelineName: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const DeletePipelineRequest: Schema.Schema<DeletePipelineRequest>;
export type DeletePipelineResponse = unknown;
export declare const DeletePipelineResponse: Schema.Schema<DeletePipelineResponse>;
export type DeletePipelineError = DefaultErrors | PipelineNotExists;
export declare const deletePipeline: API.OperationMethod<DeletePipelineRequest, DeletePipelineResponse, DeletePipelineError, Credentials | HttpClient.HttpClient>;
export interface GetSinkRequest {
    sinkId: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const GetSinkRequest: Schema.Schema<GetSinkRequest>;
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: "r2" | "r2_data_catalog";
    /** Defines the configuration of the R2 Sink. */
    config?: {
        accountId: string;
        bucket: string;
        credentials: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        fileNaming?: {
            prefix?: string | null;
            strategy?: "serial" | "uuid" | "uuid_v7" | "ulid" | null;
            suffix?: string | null;
        } | null;
        jurisdiction?: string | null;
        partitioning?: {
            timePattern?: string | null;
        } | null;
        path?: string | null;
        rollingPolicy?: {
            fileSizeBytes?: number | null;
            inactivitySeconds?: number | null;
            intervalSeconds?: number | null;
        } | null;
    } | {
        token: string;
        accountId: string;
        bucket: string;
        tableName: string;
        namespace?: string | null;
        rollingPolicy?: {
            fileSizeBytes?: number | null;
            inactivitySeconds?: number | null;
            intervalSeconds?: number | null;
        } | null;
    } | null;
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes" | null;
        timestampFormat?: "rfc3339" | "unix_millis" | null;
        unstructured?: boolean | null;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
        rowGroupBytes?: number | null;
    } | null;
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | unknown)[] | null;
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        inferred?: boolean | null;
    } | null;
}
export declare const GetSinkResponse: Schema.Schema<GetSinkResponse>;
export type GetSinkError = DefaultErrors | SinkNotFound | InvalidSinkId;
export declare const getSink: API.OperationMethod<GetSinkRequest, GetSinkResponse, GetSinkError, Credentials | HttpClient.HttpClient>;
export interface ListSinksRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: */
    pipelineId?: string;
}
export declare const ListSinksRequest: Schema.Schema<ListSinksRequest>;
export interface ListSinksResponse {
    result: {
        id: string;
        createdAt: string;
        modifiedAt: string;
        name: string;
        type: "r2" | "r2_data_catalog";
        config?: {
            accountId: string;
            bucket: string;
            credentials: {
                accessKeyId: string;
                secretAccessKey: string;
            };
            fileNaming?: {
                prefix?: string | null;
                strategy?: "serial" | "uuid" | "uuid_v7" | "ulid" | null;
                suffix?: string | null;
            } | null;
            jurisdiction?: string | null;
            partitioning?: {
                timePattern?: string | null;
            } | null;
            path?: string | null;
            rollingPolicy?: {
                fileSizeBytes?: number | null;
                inactivitySeconds?: number | null;
                intervalSeconds?: number | null;
            } | null;
        } | {
            token: string;
            accountId: string;
            bucket: string;
            tableName: string;
            namespace?: string | null;
            rollingPolicy?: {
                fileSizeBytes?: number | null;
                inactivitySeconds?: number | null;
                intervalSeconds?: number | null;
            } | null;
        } | null;
        format?: {
            type: "json";
            decimalEncoding?: "number" | "string" | "bytes" | null;
            timestampFormat?: "rfc3339" | "unix_millis" | null;
            unstructured?: boolean | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        schema?: {
            fields?: ({
                type: "int32";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "int64";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "float32";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "float64";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "bool";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "string";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "binary";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "timestamp";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
                unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
            } | {
                type: "json";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | unknown)[] | null;
            format?: {
                type: "json";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "parquet";
                compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
                rowGroupBytes?: number | null;
            } | null;
            inferred?: boolean | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListSinksResponse: Schema.Schema<ListSinksResponse>;
export type ListSinksError = DefaultErrors;
export declare const listSinks: API.PaginatedOperationMethod<ListSinksRequest, ListSinksResponse, ListSinksError, Credentials | HttpClient.HttpClient>;
export interface CreateSinkRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: Defines the name of the Sink. */
    name: string;
    /** Body param: Specifies the type of sink. */
    type: "r2" | "r2_data_catalog";
    /** Body param: Defines the configuration of the R2 Sink. */
    config?: {
        accountId: string;
        bucket: string;
        credentials: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        fileNaming?: {
            prefix?: string;
            strategy?: "serial" | "uuid" | "uuid_v7" | "ulid";
            suffix?: string;
        };
        jurisdiction?: string;
        partitioning?: {
            timePattern?: string;
        };
        path?: string;
        rollingPolicy?: {
            fileSizeBytes?: number;
            inactivitySeconds?: number;
            intervalSeconds?: number;
        };
    } | {
        token: string;
        accountId: string;
        bucket: string;
        tableName: string;
        namespace?: string;
        rollingPolicy?: {
            fileSizeBytes?: number;
            inactivitySeconds?: number;
            intervalSeconds?: number;
        };
    };
    /** Body param: */
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes";
        timestampFormat?: "rfc3339" | "unix_millis";
        unstructured?: boolean;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4";
        rowGroupBytes?: number | null;
    };
    /** Body param: */
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond";
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | unknown)[];
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4";
            rowGroupBytes?: number | null;
        };
        inferred?: boolean | null;
    };
}
export declare const CreateSinkRequest: Schema.Schema<CreateSinkRequest>;
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: "r2" | "r2_data_catalog";
    /** R2 Data Catalog Sink */
    config?: {
        accountId: string;
        bucket: string;
        credentials: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        fileNaming?: {
            prefix?: string | null;
            strategy?: "serial" | "uuid" | "uuid_v7" | "ulid" | null;
            suffix?: string | null;
        } | null;
        jurisdiction?: string | null;
        partitioning?: {
            timePattern?: string | null;
        } | null;
        path?: string | null;
        rollingPolicy?: {
            fileSizeBytes?: number | null;
            inactivitySeconds?: number | null;
            intervalSeconds?: number | null;
        } | null;
    } | {
        token: string;
        accountId: string;
        bucket: string;
        tableName: string;
        namespace?: string | null;
        rollingPolicy?: {
            fileSizeBytes?: number | null;
            inactivitySeconds?: number | null;
            intervalSeconds?: number | null;
        } | null;
    } | null;
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes" | null;
        timestampFormat?: "rfc3339" | "unix_millis" | null;
        unstructured?: boolean | null;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
        rowGroupBytes?: number | null;
    } | null;
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | unknown)[] | null;
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        inferred?: boolean | null;
    } | null;
}
export declare const CreateSinkResponse: Schema.Schema<CreateSinkResponse>;
export type CreateSinkError = DefaultErrors | SinkAuthFailed | InvalidSinkConfig | SinkAlreadyExists;
export declare const createSink: API.OperationMethod<CreateSinkRequest, CreateSinkResponse, CreateSinkError, Credentials | HttpClient.HttpClient>;
export interface DeleteSinkRequest {
    sinkId: string;
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Query param: Delete sink forcefully, including deleting any dependent pipelines. */
    force?: string;
}
export declare const DeleteSinkRequest: Schema.Schema<DeleteSinkRequest>;
export type DeleteSinkResponse = unknown;
export declare const DeleteSinkResponse: Schema.Schema<DeleteSinkResponse>;
export type DeleteSinkError = DefaultErrors;
export declare const deleteSink: API.OperationMethod<DeleteSinkRequest, DeleteSinkResponse, DeleteSinkError, Credentials | HttpClient.HttpClient>;
export interface ValidateSqlPipelineRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: Specifies SQL to validate. */
    sql: string;
}
export declare const ValidateSqlPipelineRequest: Schema.Schema<ValidateSqlPipelineRequest>;
export interface ValidateSqlPipelineResponse {
    /** Indicates tables involved in the processing. */
    tables: Record<string, unknown>;
    graph?: {
        edges: {
            destId: number;
            edgeType: string;
            keyType: string;
            srcId: number;
            valueType: string;
        }[];
        nodes: {
            description: string;
            nodeId: number;
            operator: string;
            parallelism: number;
        }[];
    } | null;
}
export declare const ValidateSqlPipelineResponse: Schema.Schema<ValidateSqlPipelineResponse>;
export type ValidateSqlPipelineError = DefaultErrors | TableNotFound | InvalidSql;
export declare const validateSqlPipeline: API.OperationMethod<ValidateSqlPipelineRequest, ValidateSqlPipelineResponse, ValidateSqlPipelineError, Credentials | HttpClient.HttpClient>;
export interface GetStreamRequest {
    streamId: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const GetStreamRequest: Schema.Schema<GetStreamRequest>;
export interface GetStreamResponse {
    /** Indicates a unique identifier for this stream. */
    id: string;
    createdAt: string;
    http: {
        authentication: boolean;
        enabled: boolean;
        cors?: {
            origins?: string[] | null;
        } | null;
    };
    modifiedAt: string;
    /** Indicates the name of the Stream. */
    name: string;
    /** Indicates the current version of this stream. */
    version: number;
    workerBinding: {
        enabled: boolean;
    };
    /** Indicates the endpoint URL of this stream. */
    endpoint?: string | null;
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes" | null;
        timestampFormat?: "rfc3339" | "unix_millis" | null;
        unstructured?: boolean | null;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
        rowGroupBytes?: number | null;
    } | null;
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | unknown)[] | null;
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        inferred?: boolean | null;
    } | null;
}
export declare const GetStreamResponse: Schema.Schema<GetStreamResponse>;
export type GetStreamError = DefaultErrors | StreamNotFound | InvalidStreamId;
export declare const getStream: API.OperationMethod<GetStreamRequest, GetStreamResponse, GetStreamError, Credentials | HttpClient.HttpClient>;
export interface ListStreamsRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Specifies the public ID of the pipeline. */
    pipelineId?: string;
}
export declare const ListStreamsRequest: Schema.Schema<ListStreamsRequest>;
export interface ListStreamsResponse {
    result: {
        id: string;
        createdAt: string;
        http: {
            authentication: boolean;
            enabled: boolean;
            cors?: {
                origins?: string[] | null;
            } | null;
        };
        modifiedAt: string;
        name: string;
        version: number;
        workerBinding: {
            enabled: boolean;
        };
        endpoint?: string | null;
        format?: {
            type: "json";
            decimalEncoding?: "number" | "string" | "bytes" | null;
            timestampFormat?: "rfc3339" | "unix_millis" | null;
            unstructured?: boolean | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        schema?: {
            fields?: ({
                type: "int32";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "int64";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "float32";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "float64";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "bool";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "string";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "binary";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "timestamp";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
                unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
            } | {
                type: "json";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | unknown)[] | null;
            format?: {
                type: "json";
                metadataKey?: string | null;
                name?: string | null;
                required?: boolean | null;
                sqlName?: string | null;
            } | {
                type: "parquet";
                compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
                rowGroupBytes?: number | null;
            } | null;
            inferred?: boolean | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListStreamsResponse: Schema.Schema<ListStreamsResponse>;
export type ListStreamsError = DefaultErrors;
export declare const listStreams: API.PaginatedOperationMethod<ListStreamsRequest, ListStreamsResponse, ListStreamsError, Credentials | HttpClient.HttpClient>;
export interface CreateStreamRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: Specifies the name of the Stream. */
    name: string;
    /** Body param: */
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes";
        timestampFormat?: "rfc3339" | "unix_millis";
        unstructured?: boolean;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4";
        rowGroupBytes?: number | null;
    };
    /** Body param: */
    http?: {
        authentication: boolean;
        enabled: boolean;
        cors?: {
            origins?: string[];
        };
    };
    /** Body param: */
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond";
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | unknown)[];
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string;
            required?: boolean;
            sqlName?: string;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4";
            rowGroupBytes?: number | null;
        };
        inferred?: boolean | null;
    };
    /** Body param: */
    workerBinding?: {
        enabled: boolean;
    };
}
export declare const CreateStreamRequest: Schema.Schema<CreateStreamRequest>;
export interface CreateStreamResponse {
    /** Indicates a unique identifier for this stream. */
    id: string;
    createdAt: string;
    http: {
        authentication: boolean;
        enabled: boolean;
        cors?: {
            origins?: string[] | null;
        } | null;
    };
    modifiedAt: string;
    /** Indicates the name of the Stream. */
    name: string;
    /** Indicates the current version of this stream. */
    version: number;
    workerBinding: {
        enabled: boolean;
    };
    /** Indicates the endpoint URL of this stream. */
    endpoint?: string | null;
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes" | null;
        timestampFormat?: "rfc3339" | "unix_millis" | null;
        unstructured?: boolean | null;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
        rowGroupBytes?: number | null;
    } | null;
    schema?: {
        fields?: ({
            type: "int32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "int64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float32";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "float64";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "bool";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "string";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "binary";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "timestamp";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
            unit?: "second" | "millisecond" | "microsecond" | "nanosecond" | null;
        } | {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | unknown)[] | null;
        format?: {
            type: "json";
            metadataKey?: string | null;
            name?: string | null;
            required?: boolean | null;
            sqlName?: string | null;
        } | {
            type: "parquet";
            compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
            rowGroupBytes?: number | null;
        } | null;
        inferred?: boolean | null;
    } | null;
}
export declare const CreateStreamResponse: Schema.Schema<CreateStreamResponse>;
export type CreateStreamError = DefaultErrors | InvalidStreamName | StreamAlreadyExists;
export declare const createStream: API.OperationMethod<CreateStreamRequest, CreateStreamResponse, CreateStreamError, Credentials | HttpClient.HttpClient>;
export interface PatchStreamRequest {
    streamId: string;
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: */
    http?: {
        authentication: boolean;
        enabled: boolean;
        cors?: {
            origins?: string[];
        };
    };
    /** Body param: */
    workerBinding?: {
        enabled: boolean;
    };
}
export declare const PatchStreamRequest: Schema.Schema<PatchStreamRequest>;
export interface PatchStreamResponse {
    /** Indicates a unique identifier for this stream. */
    id: string;
    createdAt: string;
    http: {
        authentication: boolean;
        enabled: boolean;
        cors?: {
            origins?: string[] | null;
        } | null;
    };
    modifiedAt: string;
    /** Indicates the name of the Stream. */
    name: string;
    /** Indicates the current version of this stream. */
    version: number;
    workerBinding: {
        enabled: boolean;
    };
    /** Indicates the endpoint URL of this stream. */
    endpoint?: string | null;
    format?: {
        type: "json";
        decimalEncoding?: "number" | "string" | "bytes" | null;
        timestampFormat?: "rfc3339" | "unix_millis" | null;
        unstructured?: boolean | null;
    } | {
        type: "parquet";
        compression?: "uncompressed" | "snappy" | "gzip" | "zstd" | "lz4" | null;
        rowGroupBytes?: number | null;
    } | null;
}
export declare const PatchStreamResponse: Schema.Schema<PatchStreamResponse>;
export type PatchStreamError = DefaultErrors | StreamNotFound;
export declare const patchStream: API.OperationMethod<PatchStreamRequest, PatchStreamResponse, PatchStreamError, Credentials | HttpClient.HttpClient>;
export interface DeleteStreamRequest {
    streamId: string;
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Query param: Delete stream forcefully, including deleting any dependent pipelines. */
    force?: string;
}
export declare const DeleteStreamRequest: Schema.Schema<DeleteStreamRequest>;
export type DeleteStreamResponse = unknown;
export declare const DeleteStreamResponse: Schema.Schema<DeleteStreamResponse>;
export type DeleteStreamError = DefaultErrors | PipelineNotExists;
export declare const deleteStream: API.OperationMethod<DeleteStreamRequest, DeleteStreamResponse, DeleteStreamError, Credentials | HttpClient.HttpClient>;
export interface GetV1PipelineRequest {
    pipelineId: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const GetV1PipelineRequest: Schema.Schema<GetV1PipelineRequest>;
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: {
        id: string;
        latest: number;
        name: string;
        type: "stream" | "sink";
        version: number;
    }[];
}
export declare const GetV1PipelineResponse: Schema.Schema<GetV1PipelineResponse>;
export type GetV1PipelineError = DefaultErrors | PipelineNotExists;
export declare const getV1Pipeline: API.OperationMethod<GetV1PipelineRequest, GetV1PipelineResponse, GetV1PipelineError, Credentials | HttpClient.HttpClient>;
export interface ListV1PipelineRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListV1PipelineRequest: Schema.Schema<ListV1PipelineRequest>;
export interface ListV1PipelineResponse {
    result: {
        id: string;
        createdAt: string;
        modifiedAt: string;
        name: string;
        sql: string;
        status: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListV1PipelineResponse: Schema.Schema<ListV1PipelineResponse>;
export type ListV1PipelineError = DefaultErrors;
export declare const listV1Pipeline: API.PaginatedOperationMethod<ListV1PipelineRequest, ListV1PipelineResponse, ListV1PipelineError, Credentials | HttpClient.HttpClient>;
export interface CreateV1PipelineRequest {
    /** Path param: Specifies the public ID of the account. */
    accountId: string;
    /** Body param: Specifies the name of the Pipeline. */
    name: string;
    /** Body param: Specifies SQL for the Pipeline processing flow. */
    sql: string;
}
export declare const CreateV1PipelineRequest: Schema.Schema<CreateV1PipelineRequest>;
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 declare const CreateV1PipelineResponse: Schema.Schema<CreateV1PipelineResponse>;
export type CreateV1PipelineError = DefaultErrors | TableNotFound | InvalidSql | PipelineAlreadyExists;
export declare const createV1Pipeline: API.OperationMethod<CreateV1PipelineRequest, CreateV1PipelineResponse, CreateV1PipelineError, Credentials | HttpClient.HttpClient>;
export interface DeleteV1PipelineRequest {
    pipelineId: string;
    /** Specifies the public ID of the account. */
    accountId: string;
}
export declare const DeleteV1PipelineRequest: Schema.Schema<DeleteV1PipelineRequest>;
export type DeleteV1PipelineResponse = unknown;
export declare const DeleteV1PipelineResponse: Schema.Schema<DeleteV1PipelineResponse>;
export type DeleteV1PipelineError = DefaultErrors | PipelineNotExists;
export declare const deleteV1Pipeline: API.OperationMethod<DeleteV1PipelineRequest, DeleteV1PipelineResponse, DeleteV1PipelineError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=pipelines.d.ts.map