@objectstack/spec 0.6.0 → 0.7.1

package/dist/data/driver-nosql.zod.d.ts

@@ -0,0 +1,1008 @@
+import { z } from 'zod';
+/**
+ * NoSQL Database Type Enumeration
+ * Supported NoSQL database types
+ */
+export declare const NoSQLDatabaseTypeSchema: z.ZodEnum<["mongodb", "couchdb", "dynamodb", "cassandra", "redis", "elasticsearch", "neo4j", "orientdb"]>;
+export type NoSQLDatabaseType = z.infer<typeof NoSQLDatabaseTypeSchema>;
+/**
+ * NoSQL Query Operation Types
+ * Different types of operations supported by NoSQL databases
+ */
+export declare const NoSQLOperationTypeSchema: z.ZodEnum<["find", "findOne", "insert", "update", "delete", "aggregate", "mapReduce", "count", "distinct", "createIndex", "dropIndex"]>;
+export type NoSQLOperationType = z.infer<typeof NoSQLOperationTypeSchema>;
+/**
+ * NoSQL Consistency Level
+ * Consistency guarantees for distributed NoSQL databases
+ *
+ * Consistency levels (from strongest to weakest):
+ * - **all**: All replicas must respond (strongest consistency, lowest availability)
+ * - **quorum**: Majority of replicas must respond (balanced)
+ * - **one**: Any single replica responds (weakest consistency, highest availability)
+ * - **local_quorum**: Majority of replicas in local datacenter
+ * - **each_quorum**: Quorum of replicas in each datacenter
+ * - **eventual**: Eventual consistency (highest availability, weakest consistency)
+ */
+export declare const ConsistencyLevelSchema: z.ZodEnum<["all", "quorum", "one", "local_quorum", "each_quorum", "eventual"]>;
+export type ConsistencyLevel = z.infer<typeof ConsistencyLevelSchema>;
+/**
+ * NoSQL Index Type
+ * Types of indexes supported by NoSQL databases
+ */
+export declare const NoSQLIndexTypeSchema: z.ZodEnum<["single", "compound", "unique", "text", "geospatial", "hashed", "ttl", "sparse"]>;
+export type NoSQLIndexType = z.infer<typeof NoSQLIndexTypeSchema>;
+/**
+ * NoSQL Sharding Configuration
+ * Configuration for horizontal partitioning across multiple nodes
+ */
+export declare const ShardingConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    shardKey: z.ZodOptional<z.ZodString>;
+    shardingStrategy: z.ZodOptional<z.ZodEnum<["hash", "range", "zone"]>>;
+    numShards: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    shardKey?: string | undefined;
+    shardingStrategy?: "hash" | "range" | "zone" | undefined;
+    numShards?: number | undefined;
+}, {
+    enabled?: boolean | undefined;
+    shardKey?: string | undefined;
+    shardingStrategy?: "hash" | "range" | "zone" | undefined;
+    numShards?: number | undefined;
+}>;
+export type ShardingConfig = z.infer<typeof ShardingConfigSchema>;
+/**
+ * NoSQL Replication Configuration
+ * Configuration for data replication across nodes
+ */
+export declare const ReplicationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    replicaSetName: z.ZodOptional<z.ZodString>;
+    replicas: z.ZodOptional<z.ZodNumber>;
+    readPreference: z.ZodOptional<z.ZodEnum<["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]>>;
+    writeConcern: z.ZodOptional<z.ZodEnum<["majority", "acknowledged", "unacknowledged"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    replicaSetName?: string | undefined;
+    replicas?: number | undefined;
+    readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+    writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+}, {
+    enabled?: boolean | undefined;
+    replicaSetName?: string | undefined;
+    replicas?: number | undefined;
+    readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+    writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+}>;
+export type ReplicationConfig = z.infer<typeof ReplicationConfigSchema>;
+/**
+ * Document Schema Validation
+ * Schema validation rules for document-based NoSQL databases
+ */
+export declare const DocumentSchemaValidationSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    validationLevel: z.ZodOptional<z.ZodEnum<["strict", "moderate", "off"]>>;
+    validationAction: z.ZodOptional<z.ZodEnum<["error", "warn"]>>;
+    jsonSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    validationLevel?: "strict" | "moderate" | "off" | undefined;
+    validationAction?: "error" | "warn" | undefined;
+    jsonSchema?: Record<string, any> | undefined;
+}, {
+    enabled?: boolean | undefined;
+    validationLevel?: "strict" | "moderate" | "off" | undefined;
+    validationAction?: "error" | "warn" | undefined;
+    jsonSchema?: Record<string, any> | undefined;
+}>;
+export type DocumentSchemaValidation = z.infer<typeof DocumentSchemaValidationSchema>;
+/**
+ * NoSQL Data Type Mapping Schema
+ * Maps ObjectStack field types to NoSQL-specific data types
+ *
+ * @example MongoDB data type mapping
+ * {
+ *   text: 'string',
+ *   number: 'double',
+ *   boolean: 'bool',
+ *   date: 'date',
+ *   datetime: 'date',
+ *   json: 'object',
+ *   uuid: 'string',
+ *   binary: 'binData',
+ *   array: 'array',
+ *   objectId: 'objectId'
+ * }
+ */
+export declare const NoSQLDataTypeMappingSchema: z.ZodObject<{
+    text: z.ZodString;
+    number: z.ZodString;
+    boolean: z.ZodString;
+    date: z.ZodString;
+    datetime: z.ZodString;
+    json: z.ZodOptional<z.ZodString>;
+    uuid: z.ZodOptional<z.ZodString>;
+    binary: z.ZodOptional<z.ZodString>;
+    array: z.ZodOptional<z.ZodString>;
+    objectId: z.ZodOptional<z.ZodString>;
+    geopoint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    number: string;
+    boolean: string;
+    date: string;
+    text: string;
+    datetime: string;
+    array?: string | undefined;
+    json?: string | undefined;
+    uuid?: string | undefined;
+    binary?: string | undefined;
+    objectId?: string | undefined;
+    geopoint?: string | undefined;
+}, {
+    number: string;
+    boolean: string;
+    date: string;
+    text: string;
+    datetime: string;
+    array?: string | undefined;
+    json?: string | undefined;
+    uuid?: string | undefined;
+    binary?: string | undefined;
+    objectId?: string | undefined;
+    geopoint?: string | undefined;
+}>;
+export type NoSQLDataTypeMapping = z.infer<typeof NoSQLDataTypeMappingSchema>;
+/**
+ * NoSQL Driver Configuration Schema
+ * Extended driver configuration specific to NoSQL databases
+ *
+ * @example MongoDB driver configuration
+ * {
+ *   name: 'primary-mongo',
+ *   type: 'nosql',
+ *   databaseType: 'mongodb',
+ *   connectionString: 'mongodb://user:pass@localhost:27017/mydb',
+ *   dataTypeMapping: {
+ *     text: 'string',
+ *     number: 'double',
+ *     boolean: 'bool',
+ *     date: 'date',
+ *     datetime: 'date',
+ *     json: 'object',
+ *     uuid: 'string',
+ *     binary: 'binData',
+ *     array: 'array',
+ *     objectId: 'objectId'
+ *   },
+ *   consistency: 'quorum',
+ *   replication: {
+ *     enabled: true,
+ *     replicaSetName: 'rs0',
+ *     replicas: 3,
+ *     readPreference: 'primaryPreferred',
+ *     writeConcern: 'majority'
+ *   },
+ *   sharding: {
+ *     enabled: true,
+ *     shardKey: '_id',
+ *     shardingStrategy: 'hash',
+ *     numShards: 4
+ *   },
+ *   capabilities: {
+ *     create: true,
+ *     read: true,
+ *     update: true,
+ *     delete: true,
+ *     bulkCreate: true,
+ *     bulkUpdate: true,
+ *     bulkDelete: true,
+ *     transactions: true,
+ *     savepoints: false,
+ *     queryFilters: true,
+ *     queryAggregations: true,
+ *     querySorting: true,
+ *     queryPagination: true,
+ *     queryWindowFunctions: false,
+ *     querySubqueries: false,
+ *     queryCTE: false,
+ *     joins: false,
+ *     fullTextSearch: true,
+ *     jsonQuery: true,
+ *     geospatialQuery: true,
+ *     streaming: true,
+ *     jsonFields: true,
+ *     arrayFields: true,
+ *     vectorSearch: false,
+ *     schemaSync: true,
+ *     migrations: false,
+ *     indexes: true,
+ *     connectionPooling: true,
+ *     preparedStatements: false,
+ *     queryCache: false
+ *   }
+ * }
+ *
+ * @example DynamoDB driver configuration
+ * {
+ *   name: 'dynamodb-main',
+ *   type: 'nosql',
+ *   databaseType: 'dynamodb',
+ *   region: 'us-east-1',
+ *   accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+ *   secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+ *   consistency: 'eventual',
+ *   capabilities: {
+ *     create: true,
+ *     read: true,
+ *     update: true,
+ *     delete: true,
+ *     bulkCreate: true,
+ *     bulkUpdate: false,
+ *     bulkDelete: false,
+ *     transactions: true,
+ *     queryFilters: true,
+ *     queryAggregations: false,
+ *     querySorting: true,
+ *     queryPagination: true,
+ *     fullTextSearch: false,
+ *     jsonQuery: true,
+ *     indexes: true
+ *   }
+ * }
+ */
+export declare const NoSQLDriverConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    capabilities: z.ZodEffects<z.ZodObject<{
+        create: z.ZodDefault<z.ZodBoolean>;
+        read: z.ZodDefault<z.ZodBoolean>;
+        update: z.ZodDefault<z.ZodBoolean>;
+        delete: z.ZodDefault<z.ZodBoolean>;
+        bulkCreate: z.ZodDefault<z.ZodBoolean>;
+        bulkUpdate: z.ZodDefault<z.ZodBoolean>;
+        bulkDelete: z.ZodDefault<z.ZodBoolean>;
+        transactions: z.ZodDefault<z.ZodBoolean>;
+        savepoints: z.ZodDefault<z.ZodBoolean>;
+        isolationLevels: z.ZodOptional<z.ZodArray<z.ZodEnum<["read-uncommitted", "read-committed", "repeatable-read", "serializable"]>, "many">>;
+        queryFilters: z.ZodDefault<z.ZodBoolean>;
+        queryAggregations: z.ZodDefault<z.ZodBoolean>;
+        querySorting: z.ZodDefault<z.ZodBoolean>;
+        queryPagination: z.ZodDefault<z.ZodBoolean>;
+        queryWindowFunctions: z.ZodDefault<z.ZodBoolean>;
+        querySubqueries: z.ZodDefault<z.ZodBoolean>;
+        queryCTE: z.ZodDefault<z.ZodBoolean>;
+        joins: z.ZodDefault<z.ZodBoolean>;
+        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+        jsonQuery: z.ZodDefault<z.ZodBoolean>;
+        geospatialQuery: z.ZodDefault<z.ZodBoolean>;
+        streaming: z.ZodDefault<z.ZodBoolean>;
+        jsonFields: z.ZodDefault<z.ZodBoolean>;
+        arrayFields: z.ZodDefault<z.ZodBoolean>;
+        vectorSearch: z.ZodDefault<z.ZodBoolean>;
+        geoSpatial: z.ZodDefault<z.ZodBoolean>;
+        schemaSync: z.ZodDefault<z.ZodBoolean>;
+        migrations: z.ZodDefault<z.ZodBoolean>;
+        indexes: z.ZodDefault<z.ZodBoolean>;
+        connectionPooling: z.ZodDefault<z.ZodBoolean>;
+        preparedStatements: z.ZodDefault<z.ZodBoolean>;
+        queryCache: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        update: boolean;
+        delete: boolean;
+        create: boolean;
+        indexes: boolean;
+        read: boolean;
+        bulkCreate: boolean;
+        bulkUpdate: boolean;
+        bulkDelete: boolean;
+        transactions: boolean;
+        savepoints: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        queryCTE: boolean;
+        fullTextSearch: boolean;
+        jsonQuery: boolean;
+        geospatialQuery: boolean;
+        streaming: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch: boolean;
+        geoSpatial: boolean;
+        schemaSync: boolean;
+        migrations: boolean;
+        connectionPooling: boolean;
+        preparedStatements: boolean;
+        queryCache: boolean;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+    }, {
+        joins?: boolean | undefined;
+        update?: boolean | undefined;
+        delete?: boolean | undefined;
+        create?: boolean | undefined;
+        indexes?: boolean | undefined;
+        read?: boolean | undefined;
+        bulkCreate?: boolean | undefined;
+        bulkUpdate?: boolean | undefined;
+        bulkDelete?: boolean | undefined;
+        transactions?: boolean | undefined;
+        savepoints?: boolean | undefined;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+        queryFilters?: boolean | undefined;
+        queryAggregations?: boolean | undefined;
+        querySorting?: boolean | undefined;
+        queryPagination?: boolean | undefined;
+        queryWindowFunctions?: boolean | undefined;
+        querySubqueries?: boolean | undefined;
+        queryCTE?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        jsonQuery?: boolean | undefined;
+        geospatialQuery?: boolean | undefined;
+        streaming?: boolean | undefined;
+        jsonFields?: boolean | undefined;
+        arrayFields?: boolean | undefined;
+        vectorSearch?: boolean | undefined;
+        geoSpatial?: boolean | undefined;
+        schemaSync?: boolean | undefined;
+        migrations?: boolean | undefined;
+        connectionPooling?: boolean | undefined;
+        preparedStatements?: boolean | undefined;
+        queryCache?: boolean | undefined;
+    }>, {
+        joins: boolean;
+        update: boolean;
+        delete: boolean;
+        create: boolean;
+        indexes: boolean;
+        read: boolean;
+        bulkCreate: boolean;
+        bulkUpdate: boolean;
+        bulkDelete: boolean;
+        transactions: boolean;
+        savepoints: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        queryCTE: boolean;
+        fullTextSearch: boolean;
+        jsonQuery: boolean;
+        geospatialQuery: boolean;
+        streaming: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch: boolean;
+        geoSpatial: boolean;
+        schemaSync: boolean;
+        migrations: boolean;
+        connectionPooling: boolean;
+        preparedStatements: boolean;
+        queryCache: boolean;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+    }, {
+        joins?: boolean | undefined;
+        update?: boolean | undefined;
+        delete?: boolean | undefined;
+        create?: boolean | undefined;
+        indexes?: boolean | undefined;
+        read?: boolean | undefined;
+        bulkCreate?: boolean | undefined;
+        bulkUpdate?: boolean | undefined;
+        bulkDelete?: boolean | undefined;
+        transactions?: boolean | undefined;
+        savepoints?: boolean | undefined;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+        queryFilters?: boolean | undefined;
+        queryAggregations?: boolean | undefined;
+        querySorting?: boolean | undefined;
+        queryPagination?: boolean | undefined;
+        queryWindowFunctions?: boolean | undefined;
+        querySubqueries?: boolean | undefined;
+        queryCTE?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        jsonQuery?: boolean | undefined;
+        geospatialQuery?: boolean | undefined;
+        streaming?: boolean | undefined;
+        jsonFields?: boolean | undefined;
+        arrayFields?: boolean | undefined;
+        vectorSearch?: boolean | undefined;
+        geoSpatial?: boolean | undefined;
+        schemaSync?: boolean | undefined;
+        migrations?: boolean | undefined;
+        connectionPooling?: boolean | undefined;
+        preparedStatements?: boolean | undefined;
+        queryCache?: boolean | undefined;
+    }>;
+    connectionString: z.ZodOptional<z.ZodString>;
+    poolConfig: z.ZodOptional<z.ZodObject<{
+        min: z.ZodDefault<z.ZodNumber>;
+        max: z.ZodDefault<z.ZodNumber>;
+        idleTimeoutMillis: z.ZodDefault<z.ZodNumber>;
+        connectionTimeoutMillis: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        min: number;
+        max: number;
+        idleTimeoutMillis: number;
+        connectionTimeoutMillis: number;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        idleTimeoutMillis?: number | undefined;
+        connectionTimeoutMillis?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"nosql">;
+    databaseType: z.ZodEnum<["mongodb", "couchdb", "dynamodb", "cassandra", "redis", "elasticsearch", "neo4j", "orientdb"]>;
+    dataTypeMapping: z.ZodObject<{
+        text: z.ZodString;
+        number: z.ZodString;
+        boolean: z.ZodString;
+        date: z.ZodString;
+        datetime: z.ZodString;
+        json: z.ZodOptional<z.ZodString>;
+        uuid: z.ZodOptional<z.ZodString>;
+        binary: z.ZodOptional<z.ZodString>;
+        array: z.ZodOptional<z.ZodString>;
+        objectId: z.ZodOptional<z.ZodString>;
+        geopoint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        number: string;
+        boolean: string;
+        date: string;
+        text: string;
+        datetime: string;
+        array?: string | undefined;
+        json?: string | undefined;
+        uuid?: string | undefined;
+        binary?: string | undefined;
+        objectId?: string | undefined;
+        geopoint?: string | undefined;
+    }, {
+        number: string;
+        boolean: string;
+        date: string;
+        text: string;
+        datetime: string;
+        array?: string | undefined;
+        json?: string | undefined;
+        uuid?: string | undefined;
+        binary?: string | undefined;
+        objectId?: string | undefined;
+        geopoint?: string | undefined;
+    }>;
+    consistency: z.ZodOptional<z.ZodEnum<["all", "quorum", "one", "local_quorum", "each_quorum", "eventual"]>>;
+    replication: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        replicaSetName: z.ZodOptional<z.ZodString>;
+        replicas: z.ZodOptional<z.ZodNumber>;
+        readPreference: z.ZodOptional<z.ZodEnum<["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]>>;
+        writeConcern: z.ZodOptional<z.ZodEnum<["majority", "acknowledged", "unacknowledged"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        replicaSetName?: string | undefined;
+        replicas?: number | undefined;
+        readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+        writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        replicaSetName?: string | undefined;
+        replicas?: number | undefined;
+        readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+        writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    }>>;
+    sharding: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        shardKey: z.ZodOptional<z.ZodString>;
+        shardingStrategy: z.ZodOptional<z.ZodEnum<["hash", "range", "zone"]>>;
+        numShards: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        shardKey?: string | undefined;
+        shardingStrategy?: "hash" | "range" | "zone" | undefined;
+        numShards?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        shardKey?: string | undefined;
+        shardingStrategy?: "hash" | "range" | "zone" | undefined;
+        numShards?: number | undefined;
+    }>>;
+    schemaValidation: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        validationLevel: z.ZodOptional<z.ZodEnum<["strict", "moderate", "off"]>>;
+        validationAction: z.ZodOptional<z.ZodEnum<["error", "warn"]>>;
+        jsonSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        validationLevel?: "strict" | "moderate" | "off" | undefined;
+        validationAction?: "error" | "warn" | undefined;
+        jsonSchema?: Record<string, any> | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        validationLevel?: "strict" | "moderate" | "off" | undefined;
+        validationAction?: "error" | "warn" | undefined;
+        jsonSchema?: Record<string, any> | undefined;
+    }>>;
+    region: z.ZodOptional<z.ZodString>;
+    accessKeyId: z.ZodOptional<z.ZodString>;
+    secretAccessKey: z.ZodOptional<z.ZodString>;
+    ttlField: z.ZodOptional<z.ZodString>;
+    maxDocumentSize: z.ZodOptional<z.ZodNumber>;
+    collectionPrefix: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "nosql";
+    name: string;
+    capabilities: {
+        joins: boolean;
+        update: boolean;
+        delete: boolean;
+        create: boolean;
+        indexes: boolean;
+        read: boolean;
+        bulkCreate: boolean;
+        bulkUpdate: boolean;
+        bulkDelete: boolean;
+        transactions: boolean;
+        savepoints: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        queryCTE: boolean;
+        fullTextSearch: boolean;
+        jsonQuery: boolean;
+        geospatialQuery: boolean;
+        streaming: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch: boolean;
+        geoSpatial: boolean;
+        schemaSync: boolean;
+        migrations: boolean;
+        connectionPooling: boolean;
+        preparedStatements: boolean;
+        queryCache: boolean;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+    };
+    dataTypeMapping: {
+        number: string;
+        boolean: string;
+        date: string;
+        text: string;
+        datetime: string;
+        array?: string | undefined;
+        json?: string | undefined;
+        uuid?: string | undefined;
+        binary?: string | undefined;
+        objectId?: string | undefined;
+        geopoint?: string | undefined;
+    };
+    databaseType: "mongodb" | "couchdb" | "dynamodb" | "cassandra" | "redis" | "elasticsearch" | "neo4j" | "orientdb";
+    connectionString?: string | undefined;
+    poolConfig?: {
+        min: number;
+        max: number;
+        idleTimeoutMillis: number;
+        connectionTimeoutMillis: number;
+    } | undefined;
+    consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+    replication?: {
+        enabled: boolean;
+        replicaSetName?: string | undefined;
+        replicas?: number | undefined;
+        readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+        writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    } | undefined;
+    sharding?: {
+        enabled: boolean;
+        shardKey?: string | undefined;
+        shardingStrategy?: "hash" | "range" | "zone" | undefined;
+        numShards?: number | undefined;
+    } | undefined;
+    schemaValidation?: {
+        enabled: boolean;
+        validationLevel?: "strict" | "moderate" | "off" | undefined;
+        validationAction?: "error" | "warn" | undefined;
+        jsonSchema?: Record<string, any> | undefined;
+    } | undefined;
+    region?: string | undefined;
+    accessKeyId?: string | undefined;
+    secretAccessKey?: string | undefined;
+    ttlField?: string | undefined;
+    maxDocumentSize?: number | undefined;
+    collectionPrefix?: string | undefined;
+}, {
+    type: "nosql";
+    name: string;
+    capabilities: {
+        joins?: boolean | undefined;
+        update?: boolean | undefined;
+        delete?: boolean | undefined;
+        create?: boolean | undefined;
+        indexes?: boolean | undefined;
+        read?: boolean | undefined;
+        bulkCreate?: boolean | undefined;
+        bulkUpdate?: boolean | undefined;
+        bulkDelete?: boolean | undefined;
+        transactions?: boolean | undefined;
+        savepoints?: boolean | undefined;
+        isolationLevels?: ("read-uncommitted" | "read-committed" | "repeatable-read" | "serializable")[] | undefined;
+        queryFilters?: boolean | undefined;
+        queryAggregations?: boolean | undefined;
+        querySorting?: boolean | undefined;
+        queryPagination?: boolean | undefined;
+        queryWindowFunctions?: boolean | undefined;
+        querySubqueries?: boolean | undefined;
+        queryCTE?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        jsonQuery?: boolean | undefined;
+        geospatialQuery?: boolean | undefined;
+        streaming?: boolean | undefined;
+        jsonFields?: boolean | undefined;
+        arrayFields?: boolean | undefined;
+        vectorSearch?: boolean | undefined;
+        geoSpatial?: boolean | undefined;
+        schemaSync?: boolean | undefined;
+        migrations?: boolean | undefined;
+        connectionPooling?: boolean | undefined;
+        preparedStatements?: boolean | undefined;
+        queryCache?: boolean | undefined;
+    };
+    dataTypeMapping: {
+        number: string;
+        boolean: string;
+        date: string;
+        text: string;
+        datetime: string;
+        array?: string | undefined;
+        json?: string | undefined;
+        uuid?: string | undefined;
+        binary?: string | undefined;
+        objectId?: string | undefined;
+        geopoint?: string | undefined;
+    };
+    databaseType: "mongodb" | "couchdb" | "dynamodb" | "cassandra" | "redis" | "elasticsearch" | "neo4j" | "orientdb";
+    connectionString?: string | undefined;
+    poolConfig?: {
+        min?: number | undefined;
+        max?: number | undefined;
+        idleTimeoutMillis?: number | undefined;
+        connectionTimeoutMillis?: number | undefined;
+    } | undefined;
+    consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+    replication?: {
+        enabled?: boolean | undefined;
+        replicaSetName?: string | undefined;
+        replicas?: number | undefined;
+        readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+        writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    } | undefined;
+    sharding?: {
+        enabled?: boolean | undefined;
+        shardKey?: string | undefined;
+        shardingStrategy?: "hash" | "range" | "zone" | undefined;
+        numShards?: number | undefined;
+    } | undefined;
+    schemaValidation?: {
+        enabled?: boolean | undefined;
+        validationLevel?: "strict" | "moderate" | "off" | undefined;
+        validationAction?: "error" | "warn" | undefined;
+        jsonSchema?: Record<string, any> | undefined;
+    } | undefined;
+    region?: string | undefined;
+    accessKeyId?: string | undefined;
+    secretAccessKey?: string | undefined;
+    ttlField?: string | undefined;
+    maxDocumentSize?: number | undefined;
+    collectionPrefix?: string | undefined;
+}>;
+export type NoSQLDriverConfig = z.infer<typeof NoSQLDriverConfigSchema>;
+/**
+ * NoSQL Query Options
+ * Additional options for NoSQL queries
+ */
+export declare const NoSQLQueryOptionsSchema: z.ZodObject<{
+    /**
+     * Consistency level for this query
+     */
+    consistency: z.ZodOptional<z.ZodEnum<["all", "quorum", "one", "local_quorum", "each_quorum", "eventual"]>>;
+    /**
+     * Read from secondary replicas
+     */
+    readFromSecondary: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Projection (fields to include/exclude)
+     */
+    projection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
+    /**
+     * Query timeout in milliseconds
+     */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Use cursor for large result sets
+     */
+    useCursor: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Batch size for cursor iteration
+     */
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Enable query profiling
+     */
+    profile: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Use hinted index
+     */
+    hint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number | undefined;
+    batchSize?: number | undefined;
+    consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+    readFromSecondary?: boolean | undefined;
+    projection?: Record<string, 0 | 1> | undefined;
+    useCursor?: boolean | undefined;
+    profile?: boolean | undefined;
+    hint?: string | undefined;
+}, {
+    timeout?: number | undefined;
+    batchSize?: number | undefined;
+    consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+    readFromSecondary?: boolean | undefined;
+    projection?: Record<string, 0 | 1> | undefined;
+    useCursor?: boolean | undefined;
+    profile?: boolean | undefined;
+    hint?: string | undefined;
+}>;
+export type NoSQLQueryOptions = z.infer<typeof NoSQLQueryOptionsSchema>;
+/**
+ * NoSQL Aggregation Pipeline Stage
+ * Represents a single stage in an aggregation pipeline (MongoDB-style)
+ */
+export declare const AggregationStageSchema: z.ZodObject<{
+    /**
+     * Stage operator (e.g., $match, $group, $sort, $project)
+     */
+    operator: z.ZodString;
+    /**
+     * Stage parameters/options
+     */
+    options: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    options: Record<string, any>;
+    operator: string;
+}, {
+    options: Record<string, any>;
+    operator: string;
+}>;
+export type AggregationStage = z.infer<typeof AggregationStageSchema>;
+/**
+ * NoSQL Aggregation Pipeline
+ * Sequence of aggregation stages for complex data transformations
+ */
+export declare const AggregationPipelineSchema: z.ZodObject<{
+    /**
+     * Collection/Table to aggregate
+     */
+    collection: z.ZodString;
+    /**
+     * Pipeline stages
+     */
+    stages: z.ZodArray<z.ZodObject<{
+        /**
+         * Stage operator (e.g., $match, $group, $sort, $project)
+         */
+        operator: z.ZodString;
+        /**
+         * Stage parameters/options
+         */
+        options: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        options: Record<string, any>;
+        operator: string;
+    }, {
+        options: Record<string, any>;
+        operator: string;
+    }>, "many">;
+    /**
+     * Additional options
+     */
+    options: z.ZodOptional<z.ZodObject<{
+        /**
+         * Consistency level for this query
+         */
+        consistency: z.ZodOptional<z.ZodEnum<["all", "quorum", "one", "local_quorum", "each_quorum", "eventual"]>>;
+        /**
+         * Read from secondary replicas
+         */
+        readFromSecondary: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Projection (fields to include/exclude)
+         */
+        projection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
+        /**
+         * Query timeout in milliseconds
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Use cursor for large result sets
+         */
+        useCursor: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Batch size for cursor iteration
+         */
+        batchSize: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Enable query profiling
+         */
+        profile: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Use hinted index
+         */
+        hint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        batchSize?: number | undefined;
+        consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+        readFromSecondary?: boolean | undefined;
+        projection?: Record<string, 0 | 1> | undefined;
+        useCursor?: boolean | undefined;
+        profile?: boolean | undefined;
+        hint?: string | undefined;
+    }, {
+        timeout?: number | undefined;
+        batchSize?: number | undefined;
+        consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+        readFromSecondary?: boolean | undefined;
+        projection?: Record<string, 0 | 1> | undefined;
+        useCursor?: boolean | undefined;
+        profile?: boolean | undefined;
+        hint?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    stages: {
+        options: Record<string, any>;
+        operator: string;
+    }[];
+    options?: {
+        timeout?: number | undefined;
+        batchSize?: number | undefined;
+        consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+        readFromSecondary?: boolean | undefined;
+        projection?: Record<string, 0 | 1> | undefined;
+        useCursor?: boolean | undefined;
+        profile?: boolean | undefined;
+        hint?: string | undefined;
+    } | undefined;
+}, {
+    collection: string;
+    stages: {
+        options: Record<string, any>;
+        operator: string;
+    }[];
+    options?: {
+        timeout?: number | undefined;
+        batchSize?: number | undefined;
+        consistency?: "all" | "quorum" | "one" | "local_quorum" | "each_quorum" | "eventual" | undefined;
+        readFromSecondary?: boolean | undefined;
+        projection?: Record<string, 0 | 1> | undefined;
+        useCursor?: boolean | undefined;
+        profile?: boolean | undefined;
+        hint?: string | undefined;
+    } | undefined;
+}>;
+export type AggregationPipeline = z.infer<typeof AggregationPipelineSchema>;
+/**
+ * NoSQL Index Definition
+ * Definition for creating indexes in NoSQL databases
+ */
+export declare const NoSQLIndexSchema: z.ZodObject<{
+    /**
+     * Index name
+     */
+    name: z.ZodString;
+    /**
+     * Index type
+     */
+    type: z.ZodEnum<["single", "compound", "unique", "text", "geospatial", "hashed", "ttl", "sparse"]>;
+    /**
+     * Fields to index
+     * For compound indexes, order matters
+     */
+    fields: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodOptional<z.ZodEnum<["asc", "desc", "text", "2dsphere"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        order?: "asc" | "desc" | "text" | "2dsphere" | undefined;
+    }, {
+        field: string;
+        order?: "asc" | "desc" | "text" | "2dsphere" | undefined;
+    }>, "many">;
+    /**
+     * Unique constraint
+     */
+    unique: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Sparse index (only index documents with the field)
+     */
+    sparse: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * TTL in seconds (for TTL indexes)
+     */
+    expireAfterSeconds: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Partial index filter
+     */
+    partialFilterExpression: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Background index creation
+     */
+    background: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "text" | "ttl" | "unique" | "single" | "compound" | "geospatial" | "hashed" | "sparse";
+    fields: {
+        field: string;
+        order?: "asc" | "desc" | "text" | "2dsphere" | undefined;
+    }[];
+    name: string;
+    unique: boolean;
+    sparse: boolean;
+    background: boolean;
+    expireAfterSeconds?: number | undefined;
+    partialFilterExpression?: Record<string, any> | undefined;
+}, {
+    type: "text" | "ttl" | "unique" | "single" | "compound" | "geospatial" | "hashed" | "sparse";
+    fields: {
+        field: string;
+        order?: "asc" | "desc" | "text" | "2dsphere" | undefined;
+    }[];
+    name: string;
+    unique?: boolean | undefined;
+    sparse?: boolean | undefined;
+    expireAfterSeconds?: number | undefined;
+    partialFilterExpression?: Record<string, any> | undefined;
+    background?: boolean | undefined;
+}>;
+export type NoSQLIndex = z.infer<typeof NoSQLIndexSchema>;
+/**
+ * NoSQL Transaction Options
+ * Options for NoSQL transactions (where supported)
+ */
+export declare const NoSQLTransactionOptionsSchema: z.ZodObject<{
+    /**
+     * Read concern level
+     */
+    readConcern: z.ZodOptional<z.ZodEnum<["local", "majority", "linearizable", "snapshot"]>>;
+    /**
+     * Write concern level
+     */
+    writeConcern: z.ZodOptional<z.ZodEnum<["majority", "acknowledged", "unacknowledged"]>>;
+    /**
+     * Read preference
+     */
+    readPreference: z.ZodOptional<z.ZodEnum<["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]>>;
+    /**
+     * Transaction timeout in milliseconds
+     */
+    maxCommitTimeMS: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+    writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    readConcern?: "local" | "snapshot" | "majority" | "linearizable" | undefined;
+    maxCommitTimeMS?: number | undefined;
+}, {
+    readPreference?: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest" | undefined;
+    writeConcern?: "majority" | "acknowledged" | "unacknowledged" | undefined;
+    readConcern?: "local" | "snapshot" | "majority" | "linearizable" | undefined;
+    maxCommitTimeMS?: number | undefined;
+}>;
+export type NoSQLTransactionOptions = z.infer<typeof NoSQLTransactionOptionsSchema>;
+//# sourceMappingURL=driver-nosql.zod.d.ts.map