@ductape/sdk 0.0.4-v42 → 0.0.4-v43

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

@@ -0,0 +1,73 @@
+"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 || (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,iBAOX;AAPD,WAAY,iBAAiB;IAC3B,0DAAqC,CAAA;IACrC,gDAA2B,CAAA;IAC3B,0DAAqC,CAAA;IACrC,wDAAmC,CAAA;IACnC,kDAA6B,CAAA;IAC7B,gDAA2B,CAAA;AAC7B,CAAC,EAPW,iBAAiB,iCAAjB,iBAAiB,QAO5B;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"}

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

@@ -0,0 +1,220 @@
+/**
+ * Index type definitions for database indexes
+ */
+/**
+ * Index type
+ */
+export declare enum IndexType {
+    /** B-Tree index (default for most databases) */
+    BTREE = "btree",
+    /** Hash index */
+    HASH = "hash",
+    /** GIN (Generalized Inverted Index) - PostgreSQL */
+    GIN = "gin",
+    /** GiST (Generalized Search Tree) - PostgreSQL */
+    GIST = "gist",
+    /** Full-text index */
+    FULLTEXT = "fulltext",
+    /** Spatial index */
+    SPATIAL = "spatial",
+    /** Unique index */
+    UNIQUE = "unique"
+}
+/**
+ * Index column definition
+ */
+export interface IIndexColumn {
+    /** Column name */
+    name: string;
+    /** Sort order */
+    order?: 'ASC' | 'DESC';
+    /** Length (for partial indexes on string columns) */
+    length?: number;
+    /** Expression (for expression-based indexes) */
+    expression?: string;
+}
+/**
+ * Index definition
+ */
+export interface IIndexDefinition {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Columns in the index */
+    columns: IIndexColumn[];
+    /** Index type */
+    type?: IndexType;
+    /** Is unique index */
+    unique?: boolean;
+    /** Partial index condition (WHERE clause) */
+    where?: string;
+    /** Index method (database-specific) */
+    method?: string;
+    /** Include columns (PostgreSQL covering indexes) */
+    include?: string[];
+    /** Comment */
+    comment?: string;
+    /** Storage parameters */
+    storageParams?: Record<string, any>;
+}
+/**
+ * Create index options
+ */
+export interface ICreateIndexOptions {
+    /** Table name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Index definition */
+    index: IIndexDefinition;
+    /** Create if not exists */
+    ifNotExists?: boolean;
+    /** Create concurrently (PostgreSQL - doesn't lock table) */
+    concurrent?: boolean;
+    /** Generate migration */
+    generateMigration?: boolean;
+}
+/**
+ * Drop index options
+ */
+export interface IDropIndexOptions {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Drop if exists */
+    ifExists?: boolean;
+    /** Drop concurrently (PostgreSQL) */
+    concurrent?: boolean;
+    /** Cascade drop (also drop dependent objects) */
+    cascade?: boolean;
+    /** Generate migration */
+    generateMigration?: boolean;
+}
+/**
+ * List indexes options
+ */
+export interface IListIndexesOptions {
+    /** Table name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Include system indexes */
+    includeSystem?: boolean;
+}
+/**
+ * Index info (returned when listing indexes)
+ */
+export interface IIndexInfo {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Column names */
+    columns: string[];
+    /** Column definitions with details */
+    columnDetails: IIndexColumn[];
+    /** Is unique */
+    unique: boolean;
+    /** Is primary key */
+    primaryKey: boolean;
+    /** Index type */
+    type: string;
+    /** Index size (in bytes, if available) */
+    size?: number;
+    /** Number of rows in index */
+    rowCount?: number;
+    /** Partial index condition */
+    where?: string;
+    /** Comment */
+    comment?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Index statistics
+ */
+export interface IIndexStatistics {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Number of index scans */
+    scans?: number;
+    /** Number of tuples/rows read */
+    tuplesRead?: number;
+    /** Number of tuples fetched */
+    tuplesFetched?: number;
+    /** Index size in bytes */
+    size: number;
+    /** Index size (human-readable) */
+    sizeFormatted?: string;
+    /** Last used timestamp */
+    lastUsed?: Date | string;
+    /** Is index bloated */
+    bloated?: boolean;
+    /** Bloat percentage */
+    bloatPercentage?: number;
+}
+/**
+ * Analyze index options
+ */
+export interface IAnalyzeIndexOptions {
+    /** Index name */
+    indexName?: string;
+    /** Table name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+}
+/**
+ * Rebuild index options
+ */
+export interface IRebuildIndexOptions {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Rebuild concurrently (PostgreSQL) */
+    concurrent?: boolean;
+}
+/**
+ * Index recommendation
+ */
+export interface IIndexRecommendation {
+    /** Recommended index definition */
+    index: IIndexDefinition;
+    /** Reason for recommendation */
+    reason: string;
+    /** Estimated performance impact */
+    impact: 'high' | 'medium' | 'low';
+    /** Query patterns that would benefit */
+    affectedQueries?: string[];
+    /** Estimated index size */
+    estimatedSize?: number;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Index type definitions for database indexes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexType = void 0;
+/**
+ * Index type
+ */
+var IndexType;
+(function (IndexType) {
+    /** B-Tree index (default for most databases) */
+    IndexType["BTREE"] = "btree";
+    /** Hash index */
+    IndexType["HASH"] = "hash";
+    /** GIN (Generalized Inverted Index) - PostgreSQL */
+    IndexType["GIN"] = "gin";
+    /** GiST (Generalized Search Tree) - PostgreSQL */
+    IndexType["GIST"] = "gist";
+    /** Full-text index */
+    IndexType["FULLTEXT"] = "fulltext";
+    /** Spatial index */
+    IndexType["SPATIAL"] = "spatial";
+    /** Unique index */
+    IndexType["UNIQUE"] = "unique";
+})(IndexType || (exports.IndexType = IndexType = {}));
+//# sourceMappingURL=index.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.types.js","sourceRoot":"","sources":["../../../src/database/types/index.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,IAAY,SAeX;AAfD,WAAY,SAAS;IACnB,gDAAgD;IAChD,4BAAe,CAAA;IACf,iBAAiB;IACjB,0BAAa,CAAA;IACb,oDAAoD;IACpD,wBAAW,CAAA;IACX,kDAAkD;IAClD,0BAAa,CAAA;IACb,sBAAsB;IACtB,kCAAqB,CAAA;IACrB,oBAAoB;IACpB,gCAAmB,CAAA;IACnB,mBAAmB;IACnB,8BAAiB,CAAA;AACnB,CAAC,EAfW,SAAS,yBAAT,SAAS,QAepB"}

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

@@ -0,0 +1,205 @@
+/**
+ * Migration type definitions for database schema versioning
+ */
+/**
+ * Migration status
+ */
+export declare enum MigrationStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    ROLLED_BACK = "rolled_back"
+}
+/**
+ * Migration direction
+ */
+export declare enum MigrationDirection {
+    UP = "up",
+    DOWN = "down"
+}
+/**
+ * Migration operation type
+ */
+export declare enum MigrationOperationType {
+    CREATE_TABLE = "create_table",
+    DROP_TABLE = "drop_table",
+    ALTER_TABLE = "alter_table",
+    ADD_COLUMN = "add_column",
+    DROP_COLUMN = "drop_column",
+    MODIFY_COLUMN = "modify_column",
+    RENAME_COLUMN = "rename_column",
+    ADD_INDEX = "add_index",
+    DROP_INDEX = "drop_index",
+    ADD_CONSTRAINT = "add_constraint",
+    DROP_CONSTRAINT = "drop_constraint",
+    RAW_SQL = "raw_sql"
+}
+/**
+ * Migration operation
+ */
+export interface IMigrationOperation {
+    /** Operation type */
+    type: MigrationOperationType;
+    /** Table name */
+    table?: string;
+    /** Raw SQL (for RAW_SQL type) */
+    sql?: string;
+    /** Operation parameters */
+    params?: Record<string, any>;
+}
+/**
+ * Migration definition
+ */
+export interface IMigrationDefinition {
+    /** Migration name */
+    name: string;
+    /** Migration description */
+    description?: string;
+    /** Migration tag/identifier */
+    tag: string;
+    /** Up operations */
+    up: IMigrationOperation[];
+    /** Down operations (rollback) */
+    down: IMigrationOperation[];
+    /** Migration dependencies (tags of migrations that must run first) */
+    dependencies?: string[];
+    /** Created timestamp */
+    createdAt?: Date | string;
+}
+/**
+ * Migration execution result
+ */
+export interface IMigrationResult {
+    /** Migration tag */
+    tag: string;
+    /** Execution status */
+    status: MigrationStatus;
+    /** Direction executed */
+    direction: MigrationDirection;
+    /** Executed at timestamp */
+    executedAt: Date | string;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Error message (if failed) */
+    error?: string;
+    /** SQL statements executed */
+    statements?: string[];
+}
+/**
+ * Migration history entry
+ */
+export interface IMigrationHistory {
+    /** Migration tag */
+    tag: string;
+    /** Migration name */
+    name: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Status */
+    status: MigrationStatus;
+    /** Last direction executed */
+    direction: MigrationDirection;
+    /** Applied at timestamp */
+    appliedAt: Date | string;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Error details (if failed) */
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    /** Batch number (for grouping migrations) */
+    batch?: number;
+}
+/**
+ * Migration generation options
+ */
+export interface IMigrationGenerationOptions {
+    /** Migration name */
+    name: string;
+    /** Table name (if applicable) */
+    table?: string;
+    /** Description */
+    description?: string;
+    /** Auto-generate based on schema changes */
+    autoGenerate?: boolean;
+    /** Include timestamp in filename */
+    timestamp?: boolean;
+}
+/**
+ * Migration execution options
+ */
+export interface IMigrationExecutionOptions {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Run specific migration tag */
+    tag?: string;
+    /** Run up to specific migration */
+    to?: string;
+    /** Batch mode */
+    batch?: boolean;
+    /** Dry run (don't execute, just show what would run) */
+    dryRun?: boolean;
+    /** Force execution even if migration already ran */
+    force?: boolean;
+}
+/**
+ * Migration rollback options
+ */
+export interface IMigrationRollbackOptions {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Rollback specific migration */
+    tag?: string;
+    /** Rollback last N migrations */
+    steps?: number;
+    /** Rollback last batch */
+    batch?: boolean;
+    /** Dry run */
+    dryRun?: boolean;
+}
+/**
+ * Pending migration info
+ */
+export interface IPendingMigration {
+    /** Migration tag */
+    tag: string;
+    /** Migration name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Created at */
+    createdAt: Date | string;
+    /** Dependencies */
+    dependencies?: string[];
+}
+/**
+ * Migration status summary
+ */
+export interface IMigrationStatus {
+    /** Total migrations */
+    total: number;
+    /** Completed migrations */
+    completed: number;
+    /** Pending migrations */
+    pending: number;
+    /** Failed migrations */
+    failed: number;
+    /** Last migration applied */
+    lastApplied?: IMigrationHistory;
+    /** Pending migrations list */
+    pendingMigrations: IPendingMigration[];
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Migration type definitions for database schema versioning
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationOperationType = exports.MigrationDirection = exports.MigrationStatus = void 0;
+/**
+ * Migration status
+ */
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["PENDING"] = "pending";
+    MigrationStatus["RUNNING"] = "running";
+    MigrationStatus["COMPLETED"] = "completed";
+    MigrationStatus["FAILED"] = "failed";
+    MigrationStatus["ROLLED_BACK"] = "rolled_back";
+})(MigrationStatus || (exports.MigrationStatus = MigrationStatus = {}));
+/**
+ * Migration direction
+ */
+var MigrationDirection;
+(function (MigrationDirection) {
+    MigrationDirection["UP"] = "up";
+    MigrationDirection["DOWN"] = "down";
+})(MigrationDirection || (exports.MigrationDirection = MigrationDirection = {}));
+/**
+ * Migration operation type
+ */
+var MigrationOperationType;
+(function (MigrationOperationType) {
+    MigrationOperationType["CREATE_TABLE"] = "create_table";
+    MigrationOperationType["DROP_TABLE"] = "drop_table";
+    MigrationOperationType["ALTER_TABLE"] = "alter_table";
+    MigrationOperationType["ADD_COLUMN"] = "add_column";
+    MigrationOperationType["DROP_COLUMN"] = "drop_column";
+    MigrationOperationType["MODIFY_COLUMN"] = "modify_column";
+    MigrationOperationType["RENAME_COLUMN"] = "rename_column";
+    MigrationOperationType["ADD_INDEX"] = "add_index";
+    MigrationOperationType["DROP_INDEX"] = "drop_index";
+    MigrationOperationType["ADD_CONSTRAINT"] = "add_constraint";
+    MigrationOperationType["DROP_CONSTRAINT"] = "drop_constraint";
+    MigrationOperationType["RAW_SQL"] = "raw_sql";
+})(MigrationOperationType || (exports.MigrationOperationType = MigrationOperationType = {}));
+//# sourceMappingURL=migration.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration.types.js","sourceRoot":"","sources":["../../../src/database/types/migration.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,IAAY,eAMX;AAND,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,sCAAmB,CAAA;IACnB,0CAAuB,CAAA;IACvB,oCAAiB,CAAA;IACjB,8CAA2B,CAAA;AAC7B,CAAC,EANW,eAAe,+BAAf,eAAe,QAM1B;AAED;;GAEG;AACH,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,+BAAS,CAAA;IACT,mCAAa,CAAA;AACf,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B;AAED;;GAEG;AACH,IAAY,sBAaX;AAbD,WAAY,sBAAsB;IAChC,uDAA6B,CAAA;IAC7B,mDAAyB,CAAA;IACzB,qDAA2B,CAAA;IAC3B,mDAAyB,CAAA;IACzB,qDAA2B,CAAA;IAC3B,yDAA+B,CAAA;IAC/B,yDAA+B,CAAA;IAC/B,iDAAuB,CAAA;IACvB,mDAAyB,CAAA;IACzB,2DAAiC,CAAA;IACjC,6DAAmC,CAAA;IACnC,6CAAmB,CAAA;AACrB,CAAC,EAbW,sBAAsB,sCAAtB,sBAAsB,QAajC"}