@forestadmin-experimental/datasource-cosmos 1.0.0

package/README.md

@@ -0,0 +1,512 @@
+# Forest Admin Cosmos DB NoSQL Datasource
+
+[![npm version](https://badge.fury.io/js/@forestadmin-experimental%2Fdatasource-cosmos.svg)](https://www.npmjs.com/package/@forestadmin-experimental/datasource-cosmos)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
+A Forest Admin datasource for Azure Cosmos DB NoSQL API with full support for:
+- 🔍 **Introspection** - Automatic schema detection from sample documents
+- 📝 **CRUD Operations** - Create, Read, Update, Delete
+- 📊 **Aggregations** - Sum, Count, Avg, Min, Max with grouping
+- 🔎 **Advanced Filtering** - Complex queries with AND/OR conditions
+- 🔢 **Sorting & Pagination** - Efficient data retrieval
+
+## Installation
+
+```bash
+npm install @forestadmin-experimental/datasource-cosmos @azure/cosmos
+# or
+yarn add @forestadmin-experimental/datasource-cosmos @azure/cosmos
+```
+
+## Quick Start
+
+### Using the Cosmos DB Emulator (for development)
+
+```typescript
+import { createAgent } from '@forestadmin/agent';
+import { createCosmosDataSourceForEmulator } from '@forestadmin-experimental/datasource-cosmos';
+
+const agent = createAgent({
+  authSecret: process.env.FOREST_AUTH_SECRET,
+  envSecret: process.env.FOREST_ENV_SECRET,
+  isProduction: false,
+});
+
+agent.addDataSource(
+  createCosmosDataSourceForEmulator('myDatabase', {
+    builder: configurator =>
+      configurator
+        .addCollectionFromContainer({
+          name: 'Users',
+          databaseName: 'myDatabase',
+          containerName: 'users',
+        })
+        .addCollectionFromContainer({
+          name: 'Products',
+          databaseName: 'myDatabase',
+          containerName: 'products',
+        }),
+  }),
+);
+
+agent.start();
+```
+
+### Using Azure Cosmos DB
+
+```typescript
+import { createAgent } from '@forestadmin/agent';
+import { createCosmosDataSource } from '@forestadmin-experimental/datasource-cosmos';
+
+const agent = createAgent({
+  authSecret: process.env.FOREST_AUTH_SECRET,
+  envSecret: process.env.FOREST_ENV_SECRET,
+  isProduction: true,
+});
+
+agent.addDataSource(
+  createCosmosDataSource(
+    process.env.COSMOS_ENDPOINT,
+    process.env.COSMOS_KEY,
+    'myDatabase',
+    {
+      builder: configurator =>
+        configurator
+          .addCollectionFromContainer({
+            name: 'Users',
+            databaseName: 'myDatabase',
+            containerName: 'users',
+            partitionKeyPath: '/userId',
+          })
+          .addCollectionFromContainer({
+            name: 'Orders',
+            databaseName: 'myDatabase',
+            containerName: 'orders',
+            partitionKeyPath: '/customerId',
+            sampleSize: 200, // Analyze 200 documents for schema inference
+          }),
+    },
+  ),
+);
+
+agent.start();
+```
+
+## Configuration Options
+
+### Factory Functions
+
+#### `createCosmosDataSource(endpoint, key, databaseName?, options?)`
+
+Create a datasource with Azure Cosmos DB connection details.
+
+**Parameters:**
+- `endpoint` (string): Cosmos DB endpoint URL
+- `key` (string): Cosmos DB access key
+- `databaseName` (string, optional): Database name for auto-introspection
+- `options` (object, optional):
+  - `builder`: Configuration function for manual collection setup
+  - `liveQueryConnections`: Name for native query connection
+  - `liveQueryDatabase`: Database for native queries
+  - `clientOptions`: Additional CosmosClient options
+
+**Example:**
+```typescript
+createCosmosDataSource(
+  'https://myaccount.documents.azure.com:443/',
+  'myAccessKey',
+  'myDatabase',
+  {
+    builder: configurator =>
+      configurator.addCollectionFromContainer({
+        name: 'Users',
+        databaseName: 'myDatabase',
+        containerName: 'users',
+      }),
+    liveQueryConnections: 'cosmos',
+    liveQueryDatabase: 'myDatabase',
+  },
+)
+```
+
+#### `createCosmosDataSourceForEmulator(databaseName?, options?)`
+
+Create a datasource for the Cosmos DB Emulator (localhost:8081).
+
+**Parameters:**
+- `databaseName` (string, optional): Database name for auto-introspection
+- `options` (object, optional): Same as `createCosmosDataSource`
+
+**Example:**
+```typescript
+createCosmosDataSourceForEmulator('testDatabase', {
+  builder: configurator =>
+    configurator.addCollectionFromContainer({
+      name: 'TestCollection',
+      databaseName: 'testDatabase',
+      containerName: 'test-container',
+    }),
+})
+```
+
+#### `createCosmosDataSourceWithExistingClient(client, databaseName?)`
+
+Create a datasource with an existing CosmosClient instance.
+
+**Parameters:**
+- `client` (CosmosClient): Existing Cosmos DB client
+- `databaseName` (string, optional): Database name for auto-introspection
+
+**Example:**
+```typescript
+import { CosmosClient } from '@azure/cosmos';
+import { createCosmosDataSourceWithExistingClient } from '@forestadmin-experimental/datasource-cosmos';
+
+const client = new CosmosClient({
+  endpoint: 'https://myaccount.documents.azure.com:443/',
+  key: 'myAccessKey',
+});
+
+createCosmosDataSourceWithExistingClient(client, 'myDatabase')
+```
+
+### Collection Configuration
+
+When using the builder pattern, you can configure collections with these options:
+
+```typescript
+configurator.addCollectionFromContainer({
+  // Required
+  name: 'Users',                    // Forest Admin collection name
+  databaseName: 'myDatabase',       // Cosmos DB database name
+  containerName: 'users',           // Cosmos DB container name
+
+  // Optional
+  partitionKeyPath: '/userId',      // Partition key (auto-detected if not provided)
+  sampleSize: 100,                  // Number of documents to analyze for schema (default: 100)
+  enableCount: true,                // Enable total count in pagination (default: true)
+
+  overrideTypeConverter: (field) => {
+    // Custom type conversion logic
+    if (field.fieldName === 'customField') {
+      return {
+        ...field.generatedFieldSchema,
+        columnType: 'String',
+      };
+    }
+  },
+})
+```
+
+## Features
+
+### Schema Introspection
+
+The datasource automatically analyzes sample documents to infer the schema:
+
+```typescript
+// Automatic introspection of all containers in a database
+createCosmosDataSource(endpoint, key, 'myDatabase')
+
+// Manual configuration for specific containers
+createCosmosDataSource(endpoint, key, undefined, {
+  builder: configurator =>
+    configurator
+      .addCollectionFromContainer({
+        name: 'Users',
+        databaseName: 'myDatabase',
+        containerName: 'users',
+        sampleSize: 200, // Analyze 200 documents for better accuracy
+      }),
+})
+```
+
+**Supported Data Types:**
+- `string` → Forest Admin `String`
+- `number` → Forest Admin `Number`
+- `boolean` → Forest Admin `Boolean`
+- `date` (ISO 8601 strings or Date objects) → Forest Admin `Date`
+- `object` → Forest Admin `Json`
+- `array` → Forest Admin `Json`
+- GeoJSON Point → Forest Admin `Point`
+
+### CRUD Operations
+
+All standard CRUD operations are fully supported:
+
+```typescript
+// Create
+await collection.create(caller, [
+  { name: 'John Doe', email: 'john@example.com', age: 30 },
+  { name: 'Jane Doe', email: 'jane@example.com', age: 28 },
+]);
+
+// Read with filters
+await collection.list(
+  caller,
+  new PaginatedFilter({
+    conditionTree: {
+      field: 'age',
+      operator: 'GreaterThan',
+      value: 25,
+    },
+    page: { limit: 10, skip: 0 },
+  }),
+  new Projection('id', 'name', 'email'),
+);
+
+// Update
+await collection.update(
+  caller,
+  new Filter({
+    conditionTree: {
+      field: 'status',
+      operator: 'Equal',
+      value: 'pending',
+    },
+  }),
+  { status: 'active' },
+);
+
+// Delete
+await collection.delete(
+  caller,
+  new Filter({
+    conditionTree: {
+      field: 'status',
+      operator: 'Equal',
+      value: 'archived',
+    },
+  }),
+);
+```
+
+### Filtering
+
+**Supported Operators:**
+- Presence: `Present`, `Missing`
+- Equality: `Equal`, `NotEqual`, `In`, `NotIn`
+- Comparison: `LessThan`, `GreaterThan`
+- Strings: `Like`, `ILike`, `Contains`, `NotContains`, `StartsWith`, `EndsWith`
+- Arrays: `IncludesAll`
+
+**Complex Queries:**
+```typescript
+// AND condition
+const filter = new PaginatedFilter({
+  conditionTree: {
+    aggregator: 'And',
+    conditions: [
+      { field: 'status', operator: 'Equal', value: 'active' },
+      { field: 'age', operator: 'GreaterThan', value: 18 },
+      { field: 'role', operator: 'In', value: ['admin', 'moderator'] },
+    ],
+  },
+});
+
+// OR condition
+const filter = new PaginatedFilter({
+  conditionTree: {
+    aggregator: 'Or',
+    conditions: [
+      { field: 'priority', operator: 'Equal', value: 'high' },
+      { field: 'urgent', operator: 'Equal', value: true },
+    ],
+  },
+});
+
+// Nested conditions
+const filter = new PaginatedFilter({
+  conditionTree: {
+    aggregator: 'And',
+    conditions: [
+      { field: 'status', operator: 'Equal', value: 'active' },
+      {
+        aggregator: 'Or',
+        conditions: [
+          { field: 'role', operator: 'Equal', value: 'admin' },
+          { field: 'role', operator: 'Equal', value: 'owner' },
+        ],
+      },
+    ],
+  },
+});
+```
+
+### Aggregations
+
+Full support for aggregations with grouping:
+
+```typescript
+// Simple count
+await collection.aggregate(
+  caller,
+  new Filter({}),
+  {
+    operation: 'Count',
+    field: null,
+  },
+);
+
+// Sum with grouping
+await collection.aggregate(
+  caller,
+  new Filter({}),
+  {
+    operation: 'Sum',
+    field: 'revenue',
+    groups: [{ field: 'category' }],
+  },
+  10, // limit to 10 groups
+);
+
+// Average by date
+await collection.aggregate(
+  caller,
+  new Filter({}),
+  {
+    operation: 'Avg',
+    field: 'score',
+    groups: [{ field: 'createdAt', operation: 'Month' }],
+  },
+);
+```
+
+**Supported Aggregation Operations:**
+- `Count` - Count records
+- `Sum` - Sum numeric field
+- `Avg` - Average of numeric field
+- `Min` - Minimum value
+- `Max` - Maximum value
+
+**Supported Date Grouping:**
+- `Year`
+- `Month`
+- `Week` (approximation)
+- `Day`
+
+### Sorting & Pagination
+
+```typescript
+// Sort by single field
+const filter = new PaginatedFilter({
+  sort: [{ field: 'createdAt', ascending: false }],
+  page: { limit: 20, skip: 0 },
+});
+
+// Sort by multiple fields
+const filter = new PaginatedFilter({
+  sort: [
+    { field: 'status', ascending: true },
+    { field: 'priority', ascending: false },
+    { field: 'createdAt', ascending: false },
+  ],
+  page: { limit: 50, skip: 100 },
+});
+```
+
+### Native SQL Queries
+
+Execute native Cosmos DB SQL queries:
+
+```typescript
+createCosmosDataSource(endpoint, key, 'myDatabase', {
+  liveQueryConnections: 'cosmos',
+  liveQueryDatabase: 'myDatabase',
+});
+
+// In your Forest Admin dashboard, you can now execute:
+// SELECT * FROM users WHERE users.age > $minAge AND users.status = $status
+// With parameters: { minAge: 18, status: 'active' }
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Unit tests
+yarn test
+
+# Integration tests (requires Cosmos DB Emulator)
+docker compose up -d
+yarn test
+```
+
+### Cosmos DB Emulator
+
+For local development, use the Azure Cosmos DB Emulator:
+
+**Docker:**
+```bash
+docker compose up -d
+```
+
+**Connection Details:**
+- Endpoint: `https://localhost:8081`
+- Key: `C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==`
+
+## Architecture
+
+The datasource follows the Forest Admin datasource architecture:
+
+```
+src/
+├── datasource.ts                 # Main CosmosDataSource class
+├── collection.ts                 # CosmosCollection with CRUD operations
+├── model-builder/
+│   └── model.ts                 # ModelCosmos - Cosmos DB client wrapper
+├── introspection/
+│   ├── introspector.ts          # Auto-discovery of containers
+│   ├── container-introspector.ts # Schema inference from documents
+│   └── builder.ts               # Configuration builder pattern
+├── utils/
+│   ├── type-converter.ts        # Cosmos to Forest Admin type mapping
+│   ├── query-converter.ts       # Filter to Cosmos SQL conversion
+│   ├── aggregation-converter.ts # Aggregation query builder
+│   ├── model-to-collection-schema-converter.ts # Schema generation
+│   └── serializer.ts            # Result serialization
+└── index.ts                     # Public API and factory functions
+```
+
+## Limitations
+
+1. **Cosmos DB SQL API Limitations:**
+   - GROUP BY with multiple fields requires complex implementation
+   - No native JOIN support (use nested objects instead)
+   - Partition key required for efficient queries
+
+2. **Performance Considerations:**
+   - Schema introspection analyzes sample documents (configurable sample size)
+   - Large result sets should use pagination
+   - Consider indexing policies for optimal query performance
+
+3. **Type Inference:**
+   - Schema is inferred from sample documents
+   - Mixed types in the same field are treated as Json
+   - Nested objects are flattened or treated as Json
+
+## Contributing
+
+Contributions are welcome! Please see the main repository for contribution guidelines.
+
+## License
+
+GPL-3.0 - See LICENSE file for details
+
+## Support
+
+- 📚 [Forest Admin Documentation](https://docs.forestadmin.com)
+- 💬 [Community Forum](https://community.forestadmin.com)
+- 🐛 [Issue Tracker](https://github.com/ForestAdmin/forestadmin-experimental/issues)
+- 📧 [Email Support](mailto:support@forestadmin.com)
+
+## Related Packages
+
+- [@forestadmin/agent](https://www.npmjs.com/package/@forestadmin/agent) - Forest Admin Agent
+- [@forestadmin/datasource-toolkit](https://www.npmjs.com/package/@forestadmin/datasource-toolkit) - Base toolkit
+- [@azure/cosmos](https://www.npmjs.com/package/@azure/cosmos) - Azure Cosmos DB SDK
+
+---
+
+Made with ❤️ by [Forest Admin](https://www.forestadmin.com)

package/dist/collection.d.ts

@@ -0,0 +1,14 @@
+import { CosmosClient } from '@azure/cosmos';
+import { AggregateResult, Aggregation, BaseCollection, Caller, DataSource, Filter, Logger, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import ModelCosmos from './model-builder/model';
+export default class CosmosCollection extends BaseCollection {
+    protected internalModel: ModelCosmos;
+    private queryConverter;
+    constructor(datasource: DataSource, model: ModelCosmos, logger: Logger, nativeDriver: CosmosClient);
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,eAAe,EACf,WAAW,EACX,cAAc,EACd,MAAM,EACN,UAAU,EACV,MAAM,EACN,MAAM,EACN,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAKhD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,SAAS,CAAC,aAAa,EAAE,WAAW,CAAC;IAErC,OAAO,CAAC,cAAc,CAAiB;gBAGrC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY;IAmBtB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAUjE,IAAI,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,EAAE,CAAC;IAyBlB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC;CAkB9B"}

package/dist/collection.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const aggregation_converter_1 = __importDefault(require("./utils/aggregation-converter"));
+const model_to_collection_schema_converter_1 = __importDefault(require("./utils/model-to-collection-schema-converter"));
+const query_converter_1 = __importDefault(require("./utils/query-converter"));
+class CosmosCollection extends datasource_toolkit_1.BaseCollection {
+    constructor(datasource, model, logger, nativeDriver) {
+        if (!model)
+            throw new Error('Invalid (null) model instance.');
+        super(model.name, datasource, nativeDriver);
+        this.internalModel = model;
+        this.queryConverter = new query_converter_1.default();
+        const modelSchema = model_to_collection_schema_converter_1.default.convert(this.internalModel, logger);
+        if (this.internalModel.enableCount !== false)
+            this.enableCount();
+        this.addFields(modelSchema.fields);
+        this.addSegments(modelSchema.segments);
+        logger('Debug', `CosmosCollection - ${this.name} added`);
+    }
+    async create(caller, data) {
+        try {
+            const recordsResponse = await this.internalModel.create(data);
+            return recordsResponse;
+        }
+        catch (error) {
+            throw new Error(`Failed to create records: ${error.message}`);
+        }
+    }
+    async list(caller, filter, projection) {
+        try {
+            // Build the SQL query from the filter
+            const projectionFields = projection.columns.length > 0 ? projection.columns : undefined;
+            const querySpec = this.queryConverter.getSqlQuerySpec(filter.conditionTree, filter.sort, projectionFields);
+            // Execute the query with pagination
+            const recordsResponse = await this.internalModel.query(querySpec, filter.page?.skip, filter.page?.limit);
+            // Apply projection to only return projected fields
+            return projection.apply(recordsResponse);
+        }
+        catch (error) {
+            throw new Error(`Failed to list records: ${error.message}`);
+        }
+    }
+    async update(caller, filter, patch) {
+        try {
+            // First, get the IDs of records to update
+            const records = await this.list(caller, filter, new datasource_toolkit_1.Projection('id'));
+            const ids = records.map(record => record.id);
+            if (ids.length === 0) {
+                return; // Nothing to update
+            }
+            await this.internalModel.update(ids, patch);
+        }
+        catch (error) {
+            throw new Error(`Failed to update records: ${error.message}`);
+        }
+    }
+    async delete(caller, filter) {
+        try {
+            // First, get the IDs of records to delete
+            const records = await this.list(caller, filter, new datasource_toolkit_1.Projection('id'));
+            const ids = records.map(record => record.id);
+            if (ids.length === 0) {
+                return; // Nothing to delete
+            }
+            await this.internalModel.delete(ids);
+        }
+        catch (error) {
+            throw new Error(`Failed to delete records: ${error.message}`);
+        }
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        try {
+            // Build aggregation query
+            const querySpec = aggregation_converter_1.default.buildAggregationQuery(aggregation, filter.conditionTree, limit);
+            // Execute aggregation query
+            const rawResults = await this.internalModel.aggregateQuery(querySpec);
+            // Process results into Forest Admin format
+            return aggregation_converter_1.default.processAggregationResults(rawResults, aggregation);
+        }
+        catch (error) {
+            throw new Error(`Failed to aggregate records: ${error.message}`);
+        }
+    }
+}
+exports.default = CosmosCollection;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource.d.ts

@@ -0,0 +1,26 @@
+import { CosmosClient } from '@azure/cosmos';
+import { BaseDataSource, Logger } from '@forestadmin/datasource-toolkit';
+import CosmosCollection from './collection';
+import ModelCosmos from './model-builder/model';
+export default class CosmosDataSource extends BaseDataSource<CosmosCollection> {
+    /**
+     * Cosmos DB client instance
+     */
+    protected cosmosClient: CosmosClient;
+    constructor(cosmosClient: CosmosClient, collectionModels: ModelCosmos[], logger: Logger, options?: {
+        liveQueryConnections?: string;
+        liveQueryDatabase?: string;
+    });
+    protected createCollections(collectionModels: ModelCosmos[], logger: Logger): Promise<void>;
+    executeNativeQuery(connectionName: string, query: string, contextVariables?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    /**
+     * Parse the query string and extract container name and build SqlQuerySpec
+     * Expected format: "SELECT * FROM containerName WHERE ..."
+     */
+    private parseQuery;
+    /**
+     * Replace placeholders ($variableName) with Cosmos DB parameters (@paramN)
+     */
+    private replacePlaceholders;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.d.ts","sourceRoot":"","sources":["../src/datasource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,gBAAgB,MAAM,cAAc,CAAC;AAC5C,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAOhD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc,CAAC,gBAAgB,CAAC;IAC5E;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC;gBAGnC,YAAY,EAAE,YAAY,EAC1B,gBAAgB,EAAE,WAAW,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QAAE,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAE;cAoBzD,iBAAiB,CAAC,gBAAgB,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,MAAM;IAUlE,kBAAkB,CAC/B,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACb,gBAAgB,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAC7C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAiBrC;;;OAGG;IACH,OAAO,CAAC,UAAU;IAwBlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CA0B5B"}