/**
 * Cloudflare R2-DATA-CATALOG API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service r2-data-catalog
 */
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 InvalidCredential_base: Schema.Class<InvalidCredential, Schema.TaggedStruct<"InvalidCredential", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidCredential extends InvalidCredential_base {
}
declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidRoute extends InvalidRoute_base {
}
declare const NoSuchBucket_base: Schema.Class<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoSuchBucket extends NoSuchBucket_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 {
}
declare const WarehouseInactive_base: Schema.Class<WarehouseInactive, Schema.TaggedStruct<"WarehouseInactive", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class WarehouseInactive extends WarehouseInactive_base {
}
declare const WarehouseNotFound_base: Schema.Class<WarehouseNotFound, Schema.TaggedStruct<"WarehouseNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class WarehouseNotFound extends WarehouseNotFound_base {
}
export interface CreateCredentialRequest {
    bucketName: string;
    /** Path param: Use this to identify the account. */
    accountId: string;
    /** Body param: Provides the Cloudflare API token for accessing R2. */
    token: string;
}
export declare const CreateCredentialRequest: Schema.Schema<CreateCredentialRequest>;
export type CreateCredentialResponse = unknown;
export declare const CreateCredentialResponse: Schema.Schema<CreateCredentialResponse>;
export type CreateCredentialError = DefaultErrors | InvalidRoute | InvalidCredential;
export declare const createCredential: API.OperationMethod<CreateCredentialRequest, CreateCredentialResponse, CreateCredentialError, Credentials | HttpClient.HttpClient>;
export interface GetMaintenanceConfigRequest {
    bucketName: string;
    /** Use this to identify the account. */
    accountId: string;
}
export declare const GetMaintenanceConfigRequest: Schema.Schema<GetMaintenanceConfigRequest>;
export interface GetMaintenanceConfigResponse {
    /** Shows the credential configuration status. */
    credentialStatus: "present" | "absent";
    /** Configures maintenance for the catalog. */
    maintenanceConfig: {
        compaction?: {
            state: "enabled" | "disabled";
            targetSizeMb: "64" | "128" | "256" | "512";
        } | null;
        snapshotExpiration?: {
            maxSnapshotAge: string;
            minSnapshotsToKeep: number;
            state: "enabled" | "disabled";
        } | null;
    };
}
export declare const GetMaintenanceConfigResponse: Schema.Schema<GetMaintenanceConfigResponse>;
export type GetMaintenanceConfigError = DefaultErrors | InvalidRoute | WarehouseInactive | WarehouseNotFound;
export declare const getMaintenanceConfig: API.OperationMethod<GetMaintenanceConfigRequest, GetMaintenanceConfigResponse, GetMaintenanceConfigError, Credentials | HttpClient.HttpClient>;
export interface UpdateMaintenanceConfigRequest {
    bucketName: string;
    /** Path param: Use this to identify the account. */
    accountId: string;
    /** Body param: Updates compaction configuration (all fields optional). */
    compaction?: {
        state?: "enabled" | "disabled";
        targetSizeMb?: "64" | "128" | "256" | "512";
    };
    /** Body param: Updates snapshot expiration configuration (all fields optional). */
    snapshotExpiration?: {
        maxSnapshotAge?: string;
        minSnapshotsToKeep?: number;
        state?: "enabled" | "disabled";
    };
}
export declare const UpdateMaintenanceConfigRequest: Schema.Schema<UpdateMaintenanceConfigRequest>;
export interface UpdateMaintenanceConfigResponse {
    /** Configures compaction for catalog maintenance. */
    compaction?: {
        state: "enabled" | "disabled";
        targetSizeMb: "64" | "128" | "256" | "512";
    } | null;
    /** Configures snapshot expiration settings. */
    snapshotExpiration?: {
        maxSnapshotAge: string;
        minSnapshotsToKeep: number;
        state: "enabled" | "disabled";
    } | null;
}
export declare const UpdateMaintenanceConfigResponse: Schema.Schema<UpdateMaintenanceConfigResponse>;
export type UpdateMaintenanceConfigError = DefaultErrors | InvalidRoute | WarehouseInactive;
export declare const updateMaintenanceConfig: API.OperationMethod<UpdateMaintenanceConfigRequest, UpdateMaintenanceConfigResponse, UpdateMaintenanceConfigError, Credentials | HttpClient.HttpClient>;
export interface ListNamespacesRequest {
    bucketName: string;
    /** Path param: Use this to identify the account. */
    accountId: string;
    /** Query param: Maximum number of namespaces to return per page. Defaults to 100, maximum 1000. */
    pageSize?: number;
    /** Query param: Opaque pagination token from a previous response. Use this to fetch the next page of results. */
    pageToken?: string;
    /** Query param: Parent namespace to filter by. Only returns direct children of this namespace. For nested namespaces, use %1F as separator (e.g., "bronze%1Fanalytics"). Omit this parameter to list top-le */
    parent?: string;
    /** Query param: Whether to include additional metadata (timestamps). When true, response includes created_at and updated_at arrays. */
    returnDetails?: boolean;
    /** Query param: Whether to include namespace UUIDs in the response. Set to true to receive the namespace_uuids array. */
    returnUuids?: boolean;
}
export declare const ListNamespacesRequest: Schema.Schema<ListNamespacesRequest>;
export interface ListNamespacesResponse {
    /** Lists namespaces in the catalog. */
    namespaces: string[][];
    /** Contains detailed metadata for each namespace when return_details is true. Each object includes the namespace, UUID, and timestamps. */
    details?: {
        namespace: string[];
        namespaceUuid: string;
        createdAt?: string | null;
        updatedAt?: string | null;
    }[] | null;
    /** Contains UUIDs for each namespace when return_uuids is true. The order corresponds to the namespaces array. */
    namespaceUuids?: string[] | null;
    /** Use this opaque token to fetch the next page of results. A null or absent value indicates the last page. */
    nextPageToken?: string | null;
}
export declare const ListNamespacesResponse: Schema.Schema<ListNamespacesResponse>;
export type ListNamespacesError = DefaultErrors | InvalidRoute | WarehouseInactive | WarehouseNotFound;
export declare const listNamespaces: API.OperationMethod<ListNamespacesRequest, ListNamespacesResponse, ListNamespacesError, Credentials | HttpClient.HttpClient>;
export interface ListNamespaceTablesRequest {
    bucketName: string;
    namespace: string;
    /** Path param: Use this to identify the account. */
    accountId: string;
    /** Query param: Maximum number of tables to return per page. Defaults to 100, maximum 1000. */
    pageSize?: number;
    /** Query param: Opaque pagination token from a previous response. Use this to fetch the next page of results. */
    pageToken?: string;
    /** Query param: Whether to include additional metadata (timestamps, locations). When true, response includes created_at, updated_at, metadata_locations, and locations arrays. */
    returnDetails?: boolean;
    /** Query param: Whether to include table UUIDs in the response. Set to true to receive the table_uuids array. */
    returnUuids?: boolean;
}
export declare const ListNamespaceTablesRequest: Schema.Schema<ListNamespaceTablesRequest>;
export interface ListNamespaceTablesResponse {
    /** Lists tables in the namespace. */
    identifiers: {
        name: string;
        namespace: string[];
    }[];
    /** Contains detailed metadata for each table when return_details is true. Each object includes identifier, UUID, timestamps, and locations. */
    details?: {
        identifier: {
            name: string;
            namespace: string[];
        };
        tableUuid: string;
        createdAt?: string | null;
        location?: string | null;
        metadataLocation?: string | null;
        updatedAt?: string | null;
    }[] | null;
    /** Use this opaque token to fetch the next page of results. A null or absent value indicates the last page. */
    nextPageToken?: string | null;
    /** Contains UUIDs for each table when return_uuids is true. The order corresponds to the identifiers array. */
    tableUuids?: string[] | null;
}
export declare const ListNamespaceTablesResponse: Schema.Schema<ListNamespaceTablesResponse>;
export type ListNamespaceTablesError = DefaultErrors | InvalidRoute | WarehouseInactive;
export declare const listNamespaceTables: API.OperationMethod<ListNamespaceTablesRequest, ListNamespaceTablesResponse, ListNamespaceTablesError, Credentials | HttpClient.HttpClient>;
export interface GetNamespaceTableMaintenanceConfigRequest {
    bucketName: string;
    namespace: string;
    tableName: string;
    /** Use this to identify the account. */
    accountId: string;
}
export declare const GetNamespaceTableMaintenanceConfigRequest: Schema.Schema<GetNamespaceTableMaintenanceConfigRequest>;
export interface GetNamespaceTableMaintenanceConfigResponse {
    /** Configures maintenance for the table. */
    maintenanceConfig: {
        compaction?: {
            state: "enabled" | "disabled";
            targetSizeMb: "64" | "128" | "256" | "512";
        } | null;
        snapshotExpiration?: {
            maxSnapshotAge: string;
            minSnapshotsToKeep: number;
            state: "enabled" | "disabled";
        } | null;
    };
}
export declare const GetNamespaceTableMaintenanceConfigResponse: Schema.Schema<GetNamespaceTableMaintenanceConfigResponse>;
export type GetNamespaceTableMaintenanceConfigError = DefaultErrors | TableNotFound | InvalidRoute | WarehouseInactive;
export declare const getNamespaceTableMaintenanceConfig: API.OperationMethod<GetNamespaceTableMaintenanceConfigRequest, GetNamespaceTableMaintenanceConfigResponse, GetNamespaceTableMaintenanceConfigError, Credentials | HttpClient.HttpClient>;
export interface UpdateNamespaceTableMaintenanceConfigRequest {
    bucketName: string;
    namespace: string;
    tableName: string;
    /** Path param: Use this to identify the account. */
    accountId: string;
    /** Body param: Updates compaction configuration (all fields optional). */
    compaction?: {
        state?: "enabled" | "disabled";
        targetSizeMb?: "64" | "128" | "256" | "512";
    };
    /** Body param: Updates snapshot expiration configuration (all fields optional). */
    snapshotExpiration?: {
        maxSnapshotAge?: string;
        minSnapshotsToKeep?: number;
        state?: "enabled" | "disabled";
    };
}
export declare const UpdateNamespaceTableMaintenanceConfigRequest: Schema.Schema<UpdateNamespaceTableMaintenanceConfigRequest>;
export interface UpdateNamespaceTableMaintenanceConfigResponse {
    /** Configures compaction settings for table optimization. */
    compaction?: {
        state: "enabled" | "disabled";
        targetSizeMb: "64" | "128" | "256" | "512";
    } | null;
    /** Configures snapshot expiration settings. */
    snapshotExpiration?: {
        maxSnapshotAge: string;
        minSnapshotsToKeep: number;
        state: "enabled" | "disabled";
    } | null;
}
export declare const UpdateNamespaceTableMaintenanceConfigResponse: Schema.Schema<UpdateNamespaceTableMaintenanceConfigResponse>;
export type UpdateNamespaceTableMaintenanceConfigError = DefaultErrors | TableNotFound | InvalidRoute | WarehouseInactive;
export declare const updateNamespaceTableMaintenanceConfig: API.OperationMethod<UpdateNamespaceTableMaintenanceConfigRequest, UpdateNamespaceTableMaintenanceConfigResponse, UpdateNamespaceTableMaintenanceConfigError, Credentials | HttpClient.HttpClient>;
export interface GetR2DataCatalogRequest {
    bucketName: string;
    /** Use this to identify the account. */
    accountId: string;
}
export declare const GetR2DataCatalogRequest: Schema.Schema<GetR2DataCatalogRequest>;
export interface GetR2DataCatalogResponse {
    /** Use this to uniquely identify the catalog. */
    id: string;
    /** Specifies the associated R2 bucket name. */
    bucket: string;
    /** Specifies the catalog name (generated from account and bucket name). */
    name: string;
    /** Indicates the status of the catalog. */
    status: "active" | "inactive";
    /** Shows the credential configuration status. */
    credentialStatus?: "present" | "absent" | null;
    /** Configures maintenance for the catalog. */
    maintenanceConfig?: {
        compaction?: {
            state: "enabled" | "disabled";
            targetSizeMb: "64" | "128" | "256" | "512";
        } | null;
        snapshotExpiration?: {
            maxSnapshotAge: string;
            minSnapshotsToKeep: number;
            state: "enabled" | "disabled";
        } | null;
    } | null;
}
export declare const GetR2DataCatalogResponse: Schema.Schema<GetR2DataCatalogResponse>;
export type GetR2DataCatalogError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const getR2DataCatalog: API.OperationMethod<GetR2DataCatalogRequest, GetR2DataCatalogResponse, GetR2DataCatalogError, Credentials | HttpClient.HttpClient>;
export interface ListR2DataCatalogsRequest {
    /** Use this to identify the account. */
    accountId: string;
}
export declare const ListR2DataCatalogsRequest: Schema.Schema<ListR2DataCatalogsRequest>;
export interface ListR2DataCatalogsResponse {
    /** Lists catalogs in the account. */
    warehouses: {
        id: string;
        bucket: string;
        name: string;
        status: "active" | "inactive";
        credentialStatus?: "present" | "absent" | null;
        maintenanceConfig?: {
            compaction?: {
                state: "enabled" | "disabled";
                targetSizeMb: "64" | "128" | "256" | "512";
            } | null;
            snapshotExpiration?: {
                maxSnapshotAge: string;
                minSnapshotsToKeep: number;
                state: "enabled" | "disabled";
            } | null;
        } | null;
    }[];
}
export declare const ListR2DataCatalogsResponse: Schema.Schema<ListR2DataCatalogsResponse>;
export type ListR2DataCatalogsError = DefaultErrors | InvalidRoute;
export declare const listR2DataCatalogs: API.OperationMethod<ListR2DataCatalogsRequest, ListR2DataCatalogsResponse, ListR2DataCatalogsError, Credentials | HttpClient.HttpClient>;
export interface EnableR2DataCatalogRequest {
    bucketName: string;
    /** Use this to identify the account. */
    accountId: string;
}
export declare const EnableR2DataCatalogRequest: Schema.Schema<EnableR2DataCatalogRequest>;
export interface EnableR2DataCatalogResponse {
    /** Use this to uniquely identify the activated catalog. */
    id?: string | null;
    /** Specifies the name of the activated catalog. */
    name: string;
}
export declare const EnableR2DataCatalogResponse: Schema.Schema<EnableR2DataCatalogResponse>;
export type EnableR2DataCatalogError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const enableR2DataCatalog: API.OperationMethod<EnableR2DataCatalogRequest, EnableR2DataCatalogResponse, EnableR2DataCatalogError, Credentials | HttpClient.HttpClient>;
export interface DisableR2DataCatalogRequest {
    bucketName: string;
    /** Use this to identify the account. */
    accountId: string;
}
export declare const DisableR2DataCatalogRequest: Schema.Schema<DisableR2DataCatalogRequest>;
export type DisableR2DataCatalogResponse = unknown;
export declare const DisableR2DataCatalogResponse: Schema.Schema<DisableR2DataCatalogResponse>;
export type DisableR2DataCatalogError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const disableR2DataCatalog: API.OperationMethod<DisableR2DataCatalogRequest, DisableR2DataCatalogResponse, DisableR2DataCatalogError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=r2-data-catalog.d.ts.map