import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type Arn = string;
export type TagKey = string;
export type TagValue = string;
export type DbClusterName = string;
export type Username = string | redacted.Redacted<string>;
export type Password = string | redacted.Redacted<string>;
export type Organization = string;
export type Bucket = string;
export type Port = number;
export type DbParameterGroupIdentifier = string;
export type AllocatedStorage = number;
export type VpcSubnetId = string;
export type VpcSecurityGroupId = string;
export type IanaTimezone = string;
export type MaintenanceWindow = string;
export type DbClusterId = string;
export type NextToken = string;
export type MaxResults = number;
export type DbInstanceId = string;
export type DbInstanceName = string;
export type DbInstanceIdentifier = string;
export type DbParameterGroupName = string;
export type DbParameterGroupId = string;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type ResponseTagMap = {
    [key: string]: string | undefined;
};
export declare const ResponseTagMap: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type RequestTagMap = {
    [key: string]: string | undefined;
};
export declare const RequestTagMap: S.$Record<S.String, S.optional<S.String>>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export type DbInstanceType = "db.influx.medium" | "db.influx.large" | "db.influx.xlarge" | "db.influx.2xlarge" | "db.influx.4xlarge" | "db.influx.8xlarge" | "db.influx.12xlarge" | "db.influx.16xlarge" | "db.influx.24xlarge" | (string & {});
export declare const DbInstanceType: S.String;
export type DbStorageType = "InfluxIOIncludedT1" | "InfluxIOIncludedT2" | "InfluxIOIncludedT3" | (string & {});
export declare const DbStorageType: S.String;
export type NetworkType = "IPV4" | "DUAL" | (string & {});
export declare const NetworkType: S.String;
export type VpcSubnetIdList = string[];
export declare const VpcSubnetIdList: S.$Array<S.String>;
export type VpcSecurityGroupIdList = string[];
export declare const VpcSecurityGroupIdList: S.$Array<S.String>;
export type ClusterDeploymentType = "MULTI_NODE_READ_REPLICAS" | (string & {});
export declare const ClusterDeploymentType: S.String;
export type FailoverMode = "AUTOMATIC" | "NO_FAILOVER" | (string & {});
export declare const FailoverMode: S.String;
export interface S3Configuration {
    bucketName: string;
    enabled: boolean;
}
export declare const S3Configuration: S.Schema<S3Configuration>;
export interface LogDeliveryConfiguration {
    s3Configuration: S3Configuration;
}
export declare const LogDeliveryConfiguration: S.Schema<LogDeliveryConfiguration>;
export interface MaintenanceSchedule {
    timezone: string;
    preferredMaintenanceWindow: string;
}
export declare const MaintenanceSchedule: S.Schema<MaintenanceSchedule>;
export interface CreateDbClusterInput {
    name: string;
    username?: string | redacted.Redacted<string>;
    password?: string | redacted.Redacted<string>;
    organization?: string;
    bucket?: string;
    port?: number;
    dbParameterGroupIdentifier?: string;
    dbInstanceType: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    networkType?: NetworkType;
    publiclyAccessible?: boolean;
    vpcSubnetIds: string[];
    vpcSecurityGroupIds: string[];
    deploymentType?: ClusterDeploymentType;
    failoverMode?: FailoverMode;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    maintenanceSchedule?: MaintenanceSchedule;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateDbClusterInput: S.Schema<CreateDbClusterInput>;
export type ClusterStatus = "CREATING" | "UPDATING" | "DELETING" | "AVAILABLE" | "FAILED" | "DELETED" | "MAINTENANCE" | "UPDATING_INSTANCE_TYPE" | "REBOOTING" | "REBOOT_FAILED" | "PARTIALLY_AVAILABLE" | (string & {});
export declare const ClusterStatus: S.String;
export interface CreateDbClusterOutput {
    dbClusterId?: string;
    dbClusterStatus?: ClusterStatus;
}
export declare const CreateDbClusterOutput: S.Schema<CreateDbClusterOutput>;
export type ValidationExceptionReason = "FIELD_VALIDATION_FAILED" | "OTHER" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface GetDbClusterInput {
    dbClusterId: string;
}
export declare const GetDbClusterInput: S.Schema<GetDbClusterInput>;
export type EngineType = "INFLUXDB_V2" | "INFLUXDB_V3_CORE" | "INFLUXDB_V3_ENTERPRISE" | (string & {});
export declare const EngineType: S.String;
export interface ClusterConfiguration {
    ingestQueryInstances?: number;
    queryOnlyInstances?: number;
    dedicatedCompactor?: boolean;
}
export declare const ClusterConfiguration: S.Schema<ClusterConfiguration>;
export interface GetDbClusterOutput {
    id: string;
    name: string;
    arn: string;
    status?: ClusterStatus;
    endpoint?: string;
    readerEndpoint?: string;
    port?: number;
    deploymentType?: ClusterDeploymentType;
    dbInstanceType?: DbInstanceType;
    networkType?: NetworkType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    engineType?: EngineType;
    publiclyAccessible?: boolean;
    dbParameterGroupIdentifier?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
    influxAuthParametersSecretArn?: string;
    vpcSubnetIds?: string[];
    vpcSecurityGroupIds?: string[];
    failoverMode?: FailoverMode;
    clusterConfiguration?: ClusterConfiguration;
}
export declare const GetDbClusterOutput: S.Schema<GetDbClusterOutput>;
export interface UpdateDbClusterInput {
    dbClusterId: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    dbParameterGroupIdentifier?: string;
    port?: number;
    dbInstanceType?: DbInstanceType;
    failoverMode?: FailoverMode;
    maintenanceSchedule?: MaintenanceSchedule;
}
export declare const UpdateDbClusterInput: S.Schema<UpdateDbClusterInput>;
export interface UpdateDbClusterOutput {
    dbClusterStatus?: ClusterStatus;
}
export declare const UpdateDbClusterOutput: S.Schema<UpdateDbClusterOutput>;
export interface DeleteDbClusterInput {
    dbClusterId: string;
}
export declare const DeleteDbClusterInput: S.Schema<DeleteDbClusterInput>;
export interface DeleteDbClusterOutput {
    dbClusterStatus?: ClusterStatus;
}
export declare const DeleteDbClusterOutput: S.Schema<DeleteDbClusterOutput>;
export interface ListDbClustersInput {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListDbClustersInput: S.Schema<ListDbClustersInput>;
export interface DbClusterSummary {
    id: string;
    name: string;
    arn: string;
    status?: ClusterStatus;
    endpoint?: string;
    readerEndpoint?: string;
    port?: number;
    deploymentType?: ClusterDeploymentType;
    dbInstanceType?: DbInstanceType;
    networkType?: NetworkType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    engineType?: EngineType;
}
export declare const DbClusterSummary: S.Schema<DbClusterSummary>;
export type DbClusterSummaryList = DbClusterSummary[];
export declare const DbClusterSummaryList: S.$Array<S.Schema<DbClusterSummary>>;
export interface ListDbClustersOutput {
    items: DbClusterSummary[];
    nextToken?: string;
}
export declare const ListDbClustersOutput: S.Schema<ListDbClustersOutput>;
export interface ListDbInstancesForClusterInput {
    dbClusterId: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListDbInstancesForClusterInput: S.Schema<ListDbInstancesForClusterInput>;
export type Status = "CREATING" | "AVAILABLE" | "DELETING" | "MODIFYING" | "UPDATING" | "DELETED" | "FAILED" | "UPDATING_DEPLOYMENT_TYPE" | "UPDATING_INSTANCE_TYPE" | "MAINTENANCE" | "REBOOTING" | "REBOOT_FAILED" | (string & {});
export declare const Status: S.String;
export type DeploymentType = "SINGLE_AZ" | "WITH_MULTIAZ_STANDBY" | (string & {});
export declare const DeploymentType: S.String;
export type InstanceMode = "PRIMARY" | "STANDBY" | "REPLICA" | "INGEST" | "QUERY" | "COMPACT" | "PROCESS" | (string & {});
export declare const InstanceMode: S.String;
export type InstanceModeList = InstanceMode[];
export declare const InstanceModeList: S.$Array<S.String>;
export interface DbInstanceForClusterSummary {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
}
export declare const DbInstanceForClusterSummary: S.Schema<DbInstanceForClusterSummary>;
export type DbInstanceForClusterSummaryList = DbInstanceForClusterSummary[];
export declare const DbInstanceForClusterSummaryList: S.$Array<S.Schema<DbInstanceForClusterSummary>>;
export interface ListDbInstancesForClusterOutput {
    items: DbInstanceForClusterSummary[];
    nextToken?: string;
}
export declare const ListDbInstancesForClusterOutput: S.Schema<ListDbInstancesForClusterOutput>;
export type DbInstanceIdList = string[];
export declare const DbInstanceIdList: S.$Array<S.String>;
export interface RebootDbClusterInput {
    dbClusterId: string;
    instanceIds?: string[];
}
export declare const RebootDbClusterInput: S.Schema<RebootDbClusterInput>;
export interface RebootDbClusterOutput {
    dbClusterStatus?: ClusterStatus;
}
export declare const RebootDbClusterOutput: S.Schema<RebootDbClusterOutput>;
export interface CreateDbInstanceInput {
    name: string;
    username?: string | redacted.Redacted<string>;
    password: string | redacted.Redacted<string>;
    organization?: string;
    bucket?: string;
    dbInstanceType: DbInstanceType;
    vpcSubnetIds: string[];
    vpcSecurityGroupIds: string[];
    publiclyAccessible?: boolean;
    dbStorageType?: DbStorageType;
    allocatedStorage: number;
    dbParameterGroupIdentifier?: string;
    deploymentType?: DeploymentType;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    maintenanceSchedule?: MaintenanceSchedule;
    tags?: {
        [key: string]: string | undefined;
    };
    port?: number;
    networkType?: NetworkType;
}
export declare const CreateDbInstanceInput: S.Schema<CreateDbInstanceInput>;
export interface CreateDbInstanceOutput {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    vpcSubnetIds: string[];
    publiclyAccessible?: boolean;
    vpcSecurityGroupIds?: string[];
    dbParameterGroupIdentifier?: string;
    availabilityZone?: string;
    secondaryAvailabilityZone?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    influxAuthParametersSecretArn?: string;
    dbClusterId?: string;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
}
export declare const CreateDbInstanceOutput: S.Schema<CreateDbInstanceOutput>;
export interface GetDbInstanceInput {
    identifier: string;
}
export declare const GetDbInstanceInput: S.Schema<GetDbInstanceInput>;
export interface GetDbInstanceOutput {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    vpcSubnetIds: string[];
    publiclyAccessible?: boolean;
    vpcSecurityGroupIds?: string[];
    dbParameterGroupIdentifier?: string;
    availabilityZone?: string;
    secondaryAvailabilityZone?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    influxAuthParametersSecretArn?: string;
    dbClusterId?: string;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
}
export declare const GetDbInstanceOutput: S.Schema<GetDbInstanceOutput>;
export interface UpdateDbInstanceInput {
    identifier: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    dbParameterGroupIdentifier?: string;
    port?: number;
    dbInstanceType?: DbInstanceType;
    deploymentType?: DeploymentType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    maintenanceSchedule?: MaintenanceSchedule;
}
export declare const UpdateDbInstanceInput: S.Schema<UpdateDbInstanceInput>;
export interface UpdateDbInstanceOutput {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    vpcSubnetIds: string[];
    publiclyAccessible?: boolean;
    vpcSecurityGroupIds?: string[];
    dbParameterGroupIdentifier?: string;
    availabilityZone?: string;
    secondaryAvailabilityZone?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    influxAuthParametersSecretArn?: string;
    dbClusterId?: string;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
}
export declare const UpdateDbInstanceOutput: S.Schema<UpdateDbInstanceOutput>;
export interface DeleteDbInstanceInput {
    identifier: string;
}
export declare const DeleteDbInstanceInput: S.Schema<DeleteDbInstanceInput>;
export interface DeleteDbInstanceOutput {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    vpcSubnetIds: string[];
    publiclyAccessible?: boolean;
    vpcSecurityGroupIds?: string[];
    dbParameterGroupIdentifier?: string;
    availabilityZone?: string;
    secondaryAvailabilityZone?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    influxAuthParametersSecretArn?: string;
    dbClusterId?: string;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
}
export declare const DeleteDbInstanceOutput: S.Schema<DeleteDbInstanceOutput>;
export interface ListDbInstancesInput {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListDbInstancesInput: S.Schema<ListDbInstancesInput>;
export interface DbInstanceSummary {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
}
export declare const DbInstanceSummary: S.Schema<DbInstanceSummary>;
export type DbInstanceSummaryList = DbInstanceSummary[];
export declare const DbInstanceSummaryList: S.$Array<S.Schema<DbInstanceSummary>>;
export interface ListDbInstancesOutput {
    items: DbInstanceSummary[];
    nextToken?: string;
}
export declare const ListDbInstancesOutput: S.Schema<ListDbInstancesOutput>;
export interface RebootDbInstanceInput {
    identifier: string;
}
export declare const RebootDbInstanceInput: S.Schema<RebootDbInstanceInput>;
export interface RebootDbInstanceOutput {
    id: string;
    name: string;
    arn: string;
    status?: Status;
    endpoint?: string;
    port?: number;
    networkType?: NetworkType;
    dbInstanceType?: DbInstanceType;
    dbStorageType?: DbStorageType;
    allocatedStorage?: number;
    deploymentType?: DeploymentType;
    vpcSubnetIds: string[];
    publiclyAccessible?: boolean;
    vpcSecurityGroupIds?: string[];
    dbParameterGroupIdentifier?: string;
    availabilityZone?: string;
    secondaryAvailabilityZone?: string;
    logDeliveryConfiguration?: LogDeliveryConfiguration;
    influxAuthParametersSecretArn?: string;
    dbClusterId?: string;
    instanceMode?: InstanceMode;
    instanceModes?: InstanceMode[];
    maintenanceSchedule?: MaintenanceSchedule;
    lastMaintenanceTime?: Date;
    nextMaintenanceTime?: Date;
}
export declare const RebootDbInstanceOutput: S.Schema<RebootDbInstanceOutput>;
export type LogLevel = "debug" | "info" | "error" | (string & {});
export declare const LogLevel: S.String;
export type TracingType = "log" | "jaeger" | "disabled" | (string & {});
export declare const TracingType: S.String;
export type DurationType = "hours" | "minutes" | "seconds" | "milliseconds" | "days" | (string & {});
export declare const DurationType: S.String;
export interface Duration {
    durationType: DurationType;
    value: number;
}
export declare const Duration: S.Schema<Duration>;
export interface InfluxDBv2Parameters {
    fluxLogEnabled?: boolean;
    logLevel?: LogLevel;
    noTasks?: boolean;
    queryConcurrency?: number;
    queryQueueSize?: number;
    tracingType?: TracingType;
    metricsDisabled?: boolean;
    httpIdleTimeout?: Duration;
    httpReadHeaderTimeout?: Duration;
    httpReadTimeout?: Duration;
    httpWriteTimeout?: Duration;
    influxqlMaxSelectBuckets?: number;
    influxqlMaxSelectPoint?: number;
    influxqlMaxSelectSeries?: number;
    pprofDisabled?: boolean;
    queryInitialMemoryBytes?: number;
    queryMaxMemoryBytes?: number;
    queryMemoryBytes?: number;
    sessionLength?: number;
    sessionRenewDisabled?: boolean;
    storageCacheMaxMemorySize?: number;
    storageCacheSnapshotMemorySize?: number;
    storageCacheSnapshotWriteColdDuration?: Duration;
    storageCompactFullWriteColdDuration?: Duration;
    storageCompactThroughputBurst?: number;
    storageMaxConcurrentCompactions?: number;
    storageMaxIndexLogFileSize?: number;
    storageNoValidateFieldSize?: boolean;
    storageRetentionCheckInterval?: Duration;
    storageSeriesFileMaxConcurrentSnapshotCompactions?: number;
    storageSeriesIdSetCacheSize?: number;
    storageWalMaxConcurrentWrites?: number;
    storageWalMaxWriteDelay?: Duration;
    uiDisabled?: boolean;
}
export declare const InfluxDBv2Parameters: S.Schema<InfluxDBv2Parameters>;
export type LogFormats = "full" | (string & {});
export declare const LogFormats: S.String;
export type DataFusionRuntimeType = "multi-thread" | "multi-thread-alt" | (string & {});
export declare const DataFusionRuntimeType: S.String;
export type PercentOrAbsoluteLong = {
    percent: string;
    absolute?: never;
} | {
    percent?: never;
    absolute: number;
};
export declare const PercentOrAbsoluteLong: S.Union<readonly [S.Struct<{
    readonly percent: S.String;
}>, S.Struct<{
    readonly absolute: S.Number;
}>]>;
export interface InfluxDBv3CoreParameters {
    queryFileLimit?: number;
    queryLogSize?: number;
    logFilter?: string;
    logFormat?: LogFormats;
    dataFusionNumThreads?: number;
    dataFusionRuntimeType?: DataFusionRuntimeType;
    dataFusionRuntimeDisableLifoSlot?: boolean;
    dataFusionRuntimeEventInterval?: number;
    dataFusionRuntimeGlobalQueueInterval?: number;
    dataFusionRuntimeMaxBlockingThreads?: number;
    dataFusionRuntimeMaxIoEventsPerTick?: number;
    dataFusionRuntimeThreadKeepAlive?: Duration;
    dataFusionRuntimeThreadPriority?: number;
    dataFusionMaxParquetFanout?: number;
    dataFusionUseCachedParquetLoader?: boolean;
    dataFusionConfig?: string;
    maxHttpRequestSize?: number;
    forceSnapshotMemThreshold?: PercentOrAbsoluteLong;
    walSnapshotSize?: number;
    walMaxWriteBufferSize?: number;
    snapshottedWalFilesToKeep?: number;
    preemptiveCacheAge?: Duration;
    parquetMemCachePrunePercentage?: number;
    parquetMemCachePruneInterval?: Duration;
    disableParquetMemCache?: boolean;
    parquetMemCacheQueryPathDuration?: Duration;
    lastCacheEvictionInterval?: Duration;
    distinctCacheEvictionInterval?: Duration;
    gen1Duration?: Duration;
    execMemPoolBytes?: PercentOrAbsoluteLong;
    parquetMemCacheSize?: PercentOrAbsoluteLong;
    walReplayFailOnError?: boolean;
    walReplayConcurrencyLimit?: number;
    tableIndexCacheMaxEntries?: number;
    tableIndexCacheConcurrencyLimit?: number;
    gen1LookbackDuration?: Duration;
    retentionCheckInterval?: Duration;
    deleteGracePeriod?: Duration;
    hardDeleteDefaultDuration?: Duration;
}
export declare const InfluxDBv3CoreParameters: S.Schema<InfluxDBv3CoreParameters>;
export interface InfluxDBv3EnterpriseParameters {
    queryFileLimit?: number;
    queryLogSize?: number;
    logFilter?: string;
    logFormat?: LogFormats;
    dataFusionNumThreads?: number;
    dataFusionRuntimeType?: DataFusionRuntimeType;
    dataFusionRuntimeDisableLifoSlot?: boolean;
    dataFusionRuntimeEventInterval?: number;
    dataFusionRuntimeGlobalQueueInterval?: number;
    dataFusionRuntimeMaxBlockingThreads?: number;
    dataFusionRuntimeMaxIoEventsPerTick?: number;
    dataFusionRuntimeThreadKeepAlive?: Duration;
    dataFusionRuntimeThreadPriority?: number;
    dataFusionMaxParquetFanout?: number;
    dataFusionUseCachedParquetLoader?: boolean;
    dataFusionConfig?: string;
    maxHttpRequestSize?: number;
    forceSnapshotMemThreshold?: PercentOrAbsoluteLong;
    walSnapshotSize?: number;
    walMaxWriteBufferSize?: number;
    snapshottedWalFilesToKeep?: number;
    preemptiveCacheAge?: Duration;
    parquetMemCachePrunePercentage?: number;
    parquetMemCachePruneInterval?: Duration;
    disableParquetMemCache?: boolean;
    parquetMemCacheQueryPathDuration?: Duration;
    lastCacheEvictionInterval?: Duration;
    distinctCacheEvictionInterval?: Duration;
    gen1Duration?: Duration;
    execMemPoolBytes?: PercentOrAbsoluteLong;
    parquetMemCacheSize?: PercentOrAbsoluteLong;
    walReplayFailOnError?: boolean;
    walReplayConcurrencyLimit?: number;
    tableIndexCacheMaxEntries?: number;
    tableIndexCacheConcurrencyLimit?: number;
    gen1LookbackDuration?: Duration;
    retentionCheckInterval?: Duration;
    deleteGracePeriod?: Duration;
    hardDeleteDefaultDuration?: Duration;
    ingestQueryInstances: number;
    queryOnlyInstances: number;
    dedicatedCompactor: boolean;
    compactionRowLimit?: number;
    compactionMaxNumFilesPerPlan?: number;
    compactionGen2Duration?: Duration;
    compactionMultipliers?: string;
    compactionCleanupWait?: Duration;
    compactionCheckInterval?: Duration;
    lastValueCacheDisableFromHistory?: boolean;
    distinctValueCacheDisableFromHistory?: boolean;
    replicationInterval?: Duration;
    catalogSyncInterval?: Duration;
}
export declare const InfluxDBv3EnterpriseParameters: S.Schema<InfluxDBv3EnterpriseParameters>;
export type Parameters = {
    InfluxDBv2: InfluxDBv2Parameters;
    InfluxDBv3Core?: never;
    InfluxDBv3Enterprise?: never;
} | {
    InfluxDBv2?: never;
    InfluxDBv3Core: InfluxDBv3CoreParameters;
    InfluxDBv3Enterprise?: never;
} | {
    InfluxDBv2?: never;
    InfluxDBv3Core?: never;
    InfluxDBv3Enterprise: InfluxDBv3EnterpriseParameters;
};
export declare const Parameters: S.Union<readonly [S.Struct<{
    readonly InfluxDBv2: S.Schema<InfluxDBv2Parameters>;
}>, S.Struct<{
    readonly InfluxDBv3Core: S.Schema<InfluxDBv3CoreParameters>;
}>, S.Struct<{
    readonly InfluxDBv3Enterprise: S.Schema<InfluxDBv3EnterpriseParameters>;
}>]>;
export interface CreateDbParameterGroupInput {
    name: string;
    description?: string;
    parameters?: Parameters;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateDbParameterGroupInput: S.Schema<CreateDbParameterGroupInput>;
export interface CreateDbParameterGroupOutput {
    id: string;
    name: string;
    arn: string;
    description?: string;
    parameters?: Parameters;
}
export declare const CreateDbParameterGroupOutput: S.Schema<CreateDbParameterGroupOutput>;
export interface GetDbParameterGroupInput {
    identifier: string;
}
export declare const GetDbParameterGroupInput: S.Schema<GetDbParameterGroupInput>;
export interface GetDbParameterGroupOutput {
    id: string;
    name: string;
    arn: string;
    description?: string;
    parameters?: Parameters;
}
export declare const GetDbParameterGroupOutput: S.Schema<GetDbParameterGroupOutput>;
export interface ListDbParameterGroupsInput {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListDbParameterGroupsInput: S.Schema<ListDbParameterGroupsInput>;
export interface DbParameterGroupSummary {
    id: string;
    name: string;
    arn: string;
    description?: string;
}
export declare const DbParameterGroupSummary: S.Schema<DbParameterGroupSummary>;
export type DbParameterGroupSummaryList = DbParameterGroupSummary[];
export declare const DbParameterGroupSummaryList: S.$Array<S.Schema<DbParameterGroupSummary>>;
export interface ListDbParameterGroupsOutput {
    items: DbParameterGroupSummary[];
    nextToken?: string;
}
export declare const ListDbParameterGroupsOutput: S.Schema<ListDbParameterGroupsOutput>;
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
export type ListTagsForResourceError = ResourceNotFoundException | CommonErrors;
/**
 * A list of tags applied to the resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * Tags are composed of a Key/Value pairs. You can use tags to categorize and track your Timestream for InfluxDB resources.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = ResourceNotFoundException | CommonErrors;
/**
 * Removes the tag from the specified resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDbClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new Timestream for InfluxDB cluster.
 */
export declare const createDbCluster: API.OperationMethod<CreateDbClusterInput, CreateDbClusterOutput, CreateDbClusterError, Credentials | Region | HttpClient.HttpClient>;
export type GetDbClusterError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves information about a Timestream for InfluxDB cluster.
 */
export declare const getDbCluster: API.OperationMethod<GetDbClusterInput, GetDbClusterOutput, GetDbClusterError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDbClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates a Timestream for InfluxDB cluster.
 */
export declare const updateDbCluster: API.OperationMethod<UpdateDbClusterInput, UpdateDbClusterOutput, UpdateDbClusterError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDbClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a Timestream for InfluxDB cluster.
 */
export declare const deleteDbCluster: API.OperationMethod<DeleteDbClusterInput, DeleteDbClusterOutput, DeleteDbClusterError, Credentials | Region | HttpClient.HttpClient>;
export type ListDbClustersError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of Timestream for InfluxDB DB clusters.
 */
export declare const listDbClusters: API.OperationMethod<ListDbClustersInput, ListDbClustersOutput, ListDbClustersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDbClustersInput) => stream.Stream<ListDbClustersOutput, ListDbClustersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDbClustersInput) => stream.Stream<DbClusterSummary, ListDbClustersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListDbInstancesForClusterError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of Timestream for InfluxDB clusters.
 */
export declare const listDbInstancesForCluster: API.OperationMethod<ListDbInstancesForClusterInput, ListDbInstancesForClusterOutput, ListDbInstancesForClusterError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDbInstancesForClusterInput) => stream.Stream<ListDbInstancesForClusterOutput, ListDbInstancesForClusterError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDbInstancesForClusterInput) => stream.Stream<DbInstanceForClusterSummary, ListDbInstancesForClusterError, Credentials | Region | HttpClient.HttpClient>;
};
export type RebootDbClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Reboots a Timestream for InfluxDB cluster.
 */
export declare const rebootDbCluster: API.OperationMethod<RebootDbClusterInput, RebootDbClusterOutput, RebootDbClusterError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDbInstanceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new Timestream for InfluxDB DB instance.
 */
export declare const createDbInstance: API.OperationMethod<CreateDbInstanceInput, CreateDbInstanceOutput, CreateDbInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type GetDbInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a Timestream for InfluxDB DB instance.
 */
export declare const getDbInstance: API.OperationMethod<GetDbInstanceInput, GetDbInstanceOutput, GetDbInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDbInstanceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates a Timestream for InfluxDB DB instance.
 */
export declare const updateDbInstance: API.OperationMethod<UpdateDbInstanceInput, UpdateDbInstanceOutput, UpdateDbInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDbInstanceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a Timestream for InfluxDB DB instance.
 */
export declare const deleteDbInstance: API.OperationMethod<DeleteDbInstanceInput, DeleteDbInstanceOutput, DeleteDbInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type ListDbInstancesError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of Timestream for InfluxDB DB instances.
 */
export declare const listDbInstances: API.OperationMethod<ListDbInstancesInput, ListDbInstancesOutput, ListDbInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDbInstancesInput) => stream.Stream<ListDbInstancesOutput, ListDbInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDbInstancesInput) => stream.Stream<DbInstanceSummary, ListDbInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type RebootDbInstanceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Reboots a Timestream for InfluxDB instance.
 */
export declare const rebootDbInstance: API.OperationMethod<RebootDbInstanceInput, RebootDbInstanceOutput, RebootDbInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDbParameterGroupError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new Timestream for InfluxDB DB parameter group to associate with DB instances.
 */
export declare const createDbParameterGroup: API.OperationMethod<CreateDbParameterGroupInput, CreateDbParameterGroupOutput, CreateDbParameterGroupError, Credentials | Region | HttpClient.HttpClient>;
export type GetDbParameterGroupError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a Timestream for InfluxDB DB parameter group.
 */
export declare const getDbParameterGroup: API.OperationMethod<GetDbParameterGroupInput, GetDbParameterGroupOutput, GetDbParameterGroupError, Credentials | Region | HttpClient.HttpClient>;
export type ListDbParameterGroupsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of Timestream for InfluxDB DB parameter groups.
 */
export declare const listDbParameterGroups: API.OperationMethod<ListDbParameterGroupsInput, ListDbParameterGroupsOutput, ListDbParameterGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDbParameterGroupsInput) => stream.Stream<ListDbParameterGroupsOutput, ListDbParameterGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDbParameterGroupsInput) => stream.Stream<DbParameterGroupSummary, ListDbParameterGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=timestream-influxdb.d.ts.map