@ductape/sdk 0.0.4-v42 → 0.0.4-v44

package/dist/database/types/aggregation.types.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Aggregation type definitions for database operations
+ */
+import { WhereClause, IOrderBy } from './query.types';
+/**
+ * Aggregation function types
+ */
+export declare enum AggregationFunction {
+    COUNT = "count",
+    SUM = "sum",
+    AVG = "avg",
+    MIN = "min",
+    MAX = "max",
+    GROUP_CONCAT = "group_concat",// MySQL
+    STRING_AGG = "string_agg",// PostgreSQL
+    ARRAY_AGG = "array_agg"
+}
+/**
+ * Single aggregation operation
+ */
+export interface IAggregationOperation {
+    /** Aggregation function */
+    function: AggregationFunction;
+    /** Column to aggregate */
+    column: string;
+    /** Alias for the result */
+    alias?: string;
+    /** Distinct values only */
+    distinct?: boolean;
+}
+/**
+ * Count options
+ */
+export interface ICountOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Where clause */
+    where?: WhereClause;
+    /** Column to count (default: '*') */
+    column?: string;
+    /** Count distinct values only */
+    distinct?: boolean;
+}
+/**
+ * Sum options
+ */
+export interface ISumOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Column to sum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Average options
+ */
+export interface IAvgOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Column to average */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Min options
+ */
+export interface IMinOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Column to find minimum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Max options
+ */
+export interface IMaxOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Column to find maximum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Group by options
+ */
+export interface IGroupByOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Columns to group by */
+    groupBy: string[];
+    /** Aggregation operations */
+    aggregate?: Record<string, IAggregationOperation>;
+    /** Where clause (applied before grouping) */
+    where?: WhereClause;
+    /** Having clause (applied after grouping) */
+    having?: WhereClause;
+    /** Order by */
+    orderBy?: IOrderBy | IOrderBy[];
+    /** Limit results */
+    limit?: number;
+    /** Offset */
+    offset?: number;
+}
+/**
+ * Aggregate options (multiple aggregations)
+ */
+export interface IAggregateOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Aggregation operations */
+    operations: Record<string, IAggregationOperation>;
+    /** Where clause */
+    where?: WhereClause;
+    /** Group by columns (optional) */
+    groupBy?: string[];
+    /** Having clause */
+    having?: WhereClause;
+}
+/**
+ * Aggregation result for a single operation
+ */
+export interface IAggregationResult {
+    /** Result value */
+    value: number | string | null;
+    /** Column that was aggregated */
+    column?: string;
+    /** Function used */
+    function: AggregationFunction;
+}
+/**
+ * Group by result
+ */
+export interface IGroupByResult {
+    /** Grouped columns and their values */
+    groupedBy: Record<string, any>;
+    /** Aggregated values */
+    aggregates: Record<string, number | string | null>;
+}
+/**
+ * Statistics result (multiple aggregations)
+ */
+export interface IStatisticsResult {
+    /** Count */
+    count?: number;
+    /** Sum */
+    sum?: number;
+    /** Average */
+    avg?: number;
+    /** Minimum */
+    min?: number | string;
+    /** Maximum */
+    max?: number | string;
+    /** Additional custom aggregations */
+    [key: string]: any;
+}

package/dist/database/types/aggregation.types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Aggregation type definitions for database operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationFunction = void 0;
+/**
+ * Aggregation function types
+ */
+var AggregationFunction;
+(function (AggregationFunction) {
+    AggregationFunction["COUNT"] = "count";
+    AggregationFunction["SUM"] = "sum";
+    AggregationFunction["AVG"] = "avg";
+    AggregationFunction["MIN"] = "min";
+    AggregationFunction["MAX"] = "max";
+    AggregationFunction["GROUP_CONCAT"] = "group_concat";
+    AggregationFunction["STRING_AGG"] = "string_agg";
+    AggregationFunction["ARRAY_AGG"] = "array_agg";
+})(AggregationFunction || (exports.AggregationFunction = AggregationFunction = {}));
+//# sourceMappingURL=aggregation.types.js.map

package/dist/database/types/aggregation.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation.types.js","sourceRoot":"","sources":["../../../src/database/types/aggregation.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAIH;;GAEG;AACH,IAAY,mBASX;AATD,WAAY,mBAAmB;IAC7B,sCAAe,CAAA;IACf,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,oDAA6B,CAAA;IAC7B,gDAAyB,CAAA;IACzB,8CAAuB,CAAA;AACzB,CAAC,EATW,mBAAmB,mCAAnB,mBAAmB,QAS9B"}

package/dist/database/types/connection.types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Connection configuration types for different database systems
+ */
+import { DatabaseType } from './database.types';
+/**
+ * Base connection configuration
+ */
+export interface IBaseConnectionConfig {
+    /** Database type */
+    type: DatabaseType;
+    /** Environment slug */
+    env: string;
+    /** Optional connection tag */
+    connectionTag?: string;
+}
+/**
+ * Product-based connection configuration
+ * Connects using a configured database in a product
+ */
+export interface IProductConnectionConfig {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product: string;
+    /** Database tag within the product */
+    database: string;
+}
+/**
+ * PostgreSQL connection configuration
+ */
+export interface IPostgreSQLConfig extends IBaseConnectionConfig {
+    type: DatabaseType.POSTGRESQL;
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: boolean | {
+        [key: string]: any;
+    };
+    poolSize?: number;
+    connectionTimeout?: number;
+}
+/**
+ * MySQL connection configuration
+ */
+export interface IMySQLConfig extends IBaseConnectionConfig {
+    type: DatabaseType.MYSQL;
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: boolean | {
+        [key: string]: any;
+    };
+    poolSize?: number;
+    connectionTimeout?: number;
+    charset?: string;
+}
+/**
+ * MongoDB connection configuration
+ */
+export interface IMongoDBConfig extends IBaseConnectionConfig {
+    type: DatabaseType.MONGODB;
+    uri: string;
+    database: string;
+    options?: {
+        useNewUrlParser?: boolean;
+        useUnifiedTopology?: boolean;
+        poolSize?: number;
+        serverSelectionTimeoutMS?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * DynamoDB connection configuration
+ */
+export interface IDynamoDBConfig extends IBaseConnectionConfig {
+    type: DatabaseType.DYNAMODB;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    options?: {
+        maxRetries?: number;
+        httpOptions?: {
+            timeout?: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * SQLite connection configuration
+ */
+export interface ISQLiteConfig extends IBaseConnectionConfig {
+    type: DatabaseType.SQLITE;
+    filename: string;
+    mode?: number;
+    options?: {
+        readonly?: boolean;
+        fileMustExist?: boolean;
+        timeout?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Union type for all connection configurations
+ */
+export type DatabaseConnectionConfig = IPostgreSQLConfig | IMySQLConfig | IMongoDBConfig | IDynamoDBConfig | ISQLiteConfig | IProductConnectionConfig;
+/**
+ * Connection pool configuration
+ */
+export interface IConnectionPoolConfig {
+    min?: number;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+}
+/**
+ * Connection options
+ */
+export interface IConnectionOptions {
+    /** Auto-retry connection on failure */
+    autoRetry?: boolean;
+    /** Max retry attempts */
+    maxRetries?: number;
+    /** Retry delay in milliseconds */
+    retryDelay?: number;
+    /** Connection pool configuration */
+    pool?: IConnectionPoolConfig;
+}

package/dist/database/types/connection.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Connection configuration types for different database systems
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=connection.types.js.map

package/dist/database/types/connection.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.types.js","sourceRoot":"","sources":["../../../src/database/types/connection.types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/database/types/database.types.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Core database type definitions for the Ductape Database ORM
+ * Provides unified interface for SQL and NoSQL databases
+ */
+/**
+ * Supported database types
+ */
+export declare enum DatabaseType {
+    POSTGRESQL = "postgresql",
+    MYSQL = "mysql",
+    MONGODB = "mongodb",
+    DYNAMODB = "dynamodb",
+    SQLITE = "sqlite"
+}
+/**
+ * Database connection status
+ */
+export declare enum ConnectionStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+/**
+ * Base database configuration
+ */
+export interface IDatabaseConfig {
+    /** Database type */
+    type: DatabaseType;
+    /** Environment slug */
+    env: string;
+    /** Optional connection tag for reusing existing connections */
+    connectionTag?: string;
+    /** Optional database name */
+    database?: string;
+    /** Custom connection options */
+    options?: Record<string, any>;
+}
+/**
+ * Database connection interface
+ */
+export interface IConnection {
+    /** Unique connection ID */
+    id: string;
+    /** Database type */
+    type: DatabaseType;
+    /** Connection status */
+    status: ConnectionStatus;
+    /** Connect to database */
+    connect(): Promise<void>;
+    /** Disconnect from database */
+    disconnect(): Promise<void>;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Get native client */
+    getClient<T = any>(): T;
+}
+/**
+ * Base database adapter interface
+ * All database-specific adapters must implement this interface
+ */
+export interface IDatabaseAdapter {
+    /** Database type this adapter handles */
+    readonly type: DatabaseType;
+    /** Create a connection */
+    createConnection(config: IDatabaseConfig): Promise<IConnection>;
+    /** Close a connection */
+    closeConnection(connection: IConnection): Promise<void>;
+    /** Execute a query */
+    executeQuery(connection: IConnection, query: string, params?: any[]): Promise<any>;
+    /** Begin transaction */
+    beginTransaction(connection: IConnection): Promise<any>;
+    /** Commit transaction */
+    commitTransaction(connection: IConnection, transaction: any): Promise<void>;
+    /** Rollback transaction */
+    rollbackTransaction(connection: IConnection, transaction: any): Promise<void>;
+}
+/**
+ * Database error types
+ */
+export declare enum DatabaseErrorType {
+    CONNECTION_ERROR = "connection_error",
+    QUERY_ERROR = "query_error",
+    VALIDATION_ERROR = "validation_error",
+    MIGRATION_ERROR = "migration_error",
+    SCHEMA_ERROR = "schema_error",
+    INDEX_ERROR = "index_error",
+    TRANSACTION_ERROR = "TRANSACTION_ERROR"
+}
+/**
+ * Database error class
+ */
+export declare class DatabaseError extends Error {
+    type: DatabaseErrorType;
+    originalError?: Error;
+    constructor(type: DatabaseErrorType, message: string, originalError?: Error);
+}
+/**
+ * Transaction isolation levels
+ */
+export declare enum TransactionIsolationLevel {
+    READ_UNCOMMITTED = "READ_UNCOMMITTED",
+    READ_COMMITTED = "READ_COMMITTED",
+    REPEATABLE_READ = "REPEATABLE_READ",
+    SERIALIZABLE = "SERIALIZABLE"
+}
+/**
+ * Transaction status
+ */
+export declare enum TransactionStatus {
+    ACTIVE = "active",
+    COMMITTED = "committed",
+    ROLLED_BACK = "rolled_back",
+    FAILED = "failed"
+}
+/**
+ * Transaction interface
+ */
+export interface ITransaction {
+    /** Unique transaction ID */
+    id: string;
+    /** Connection this transaction belongs to */
+    connection: IConnection;
+    /** Transaction status */
+    status: TransactionStatus;
+    /** Isolation level */
+    isolationLevel?: TransactionIsolationLevel;
+    /** Parent transaction (for nested transactions) */
+    parent?: ITransaction;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Native transaction object */
+    native: any;
+    /** Commit the transaction */
+    commit(): Promise<void>;
+    /** Rollback the transaction */
+    rollback(): Promise<void>;
+    /** Create a savepoint (for nested transactions) */
+    savepoint(name: string): Promise<ISavepoint>;
+    /** Check if transaction is active */
+    isActive(): boolean;
+}
+/**
+ * Savepoint interface
+ */
+export interface ISavepoint {
+    /** Savepoint name */
+    name: string;
+    /** Transaction this savepoint belongs to */
+    transaction: ITransaction;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Rollback to this savepoint */
+    rollback(): Promise<void>;
+    /** Release this savepoint */
+    release(): Promise<void>;
+}
+/**
+ * Transaction options
+ */
+export interface ITransactionOptions {
+    /** Isolation level */
+    isolationLevel?: TransactionIsolationLevel;
+    /** Read only transaction */
+    readOnly?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Deferrable (PostgreSQL) */
+    deferrable?: boolean;
+}
+/**
+ * Transaction callback function
+ */
+export type TransactionCallback<T> = (transaction: ITransaction) => Promise<T>;

package/dist/database/types/database.types.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Core database type definitions for the Ductape Database ORM
+ * Provides unified interface for SQL and NoSQL databases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionStatus = exports.TransactionIsolationLevel = exports.DatabaseError = exports.DatabaseErrorType = exports.ConnectionStatus = exports.DatabaseType = void 0;
+/**
+ * Supported database types
+ */
+var DatabaseType;
+(function (DatabaseType) {
+    DatabaseType["POSTGRESQL"] = "postgresql";
+    DatabaseType["MYSQL"] = "mysql";
+    DatabaseType["MONGODB"] = "mongodb";
+    DatabaseType["DYNAMODB"] = "dynamodb";
+    DatabaseType["SQLITE"] = "sqlite";
+})(DatabaseType || (exports.DatabaseType = DatabaseType = {}));
+/**
+ * Database connection status
+ */
+var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["DISCONNECTED"] = "disconnected";
+    ConnectionStatus["CONNECTING"] = "connecting";
+    ConnectionStatus["CONNECTED"] = "connected";
+    ConnectionStatus["ERROR"] = "error";
+})(ConnectionStatus || (exports.ConnectionStatus = ConnectionStatus = {}));
+/**
+ * Database error types
+ */
+var DatabaseErrorType;
+(function (DatabaseErrorType) {
+    DatabaseErrorType["CONNECTION_ERROR"] = "connection_error";
+    DatabaseErrorType["QUERY_ERROR"] = "query_error";
+    DatabaseErrorType["VALIDATION_ERROR"] = "validation_error";
+    DatabaseErrorType["MIGRATION_ERROR"] = "migration_error";
+    DatabaseErrorType["SCHEMA_ERROR"] = "schema_error";
+    DatabaseErrorType["INDEX_ERROR"] = "index_error";
+    DatabaseErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
+})(DatabaseErrorType || (exports.DatabaseErrorType = DatabaseErrorType = {}));
+/**
+ * Database error class
+ */
+class DatabaseError extends Error {
+    constructor(type, message, originalError) {
+        super(message);
+        this.type = type;
+        this.originalError = originalError;
+        this.name = 'DatabaseError';
+    }
+}
+exports.DatabaseError = DatabaseError;
+/**
+ * Transaction isolation levels
+ */
+var TransactionIsolationLevel;
+(function (TransactionIsolationLevel) {
+    TransactionIsolationLevel["READ_UNCOMMITTED"] = "READ_UNCOMMITTED";
+    TransactionIsolationLevel["READ_COMMITTED"] = "READ_COMMITTED";
+    TransactionIsolationLevel["REPEATABLE_READ"] = "REPEATABLE_READ";
+    TransactionIsolationLevel["SERIALIZABLE"] = "SERIALIZABLE";
+})(TransactionIsolationLevel || (exports.TransactionIsolationLevel = TransactionIsolationLevel = {}));
+/**
+ * Transaction status
+ */
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["ACTIVE"] = "active";
+    TransactionStatus["COMMITTED"] = "committed";
+    TransactionStatus["ROLLED_BACK"] = "rolled_back";
+    TransactionStatus["FAILED"] = "failed";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+//# sourceMappingURL=database.types.js.map

package/dist/database/types/database.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.types.js","sourceRoot":"","sources":["../../../src/database/types/database.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;GAEG;AACH,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,yCAAyB,CAAA;IACzB,+BAAe,CAAA;IACf,mCAAmB,CAAA;IACnB,qCAAqB,CAAA;IACrB,iCAAiB,CAAA;AACnB,CAAC,EANW,YAAY,4BAAZ,YAAY,QAMvB;AAED;;GAEG;AACH,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,iDAA6B,CAAA;IAC7B,6CAAyB,CAAA;IACzB,2CAAuB,CAAA;IACvB,mCAAe,CAAA;AACjB,CAAC,EALW,gBAAgB,gCAAhB,gBAAgB,QAK3B;AAiED;;GAEG;AACH,IAAY,iBAQX;AARD,WAAY,iBAAiB;IAC3B,0DAAqC,CAAA;IACrC,gDAA2B,CAAA;IAC3B,0DAAqC,CAAA;IACrC,wDAAmC,CAAA;IACnC,kDAA6B,CAAA;IAC7B,gDAA2B,CAAA;IAC3B,4DAAuC,CAAA;AACzC,CAAC,EARW,iBAAiB,iCAAjB,iBAAiB,QAQ5B;AAED;;GAEG;AACH,MAAa,aAAc,SAAQ,KAAK;IACtC,YACS,IAAuB,EAC9B,OAAe,EACR,aAAqB;QAE5B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJR,SAAI,GAAJ,IAAI,CAAmB;QAEvB,kBAAa,GAAb,aAAa,CAAQ;QAG5B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AATD,sCASC;AAED;;GAEG;AACH,IAAY,yBAKX;AALD,WAAY,yBAAyB;IACnC,kEAAqC,CAAA;IACrC,8DAAiC,CAAA;IACjC,gEAAmC,CAAA;IACnC,0DAA6B,CAAA;AAC/B,CAAC,EALW,yBAAyB,yCAAzB,yBAAyB,QAKpC;AAED;;GAEG;AACH,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,4CAAuB,CAAA;IACvB,gDAA2B,CAAA;IAC3B,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,iCAAjB,iBAAiB,QAK5B"}

package/dist/database/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Database types index
+ * Exports all type definitions for the Ductape Database ORM
+ */
+export * from './database.types';
+export * from './connection.types';
+export * from './schema.types';
+export * from './migration.types';
+export * from './query.types';
+export * from './aggregation.types';
+export * from './result.types';
+export * from './index.types';

package/dist/database/types/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Database types index
+ * Exports all type definitions for the Ductape Database ORM
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Core database types
+__exportStar(require("./database.types"), exports);
+// Connection types
+__exportStar(require("./connection.types"), exports);
+// Schema types
+__exportStar(require("./schema.types"), exports);
+// Migration types
+__exportStar(require("./migration.types"), exports);
+// Query types
+__exportStar(require("./query.types"), exports);
+// Aggregation types
+__exportStar(require("./aggregation.types"), exports);
+// Result types
+__exportStar(require("./result.types"), exports);
+// Index types
+__exportStar(require("./index.types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/database/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/database/types/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;AAEH,sBAAsB;AACtB,mDAAiC;AAEjC,mBAAmB;AACnB,qDAAmC;AAEnC,eAAe;AACf,iDAA+B;AAE/B,kBAAkB;AAClB,oDAAkC;AAElC,cAAc;AACd,gDAA8B;AAE9B,oBAAoB;AACpB,sDAAoC;AAEpC,eAAe;AACf,iDAA+B;AAE/B,cAAc;AACd,gDAA8B"}