@iamkirbki/database-handler-core 2.0.0 → 3.0.1

package/dist/Database.d.ts

@@ -0,0 +1,98 @@
+import Table from "./Table";
+import Query from "./Query";
+import IDatabaseAdapter from "@core/interfaces/IDatabaseAdapter";
+/**
+ * Main Database class for interacting with SQLite databases
+ *
+ * @example
+ * ```typescript
+ * import { Database } from 'kirbkis-bettersqlite3-handler';
+ *
+ * // Create or open a database
+ * const db = new Database('./myapp.db');
+ *
+ * // Access a table
+ * const users = db.Table('users');
+ *
+ * // Create a new table
+ * const posts = db.CreateTable('posts');
+ * ```
+ */
+export default class Database {
+    private adapter;
+    /**
+     * Creates a new Database instance
+     *
+     * @param dbPath - Path to the SQLite database file (absolute or relative to process.cwd())
+     *
+     * @example
+     * ```typescript
+     * // Relative path
+     * const db = new Database('./data/app.db');
+     *
+     * // Absolute path
+     * const db = new Database('/var/data/app.db');
+     *
+     * // In-memory database
+     * const db = new Database(':memory:');
+     * ```
+     */
+    constructor(adapter: IDatabaseAdapter);
+    /**
+     * Get a Table instance to interact with an existing table
+     *
+     * @param name - Name of the table
+     * @returns Table instance for querying and manipulating data
+     * @throws Error if the table does not exist
+     *
+     * @example
+     * ```typescript
+     * const users = await db.Table('users');
+     * const allUsers = await users.Records();
+     * ```
+     */
+    Table(name: string): Promise<Table>;
+    /**
+     * Create a new table with specified columns
+     * Validates table name, column names, and column types before creation
+     * Uses CREATE TABLE IF NOT EXISTS to avoid errors if table already exists
+     *
+     * @param name - Name of the table to create
+     * @param columns - Object mapping column names to their type definitions
+     * @returns Table instance for the newly created table
+     * @throws Error if table name, column names, or column types are invalid
+     *
+     * @example
+     * ```typescript
+     * // Create a users table
+     * const users = await db.CreateTable('users', {
+     *   id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+     *   name: 'TEXT NOT NULL',
+     *   email: 'TEXT UNIQUE',
+     *   age: 'INTEGER',
+     *   created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
+     * });
+     *
+     * // Table is now ready to use
+     * await users.Insert({ name: 'John', email: 'john@example.com', age: 30 });
+     * ```
+     */
+    CreateTable(name: string, columns: object): Promise<Table>;
+    /**
+     * Create a Query object for executing custom SQL queries
+     *
+     * @param table - Table object for validation and context
+     * @param query - The SQL query string with ? placeholders
+     * @returns Query instance for executing the query
+     *
+     * @example
+     * ```typescript
+     * const users = db.Table('users');
+     * const query = db.Query(users, 'SELECT * FROM users WHERE age > ? AND status = ?');
+     * query.Parameters = { age: 18, status: 'active' };
+     * const results = query.All();
+     * ```
+     */
+    Query(table: Table, query: string): Query;
+}
+//# sourceMappingURL=Database.d.ts.map

package/dist/Database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../src/Database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,OAAO,CAAmB;IAElC;;;;;;;;;;;;;;;;OAgBG;gBACS,OAAO,EAAE,gBAAgB;IAIrC;;;;;;;;;;;;OAYG;IACU,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAMhD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAsBvE;;;;;;;;;;;;;;OAcG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK;CAGjD"}

package/dist/Query.d.ts

@@ -0,0 +1,139 @@
+import Table from "@core/Table";
+import { QueryParameters } from "./types/index";
+import Record from "@core/Record";
+import IDatabaseAdapter from "@core/interfaces/IDatabaseAdapter";
+/**
+ * Query class for executing custom SQL queries
+ *
+ * Features:
+ * - Supports named parameters using @fieldName syntax
+ * - Provides type-safe query execution (Run, All, Get)
+ * - Transaction support for atomic multi-insert/update operations
+ *
+ * @example
+ * ```typescript
+ * const users = db.Table('users');
+ *
+ * // SELECT query with parameters
+ * const query = db.Query(users, 'SELECT * FROM users WHERE age > @age AND status = @status');
+ * query.Parameters = { age: 18, status: 'active' };
+ * const results = query.All();
+ *
+ * // INSERT query
+ * const insert = db.Query(users, 'INSERT INTO users (name, email) VALUES (@name, @email)');
+ * insert.Parameters = { name: 'John', email: 'john@example.com' };
+ * insert.Run();
+ *
+ * // Transaction for multiple inserts
+ * insert.Transaction([
+ *   { name: 'John', email: 'john@example.com' },
+ *   { name: 'Jane', email: 'jane@example.com' }
+ * ]);
+ * ```
+ */
+export default class Query {
+    readonly Table: Table;
+    private readonly adapter;
+    private query;
+    Parameters: QueryParameters;
+    /**
+     * Creates a Query instance (usually called via db.Query() method)
+     *
+     * @param Table - Table instance for validation context
+     * @param Query - SQL query string with @fieldName placeholders for parameters
+     * @param DB - Database connection instance
+     *
+     * @example
+     * ```typescript
+     * // Direct instantiation (not recommended - use db.Query() instead)
+     * const query = new Query(
+     *   usersTable,
+     *   'SELECT * FROM users WHERE id = @id',
+     *   db
+     * );
+     * query.Parameters = { id: 1 };
+     *
+     * // Recommended approach
+     * const query = db.Query(usersTable, 'SELECT * FROM users WHERE id = @id');
+     * query.Parameters = { id: 1 };
+     * ```
+     */
+    constructor(Table: Table, Query: string, adapter: IDatabaseAdapter);
+    /**
+     * Execute a query that modifies data (INSERT, UPDATE, DELETE)
+     *
+     * @template Type - Expected return type (typically { lastInsertRowid: number, changes: number })
+     * @returns Result object with lastInsertRowid and changes count
+     *
+     * @example
+     * ```typescript
+     * // INSERT query
+     * const query = db.Query(users, 'INSERT INTO users (name, age) VALUES (@name, @age)');
+     * query.Parameters = { name: 'John', age: 30 };
+     * const result = query.Run<{ lastInsertRowid: number, changes: number }>();
+     * console.log(`Inserted ID: ${result.lastInsertRowid}`);
+     *
+     * // UPDATE query
+     * const update = db.Query(users, 'UPDATE users SET age = @age WHERE id = @id');
+     * update.Parameters = { age: 31, id: 1 };
+     * const updateResult = update.Run<{ changes: number }>();
+     * console.log(`Updated ${updateResult.changes} rows`);
+     * ```
+     */
+    Run<Type>(): Promise<Type>;
+    /**
+     * Execute a SELECT query and return all matching rows as Record objects
+     * Each row is wrapped in a Record instance for convenient updates/deletes
+     *
+     * @template Type - Expected row type
+     * @returns Array of Record objects containing the query results
+     *
+     * @example
+     * ```typescript
+     * interface User {
+     *   id: number;
+     *   name: string;
+     *   age: number;
+     * }
+     *
+     * const query = db.Query(users, 'SELECT * FROM users WHERE age > @age');
+     * query.Parameters = { age: 18 };
+     * const results = query.All<User>();
+     *
+     * // Each result is a Record object
+     * results.forEach(user => {
+     *   console.log(user.values); // { id: 1, name: 'John', age: 30 }
+     *   user.Update({ age: 31 }); // Can update directly
+     * });
+     * ```
+     */
+    All<Type>(): Promise<Record<Type>[]>;
+    /**
+     * Execute a SELECT query and return the first matching row as a Record object
+     * Returns undefined if no rows match the query
+     *
+     * @template Type - Expected row type
+     * @returns Single Record object or undefined if no match found
+     *
+     * @example
+     * ```typescript
+     * interface User {
+     *   id: number;
+     *   name: string;
+     *   email: string;
+     * }
+     *
+     * const query = db.Query(users, 'SELECT * FROM users WHERE id = @id');
+     * query.Parameters = { id: 1 };
+     * const user = query.Get<User>();
+     *
+     * if (user) {
+     *   console.log(user.values); // { id: 1, name: 'John', email: 'john@example.com' }
+     *   user.Update({ email: 'newemail@example.com' });
+     * }
+     * ```
+     */
+    Get<Type>(): Promise<Record<Type> | undefined>;
+    Transaction(paramList: QueryParameters[]): Promise<void>;
+}
+//# sourceMappingURL=Query.d.ts.map

package/dist/Query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Query.d.ts","sourceRoot":"","sources":["../src/Query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,MAAM,MAAM,cAAc,CAAC;AAClC,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,SAAgB,KAAK,EAAE,KAAK,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,KAAK,CAAc;IACpB,UAAU,EAAE,eAAe,CAAM;IAExC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB;IAMlE;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;IAKvC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAajD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAM9C,WAAW,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBtE"}

package/dist/Record.d.ts

@@ -0,0 +1,125 @@
+import { inspect } from "util";
+import Table from "@core/Table";
+import IDatabaseAdapter from "@core/interfaces/IDatabaseAdapter";
+/**
+ * Record class represents a single database row with methods for updates and deletion
+ * Automatically returned by Table.Records() and Table.Record() methods
+ *
+ * @example
+ * ```typescript
+ * const user = table.Record({ where: { id: 1 } });
+ *
+ * // Access values
+ * console.log(user?.values);
+ *
+ * // Update the record
+ * user?.Update({ name: 'John Doe', age: 31 });
+ *
+ * // Delete the record
+ * user?.Delete();
+ *
+ * // JSON serialization works automatically
+ * console.log(JSON.stringify(user)); // {"id": 1, "name": "John Doe", ...}
+ * ```
+ */
+export default class Record<ColumnValuesType> {
+    private readonly adapter;
+    private _values;
+    private readonly _table;
+    /**
+     * Creates a Record instance (typically called internally by Table methods)
+     *
+     * @param values - Object containing column names and their values
+     * @param db - Database connection instance
+     * @param tableName - Name of the table this record belongs to
+     */
+    constructor(values: ColumnValuesType, adapter: IDatabaseAdapter, table: Table);
+    /**
+     * Get the raw values object for this record
+     *
+     * @returns Object containing all column values
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * console.log(user?.values); // { id: 1, name: 'John', email: 'john@example.com' }
+     * ```
+     */
+    get values(): ColumnValuesType;
+    /**
+     * Update this record in the database
+     * Updates both the database and the local values
+     *
+     * @template TEntity - Record type that must include an 'id' property (number or string)
+     * @param newValues - Object with column names and new values to update
+     * @throws Error if the record doesn't have an 'id' field
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * user?.Update({ name: 'Jane Doe', age: 28 });
+     * // Database is updated and user.values reflects the changes
+     * ```
+     */
+    Update(newValues: object): Promise<void>;
+    /**
+     * Delete this record from the database
+     * Uses all current field values as WHERE clause conditions
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * user?.Delete();
+     * // Record is permanently deleted from the database
+     * ```
+     */
+    Delete(): Promise<void>;
+    /**
+     * Returns the values object when JSON.stringify() is called
+     * Allows seamless JSON serialization of Record objects
+     *
+     * @returns The values object
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * console.log(JSON.stringify(user));
+     * // Output: {"id":1,"name":"John","email":"john@example.com"}
+     * ```
+     */
+    toJSON(): ColumnValuesType;
+    /**
+     * Returns a formatted string representation of the record
+     *
+     * @returns Pretty-printed JSON string of the values
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * console.log(user?.toString());
+     * // Output:
+     * // {
+     * //   "id": 1,
+     * //   "name": "John",
+     * //   "email": "john@example.com"
+     * // }
+     * ```
+     */
+    toString(): string;
+    /**
+     * Custom inspect method for console.log() and Node.js REPL
+     * Makes Record objects display their values directly instead of the class structure
+     *
+     * @returns The values object for display
+     *
+     * @example
+     * ```typescript
+     * const user = table.Record({ where: { id: 1 } });
+     * console.log(user);
+     * // Output: { id: 1, name: 'John', email: 'john@example.com' }
+     * // Instead of: Record { _db: ..., _values: {...}, _tableName: '...' }
+     * ```
+     */
+    [inspect.custom](): ColumnValuesType;
+}
+//# sourceMappingURL=Record.d.ts.map

package/dist/Record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../src/Record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,KAAK,MAAM,aAAa,CAAC;AAGhC,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM,CAAC,gBAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;;;;;OAMG;gBACS,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK;IAM7E;;;;;;;;;;OAUG;IACH,IAAW,MAAM,IAAI,gBAAgB,CAEpC;IAED;;;;;;;;;;;;;;OAcG;IACU,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBrD;;;;;;;;;;OAUG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAUpC;;;;;;;;;;;;OAYG;IACI,MAAM,IAAI,gBAAgB;IAIjC;;;;;;;;;;;;;;;;OAgBG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;;;;;;;;;;OAaG;IACH,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,gBAAgB;CAGvC"}

package/dist/Schema.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Schema module - placeholder for future schema definition and migration features
+ *
+ * Future capabilities:
+ * - Schema versioning and migrations
+ * - Schema validation and comparison
+ * - Automatic migration generation
+ * - Schema import/export
+ *
+ * @module Schema
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=Schema.d.ts.map

package/dist/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,CAAC"}

package/dist/Table.d.ts

@@ -0,0 +1,158 @@
+import IDatabaseAdapter from "@core/interfaces/IDatabaseAdapter";
+import { DefaultQueryOptions, QueryOptions, QueryParameters, ReadableTableColumnInfo, TableColumnInfo } from "./types/index";
+import Record from "@core/Record";
+/**
+ * Table class for interacting with a specific database table
+ * Provides methods for querying, inserting, and retrieving table metadata
+ *
+ * @example
+ * ```typescript
+ * const users = db.Table('users');
+ *
+ * // Get all records
+ * const allUsers = users.Records();
+ *
+ * // Get filtered records
+ * const activeUsers = users.Records({
+ *   where: { status: 'active' }
+ * });
+ *
+ * // Insert a record
+ * users.Insert({ name: 'John', email: 'john@example.com' });
+ * ```
+ */
+export default class Table {
+    private readonly name;
+    private readonly adapter;
+    /**
+     * Private constructor - use Table.create() instead
+     *
+     * @param name - Name of the table
+     * @param adapter - Database adapter instance
+     */
+    private constructor();
+    /**
+     * Create a Table instance (async factory method)
+     *
+     * @param name - Name of the table
+     * @param adapter - Database adapter instance
+     * @param skipValidation - Skip table existence validation (used when creating new tables)
+     * @returns Table instance
+     * @throws Error if the table does not exist in the database
+     */
+    static create(name: string, adapter: IDatabaseAdapter, skipValidation?: boolean): Promise<Table>;
+    /**
+     * Get the name of the table
+     *
+     * @returns The table name
+     */
+    get Name(): string;
+    /**
+     * Get raw column information from SQLite PRAGMA
+     *
+     * @returns Array of column metadata from SQLite
+     *
+     * @example
+     * ```typescript
+     * const columns = await table.TableColumnInformation();
+     * // [{ cid: 0, name: 'id', type: 'INTEGER', notnull: 0, dflt_value: null, pk: 1 }, ...]
+     * ```
+     */
+    TableColumnInformation(): Promise<TableColumnInfo[]>;
+    /**
+     * Get readable, formatted column information
+     *
+     * @returns Array of formatted column metadata with readable properties
+     *
+     * @example
+     * ```typescript
+     * const columns = await table.ReadableTableColumnInformation();
+     * // [{ name: 'id', type: 'INTEGER', nullable: false, isPrimaryKey: true, defaultValue: null }, ...]
+     * ```
+     */
+    ReadableTableColumnInformation(): Promise<ReadableTableColumnInfo[]>;
+    Drop(): Promise<void>;
+    /**
+     * Fetch records from the table with optional filtering, ordering, and pagination
+     * @param options Query options for selecting records
+     * @returns Array of records matching the criteria
+     *
+     * @example
+     * // Get all records
+     * table.Records();
+     *
+     * @example
+     * // Get specific columns with filters
+     * table.Records({
+     *   select: 'id, name',
+     *   where: { status: 'active', age: 25 }
+     * });
+     *
+     * @example
+     * // With ordering and pagination
+     * table.Records({
+     *   orderBy: 'created_at DESC',
+     *   limit: 10,
+     *   offset: 20
+     * });
+     */
+    Records<Type>(options?: DefaultQueryOptions & QueryOptions): Promise<Record<Type>[]>;
+    /**
+     * Fetch a single record from the table
+     *
+     * @param options - Query options for selecting a record
+     * @param options.select - Columns to select (default: "*")
+     * @param options.where - Filter conditions as key-value pairs
+     * @param options.orderBy - SQL ORDER BY clause (e.g., "created_at DESC")
+     * @returns Single Record instance or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * // Get record by ID
+     * const user = table.Record({ where: { id: 1 } });
+     *
+     * // Get most recent record
+     * const latest = table.Record({ orderBy: 'created_at DESC' });
+     *
+     * // Update the record
+     * user?.update({ status: 'inactive' });
+     * ```
+     */
+    Record<Type>(options?: DefaultQueryOptions & QueryOptions): Promise<Record<Type> | undefined>;
+    /**
+     * Get the total count of records in the table
+     *
+     * @returns Number of records in the table
+     *
+     * @example
+     * ```typescript
+     * const totalUsers = table.RecordsCount;
+     * console.log(`Total users: ${totalUsers}`);
+     * ```
+     */
+    RecordsCount(): Promise<number>;
+    /**
+     * Insert one or multiple records into the table
+     * Validates data types against table schema before insertion
+     *
+     * @param values - Single object or array of objects to insert
+     * @returns Insert result with lastInsertRowid and changes count
+     * @throws Error if values is empty or contains no columns
+     * @throws Error if validation fails (wrong types, missing required fields)
+     *
+     * @example
+     * ```typescript
+     * // Insert single record
+     * const result = table.Insert({ name: 'John', age: 30 });
+     * console.log(`Inserted row ID: ${result.lastInsertRowid}`);
+     *
+     * // Insert multiple records (uses transaction for atomicity)
+     * table.Insert([
+     *   { name: 'John', age: 30 },
+     *   { name: 'Jane', age: 25 }
+     * ]);
+     * ```
+     */
+    Insert<Type>(values: QueryParameters): Promise<Record<Type> | undefined>;
+}
+//# sourceMappingURL=Table.d.ts.map

package/dist/Table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../src/Table.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AACjE,OAAO,EACH,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,uBAAuB,EAEvB,eAAe,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,MAAM,MAAM,cAAc,CAAC;AAGlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C;;;;;OAKG;IACH,OAAO;IAKP;;;;;;;;OAQG;WACiB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,cAAc,UAAQ,GAAG,OAAO,CAAC,KAAK,CAAC;IAe3G;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;;;;;;OAUG;IACU,sBAAsB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAIjE;;;;;;;;;;OAUG;IACU,8BAA8B,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAWpE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMlC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,OAAO,CAAC,IAAI,EACrB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAoB1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,MAAM,CAAC,IAAI,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAWpC;;;;;;;;;;OAUG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAM5C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;CA0FxF"}