import { Q as QueryAST, A as Address, b as AddressSchema, c as AggregationFunction, d as AggregationNode, e as AggregationNodeSchema, C as ComputedFieldCache, f as ComputedFieldCacheSchema, g as CurrencyConfig, h as CurrencyConfigInput, i as CurrencyConfigSchema, j as CurrencyValue, k as CurrencyValueSchema, D as DataQualityRules, l as DataQualityRulesInput, m as DataQualityRulesSchema, n as Field, o as FieldInput, p as FieldNodeSchema, a as FieldSchema, F as FieldType, q as FileAttachmentConfig, r as FileAttachmentConfigInput, s as FileAttachmentConfigSchema, t as FullTextSearch, u as FullTextSearchSchema, J as JoinNode, v as JoinNodeSchema, w as JoinStrategy, x as JoinType, L as LocationCoordinates, y as LocationCoordinatesSchema, z as QueryInput, B as QuerySchema, S as SelectOption, E as SelectOptionSchema, G as SortNode, H as SortNodeSchema, V as VectorConfig, I as VectorConfigInput, K as VectorConfigSchema, W as WindowFunction, M as WindowFunctionNode, N as WindowFunctionNodeSchema, O as WindowSpec, P as WindowSpecSchema } from './field.zod-D1NCePFb.js';
import { A as ALL_OPERATORS, C as ComparisonOperatorSchema, E as EqualityOperatorSchema, a as FILTER_OPERATORS, b as FieldOperators, c as FieldOperatorsSchema, d as FieldReference, e as FieldReferenceSchema, f as Filter, F as FilterCondition, g as FilterConditionSchema, h as FilterOperatorKey, L as LOGICAL_OPERATORS, i as LogicalOperatorKey, N as NormalizedFilter, j as NormalizedFilterSchema, O as OperatorKey, Q as QueryFilter, k as QueryFilterSchema, R as RangeOperatorSchema, S as Scalar, l as SetOperatorSchema, m as SpecialOperatorSchema, n as StringOperatorSchema } from './filter.zod-CtZ3VJ3e.js';
import { A as ApiMethod, a as AsyncValidation, b as AsyncValidationSchema, B as BaseValidationRuleShape, C as CDCConfig, c as CDCConfigSchema, d as ConditionalValidation, e as ConditionalValidationSchema, f as CrossFieldValidation, g as CrossFieldValidationSchema, h as CustomValidation, i as CustomValidatorSchema, F as FormatValidation, j as FormatValidationSchema, I as IndexSchema, J as JSONValidation, k as JSONValidationSchema, l as ObjectCapabilities, m as ObjectExtension, n as ObjectExtensionSchema, o as ObjectIndex, p as ObjectOwnership, q as ObjectOwnershipEnum, O as ObjectSchema, P as PartitioningConfig, r as PartitioningConfigSchema, s as ScriptValidation, t as ScriptValidationSchema, u as SearchConfigSchema, S as ServiceObject, v as ServiceObjectInput, w as SoftDeleteConfig, x as SoftDeleteConfigSchema, y as StateMachineValidation, z as StateMachineValidationSchema, T as TenancyConfig, D as TenancyConfigSchema, U as UniquenessValidation, E as UniquenessValidationSchema, V as ValidationRule, G as ValidationRuleSchema, H as VersioningConfig, K as VersioningConfigSchema } from './object.zod-CxpSoqwV.js';
import { z } from 'zod';
import { B as BaseEngineOptions, i as BaseEngineOptionsSchema, e as DataEngineAggregateOptions, j as DataEngineAggregateOptionsSchema, k as DataEngineAggregateRequestSchema, l as DataEngineBatchRequestSchema, m as DataEngineContractSchema, d as DataEngineCountOptions, n as DataEngineCountOptionsSchema, o as DataEngineCountRequestSchema, c as DataEngineDeleteOptions, p as DataEngineDeleteOptionsSchema, q as DataEngineDeleteRequestSchema, r as DataEngineExecuteRequestSchema, s as DataEngineFilter, t as DataEngineFilterSchema, u as DataEngineFindOneRequestSchema, v as DataEngineFindRequestSchema, a as DataEngineInsertOptions, w as DataEngineInsertOptionsSchema, x as DataEngineInsertRequestSchema, D as DataEngineQueryOptions, y as DataEngineQueryOptionsSchema, f as DataEngineRequest, z as DataEngineRequestSchema, A as DataEngineSort, C as DataEngineSortSchema, b as DataEngineUpdateOptions, E as DataEngineUpdateOptionsSchema, F as DataEngineUpdateRequestSchema, G as DataEngineVectorFindRequestSchema, h as DriverCapabilities, H as DriverCapabilitiesSchema, I as DriverConfig, J as DriverConfigSchema, K as DriverInterface, L as DriverInterfaceSchema, g as DriverOptions, M as DriverOptionsSchema, P as PoolConfig, N as PoolConfigSchema } from './driver.zod-BOIvRcxq.js';

/**
 * Hook Lifecycle Events
 * Defines the interception points in the ObjectQL execution pipeline.
 */
declare const HookEvent: z.ZodEnum<{
    beforeFind: "beforeFind";
    afterFind: "afterFind";
    beforeFindOne: "beforeFindOne";
    afterFindOne: "afterFindOne";
    beforeCount: "beforeCount";
    afterCount: "afterCount";
    beforeAggregate: "beforeAggregate";
    afterAggregate: "afterAggregate";
    beforeInsert: "beforeInsert";
    afterInsert: "afterInsert";
    beforeUpdate: "beforeUpdate";
    afterUpdate: "afterUpdate";
    beforeDelete: "beforeDelete";
    afterDelete: "afterDelete";
    beforeUpdateMany: "beforeUpdateMany";
    afterUpdateMany: "afterUpdateMany";
    beforeDeleteMany: "beforeDeleteMany";
    afterDeleteMany: "afterDeleteMany";
}>;
/**
 * Hook Definition Schema
 *
 * Hooks serve as the "Logic Layer" in ObjectStack, allowing developers to
 * inject custom code during the data access lifecycle.
 *
 * Use cases:
 * - Data Enrichment (Default values, Calculated fields)
 * - Validation (Complex business rules)
 * - Side Effects (Sending emails, Syncing to external systems)
 * - Security (Filtering data based on context)
 */
declare const HookSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    object: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
    events: z.ZodArray<z.ZodEnum<{
        beforeFind: "beforeFind";
        afterFind: "afterFind";
        beforeFindOne: "beforeFindOne";
        afterFindOne: "afterFindOne";
        beforeCount: "beforeCount";
        afterCount: "afterCount";
        beforeAggregate: "beforeAggregate";
        afterAggregate: "afterAggregate";
        beforeInsert: "beforeInsert";
        afterInsert: "afterInsert";
        beforeUpdate: "beforeUpdate";
        afterUpdate: "afterUpdate";
        beforeDelete: "beforeDelete";
        afterDelete: "afterDelete";
        beforeUpdateMany: "beforeUpdateMany";
        afterUpdateMany: "afterUpdateMany";
        beforeDeleteMany: "beforeDeleteMany";
        afterDeleteMany: "afterDeleteMany";
    }>>;
    handler: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>;
    priority: z.ZodDefault<z.ZodNumber>;
    async: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    retryPolicy: z.ZodOptional<z.ZodObject<{
        maxRetries: z.ZodDefault<z.ZodNumber>;
        backoffMs: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    onError: z.ZodDefault<z.ZodEnum<{
        abort: "abort";
        log: "log";
    }>>;
}, z.core.$strip>;
/**
 * Hook Runtime Context
 * Defines what is available to the hook handler during execution.
 *
 * Best Practices:
 * - **Immutability**: `object`, `event`, `id` are immutable.
 * - **Mutability**: `input` and `result` are mutable to allow transformation.
 * - **Encapsulation**: `session` isolates auth info; `transaction` ensures atomicity.
 */
declare const HookContextSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    object: z.ZodString;
    event: z.ZodEnum<{
        beforeFind: "beforeFind";
        afterFind: "afterFind";
        beforeFindOne: "beforeFindOne";
        afterFindOne: "afterFindOne";
        beforeCount: "beforeCount";
        afterCount: "afterCount";
        beforeAggregate: "beforeAggregate";
        afterAggregate: "afterAggregate";
        beforeInsert: "beforeInsert";
        afterInsert: "afterInsert";
        beforeUpdate: "beforeUpdate";
        afterUpdate: "afterUpdate";
        beforeDelete: "beforeDelete";
        afterDelete: "afterDelete";
        beforeUpdateMany: "beforeUpdateMany";
        afterUpdateMany: "afterUpdateMany";
        beforeDeleteMany: "beforeDeleteMany";
        afterDeleteMany: "afterDeleteMany";
    }>;
    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    result: z.ZodOptional<z.ZodUnknown>;
    previous: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    session: z.ZodOptional<z.ZodObject<{
        userId: z.ZodOptional<z.ZodString>;
        tenantId: z.ZodOptional<z.ZodString>;
        roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
        accessToken: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    transaction: z.ZodOptional<z.ZodUnknown>;
    ql: z.ZodUnknown;
    api: z.ZodOptional<z.ZodUnknown>;
    user: z.ZodOptional<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        email: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Hook = z.input<typeof HookSchema>;
type ResolvedHook = z.output<typeof HookSchema>;
type HookEventType = z.infer<typeof HookEvent>;
type HookContext = z.infer<typeof HookContextSchema>;

/**
 * Transformation Logic
 * Built-in helpers for converting data during import.
 */
declare const TransformType: z.ZodEnum<{
    constant: "constant";
    lookup: "lookup";
    javascript: "javascript";
    map: "map";
    join: "join";
    split: "split";
    none: "none";
}>;
/**
 * Field Mapping Item
 */
declare const FieldMappingSchema: z.ZodObject<{
    source: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
    target: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
    transform: z.ZodDefault<z.ZodEnum<{
        constant: "constant";
        lookup: "lookup";
        javascript: "javascript";
        map: "map";
        join: "join";
        split: "split";
        none: "none";
    }>>;
    params: z.ZodOptional<z.ZodObject<{
        value: z.ZodOptional<z.ZodUnknown>;
        object: z.ZodOptional<z.ZodString>;
        fromField: z.ZodOptional<z.ZodString>;
        toField: z.ZodOptional<z.ZodString>;
        autoCreate: z.ZodOptional<z.ZodBoolean>;
        valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        separator: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Data Mapping Schema
 * Defines a reusable data mapping configuration for ETL operations.
 *
 * **NAMING CONVENTION:**
 * Mapping names are machine identifiers and must be lowercase snake_case.
 *
 * @example Good mapping names
 * - 'salesforce_to_crm'
 * - 'csv_import_contacts'
 * - 'api_sync_orders'
 *
 * @example Bad mapping names (will be rejected)
 * - 'SalesforceToCRM' (PascalCase)
 * - 'CSV Import' (spaces)
 */
declare const MappingSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    sourceFormat: z.ZodDefault<z.ZodEnum<{
        json: "json";
        csv: "csv";
        xml: "xml";
        sql: "sql";
    }>>;
    targetObject: z.ZodString;
    fieldMapping: z.ZodArray<z.ZodObject<{
        source: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
        target: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
        transform: z.ZodDefault<z.ZodEnum<{
            constant: "constant";
            lookup: "lookup";
            javascript: "javascript";
            map: "map";
            join: "join";
            split: "split";
            none: "none";
        }>>;
        params: z.ZodOptional<z.ZodObject<{
            value: z.ZodOptional<z.ZodUnknown>;
            object: z.ZodOptional<z.ZodString>;
            fromField: z.ZodOptional<z.ZodString>;
            toField: z.ZodOptional<z.ZodString>;
            autoCreate: z.ZodOptional<z.ZodBoolean>;
            valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            separator: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    mode: z.ZodDefault<z.ZodEnum<{
        insert: "insert";
        update: "update";
        upsert: "upsert";
    }>>;
    upsertKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
    extractQuery: z.ZodOptional<z.ZodType<QueryAST, unknown, z.core.$ZodTypeInternals<QueryAST, unknown>>>;
    errorPolicy: z.ZodDefault<z.ZodEnum<{
        abort: "abort";
        skip: "skip";
        retry: "retry";
    }>>;
    batchSize: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
type Mapping = z.infer<typeof MappingSchema>;
type FieldMapping = z.infer<typeof FieldMappingSchema>;

/**
 * SQL Dialect Enumeration
 * Supported SQL database dialects
 */
declare const SQLDialectSchema: z.ZodEnum<{
    postgresql: "postgresql";
    mysql: "mysql";
    sqlite: "sqlite";
    mssql: "mssql";
    oracle: "oracle";
    mariadb: "mariadb";
}>;
type SQLDialect = z.infer<typeof SQLDialectSchema>;
/**
 * Data Type Mapping Schema
 * Maps ObjectStack field types to SQL-specific data types
 *
 * @example PostgreSQL data type mapping
 * {
 *   text: 'VARCHAR(255)',
 *   number: 'NUMERIC',
 *   boolean: 'BOOLEAN',
 *   date: 'DATE',
 *   datetime: 'TIMESTAMP',
 *   json: 'JSONB',
 *   uuid: 'UUID',
 *   binary: 'BYTEA'
 * }
 */
declare const DataTypeMappingSchema: 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>;
}, z.core.$strip>;
type DataTypeMapping = z.infer<typeof DataTypeMappingSchema>;
/**
 * SSL Configuration Schema
 * SSL/TLS connection configuration for secure database connections
 *
 * @example PostgreSQL SSL configuration
 * {
 *   rejectUnauthorized: true,
 *   ca: '/path/to/ca-cert.pem',
 *   cert: '/path/to/client-cert.pem',
 *   key: '/path/to/client-key.pem'
 * }
 */
declare const SSLConfigSchema: z.ZodObject<{
    rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
    ca: z.ZodOptional<z.ZodString>;
    cert: z.ZodOptional<z.ZodString>;
    key: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type SSLConfig = z.infer<typeof SSLConfigSchema>;
/**
 * SQL Driver Configuration Schema
 * Extended driver configuration specific to SQL databases
 *
 * @example PostgreSQL driver configuration
 * {
 *   name: 'primary-db',
 *   type: 'sql',
 *   dialect: 'postgresql',
 *   connectionString: 'postgresql://user:pass@localhost:5432/mydb',
 *   dataTypeMapping: {
 *     text: 'VARCHAR(255)',
 *     number: 'NUMERIC',
 *     boolean: 'BOOLEAN',
 *     date: 'DATE',
 *     datetime: 'TIMESTAMP',
 *     json: 'JSONB',
 *     uuid: 'UUID',
 *     binary: 'BYTEA'
 *   },
 *   ssl: true,
 *   sslConfig: {
 *     rejectUnauthorized: true,
 *     ca: '/etc/ssl/certs/ca.pem'
 *   },
 *   poolConfig: {
 *     min: 2,
 *     max: 10,
 *     idleTimeoutMillis: 30000,
 *     connectionTimeoutMillis: 5000
 *   },
 *   capabilities: {
 *     create: true,
 *     read: true,
 *     update: true,
 *     delete: true,
 *     bulkCreate: true,
 *     bulkUpdate: true,
 *     bulkDelete: true,
 *     transactions: true,
 *     savepoints: true,
 *     isolationLevels: ['read-committed', 'repeatable-read', 'serializable'],
 *     queryFilters: true,
 *     queryAggregations: true,
 *     querySorting: true,
 *     queryPagination: true,
 *     queryWindowFunctions: true,
 *     querySubqueries: true,
 *     queryCTE: true,
 *     joins: true,
 *     fullTextSearch: true,
 *     jsonQuery: true,
 *     geospatialQuery: false,
 *     streaming: true,
 *     jsonFields: true,
 *     arrayFields: true,
 *     vectorSearch: true,
 *     schemaSync: true,
 *     migrations: true,
 *     indexes: true,
 *     connectionPooling: true,
 *     preparedStatements: true,
 *     queryCache: false
 *   }
 * }
 */
declare const SQLDriverConfigSchema: z.ZodObject<{
    name: z.ZodString;
    capabilities: 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_uncommitted";
            read_committed: "read_committed";
            repeatable_read: "repeatable_read";
            serializable: "serializable";
            snapshot: "snapshot";
        }>>>;
        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>;
        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>;
    }, z.core.$strip>;
    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>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"sql">;
    dialect: z.ZodEnum<{
        postgresql: "postgresql";
        mysql: "mysql";
        sqlite: "sqlite";
        mssql: "mssql";
        oracle: "oracle";
        mariadb: "mariadb";
    }>;
    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>;
    }, z.core.$strip>;
    ssl: z.ZodDefault<z.ZodBoolean>;
    sslConfig: z.ZodOptional<z.ZodObject<{
        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
        ca: z.ZodOptional<z.ZodString>;
        cert: z.ZodOptional<z.ZodString>;
        key: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type SQLDriverConfig = z.infer<typeof SQLDriverConfigSchema>;

/**
 * NoSQL Database Type Enumeration
 * Supported NoSQL database types
 */
declare const NoSQLDatabaseTypeSchema: z.ZodEnum<{
    mongodb: "mongodb";
    couchdb: "couchdb";
    dynamodb: "dynamodb";
    cassandra: "cassandra";
    redis: "redis";
    elasticsearch: "elasticsearch";
    neo4j: "neo4j";
    orientdb: "orientdb";
}>;
type NoSQLDatabaseType = z.infer<typeof NoSQLDatabaseTypeSchema>;
/**
 * NoSQL Query Operation Types
 * Different types of operations supported by NoSQL databases
 */
declare const NoSQLOperationTypeSchema: z.ZodEnum<{
    count: "count";
    insert: "insert";
    update: "update";
    delete: "delete";
    find: "find";
    distinct: "distinct";
    aggregate: "aggregate";
    findOne: "findOne";
    mapReduce: "mapReduce";
    createIndex: "createIndex";
    dropIndex: "dropIndex";
}>;
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)
 */
declare const ConsistencyLevelSchema: z.ZodEnum<{
    all: "all";
    quorum: "quorum";
    one: "one";
    local_quorum: "local_quorum";
    each_quorum: "each_quorum";
    eventual: "eventual";
}>;
type ConsistencyLevel = z.infer<typeof ConsistencyLevelSchema>;
/**
 * NoSQL Index Type
 * Types of indexes supported by NoSQL databases
 */
declare const NoSQLIndexTypeSchema: z.ZodEnum<{
    ttl: "ttl";
    text: "text";
    unique: "unique";
    compound: "compound";
    single: "single";
    geospatial: "geospatial";
    hashed: "hashed";
    sparse: "sparse";
}>;
type NoSQLIndexType = z.infer<typeof NoSQLIndexTypeSchema>;
/**
 * NoSQL Sharding Configuration
 * Configuration for horizontal partitioning across multiple nodes
 */
declare const ShardingConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    shardKey: z.ZodOptional<z.ZodString>;
    shardingStrategy: z.ZodOptional<z.ZodEnum<{
        hash: "hash";
        range: "range";
        zone: "zone";
    }>>;
    numShards: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ShardingConfig = z.infer<typeof ShardingConfigSchema>;
/**
 * NoSQL Replication Configuration
 * Configuration for data replication across nodes
 */
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: "primary";
        primaryPreferred: "primaryPreferred";
        secondary: "secondary";
        secondaryPreferred: "secondaryPreferred";
        nearest: "nearest";
    }>>;
    writeConcern: z.ZodOptional<z.ZodEnum<{
        majority: "majority";
        acknowledged: "acknowledged";
        unacknowledged: "unacknowledged";
    }>>;
}, z.core.$strip>;
type ReplicationConfig = z.infer<typeof ReplicationConfigSchema>;
/**
 * Document Schema Validation
 * Schema validation rules for document-based NoSQL databases
 */
declare const DocumentSchemaValidationSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    validationLevel: z.ZodOptional<z.ZodEnum<{
        strict: "strict";
        moderate: "moderate";
        off: "off";
    }>>;
    validationAction: z.ZodOptional<z.ZodEnum<{
        error: "error";
        warn: "warn";
    }>>;
    jsonSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
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'
 * }
 */
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>;
}, z.core.$strip>;
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
 *   }
 * }
 */
declare const NoSQLDriverConfigSchema: z.ZodObject<{
    name: z.ZodString;
    capabilities: 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_uncommitted";
            read_committed: "read_committed";
            repeatable_read: "repeatable_read";
            serializable: "serializable";
            snapshot: "snapshot";
        }>>>;
        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>;
        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>;
    }, z.core.$strip>;
    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>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"nosql">;
    databaseType: z.ZodEnum<{
        mongodb: "mongodb";
        couchdb: "couchdb";
        dynamodb: "dynamodb";
        cassandra: "cassandra";
        redis: "redis";
        elasticsearch: "elasticsearch";
        neo4j: "neo4j";
        orientdb: "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>;
    }, z.core.$strip>;
    consistency: z.ZodOptional<z.ZodEnum<{
        all: "all";
        quorum: "quorum";
        one: "one";
        local_quorum: "local_quorum";
        each_quorum: "each_quorum";
        eventual: "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: "primary";
            primaryPreferred: "primaryPreferred";
            secondary: "secondary";
            secondaryPreferred: "secondaryPreferred";
            nearest: "nearest";
        }>>;
        writeConcern: z.ZodOptional<z.ZodEnum<{
            majority: "majority";
            acknowledged: "acknowledged";
            unacknowledged: "unacknowledged";
        }>>;
    }, z.core.$strip>>;
    sharding: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        shardKey: z.ZodOptional<z.ZodString>;
        shardingStrategy: z.ZodOptional<z.ZodEnum<{
            hash: "hash";
            range: "range";
            zone: "zone";
        }>>;
        numShards: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    schemaValidation: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        validationLevel: z.ZodOptional<z.ZodEnum<{
            strict: "strict";
            moderate: "moderate";
            off: "off";
        }>>;
        validationAction: z.ZodOptional<z.ZodEnum<{
            error: "error";
            warn: "warn";
        }>>;
        jsonSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>;
    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>;
}, z.core.$strip>;
type NoSQLDriverConfig = z.infer<typeof NoSQLDriverConfigSchema>;
/**
 * NoSQL Query Options
 * Additional options for NoSQL queries
 */
declare const NoSQLQueryOptionsSchema: z.ZodObject<{
    consistency: z.ZodOptional<z.ZodEnum<{
        all: "all";
        quorum: "quorum";
        one: "one";
        local_quorum: "local_quorum";
        each_quorum: "each_quorum";
        eventual: "eventual";
    }>>;
    readFromSecondary: z.ZodOptional<z.ZodBoolean>;
    projection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    useCursor: z.ZodOptional<z.ZodBoolean>;
    batchSize: z.ZodOptional<z.ZodNumber>;
    profile: z.ZodOptional<z.ZodBoolean>;
    hint: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type NoSQLQueryOptions = z.infer<typeof NoSQLQueryOptionsSchema>;
/**
 * NoSQL Aggregation Pipeline Stage
 * Represents a single stage in an aggregation pipeline (MongoDB-style)
 */
declare const AggregationStageSchema: z.ZodObject<{
    operator: z.ZodString;
    options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
type AggregationStage = z.infer<typeof AggregationStageSchema>;
/**
 * NoSQL Aggregation Pipeline
 * Sequence of aggregation stages for complex data transformations
 */
declare const AggregationPipelineSchema: z.ZodObject<{
    collection: z.ZodString;
    stages: z.ZodArray<z.ZodObject<{
        operator: z.ZodString;
        options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>>;
    options: z.ZodOptional<z.ZodObject<{
        consistency: z.ZodOptional<z.ZodEnum<{
            all: "all";
            quorum: "quorum";
            one: "one";
            local_quorum: "local_quorum";
            each_quorum: "each_quorum";
            eventual: "eventual";
        }>>;
        readFromSecondary: z.ZodOptional<z.ZodBoolean>;
        projection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
        timeout: z.ZodOptional<z.ZodNumber>;
        useCursor: z.ZodOptional<z.ZodBoolean>;
        batchSize: z.ZodOptional<z.ZodNumber>;
        profile: z.ZodOptional<z.ZodBoolean>;
        hint: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type AggregationPipeline = z.infer<typeof AggregationPipelineSchema>;
/**
 * NoSQL Index Definition
 * Definition for creating indexes in NoSQL databases
 */
declare const NoSQLIndexSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodEnum<{
        ttl: "ttl";
        text: "text";
        unique: "unique";
        compound: "compound";
        single: "single";
        geospatial: "geospatial";
        hashed: "hashed";
        sparse: "sparse";
    }>;
    fields: z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        order: z.ZodOptional<z.ZodEnum<{
            asc: "asc";
            desc: "desc";
            text: "text";
            "2dsphere": "2dsphere";
        }>>;
    }, z.core.$strip>>;
    unique: z.ZodDefault<z.ZodBoolean>;
    sparse: z.ZodDefault<z.ZodBoolean>;
    expireAfterSeconds: z.ZodOptional<z.ZodNumber>;
    partialFilterExpression: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    background: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type NoSQLIndex = z.infer<typeof NoSQLIndexSchema>;
/**
 * NoSQL Transaction Options
 * Options for NoSQL transactions (where supported)
 */
declare const NoSQLTransactionOptionsSchema: z.ZodObject<{
    readConcern: z.ZodOptional<z.ZodEnum<{
        snapshot: "snapshot";
        local: "local";
        majority: "majority";
        linearizable: "linearizable";
    }>>;
    writeConcern: z.ZodOptional<z.ZodEnum<{
        majority: "majority";
        acknowledged: "acknowledged";
        unacknowledged: "unacknowledged";
    }>>;
    readPreference: z.ZodOptional<z.ZodEnum<{
        primary: "primary";
        primaryPreferred: "primaryPreferred";
        secondary: "secondary";
        secondaryPreferred: "secondaryPreferred";
        nearest: "nearest";
    }>>;
    maxCommitTimeMS: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type NoSQLTransactionOptions = z.infer<typeof NoSQLTransactionOptionsSchema>;

/**
 * Data Import Strategy
 * Defines how the engine handles existing records.
 */
declare const DatasetMode: z.ZodEnum<{
    insert: "insert";
    update: "update";
    upsert: "upsert";
    replace: "replace";
    ignore: "ignore";
}>;
/**
 * Dataset Schema (Seed Data / Fixtures)
 *
 * Standardized format for transporting data.
 * Used for:
 * 1. System Bootstrapping (Admin accounts, Standard Roles)
 * 2. Reference Data (Countries, Currencies)
 * 3. Demo/Test Data
 */
declare const DatasetSchema: z.ZodObject<{
    object: z.ZodString;
    externalId: z.ZodDefault<z.ZodString>;
    mode: z.ZodDefault<z.ZodEnum<{
        insert: "insert";
        update: "update";
        upsert: "upsert";
        replace: "replace";
        ignore: "ignore";
    }>>;
    env: z.ZodDefault<z.ZodArray<z.ZodEnum<{
        prod: "prod";
        dev: "dev";
        test: "test";
    }>>>;
    records: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/** Parsed/output type — all defaults are applied (env, mode, externalId always present) */
type Dataset = z.infer<typeof DatasetSchema>;
/** Input type — fields with defaults (env, mode, externalId) are optional */
type DatasetInput = z.input<typeof DatasetSchema>;
type DatasetImportMode = z.infer<typeof DatasetMode>;

/**
 * Document Version Schema
 *
 * Represents a single version of a document in a version-controlled system.
 * Each version is immutable and maintains its own metadata and download URL.
 *
 * @example
 * ```json
 * {
 *   "versionNumber": 2,
 *   "createdAt": 1704067200000,
 *   "createdBy": "user_123",
 *   "size": 2048576,
 *   "checksum": "a1b2c3d4e5f6",
 *   "downloadUrl": "https://storage.example.com/docs/v2/file.pdf",
 *   "isLatest": true
 * }
 * ```
 */
declare const DocumentVersionSchema: z.ZodObject<{
    versionNumber: z.ZodNumber;
    createdAt: z.ZodNumber;
    createdBy: z.ZodString;
    size: z.ZodNumber;
    checksum: z.ZodString;
    downloadUrl: z.ZodString;
    isLatest: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, z.core.$strip>;
/**
 * Document Template Schema
 *
 * Defines a reusable document template with dynamic placeholders.
 * Templates can be used to generate documents with variable content.
 *
 * @example
 * ```json
 * {
 *   "id": "contract-template",
 *   "name": "Service Agreement",
 *   "description": "Standard service agreement template",
 *   "fileUrl": "https://example.com/templates/contract.docx",
 *   "fileType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 *   "placeholders": [
 *     {
 *       "key": "client_name",
 *       "label": "Client Name",
 *       "type": "text",
 *       "required": true
 *     },
 *     {
 *       "key": "contract_date",
 *       "label": "Contract Date",
 *       "type": "date",
 *       "required": true
 *     }
 *   ]
 * }
 * ```
 */
declare const DocumentTemplateSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    fileUrl: z.ZodString;
    fileType: z.ZodString;
    placeholders: z.ZodArray<z.ZodObject<{
        key: z.ZodString;
        label: z.ZodString;
        type: z.ZodEnum<{
            number: "number";
            date: "date";
            text: "text";
            image: "image";
        }>;
        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * E-Signature Configuration Schema
 *
 * Configuration for electronic signature workflows.
 * Supports integration with popular e-signature providers.
 *
 * @example
 * ```json
 * {
 *   "provider": "docusign",
 *   "enabled": true,
 *   "signers": [
 *     {
 *       "email": "client@example.com",
 *       "name": "John Doe",
 *       "role": "Client",
 *       "order": 1
 *     },
 *     {
 *       "email": "manager@example.com",
 *       "name": "Jane Smith",
 *       "role": "Manager",
 *       "order": 2
 *     }
 *   ],
 *   "expirationDays": 30,
 *   "reminderDays": 7
 * }
 * ```
 */
declare const ESignatureConfigSchema: z.ZodObject<{
    provider: z.ZodEnum<{
        custom: "custom";
        docusign: "docusign";
        "adobe-sign": "adobe-sign";
        hellosign: "hellosign";
    }>;
    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    signers: z.ZodArray<z.ZodObject<{
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodString;
        order: z.ZodNumber;
    }, z.core.$strip>>;
    expirationDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    reminderDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, z.core.$strip>;
/**
 * Document Schema
 *
 * Comprehensive document management protocol supporting versioning,
 * templates, e-signatures, and access control.
 *
 * @example
 * ```json
 * {
 *   "id": "doc_123",
 *   "name": "Service Agreement 2024",
 *   "description": "Annual service agreement",
 *   "fileType": "application/pdf",
 *   "fileSize": 1048576,
 *   "category": "contracts",
 *   "tags": ["legal", "2024", "services"],
 *   "versioning": {
 *     "enabled": true,
 *     "versions": [
 *       {
 *         "versionNumber": 1,
 *         "createdAt": 1704067200000,
 *         "createdBy": "user_123",
 *         "size": 1048576,
 *         "checksum": "abc123",
 *         "downloadUrl": "https://example.com/docs/v1.pdf",
 *         "isLatest": true
 *       }
 *     ],
 *     "majorVersion": 1,
 *     "minorVersion": 0
 *   },
 *   "access": {
 *     "isPublic": false,
 *     "sharedWith": ["user_456", "team_789"],
 *     "expiresAt": 1735689600000
 *   },
 *   "metadata": {
 *     "author": "John Doe",
 *     "department": "Legal"
 *   }
 * }
 * ```
 */
declare const DocumentSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    fileType: z.ZodString;
    fileSize: z.ZodNumber;
    category: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    versioning: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        versions: z.ZodArray<z.ZodObject<{
            versionNumber: z.ZodNumber;
            createdAt: z.ZodNumber;
            createdBy: z.ZodString;
            size: z.ZodNumber;
            checksum: z.ZodString;
            downloadUrl: z.ZodString;
            isLatest: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, z.core.$strip>>;
        majorVersion: z.ZodNumber;
        minorVersion: z.ZodNumber;
    }, z.core.$strip>>;
    template: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        fileUrl: z.ZodString;
        fileType: z.ZodString;
        placeholders: z.ZodArray<z.ZodObject<{
            key: z.ZodString;
            label: z.ZodString;
            type: z.ZodEnum<{
                number: "number";
                date: "date";
                text: "text";
                image: "image";
            }>;
            required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    eSignature: z.ZodOptional<z.ZodObject<{
        provider: z.ZodEnum<{
            custom: "custom";
            docusign: "docusign";
            "adobe-sign": "adobe-sign";
            hellosign: "hellosign";
        }>;
        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        signers: z.ZodArray<z.ZodObject<{
            email: z.ZodString;
            name: z.ZodString;
            role: z.ZodString;
            order: z.ZodNumber;
        }, z.core.$strip>>;
        expirationDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        reminderDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    }, z.core.$strip>>;
    access: z.ZodOptional<z.ZodObject<{
        isPublic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        sharedWith: z.ZodOptional<z.ZodArray<z.ZodString>>;
        expiresAt: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type Document = z.infer<typeof DocumentSchema>;
type DocumentVersion = z.infer<typeof DocumentVersionSchema>;
type DocumentTemplate = z.infer<typeof DocumentTemplateSchema>;
type ESignatureConfig = z.infer<typeof ESignatureConfigSchema>;

/**
 * External Data Source Schema
 *
 * Configuration for connecting to external data systems.
 * Similar to Salesforce External Objects for real-time data integration.
 *
 * @example
 * ```json
 * {
 *   "id": "salesforce-accounts",
 *   "name": "Salesforce Account Data",
 *   "type": "rest-api",
 *   "endpoint": "https://api.salesforce.com/services/data/v58.0",
 *   "authentication": {
 *     "type": "oauth2",
 *     "config": {
 *       "clientId": "...",
 *       "clientSecret": "...",
 *       "tokenUrl": "https://login.salesforce.com/services/oauth2/token"
 *     }
 *   }
 * }
 * ```
 */
declare const ExternalDataSourceSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    type: z.ZodEnum<{
        custom: "custom";
        odata: "odata";
        "rest-api": "rest-api";
        graphql: "graphql";
    }>;
    endpoint: z.ZodString;
    authentication: z.ZodObject<{
        type: z.ZodEnum<{
            none: "none";
            oauth2: "oauth2";
            "api-key": "api-key";
            basic: "basic";
        }>;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>;
}, z.core.$strip>;
/**
 * Field Mapping Schema for External Lookups
 *
 * Extends the base field mapping with external lookup specific features.
 * Uses the canonical field mapping protocol from shared/mapping.zod.ts.
 *
 * @see {@link BaseFieldMappingSchema} for the base field mapping schema
 *
 * @example
 * ```json
 * {
 *   "source": "AccountName",
 *   "target": "name",
 *   "readonly": true
 * }
 * ```
 */
declare const ExternalFieldMappingSchema: z.ZodObject<{
    source: z.ZodString;
    target: z.ZodString;
    transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"constant">;
        value: z.ZodUnknown;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"cast">;
        targetType: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            date: "date";
        }>;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"lookup">;
        table: z.ZodString;
        keyField: z.ZodString;
        valueField: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"javascript">;
        expression: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"map">;
        mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>], "type">>;
    defaultValue: z.ZodOptional<z.ZodUnknown>;
    type: z.ZodOptional<z.ZodString>;
    readonly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, z.core.$strip>;
/**
 * External Lookup Schema
 *
 * Real-time data lookup protocol for external systems.
 * Enables querying external data sources without replication.
 * Inspired by Salesforce External Objects and OData protocols.
 *
 * @example
 * ```json
 * {
 *   "fieldName": "external_account",
 *   "dataSource": {
 *     "id": "salesforce-api",
 *     "name": "Salesforce",
 *     "type": "rest-api",
 *     "endpoint": "https://api.salesforce.com/services/data/v58.0",
 *     "authentication": {
 *       "type": "oauth2",
 *       "config": {"clientId": "..."}
 *     }
 *   },
 *   "query": {
 *     "endpoint": "/sobjects/Account",
 *     "method": "GET",
 *     "parameters": {"limit": 100}
 *   },
 *   "fieldMappings": [
 *     {
 *       "externalField": "Name",
 *       "localField": "account_name",
 *       "type": "text",
 *       "readonly": true
 *     }
 *   ],
 *   "caching": {
 *     "enabled": true,
 *     "ttl": 300,
 *     "strategy": "ttl"
 *   },
 *   "fallback": {
 *     "enabled": true,
 *     "showError": true
 *   },
 *   "rateLimit": {
 *     "requestsPerSecond": 10,
 *     "burstSize": 20
 *   }
 * }
 * ```
 */
declare const ExternalLookupSchema: z.ZodObject<{
    fieldName: z.ZodString;
    dataSource: z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        type: z.ZodEnum<{
            custom: "custom";
            odata: "odata";
            "rest-api": "rest-api";
            graphql: "graphql";
        }>;
        endpoint: z.ZodString;
        authentication: z.ZodObject<{
            type: z.ZodEnum<{
                none: "none";
                oauth2: "oauth2";
                "api-key": "api-key";
                basic: "basic";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>;
    }, z.core.$strip>;
    query: z.ZodObject<{
        endpoint: z.ZodString;
        method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
            GET: "GET";
            POST: "POST";
        }>>>;
        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>;
    fieldMappings: z.ZodArray<z.ZodObject<{
        source: z.ZodString;
        target: z.ZodString;
        transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"constant">;
            value: z.ZodUnknown;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"cast">;
            targetType: z.ZodEnum<{
                string: "string";
                number: "number";
                boolean: "boolean";
                date: "date";
            }>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"lookup">;
            table: z.ZodString;
            keyField: z.ZodString;
            valueField: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"javascript">;
            expression: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"map">;
            mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>], "type">>;
        defaultValue: z.ZodOptional<z.ZodUnknown>;
        type: z.ZodOptional<z.ZodString>;
        readonly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    }, z.core.$strip>>;
    caching: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        ttl: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
            lru: "lru";
            lfu: "lfu";
            ttl: "ttl";
        }>>>;
    }, z.core.$strip>>;
    fallback: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        defaultValue: z.ZodOptional<z.ZodUnknown>;
        showError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    }, z.core.$strip>>;
    rateLimit: z.ZodOptional<z.ZodObject<{
        requestsPerSecond: z.ZodNumber;
        burstSize: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    retry: z.ZodOptional<z.ZodObject<{
        maxRetries: z.ZodDefault<z.ZodNumber>;
        initialDelayMs: z.ZodDefault<z.ZodNumber>;
        maxDelayMs: z.ZodDefault<z.ZodNumber>;
        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
        retryableStatusCodes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
    }, z.core.$strip>>;
    transform: z.ZodOptional<z.ZodObject<{
        request: z.ZodOptional<z.ZodObject<{
            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$strip>>;
        response: z.ZodOptional<z.ZodObject<{
            dataPath: z.ZodOptional<z.ZodString>;
            totalPath: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    pagination: z.ZodOptional<z.ZodObject<{
        type: z.ZodDefault<z.ZodEnum<{
            offset: "offset";
            cursor: "cursor";
            page: "page";
        }>>;
        pageSize: z.ZodDefault<z.ZodNumber>;
        maxPages: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ExternalLookup = z.infer<typeof ExternalLookupSchema>;
type ExternalDataSource = z.infer<typeof ExternalDataSourceSchema>;
type ExternalFieldMapping = z.infer<typeof ExternalFieldMappingSchema>;

/**
 * Driver Identifier
 * Can be a built-in driver or a plugin-contributed driver (e.g., "com.vendor.snowflake").
 */
declare const DriverType: z.ZodString;
/**
 * Driver Definition Schema
 * Metadata describing a Database Driver.
 * Plugins use this to register new connectivity options.
 */
declare const DriverDefinitionSchema: z.ZodObject<{
    id: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    icon: z.ZodOptional<z.ZodString>;
    configSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    capabilities: z.ZodOptional<z.ZodLazy<z.ZodObject<{
        transactions: z.ZodDefault<z.ZodBoolean>;
        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>;
        joins: z.ZodDefault<z.ZodBoolean>;
        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
        readOnly: z.ZodDefault<z.ZodBoolean>;
        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
/**
 * Datasource Capabilities Schema
 * Declares what this datasource naturally supports.
 * The ObjectQL engine uses this to determine what logic to push down
 * and what to compute in memory.
 */
declare const DatasourceCapabilities: z.ZodObject<{
    transactions: z.ZodDefault<z.ZodBoolean>;
    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>;
    joins: z.ZodDefault<z.ZodBoolean>;
    fullTextSearch: z.ZodDefault<z.ZodBoolean>;
    readOnly: z.ZodDefault<z.ZodBoolean>;
    dynamicSchema: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
/**
 * Datasource Schema
 * Represents a connection to an external data store.
 */
declare const DatasourceSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    driver: z.ZodString;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    pool: z.ZodOptional<z.ZodObject<{
        min: z.ZodDefault<z.ZodNumber>;
        max: z.ZodDefault<z.ZodNumber>;
        idleTimeoutMillis: z.ZodDefault<z.ZodNumber>;
        connectionTimeoutMillis: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    readReplicas: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    capabilities: z.ZodOptional<z.ZodObject<{
        transactions: z.ZodDefault<z.ZodBoolean>;
        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>;
        joins: z.ZodDefault<z.ZodBoolean>;
        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
        readOnly: z.ZodDefault<z.ZodBoolean>;
        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    healthCheck: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        intervalMs: z.ZodDefault<z.ZodNumber>;
        timeoutMs: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    ssl: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
        ca: z.ZodOptional<z.ZodString>;
        cert: z.ZodOptional<z.ZodString>;
        key: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    retryPolicy: z.ZodOptional<z.ZodObject<{
        maxRetries: z.ZodDefault<z.ZodNumber>;
        baseDelayMs: z.ZodDefault<z.ZodNumber>;
        maxDelayMs: z.ZodDefault<z.ZodNumber>;
        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    description: z.ZodOptional<z.ZodString>;
    active: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type Datasource = z.infer<typeof DatasourceSchema>;
type DatasourceCapabilitiesType = z.infer<typeof DatasourceCapabilities>;

/**
 * Analytics/Semantic Layer Protocol
 *
 * Defines the "Business Logic" for data analysis.
 * Inspired by Cube.dev, LookML, and dbt MetricFlow.
 *
 * This layer decouples the "Physical Data" (Tables/Columns) from the
 * "Business Data" (Metrics/Dimensions).
 */
/**
 * Aggregation Metric Type
 * The mathematical operation to perform on a metric.
 */
declare const AggregationMetricType: z.ZodEnum<{
    string: "string";
    number: "number";
    boolean: "boolean";
    count: "count";
    sum: "sum";
    avg: "avg";
    min: "min";
    max: "max";
    count_distinct: "count_distinct";
}>;
/**
 * Dimension Type
 * The nature of the grouping field.
 */
declare const DimensionType: z.ZodEnum<{
    string: "string";
    number: "number";
    boolean: "boolean";
    time: "time";
    geo: "geo";
}>;
/**
 * Time Interval for Time Dimensions
 */
declare const TimeUpdateInterval: z.ZodEnum<{
    second: "second";
    minute: "minute";
    hour: "hour";
    day: "day";
    week: "week";
    month: "month";
    quarter: "quarter";
    year: "year";
}>;
/**
 * Metric Schema
 * A quantitative measurement (e.g., "Total Revenue", "Average Order Value").
 */
declare const MetricSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        count: "count";
        sum: "sum";
        avg: "avg";
        min: "min";
        max: "max";
        count_distinct: "count_distinct";
    }>;
    sql: z.ZodString;
    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
        sql: z.ZodString;
    }, z.core.$strip>>>;
    format: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Dimension Schema
 * A categorical attribute to group by (e.g., "Product Category", "Order Date").
 */
declare const DimensionSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        time: "time";
        geo: "geo";
    }>;
    sql: z.ZodString;
    granularities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        second: "second";
        minute: "minute";
        hour: "hour";
        day: "day";
        week: "week";
        month: "month";
        quarter: "quarter";
        year: "year";
    }>>>;
}, z.core.$strip>;
/**
 * Join Schema
 * Defines how this cube relates to others.
 */
declare const CubeJoinSchema: z.ZodObject<{
    name: z.ZodString;
    relationship: z.ZodDefault<z.ZodEnum<{
        one_to_one: "one_to_one";
        one_to_many: "one_to_many";
        many_to_one: "many_to_one";
    }>>;
    sql: z.ZodString;
}, z.core.$strip>;
/**
 * Cube Schema
 * A logical data model representing a business entity or process for analysis.
 * Maps physical tables to business metrics and dimensions.
 */
declare const CubeSchema: z.ZodObject<{
    name: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    sql: z.ZodString;
    measures: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            count: "count";
            sum: "sum";
            avg: "avg";
            min: "min";
            max: "max";
            count_distinct: "count_distinct";
        }>;
        sql: z.ZodString;
        filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
            sql: z.ZodString;
        }, z.core.$strip>>>;
        format: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    dimensions: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            time: "time";
            geo: "geo";
        }>;
        sql: z.ZodString;
        granularities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            second: "second";
            minute: "minute";
            hour: "hour";
            day: "day";
            week: "week";
            month: "month";
            quarter: "quarter";
            year: "year";
        }>>>;
    }, z.core.$strip>>;
    joins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        relationship: z.ZodDefault<z.ZodEnum<{
            one_to_one: "one_to_one";
            one_to_many: "one_to_many";
            many_to_one: "many_to_one";
        }>>;
        sql: z.ZodString;
    }, z.core.$strip>>>;
    refreshKey: z.ZodOptional<z.ZodObject<{
        every: z.ZodOptional<z.ZodString>;
        sql: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    public: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
/**
 * Analytics Query Schema
 * The request format for the Analytics API.
 */
declare const AnalyticsQuerySchema: z.ZodObject<{
    cube: z.ZodOptional<z.ZodString>;
    measures: z.ZodArray<z.ZodString>;
    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
        member: z.ZodString;
        operator: z.ZodEnum<{
            set: "set";
            equals: "equals";
            notEquals: "notEquals";
            contains: "contains";
            notContains: "notContains";
            gt: "gt";
            gte: "gte";
            lt: "lt";
            lte: "lte";
            notSet: "notSet";
            inDateRange: "inDateRange";
        }>;
        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>>;
    timeDimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        dimension: z.ZodString;
        granularity: z.ZodOptional<z.ZodEnum<{
            second: "second";
            minute: "minute";
            hour: "hour";
            day: "day";
            week: "week";
            month: "month";
            quarter: "quarter";
            year: "year";
        }>>;
        dateRange: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
    }, z.core.$strip>>>;
    order: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
        asc: "asc";
        desc: "desc";
    }>>>;
    limit: z.ZodOptional<z.ZodNumber>;
    offset: z.ZodOptional<z.ZodNumber>;
    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
}, z.core.$strip>;
type Metric = z.infer<typeof MetricSchema>;
type Dimension = z.infer<typeof DimensionSchema>;
type CubeJoin = z.infer<typeof CubeJoinSchema>;
type Cube = z.infer<typeof CubeSchema>;
type AnalyticsQuery = z.infer<typeof AnalyticsQuerySchema>;

declare const index_ALL_OPERATORS: typeof ALL_OPERATORS;
declare const index_Address: typeof Address;
declare const index_AddressSchema: typeof AddressSchema;
declare const index_AggregationFunction: typeof AggregationFunction;
declare const index_AggregationMetricType: typeof AggregationMetricType;
declare const index_AggregationNode: typeof AggregationNode;
declare const index_AggregationNodeSchema: typeof AggregationNodeSchema;
type index_AggregationPipeline = AggregationPipeline;
declare const index_AggregationPipelineSchema: typeof AggregationPipelineSchema;
type index_AggregationStage = AggregationStage;
declare const index_AggregationStageSchema: typeof AggregationStageSchema;
type index_AnalyticsQuery = AnalyticsQuery;
declare const index_AnalyticsQuerySchema: typeof AnalyticsQuerySchema;
declare const index_ApiMethod: typeof ApiMethod;
declare const index_AsyncValidation: typeof AsyncValidation;
declare const index_AsyncValidationSchema: typeof AsyncValidationSchema;
declare const index_BaseEngineOptions: typeof BaseEngineOptions;
declare const index_BaseEngineOptionsSchema: typeof BaseEngineOptionsSchema;
declare const index_BaseValidationRuleShape: typeof BaseValidationRuleShape;
declare const index_CDCConfig: typeof CDCConfig;
declare const index_CDCConfigSchema: typeof CDCConfigSchema;
declare const index_ComparisonOperatorSchema: typeof ComparisonOperatorSchema;
declare const index_ComputedFieldCache: typeof ComputedFieldCache;
declare const index_ComputedFieldCacheSchema: typeof ComputedFieldCacheSchema;
declare const index_ConditionalValidation: typeof ConditionalValidation;
declare const index_ConditionalValidationSchema: typeof ConditionalValidationSchema;
type index_ConsistencyLevel = ConsistencyLevel;
declare const index_ConsistencyLevelSchema: typeof ConsistencyLevelSchema;
declare const index_CrossFieldValidation: typeof CrossFieldValidation;
declare const index_CrossFieldValidationSchema: typeof CrossFieldValidationSchema;
type index_Cube = Cube;
type index_CubeJoin = CubeJoin;
declare const index_CubeJoinSchema: typeof CubeJoinSchema;
declare const index_CubeSchema: typeof CubeSchema;
declare const index_CurrencyConfig: typeof CurrencyConfig;
declare const index_CurrencyConfigInput: typeof CurrencyConfigInput;
declare const index_CurrencyConfigSchema: typeof CurrencyConfigSchema;
declare const index_CurrencyValue: typeof CurrencyValue;
declare const index_CurrencyValueSchema: typeof CurrencyValueSchema;
declare const index_CustomValidation: typeof CustomValidation;
declare const index_CustomValidatorSchema: typeof CustomValidatorSchema;
declare const index_DataEngineAggregateOptions: typeof DataEngineAggregateOptions;
declare const index_DataEngineAggregateOptionsSchema: typeof DataEngineAggregateOptionsSchema;
declare const index_DataEngineAggregateRequestSchema: typeof DataEngineAggregateRequestSchema;
declare const index_DataEngineBatchRequestSchema: typeof DataEngineBatchRequestSchema;
declare const index_DataEngineContractSchema: typeof DataEngineContractSchema;
declare const index_DataEngineCountOptions: typeof DataEngineCountOptions;
declare const index_DataEngineCountOptionsSchema: typeof DataEngineCountOptionsSchema;
declare const index_DataEngineCountRequestSchema: typeof DataEngineCountRequestSchema;
declare const index_DataEngineDeleteOptions: typeof DataEngineDeleteOptions;
declare const index_DataEngineDeleteOptionsSchema: typeof DataEngineDeleteOptionsSchema;
declare const index_DataEngineDeleteRequestSchema: typeof DataEngineDeleteRequestSchema;
declare const index_DataEngineExecuteRequestSchema: typeof DataEngineExecuteRequestSchema;
declare const index_DataEngineFilter: typeof DataEngineFilter;
declare const index_DataEngineFilterSchema: typeof DataEngineFilterSchema;
declare const index_DataEngineFindOneRequestSchema: typeof DataEngineFindOneRequestSchema;
declare const index_DataEngineFindRequestSchema: typeof DataEngineFindRequestSchema;
declare const index_DataEngineInsertOptions: typeof DataEngineInsertOptions;
declare const index_DataEngineInsertOptionsSchema: typeof DataEngineInsertOptionsSchema;
declare const index_DataEngineInsertRequestSchema: typeof DataEngineInsertRequestSchema;
declare const index_DataEngineQueryOptions: typeof DataEngineQueryOptions;
declare const index_DataEngineQueryOptionsSchema: typeof DataEngineQueryOptionsSchema;
declare const index_DataEngineRequest: typeof DataEngineRequest;
declare const index_DataEngineRequestSchema: typeof DataEngineRequestSchema;
declare const index_DataEngineSort: typeof DataEngineSort;
declare const index_DataEngineSortSchema: typeof DataEngineSortSchema;
declare const index_DataEngineUpdateOptions: typeof DataEngineUpdateOptions;
declare const index_DataEngineUpdateOptionsSchema: typeof DataEngineUpdateOptionsSchema;
declare const index_DataEngineUpdateRequestSchema: typeof DataEngineUpdateRequestSchema;
declare const index_DataEngineVectorFindRequestSchema: typeof DataEngineVectorFindRequestSchema;
declare const index_DataQualityRules: typeof DataQualityRules;
declare const index_DataQualityRulesInput: typeof DataQualityRulesInput;
declare const index_DataQualityRulesSchema: typeof DataQualityRulesSchema;
type index_DataTypeMapping = DataTypeMapping;
declare const index_DataTypeMappingSchema: typeof DataTypeMappingSchema;
type index_Dataset = Dataset;
type index_DatasetImportMode = DatasetImportMode;
type index_DatasetInput = DatasetInput;
declare const index_DatasetMode: typeof DatasetMode;
declare const index_DatasetSchema: typeof DatasetSchema;
type index_Datasource = Datasource;
declare const index_DatasourceCapabilities: typeof DatasourceCapabilities;
type index_DatasourceCapabilitiesType = DatasourceCapabilitiesType;
declare const index_DatasourceSchema: typeof DatasourceSchema;
type index_Dimension = Dimension;
declare const index_DimensionSchema: typeof DimensionSchema;
declare const index_DimensionType: typeof DimensionType;
type index_Document = Document;
declare const index_DocumentSchema: typeof DocumentSchema;
type index_DocumentSchemaValidation = DocumentSchemaValidation;
declare const index_DocumentSchemaValidationSchema: typeof DocumentSchemaValidationSchema;
type index_DocumentTemplate = DocumentTemplate;
declare const index_DocumentTemplateSchema: typeof DocumentTemplateSchema;
type index_DocumentVersion = DocumentVersion;
declare const index_DocumentVersionSchema: typeof DocumentVersionSchema;
declare const index_DriverCapabilities: typeof DriverCapabilities;
declare const index_DriverCapabilitiesSchema: typeof DriverCapabilitiesSchema;
declare const index_DriverConfig: typeof DriverConfig;
declare const index_DriverConfigSchema: typeof DriverConfigSchema;
declare const index_DriverDefinitionSchema: typeof DriverDefinitionSchema;
declare const index_DriverInterface: typeof DriverInterface;
declare const index_DriverInterfaceSchema: typeof DriverInterfaceSchema;
declare const index_DriverOptions: typeof DriverOptions;
declare const index_DriverOptionsSchema: typeof DriverOptionsSchema;
declare const index_DriverType: typeof DriverType;
type index_ESignatureConfig = ESignatureConfig;
declare const index_ESignatureConfigSchema: typeof ESignatureConfigSchema;
declare const index_EqualityOperatorSchema: typeof EqualityOperatorSchema;
type index_ExternalDataSource = ExternalDataSource;
declare const index_ExternalDataSourceSchema: typeof ExternalDataSourceSchema;
type index_ExternalFieldMapping = ExternalFieldMapping;
declare const index_ExternalFieldMappingSchema: typeof ExternalFieldMappingSchema;
type index_ExternalLookup = ExternalLookup;
declare const index_ExternalLookupSchema: typeof ExternalLookupSchema;
declare const index_FILTER_OPERATORS: typeof FILTER_OPERATORS;
declare const index_Field: typeof Field;
declare const index_FieldInput: typeof FieldInput;
type index_FieldMapping = FieldMapping;
declare const index_FieldMappingSchema: typeof FieldMappingSchema;
declare const index_FieldNodeSchema: typeof FieldNodeSchema;
declare const index_FieldOperators: typeof FieldOperators;
declare const index_FieldOperatorsSchema: typeof FieldOperatorsSchema;
declare const index_FieldReference: typeof FieldReference;
declare const index_FieldReferenceSchema: typeof FieldReferenceSchema;
declare const index_FieldSchema: typeof FieldSchema;
declare const index_FieldType: typeof FieldType;
declare const index_FileAttachmentConfig: typeof FileAttachmentConfig;
declare const index_FileAttachmentConfigInput: typeof FileAttachmentConfigInput;
declare const index_FileAttachmentConfigSchema: typeof FileAttachmentConfigSchema;
declare const index_Filter: typeof Filter;
declare const index_FilterCondition: typeof FilterCondition;
declare const index_FilterConditionSchema: typeof FilterConditionSchema;
declare const index_FilterOperatorKey: typeof FilterOperatorKey;
declare const index_FormatValidation: typeof FormatValidation;
declare const index_FormatValidationSchema: typeof FormatValidationSchema;
declare const index_FullTextSearch: typeof FullTextSearch;
declare const index_FullTextSearchSchema: typeof FullTextSearchSchema;
type index_Hook = Hook;
type index_HookContext = HookContext;
declare const index_HookContextSchema: typeof HookContextSchema;
declare const index_HookEvent: typeof HookEvent;
type index_HookEventType = HookEventType;
declare const index_HookSchema: typeof HookSchema;
declare const index_IndexSchema: typeof IndexSchema;
declare const index_JSONValidation: typeof JSONValidation;
declare const index_JSONValidationSchema: typeof JSONValidationSchema;
declare const index_JoinNode: typeof JoinNode;
declare const index_JoinNodeSchema: typeof JoinNodeSchema;
declare const index_JoinStrategy: typeof JoinStrategy;
declare const index_JoinType: typeof JoinType;
declare const index_LOGICAL_OPERATORS: typeof LOGICAL_OPERATORS;
declare const index_LocationCoordinates: typeof LocationCoordinates;
declare const index_LocationCoordinatesSchema: typeof LocationCoordinatesSchema;
declare const index_LogicalOperatorKey: typeof LogicalOperatorKey;
type index_Mapping = Mapping;
declare const index_MappingSchema: typeof MappingSchema;
type index_Metric = Metric;
declare const index_MetricSchema: typeof MetricSchema;
type index_NoSQLDataTypeMapping = NoSQLDataTypeMapping;
declare const index_NoSQLDataTypeMappingSchema: typeof NoSQLDataTypeMappingSchema;
type index_NoSQLDatabaseType = NoSQLDatabaseType;
declare const index_NoSQLDatabaseTypeSchema: typeof NoSQLDatabaseTypeSchema;
type index_NoSQLDriverConfig = NoSQLDriverConfig;
declare const index_NoSQLDriverConfigSchema: typeof NoSQLDriverConfigSchema;
type index_NoSQLIndex = NoSQLIndex;
declare const index_NoSQLIndexSchema: typeof NoSQLIndexSchema;
type index_NoSQLIndexType = NoSQLIndexType;
declare const index_NoSQLIndexTypeSchema: typeof NoSQLIndexTypeSchema;
type index_NoSQLOperationType = NoSQLOperationType;
declare const index_NoSQLOperationTypeSchema: typeof NoSQLOperationTypeSchema;
type index_NoSQLQueryOptions = NoSQLQueryOptions;
declare const index_NoSQLQueryOptionsSchema: typeof NoSQLQueryOptionsSchema;
type index_NoSQLTransactionOptions = NoSQLTransactionOptions;
declare const index_NoSQLTransactionOptionsSchema: typeof NoSQLTransactionOptionsSchema;
declare const index_NormalizedFilter: typeof NormalizedFilter;
declare const index_NormalizedFilterSchema: typeof NormalizedFilterSchema;
declare const index_ObjectCapabilities: typeof ObjectCapabilities;
declare const index_ObjectExtension: typeof ObjectExtension;
declare const index_ObjectExtensionSchema: typeof ObjectExtensionSchema;
declare const index_ObjectIndex: typeof ObjectIndex;
declare const index_ObjectOwnership: typeof ObjectOwnership;
declare const index_ObjectOwnershipEnum: typeof ObjectOwnershipEnum;
declare const index_ObjectSchema: typeof ObjectSchema;
declare const index_OperatorKey: typeof OperatorKey;
declare const index_PartitioningConfig: typeof PartitioningConfig;
declare const index_PartitioningConfigSchema: typeof PartitioningConfigSchema;
declare const index_PoolConfig: typeof PoolConfig;
declare const index_PoolConfigSchema: typeof PoolConfigSchema;
declare const index_QueryAST: typeof QueryAST;
declare const index_QueryFilter: typeof QueryFilter;
declare const index_QueryFilterSchema: typeof QueryFilterSchema;
declare const index_QueryInput: typeof QueryInput;
declare const index_QuerySchema: typeof QuerySchema;
declare const index_RangeOperatorSchema: typeof RangeOperatorSchema;
type index_ReplicationConfig = ReplicationConfig;
declare const index_ReplicationConfigSchema: typeof ReplicationConfigSchema;
type index_ResolvedHook = ResolvedHook;
type index_SQLDialect = SQLDialect;
declare const index_SQLDialectSchema: typeof SQLDialectSchema;
type index_SQLDriverConfig = SQLDriverConfig;
declare const index_SQLDriverConfigSchema: typeof SQLDriverConfigSchema;
type index_SSLConfig = SSLConfig;
declare const index_SSLConfigSchema: typeof SSLConfigSchema;
declare const index_Scalar: typeof Scalar;
declare const index_ScriptValidation: typeof ScriptValidation;
declare const index_ScriptValidationSchema: typeof ScriptValidationSchema;
declare const index_SearchConfigSchema: typeof SearchConfigSchema;
declare const index_SelectOption: typeof SelectOption;
declare const index_SelectOptionSchema: typeof SelectOptionSchema;
declare const index_ServiceObject: typeof ServiceObject;
declare const index_ServiceObjectInput: typeof ServiceObjectInput;
declare const index_SetOperatorSchema: typeof SetOperatorSchema;
type index_ShardingConfig = ShardingConfig;
declare const index_ShardingConfigSchema: typeof ShardingConfigSchema;
declare const index_SoftDeleteConfig: typeof SoftDeleteConfig;
declare const index_SoftDeleteConfigSchema: typeof SoftDeleteConfigSchema;
declare const index_SortNode: typeof SortNode;
declare const index_SortNodeSchema: typeof SortNodeSchema;
declare const index_SpecialOperatorSchema: typeof SpecialOperatorSchema;
declare const index_StateMachineValidation: typeof StateMachineValidation;
declare const index_StateMachineValidationSchema: typeof StateMachineValidationSchema;
declare const index_StringOperatorSchema: typeof StringOperatorSchema;
declare const index_TenancyConfig: typeof TenancyConfig;
declare const index_TenancyConfigSchema: typeof TenancyConfigSchema;
declare const index_TimeUpdateInterval: typeof TimeUpdateInterval;
declare const index_TransformType: typeof TransformType;
declare const index_UniquenessValidation: typeof UniquenessValidation;
declare const index_UniquenessValidationSchema: typeof UniquenessValidationSchema;
declare const index_ValidationRule: typeof ValidationRule;
declare const index_ValidationRuleSchema: typeof ValidationRuleSchema;
declare const index_VectorConfig: typeof VectorConfig;
declare const index_VectorConfigInput: typeof VectorConfigInput;
declare const index_VectorConfigSchema: typeof VectorConfigSchema;
declare const index_VersioningConfig: typeof VersioningConfig;
declare const index_VersioningConfigSchema: typeof VersioningConfigSchema;
declare const index_WindowFunction: typeof WindowFunction;
declare const index_WindowFunctionNode: typeof WindowFunctionNode;
declare const index_WindowFunctionNodeSchema: typeof WindowFunctionNodeSchema;
declare const index_WindowSpec: typeof WindowSpec;
declare const index_WindowSpecSchema: typeof WindowSpecSchema;
declare namespace index {
  export { index_ALL_OPERATORS as ALL_OPERATORS, index_Address as Address, index_AddressSchema as AddressSchema, index_AggregationFunction as AggregationFunction, index_AggregationMetricType as AggregationMetricType, index_AggregationNode as AggregationNode, index_AggregationNodeSchema as AggregationNodeSchema, type index_AggregationPipeline as AggregationPipeline, index_AggregationPipelineSchema as AggregationPipelineSchema, type index_AggregationStage as AggregationStage, index_AggregationStageSchema as AggregationStageSchema, type index_AnalyticsQuery as AnalyticsQuery, index_AnalyticsQuerySchema as AnalyticsQuerySchema, index_ApiMethod as ApiMethod, index_AsyncValidation as AsyncValidation, index_AsyncValidationSchema as AsyncValidationSchema, index_BaseEngineOptions as BaseEngineOptions, index_BaseEngineOptionsSchema as BaseEngineOptionsSchema, index_BaseValidationRuleShape as BaseValidationRuleShape, index_CDCConfig as CDCConfig, index_CDCConfigSchema as CDCConfigSchema, index_ComparisonOperatorSchema as ComparisonOperatorSchema, index_ComputedFieldCache as ComputedFieldCache, index_ComputedFieldCacheSchema as ComputedFieldCacheSchema, index_ConditionalValidation as ConditionalValidation, index_ConditionalValidationSchema as ConditionalValidationSchema, type index_ConsistencyLevel as ConsistencyLevel, index_ConsistencyLevelSchema as ConsistencyLevelSchema, index_CrossFieldValidation as CrossFieldValidation, index_CrossFieldValidationSchema as CrossFieldValidationSchema, type index_Cube as Cube, type index_CubeJoin as CubeJoin, index_CubeJoinSchema as CubeJoinSchema, index_CubeSchema as CubeSchema, index_CurrencyConfig as CurrencyConfig, index_CurrencyConfigInput as CurrencyConfigInput, index_CurrencyConfigSchema as CurrencyConfigSchema, index_CurrencyValue as CurrencyValue, index_CurrencyValueSchema as CurrencyValueSchema, index_CustomValidation as CustomValidation, index_CustomValidatorSchema as CustomValidatorSchema, index_DataEngineAggregateOptions as DataEngineAggregateOptions, index_DataEngineAggregateOptionsSchema as DataEngineAggregateOptionsSchema, index_DataEngineAggregateRequestSchema as DataEngineAggregateRequestSchema, index_DataEngineBatchRequestSchema as DataEngineBatchRequestSchema, index_DataEngineContractSchema as DataEngineContractSchema, index_DataEngineCountOptions as DataEngineCountOptions, index_DataEngineCountOptionsSchema as DataEngineCountOptionsSchema, index_DataEngineCountRequestSchema as DataEngineCountRequestSchema, index_DataEngineDeleteOptions as DataEngineDeleteOptions, index_DataEngineDeleteOptionsSchema as DataEngineDeleteOptionsSchema, index_DataEngineDeleteRequestSchema as DataEngineDeleteRequestSchema, index_DataEngineExecuteRequestSchema as DataEngineExecuteRequestSchema, index_DataEngineFilter as DataEngineFilter, index_DataEngineFilterSchema as DataEngineFilterSchema, index_DataEngineFindOneRequestSchema as DataEngineFindOneRequestSchema, index_DataEngineFindRequestSchema as DataEngineFindRequestSchema, index_DataEngineInsertOptions as DataEngineInsertOptions, index_DataEngineInsertOptionsSchema as DataEngineInsertOptionsSchema, index_DataEngineInsertRequestSchema as DataEngineInsertRequestSchema, index_DataEngineQueryOptions as DataEngineQueryOptions, index_DataEngineQueryOptionsSchema as DataEngineQueryOptionsSchema, index_DataEngineRequest as DataEngineRequest, index_DataEngineRequestSchema as DataEngineRequestSchema, index_DataEngineSort as DataEngineSort, index_DataEngineSortSchema as DataEngineSortSchema, index_DataEngineUpdateOptions as DataEngineUpdateOptions, index_DataEngineUpdateOptionsSchema as DataEngineUpdateOptionsSchema, index_DataEngineUpdateRequestSchema as DataEngineUpdateRequestSchema, index_DataEngineVectorFindRequestSchema as DataEngineVectorFindRequestSchema, index_DataQualityRules as DataQualityRules, index_DataQualityRulesInput as DataQualityRulesInput, index_DataQualityRulesSchema as DataQualityRulesSchema, type index_DataTypeMapping as DataTypeMapping, index_DataTypeMappingSchema as DataTypeMappingSchema, type index_Dataset as Dataset, type index_DatasetImportMode as DatasetImportMode, type index_DatasetInput as DatasetInput, index_DatasetMode as DatasetMode, index_DatasetSchema as DatasetSchema, type index_Datasource as Datasource, index_DatasourceCapabilities as DatasourceCapabilities, type index_DatasourceCapabilitiesType as DatasourceCapabilitiesType, index_DatasourceSchema as DatasourceSchema, type index_Dimension as Dimension, index_DimensionSchema as DimensionSchema, index_DimensionType as DimensionType, type index_Document as Document, index_DocumentSchema as DocumentSchema, type index_DocumentSchemaValidation as DocumentSchemaValidation, index_DocumentSchemaValidationSchema as DocumentSchemaValidationSchema, type index_DocumentTemplate as DocumentTemplate, index_DocumentTemplateSchema as DocumentTemplateSchema, type index_DocumentVersion as DocumentVersion, index_DocumentVersionSchema as DocumentVersionSchema, index_DriverCapabilities as DriverCapabilities, index_DriverCapabilitiesSchema as DriverCapabilitiesSchema, index_DriverConfig as DriverConfig, index_DriverConfigSchema as DriverConfigSchema, index_DriverDefinitionSchema as DriverDefinitionSchema, index_DriverInterface as DriverInterface, index_DriverInterfaceSchema as DriverInterfaceSchema, index_DriverOptions as DriverOptions, index_DriverOptionsSchema as DriverOptionsSchema, index_DriverType as DriverType, type index_ESignatureConfig as ESignatureConfig, index_ESignatureConfigSchema as ESignatureConfigSchema, index_EqualityOperatorSchema as EqualityOperatorSchema, type index_ExternalDataSource as ExternalDataSource, index_ExternalDataSourceSchema as ExternalDataSourceSchema, type index_ExternalFieldMapping as ExternalFieldMapping, index_ExternalFieldMappingSchema as ExternalFieldMappingSchema, type index_ExternalLookup as ExternalLookup, index_ExternalLookupSchema as ExternalLookupSchema, index_FILTER_OPERATORS as FILTER_OPERATORS, index_Field as Field, index_FieldInput as FieldInput, type index_FieldMapping as FieldMapping, index_FieldMappingSchema as FieldMappingSchema, index_FieldNodeSchema as FieldNodeSchema, index_FieldOperators as FieldOperators, index_FieldOperatorsSchema as FieldOperatorsSchema, index_FieldReference as FieldReference, index_FieldReferenceSchema as FieldReferenceSchema, index_FieldSchema as FieldSchema, index_FieldType as FieldType, index_FileAttachmentConfig as FileAttachmentConfig, index_FileAttachmentConfigInput as FileAttachmentConfigInput, index_FileAttachmentConfigSchema as FileAttachmentConfigSchema, index_Filter as Filter, index_FilterCondition as FilterCondition, index_FilterConditionSchema as FilterConditionSchema, index_FilterOperatorKey as FilterOperatorKey, index_FormatValidation as FormatValidation, index_FormatValidationSchema as FormatValidationSchema, index_FullTextSearch as FullTextSearch, index_FullTextSearchSchema as FullTextSearchSchema, type index_Hook as Hook, type index_HookContext as HookContext, index_HookContextSchema as HookContextSchema, index_HookEvent as HookEvent, type index_HookEventType as HookEventType, index_HookSchema as HookSchema, index_IndexSchema as IndexSchema, index_JSONValidation as JSONValidation, index_JSONValidationSchema as JSONValidationSchema, index_JoinNode as JoinNode, index_JoinNodeSchema as JoinNodeSchema, index_JoinStrategy as JoinStrategy, index_JoinType as JoinType, index_LOGICAL_OPERATORS as LOGICAL_OPERATORS, index_LocationCoordinates as LocationCoordinates, index_LocationCoordinatesSchema as LocationCoordinatesSchema, index_LogicalOperatorKey as LogicalOperatorKey, type index_Mapping as Mapping, index_MappingSchema as MappingSchema, type index_Metric as Metric, index_MetricSchema as MetricSchema, type index_NoSQLDataTypeMapping as NoSQLDataTypeMapping, index_NoSQLDataTypeMappingSchema as NoSQLDataTypeMappingSchema, type index_NoSQLDatabaseType as NoSQLDatabaseType, index_NoSQLDatabaseTypeSchema as NoSQLDatabaseTypeSchema, type index_NoSQLDriverConfig as NoSQLDriverConfig, index_NoSQLDriverConfigSchema as NoSQLDriverConfigSchema, type index_NoSQLIndex as NoSQLIndex, index_NoSQLIndexSchema as NoSQLIndexSchema, type index_NoSQLIndexType as NoSQLIndexType, index_NoSQLIndexTypeSchema as NoSQLIndexTypeSchema, type index_NoSQLOperationType as NoSQLOperationType, index_NoSQLOperationTypeSchema as NoSQLOperationTypeSchema, type index_NoSQLQueryOptions as NoSQLQueryOptions, index_NoSQLQueryOptionsSchema as NoSQLQueryOptionsSchema, type index_NoSQLTransactionOptions as NoSQLTransactionOptions, index_NoSQLTransactionOptionsSchema as NoSQLTransactionOptionsSchema, index_NormalizedFilter as NormalizedFilter, index_NormalizedFilterSchema as NormalizedFilterSchema, index_ObjectCapabilities as ObjectCapabilities, index_ObjectExtension as ObjectExtension, index_ObjectExtensionSchema as ObjectExtensionSchema, index_ObjectIndex as ObjectIndex, index_ObjectOwnership as ObjectOwnership, index_ObjectOwnershipEnum as ObjectOwnershipEnum, index_ObjectSchema as ObjectSchema, index_OperatorKey as OperatorKey, index_PartitioningConfig as PartitioningConfig, index_PartitioningConfigSchema as PartitioningConfigSchema, index_PoolConfig as PoolConfig, index_PoolConfigSchema as PoolConfigSchema, index_QueryAST as QueryAST, index_QueryFilter as QueryFilter, index_QueryFilterSchema as QueryFilterSchema, index_QueryInput as QueryInput, index_QuerySchema as QuerySchema, index_RangeOperatorSchema as RangeOperatorSchema, type index_ReplicationConfig as ReplicationConfig, index_ReplicationConfigSchema as ReplicationConfigSchema, type index_ResolvedHook as ResolvedHook, type index_SQLDialect as SQLDialect, index_SQLDialectSchema as SQLDialectSchema, type index_SQLDriverConfig as SQLDriverConfig, index_SQLDriverConfigSchema as SQLDriverConfigSchema, type index_SSLConfig as SSLConfig, index_SSLConfigSchema as SSLConfigSchema, index_Scalar as Scalar, index_ScriptValidation as ScriptValidation, index_ScriptValidationSchema as ScriptValidationSchema, index_SearchConfigSchema as SearchConfigSchema, index_SelectOption as SelectOption, index_SelectOptionSchema as SelectOptionSchema, index_ServiceObject as ServiceObject, index_ServiceObjectInput as ServiceObjectInput, index_SetOperatorSchema as SetOperatorSchema, type index_ShardingConfig as ShardingConfig, index_ShardingConfigSchema as ShardingConfigSchema, index_SoftDeleteConfig as SoftDeleteConfig, index_SoftDeleteConfigSchema as SoftDeleteConfigSchema, index_SortNode as SortNode, index_SortNodeSchema as SortNodeSchema, index_SpecialOperatorSchema as SpecialOperatorSchema, index_StateMachineValidation as StateMachineValidation, index_StateMachineValidationSchema as StateMachineValidationSchema, index_StringOperatorSchema as StringOperatorSchema, index_TenancyConfig as TenancyConfig, index_TenancyConfigSchema as TenancyConfigSchema, index_TimeUpdateInterval as TimeUpdateInterval, index_TransformType as TransformType, index_UniquenessValidation as UniquenessValidation, index_UniquenessValidationSchema as UniquenessValidationSchema, index_ValidationRule as ValidationRule, index_ValidationRuleSchema as ValidationRuleSchema, index_VectorConfig as VectorConfig, index_VectorConfigInput as VectorConfigInput, index_VectorConfigSchema as VectorConfigSchema, index_VersioningConfig as VersioningConfig, index_VersioningConfigSchema as VersioningConfigSchema, index_WindowFunction as WindowFunction, index_WindowFunctionNode as WindowFunctionNode, index_WindowFunctionNodeSchema as WindowFunctionNodeSchema, index_WindowSpec as WindowSpec, index_WindowSpecSchema as WindowSpecSchema };
}

export { type DatasetImportMode as $, NoSQLDataTypeMappingSchema as A, type NoSQLDataTypeMapping as B, ConsistencyLevelSchema as C, DataTypeMappingSchema as D, NoSQLDriverConfigSchema as E, FieldMappingSchema as F, type NoSQLDriverConfig as G, HookEvent as H, NoSQLQueryOptionsSchema as I, type NoSQLQueryOptions as J, AggregationStageSchema as K, type AggregationStage as L, MappingSchema as M, NoSQLDatabaseTypeSchema as N, AggregationPipelineSchema as O, type AggregationPipeline as P, NoSQLIndexSchema as Q, type ResolvedHook as R, SQLDialectSchema as S, TransformType as T, type NoSQLIndex as U, NoSQLTransactionOptionsSchema as V, type NoSQLTransactionOptions as W, DatasetMode as X, DatasetSchema as Y, type Dataset as Z, type DatasetInput as _, HookSchema as a, DocumentVersionSchema as a0, DocumentTemplateSchema as a1, ESignatureConfigSchema as a2, DocumentSchema as a3, type Document as a4, type DocumentVersion as a5, type DocumentTemplate as a6, type ESignatureConfig as a7, ExternalDataSourceSchema as a8, ExternalFieldMappingSchema as a9, ExternalLookupSchema as aa, type ExternalLookup as ab, type ExternalDataSource as ac, type ExternalFieldMapping as ad, DriverType as ae, DriverDefinitionSchema as af, DatasourceCapabilities as ag, DatasourceSchema as ah, type Datasource as ai, type DatasourceCapabilitiesType as aj, AggregationMetricType as ak, DimensionType as al, TimeUpdateInterval as am, MetricSchema as an, DimensionSchema as ao, CubeJoinSchema as ap, CubeSchema as aq, AnalyticsQuerySchema as ar, type Metric as as, type Dimension as at, type CubeJoin as au, type Cube as av, type AnalyticsQuery as aw, HookContextSchema as b, type Hook as c, type HookEventType as d, type HookContext as e, type Mapping as f, type FieldMapping as g, type SQLDialect as h, index as i, type DataTypeMapping as j, SSLConfigSchema as k, type SSLConfig as l, SQLDriverConfigSchema as m, type SQLDriverConfig as n, type NoSQLDatabaseType as o, NoSQLOperationTypeSchema as p, type NoSQLOperationType as q, type ConsistencyLevel as r, NoSQLIndexTypeSchema as s, type NoSQLIndexType as t, ShardingConfigSchema as u, type ShardingConfig as v, ReplicationConfigSchema as w, type ReplicationConfig as x, DocumentSchemaValidationSchema as y, type DocumentSchemaValidation as z };
