@nice2dev/ui-tools 1.0.10

package/dist/db-adapters.d.ts

@@ -0,0 +1,704 @@
+/**
+ * @file db-adapters.ts
+ * @module @nice2dev/ui-tools/db-adapters
+ * @description PRO-10.4 — Database Adapters types
+ *
+ * Adaptery do różnych silników baz danych: PostgreSQL, MySQL, SQL Server,
+ * MongoDB, Redis, Cassandra, ClickHouse, Elasticsearch, i wiele innych.
+ */
+/** Database adapter type */
+export type DbAdapterType = 'postgresql' | 'mysql' | 'mariadb' | 'mssql' | 'oracle' | 'sqlite' | 'mongodb' | 'redis' | 'cassandra' | 'clickhouse' | 'elasticsearch' | 'dynamodb' | 'cosmosdb' | 'neo4j' | 'influxdb' | 'cockroachdb' | 'timescaledb';
+/** Base adapter configuration */
+export interface DbAdapterConfig {
+    readonly type: DbAdapterType;
+    readonly name: string;
+    readonly host: string;
+    readonly port: number;
+    readonly database?: string;
+    readonly username?: string;
+    readonly password?: string;
+    readonly connectionString?: string;
+    readonly ssl?: SslOptions;
+    readonly pool?: PoolOptions;
+    readonly timeout?: TimeoutOptions;
+    readonly options?: Record<string, unknown>;
+}
+/** SSL options */
+export interface SslOptions {
+    readonly enabled: boolean;
+    readonly mode: 'disable' | 'prefer' | 'require' | 'verify-ca' | 'verify-full';
+    readonly ca?: string;
+    readonly cert?: string;
+    readonly key?: string;
+    readonly passphrase?: string;
+    readonly rejectUnauthorized?: boolean;
+}
+/** Connection pool options */
+export interface PoolOptions {
+    readonly min: number;
+    readonly max: number;
+    readonly acquireTimeout: number;
+    readonly idleTimeout: number;
+    readonly maxLifetime: number;
+    readonly reapInterval: number;
+}
+/** Timeout options */
+export interface TimeoutOptions {
+    readonly connect: number;
+    readonly query: number;
+    readonly idle: number;
+    readonly request: number;
+}
+/** Adapter capabilities */
+export interface AdapterCapabilities {
+    readonly transactions: boolean;
+    readonly savepoints: boolean;
+    readonly nestedTransactions: boolean;
+    readonly preparedStatements: boolean;
+    readonly storedProcedures: boolean;
+    readonly triggers: boolean;
+    readonly views: boolean;
+    readonly materializedViews: boolean;
+    readonly fullTextSearch: boolean;
+    readonly jsonSupport: boolean;
+    readonly arraySupport: boolean;
+    readonly spatialSupport: boolean;
+    readonly timeSeriesSupport: boolean;
+    readonly graphQueries: boolean;
+    readonly bulkOperations: boolean;
+    readonly streaming: boolean;
+    readonly changeStreams: boolean;
+    readonly explain: boolean;
+    readonly profile: boolean;
+}
+/** PostgreSQL-specific config */
+export interface PostgresConfig extends DbAdapterConfig {
+    readonly type: 'postgresql';
+    readonly schema?: string;
+    readonly applicationName?: string;
+    readonly statementTimeout?: number;
+    readonly lockTimeout?: number;
+    readonly idleInTransactionTimeout?: number;
+    readonly searchPath?: readonly string[];
+    readonly binaryMode?: boolean;
+    readonly parseInputDatesAsUTC?: boolean;
+}
+/** PostgreSQL extension */
+export interface PostgresExtension {
+    readonly name: string;
+    readonly version: string;
+    readonly schema: string;
+    readonly installed: boolean;
+    readonly available: boolean;
+    readonly comment?: string;
+}
+/** PostgreSQL tablespace */
+export interface PostgresTablespace {
+    readonly name: string;
+    readonly owner: string;
+    readonly location: string;
+    readonly size: number;
+    readonly options?: Record<string, string>;
+}
+/** MySQL-specific config */
+export interface MysqlConfig extends DbAdapterConfig {
+    readonly type: 'mysql' | 'mariadb';
+    readonly charset?: string;
+    readonly collation?: string;
+    readonly timezone?: string;
+    readonly multipleStatements?: boolean;
+    readonly namedPlaceholders?: boolean;
+    readonly bigNumberStrings?: boolean;
+    readonly supportBigNumbers?: boolean;
+    readonly dateStrings?: boolean | readonly string[];
+    readonly localInfile?: boolean;
+}
+/** MySQL storage engine */
+export interface MysqlStorageEngine {
+    readonly name: string;
+    readonly support: 'default' | 'yes' | 'no' | 'disabled';
+    readonly transactions: boolean;
+    readonly xa: boolean;
+    readonly savepoints: boolean;
+    readonly comment?: string;
+}
+/** SQL Server-specific config */
+export interface MssqlConfig extends DbAdapterConfig {
+    readonly type: 'mssql';
+    readonly instanceName?: string;
+    readonly domain?: string;
+    readonly trustServerCertificate?: boolean;
+    readonly encrypt?: boolean;
+    readonly packetSize?: number;
+    readonly useUtc?: boolean;
+    readonly abortTransactionOnError?: boolean;
+    readonly appName?: string;
+    readonly multiSubnetFailover?: boolean;
+    readonly integratedSecurity?: boolean;
+}
+/** SQL Server edition */
+export interface MssqlEditionInfo {
+    readonly edition: string;
+    readonly productLevel: string;
+    readonly productVersion: string;
+    readonly engineEdition: number;
+    readonly isClustered: boolean;
+    readonly isAlwaysOn: boolean;
+}
+/** Oracle-specific config */
+export interface OracleConfig extends DbAdapterConfig {
+    readonly type: 'oracle';
+    readonly serviceName?: string;
+    readonly sid?: string;
+    readonly tnsAdmin?: string;
+    readonly edition?: string;
+    readonly fetchArraySize?: number;
+    readonly prefetchRows?: number;
+    readonly lobPrefetchSize?: number;
+    readonly stmtCacheSize?: number;
+    readonly externalAuth?: boolean;
+}
+/** Oracle tablespace */
+export interface OracleTablespace {
+    readonly name: string;
+    readonly status: 'online' | 'offline' | 'read_only';
+    readonly contents: 'permanent' | 'temporary' | 'undo';
+    readonly bigfile: boolean;
+    readonly maxSize: number;
+    readonly usedSize: number;
+    readonly freeSize: number;
+}
+/** SQLite-specific config */
+export interface SqliteConfig extends DbAdapterConfig {
+    readonly type: 'sqlite';
+    readonly filePath: string;
+    readonly mode: 'memory' | 'file' | 'readonly';
+    readonly busyTimeout?: number;
+    readonly journalMode?: 'delete' | 'truncate' | 'persist' | 'memory' | 'wal' | 'off';
+    readonly synchronous?: 'off' | 'normal' | 'full' | 'extra';
+    readonly foreignKeys?: boolean;
+    readonly cacheSize?: number;
+    readonly pageSize?: number;
+}
+/** SQLite pragma */
+export interface SqlitePragma {
+    readonly name: string;
+    readonly value: unknown;
+    readonly description: string;
+    readonly category: 'performance' | 'safety' | 'debug' | 'schema';
+}
+/** MongoDB-specific config */
+export interface MongoConfig extends DbAdapterConfig {
+    readonly type: 'mongodb';
+    readonly replicaSet?: string;
+    readonly authSource?: string;
+    readonly authMechanism?: 'SCRAM-SHA-1' | 'SCRAM-SHA-256' | 'MONGODB-X509' | 'MONGODB-AWS';
+    readonly readPreference?: 'primary' | 'primaryPreferred' | 'secondary' | 'secondaryPreferred' | 'nearest';
+    readonly writeConcern?: MongoWriteConcern;
+    readonly readConcern?: 'local' | 'available' | 'majority' | 'linearizable' | 'snapshot';
+    readonly maxPoolSize?: number;
+    readonly retryWrites?: boolean;
+    readonly retryReads?: boolean;
+    readonly directConnection?: boolean;
+}
+/** MongoDB write concern */
+export interface MongoWriteConcern {
+    readonly w: number | 'majority';
+    readonly j?: boolean;
+    readonly wtimeout?: number;
+}
+/** MongoDB collection info */
+export interface MongoCollectionInfo {
+    readonly name: string;
+    readonly type: 'collection' | 'view' | 'timeseries';
+    readonly options: MongoCollectionOptions;
+    readonly indexes: readonly MongoIndexInfo[];
+    readonly stats: MongoCollectionStats;
+}
+/** MongoDB collection options */
+export interface MongoCollectionOptions {
+    readonly capped?: boolean;
+    readonly size?: number;
+    readonly max?: number;
+    readonly validator?: Record<string, unknown>;
+    readonly validationLevel?: 'off' | 'strict' | 'moderate';
+    readonly validationAction?: 'error' | 'warn';
+    readonly storageEngine?: Record<string, unknown>;
+    readonly timeseries?: MongoTimeseriesOptions;
+}
+/** MongoDB timeseries options */
+export interface MongoTimeseriesOptions {
+    readonly timeField: string;
+    readonly metaField?: string;
+    readonly granularity?: 'seconds' | 'minutes' | 'hours';
+}
+/** MongoDB index info */
+export interface MongoIndexInfo {
+    readonly name: string;
+    readonly key: Record<string, 1 | -1 | 'text' | '2d' | '2dsphere' | 'hashed'>;
+    readonly unique?: boolean;
+    readonly sparse?: boolean;
+    readonly background?: boolean;
+    readonly expireAfterSeconds?: number;
+    readonly partialFilterExpression?: Record<string, unknown>;
+}
+/** MongoDB collection stats */
+export interface MongoCollectionStats {
+    readonly count: number;
+    readonly size: number;
+    readonly avgObjSize: number;
+    readonly storageSize: number;
+    readonly totalIndexSize: number;
+    readonly indexSizes: Record<string, number>;
+}
+/** Redis-specific config */
+export interface RedisConfig extends DbAdapterConfig {
+    readonly type: 'redis';
+    readonly db?: number;
+    readonly keyPrefix?: string;
+    readonly cluster?: readonly RedisClusterNode[];
+    readonly sentinel?: RedisSentinelConfig;
+    readonly enableReadyCheck?: boolean;
+    readonly maxRetriesPerRequest?: number;
+    readonly enableOfflineQueue?: boolean;
+    readonly lazyConnect?: boolean;
+}
+/** Redis cluster node */
+export interface RedisClusterNode {
+    readonly host: string;
+    readonly port: number;
+}
+/** Redis sentinel config */
+export interface RedisSentinelConfig {
+    readonly sentinels: readonly RedisClusterNode[];
+    readonly name: string;
+    readonly sentinelPassword?: string;
+}
+/** Redis key info */
+export interface RedisKeyInfo {
+    readonly key: string;
+    readonly type: 'string' | 'list' | 'set' | 'zset' | 'hash' | 'stream' | 'json';
+    readonly ttl: number;
+    readonly encoding?: string;
+    readonly refcount?: number;
+    readonly idletime?: number;
+    readonly size?: number;
+}
+/** Redis info section */
+export interface RedisServerInfo {
+    readonly version: string;
+    readonly mode: 'standalone' | 'sentinel' | 'cluster';
+    readonly os: string;
+    readonly arch: string;
+    readonly process: RedisProcessInfo;
+    readonly clients: RedisClientsInfo;
+    readonly memory: RedisMemoryInfo;
+    readonly persistence: RedisPersistenceInfo;
+    readonly stats: RedisStatsInfo;
+    readonly replication: RedisReplicationInfo;
+    readonly cpu: RedisCpuInfo;
+    readonly cluster: RedisClusterInfo;
+    readonly keyspace: Record<string, RedisKeyspaceInfo>;
+}
+/** Redis process info */
+export interface RedisProcessInfo {
+    readonly pid: number;
+    readonly uptimeInSeconds: number;
+    readonly uptimeInDays: number;
+    readonly hz: number;
+    readonly configuredHz: number;
+}
+/** Redis clients info */
+export interface RedisClientsInfo {
+    readonly connectedClients: number;
+    readonly blockedClients: number;
+    readonly trackingClients: number;
+    readonly clientsInTimeoutTable: number;
+}
+/** Redis memory info */
+export interface RedisMemoryInfo {
+    readonly usedMemory: number;
+    readonly usedMemoryHuman: string;
+    readonly usedMemoryRss: number;
+    readonly usedMemoryPeak: number;
+    readonly totalSystemMemory: number;
+    readonly memoryFragmentationRatio: number;
+}
+/** Redis persistence info */
+export interface RedisPersistenceInfo {
+    readonly loading: boolean;
+    readonly rdbLastSaveTime: number;
+    readonly rdbLastBgsaveStatus: 'ok' | 'err';
+    readonly aofEnabled: boolean;
+    readonly aofLastRewriteStatus: 'ok' | 'err';
+}
+/** Redis stats info */
+export interface RedisStatsInfo {
+    readonly totalConnectionsReceived: number;
+    readonly totalCommandsProcessed: number;
+    readonly instantaneousOpsPerSec: number;
+    readonly totalNetInputBytes: number;
+    readonly totalNetOutputBytes: number;
+    readonly keyspaceHits: number;
+    readonly keyspaceMisses: number;
+}
+/** Redis replication info */
+export interface RedisReplicationInfo {
+    readonly role: 'master' | 'slave';
+    readonly connectedSlaves: number;
+    readonly masterHost?: string;
+    readonly masterPort?: number;
+    readonly masterLinkStatus?: 'up' | 'down';
+}
+/** Redis CPU info */
+export interface RedisCpuInfo {
+    readonly usedCpuSys: number;
+    readonly usedCpuUser: number;
+    readonly usedCpuSysChildren: number;
+    readonly usedCpuUserChildren: number;
+}
+/** Redis cluster info */
+export interface RedisClusterInfo {
+    readonly enabled: boolean;
+    readonly state?: 'ok' | 'fail';
+    readonly slotsAssigned?: number;
+    readonly slotsOk?: number;
+    readonly slotsPfail?: number;
+    readonly slotsFail?: number;
+    readonly knownNodes?: number;
+    readonly size?: number;
+}
+/** Redis keyspace info */
+export interface RedisKeyspaceInfo {
+    readonly keys: number;
+    readonly expires: number;
+    readonly avgTtl: number;
+}
+/** Cassandra-specific config */
+export interface CassandraConfig extends DbAdapterConfig {
+    readonly type: 'cassandra';
+    readonly keyspace?: string;
+    readonly contactPoints: readonly string[];
+    readonly localDataCenter: string;
+    readonly consistencyLevel?: CassandraConsistency;
+    readonly serialConsistency?: 'SERIAL' | 'LOCAL_SERIAL';
+    readonly fetchSize?: number;
+    readonly protocolVersion?: number;
+}
+/** Cassandra consistency level */
+export type CassandraConsistency = 'ANY' | 'ONE' | 'TWO' | 'THREE' | 'QUORUM' | 'LOCAL_QUORUM' | 'EACH_QUORUM' | 'ALL' | 'LOCAL_ONE';
+/** Cassandra keyspace info */
+export interface CassandraKeyspaceInfo {
+    readonly name: string;
+    readonly durableWrites: boolean;
+    readonly replication: CassandraReplication;
+    readonly tables: readonly CassandraTableInfo[];
+}
+/** Cassandra replication */
+export interface CassandraReplication {
+    readonly class: 'SimpleStrategy' | 'NetworkTopologyStrategy';
+    readonly replicationFactor?: number;
+    readonly datacenters?: Record<string, number>;
+}
+/** Cassandra table info */
+export interface CassandraTableInfo {
+    readonly name: string;
+    readonly keyspace: string;
+    readonly partitionKeys: readonly string[];
+    readonly clusteringKeys: readonly CassandraClusteringKey[];
+    readonly columns: readonly CassandraColumnInfo[];
+    readonly compaction: Record<string, string>;
+    readonly compression: Record<string, string>;
+}
+/** Cassandra clustering key */
+export interface CassandraClusteringKey {
+    readonly column: string;
+    readonly order: 'asc' | 'desc';
+}
+/** Cassandra column info */
+export interface CassandraColumnInfo {
+    readonly name: string;
+    readonly type: string;
+    readonly kind: 'partition_key' | 'clustering' | 'regular' | 'static';
+    readonly position: number;
+}
+/** ClickHouse-specific config */
+export interface ClickHouseConfig extends DbAdapterConfig {
+    readonly type: 'clickhouse';
+    readonly protocol: 'http' | 'https' | 'native';
+    readonly compression?: boolean;
+    readonly httpHeaders?: Record<string, string>;
+    readonly settings?: Record<string, unknown>;
+    readonly sessionId?: string;
+    readonly format?: 'JSON' | 'JSONEachRow' | 'CSV' | 'TabSeparated';
+}
+/** ClickHouse table engine */
+export interface ClickHouseTableEngine {
+    readonly engine: string;
+    readonly parameters?: readonly unknown[];
+    readonly orderBy?: readonly string[];
+    readonly partitionBy?: string;
+    readonly primaryKey?: readonly string[];
+    readonly sampleBy?: string;
+    readonly settings?: Record<string, unknown>;
+}
+/** Elasticsearch-specific config */
+export interface ElasticsearchConfig extends DbAdapterConfig {
+    readonly type: 'elasticsearch';
+    readonly nodes: readonly string[];
+    readonly apiVersion?: string;
+    readonly apiKey?: string;
+    readonly cloudId?: string;
+    readonly maxRetries?: number;
+    readonly requestTimeout?: number;
+    readonly sniffOnStart?: boolean;
+    readonly sniffInterval?: number;
+    readonly sniffOnConnectionFault?: boolean;
+}
+/** Elasticsearch index */
+export interface ElasticsearchIndex {
+    readonly name: string;
+    readonly uuid: string;
+    readonly health: 'green' | 'yellow' | 'red';
+    readonly status: 'open' | 'close';
+    readonly primaryShards: number;
+    readonly replicaShards: number;
+    readonly docsCount: number;
+    readonly docsDeleted: number;
+    readonly storeSize: number;
+    readonly mappings: Record<string, ElasticsearchFieldMapping>;
+    readonly settings: Record<string, unknown>;
+    readonly aliases: readonly string[];
+}
+/** Elasticsearch field mapping */
+export interface ElasticsearchFieldMapping {
+    readonly type: ElasticsearchFieldType;
+    readonly index?: boolean;
+    readonly store?: boolean;
+    readonly analyzer?: string;
+    readonly searchAnalyzer?: string;
+    readonly fields?: Record<string, ElasticsearchFieldMapping>;
+    readonly properties?: Record<string, ElasticsearchFieldMapping>;
+}
+/** Elasticsearch field type */
+export type ElasticsearchFieldType = 'text' | 'keyword' | 'long' | 'integer' | 'short' | 'byte' | 'double' | 'float' | 'half_float' | 'scaled_float' | 'date' | 'date_nanos' | 'boolean' | 'binary' | 'integer_range' | 'float_range' | 'long_range' | 'double_range' | 'date_range' | 'ip' | 'completion' | 'geo_point' | 'geo_shape' | 'token_count' | 'percolator' | 'join' | 'alias' | 'flattened' | 'shape' | 'histogram' | 'constant_keyword' | 'aggregate_metric_double' | 'dense_vector' | 'sparse_vector' | 'search_as_you_type' | 'nested' | 'object';
+/** DynamoDB-specific config */
+export interface DynamoDBConfig extends DbAdapterConfig {
+    readonly type: 'dynamodb';
+    readonly region: string;
+    readonly accessKeyId?: string;
+    readonly secretAccessKey?: string;
+    readonly sessionToken?: string;
+    readonly endpoint?: string;
+    readonly maxRetries?: number;
+    readonly httpOptions?: {
+        readonly timeout?: number;
+        readonly connectTimeout?: number;
+    };
+}
+/** DynamoDB table info */
+export interface DynamoDBTableInfo {
+    readonly tableName: string;
+    readonly tableStatus: 'CREATING' | 'UPDATING' | 'DELETING' | 'ACTIVE' | 'INACCESSIBLE_ENCRYPTION_CREDENTIALS' | 'ARCHIVING' | 'ARCHIVED';
+    readonly keySchema: readonly DynamoDBKeyElement[];
+    readonly attributeDefinitions: readonly DynamoDBAttributeDefinition[];
+    readonly provisionedThroughput?: DynamoDBThroughput;
+    readonly billingMode: 'PROVISIONED' | 'PAY_PER_REQUEST';
+    readonly globalSecondaryIndexes?: readonly DynamoDBGSI[];
+    readonly localSecondaryIndexes?: readonly DynamoDBLSI[];
+    readonly itemCount: number;
+    readonly tableSizeBytes: number;
+}
+/** DynamoDB key element */
+export interface DynamoDBKeyElement {
+    readonly attributeName: string;
+    readonly keyType: 'HASH' | 'RANGE';
+}
+/** DynamoDB attribute definition */
+export interface DynamoDBAttributeDefinition {
+    readonly attributeName: string;
+    readonly attributeType: 'S' | 'N' | 'B';
+}
+/** DynamoDB throughput */
+export interface DynamoDBThroughput {
+    readonly readCapacityUnits: number;
+    readonly writeCapacityUnits: number;
+}
+/** DynamoDB Global Secondary Index */
+export interface DynamoDBGSI {
+    readonly indexName: string;
+    readonly keySchema: readonly DynamoDBKeyElement[];
+    readonly projection: {
+        readonly projectionType: 'ALL' | 'KEYS_ONLY' | 'INCLUDE';
+        readonly nonKeyAttributes?: readonly string[];
+    };
+    readonly provisionedThroughput?: DynamoDBThroughput;
+}
+/** DynamoDB Local Secondary Index */
+export interface DynamoDBLSI {
+    readonly indexName: string;
+    readonly keySchema: readonly DynamoDBKeyElement[];
+    readonly projection: {
+        readonly projectionType: 'ALL' | 'KEYS_ONLY' | 'INCLUDE';
+        readonly nonKeyAttributes?: readonly string[];
+    };
+}
+/** Neo4j-specific config */
+export interface Neo4jConfig extends DbAdapterConfig {
+    readonly type: 'neo4j';
+    readonly protocol: 'bolt' | 'bolt+s' | 'bolt+ssc' | 'neo4j' | 'neo4j+s' | 'neo4j+ssc';
+    readonly encrypted?: boolean;
+    readonly trustedCertificates?: readonly string[];
+    readonly maxConnectionLifetime?: number;
+    readonly maxConnectionPoolSize?: number;
+    readonly connectionAcquisitionTimeout?: number;
+    readonly fetchSize?: number;
+}
+/** Neo4j node label */
+export interface Neo4jLabelInfo {
+    readonly label: string;
+    readonly count: number;
+    readonly properties: readonly Neo4jPropertyInfo[];
+}
+/** Neo4j relationship type */
+export interface Neo4jRelationshipInfo {
+    readonly type: string;
+    readonly count: number;
+    readonly startLabels: readonly string[];
+    readonly endLabels: readonly string[];
+    readonly properties: readonly Neo4jPropertyInfo[];
+}
+/** Neo4j property info */
+export interface Neo4jPropertyInfo {
+    readonly name: string;
+    readonly existence: 'always' | 'sometimes' | 'never';
+    readonly types: readonly string[];
+    readonly indexed: boolean;
+    readonly unique: boolean;
+}
+/** InfluxDB-specific config */
+export interface InfluxDBConfig extends DbAdapterConfig {
+    readonly type: 'influxdb';
+    readonly version: '1.x' | '2.x';
+    readonly org?: string;
+    readonly bucket?: string;
+    readonly token?: string;
+    readonly precision?: 'ns' | 'us' | 'ms' | 's';
+    readonly retentionPolicy?: string;
+}
+/** InfluxDB bucket info */
+export interface InfluxDBBucketInfo {
+    readonly id: string;
+    readonly name: string;
+    readonly orgId: string;
+    readonly retentionPeriod: number;
+    readonly type: 'user' | 'system';
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+/** InfluxDB measurement info */
+export interface InfluxDBMeasurementInfo {
+    readonly name: string;
+    readonly tagKeys: readonly string[];
+    readonly fieldKeys: readonly InfluxDBFieldInfo[];
+    readonly earliestTime?: Date;
+    readonly latestTime?: Date;
+}
+/** InfluxDB field info */
+export interface InfluxDBFieldInfo {
+    readonly name: string;
+    readonly type: 'float' | 'integer' | 'unsigned' | 'string' | 'boolean';
+}
+/** CockroachDB-specific config */
+export interface CockroachDBConfig extends DbAdapterConfig {
+    readonly type: 'cockroachdb';
+    readonly cluster?: string;
+    readonly caCert?: string;
+    readonly clientCert?: string;
+    readonly clientKey?: string;
+    readonly experimental?: boolean;
+}
+/** TimescaleDB-specific config */
+export interface TimescaleDBConfig extends DbAdapterConfig {
+    readonly type: 'timescaledb';
+    readonly schema?: string;
+    readonly chunkTimeInterval?: string;
+}
+/** Timescale hypertable info */
+export interface TimescaleHypertableInfo {
+    readonly hypertableName: string;
+    readonly schemaName: string;
+    readonly owner: string;
+    readonly numDimensions: number;
+    readonly numChunks: number;
+    readonly tablespaces?: readonly string[];
+    readonly compressionEnabled: boolean;
+    readonly retentionPolicy?: {
+        readonly dropAfter: string;
+    };
+    readonly continuousAggregates: readonly string[];
+}
+/** Timescale chunk info */
+export interface TimescaleChunkInfo {
+    readonly chunkId: number;
+    readonly chunkName: string;
+    readonly hypertableName: string;
+    readonly rangeStart: Date;
+    readonly rangeEnd: Date;
+    readonly compressed: boolean;
+    readonly tablespace?: string;
+    readonly dataSize: number;
+    readonly indexSize: number;
+}
+/** CosmosDB-specific config */
+export interface CosmosDBConfig extends DbAdapterConfig {
+    readonly type: 'cosmosdb';
+    readonly endpoint: string;
+    readonly key: string;
+    readonly databaseId: string;
+    readonly containerId?: string;
+    readonly apiType: 'sql' | 'mongodb' | 'cassandra' | 'gremlin' | 'table';
+    readonly consistencyLevel?: 'Strong' | 'BoundedStaleness' | 'Session' | 'ConsistentPrefix' | 'Eventual';
+    readonly connectionPolicy?: {
+        readonly requestTimeout?: number;
+        readonly enableEndpointDiscovery?: boolean;
+        readonly preferredLocations?: readonly string[];
+    };
+}
+/** CosmosDB container info */
+export interface CosmosDBContainerInfo {
+    readonly id: string;
+    readonly partitionKey: {
+        readonly paths: readonly string[];
+        readonly kind: 'Hash' | 'Range' | 'MultiHash';
+        readonly version?: number;
+    };
+    readonly indexingPolicy: CosmosDBIndexingPolicy;
+    readonly defaultTtl?: number;
+    readonly uniqueKeyPolicy?: {
+        readonly uniqueKeys: readonly {
+            paths: readonly string[];
+        }[];
+    };
+    readonly throughput?: number;
+}
+/** CosmosDB indexing policy */
+export interface CosmosDBIndexingPolicy {
+    readonly automatic: boolean;
+    readonly indexingMode: 'consistent' | 'lazy' | 'none';
+    readonly includedPaths: readonly {
+        path: string;
+    }[];
+    readonly excludedPaths: readonly {
+        path: string;
+    }[];
+    readonly compositeIndexes?: readonly {
+        path: string;
+        order: 'ascending' | 'descending';
+    }[][];
+    readonly spatialIndexes?: readonly {
+        path: string;
+        types: readonly string[];
+    }[];
+}
+//# sourceMappingURL=db-adapters.d.ts.map