@objectstack/spec 0.8.1 → 0.9.0

package/dist/api/websocket.zod.d.ts

@@ -38,9 +38,9 @@ export declare const FilterOperator: z.ZodEnum<{
     gt: "gt";
     gte: "gte";
     eq: "eq";
+    contains: "contains";
     ne: "ne";
     nin: "nin";
-    contains: "contains";
     exists: "exists";
 }>;
 export type FilterOperator = z.infer<typeof FilterOperator>;
@@ -60,9 +60,9 @@ export declare const EventFilterCondition: z.ZodObject<{
         gt: "gt";
         gte: "gte";
         eq: "eq";
+        contains: "contains";
         ne: "ne";
         nin: "nin";
-        contains: "contains";
         exists: "exists";
     }>;
     value: z.ZodOptional<z.ZodAny>;
@@ -142,10 +142,10 @@ export declare const PresenceStateSchema: z.ZodObject<{
     lastSeen: z.ZodString;
     currentLocation: z.ZodOptional<z.ZodString>;
     device: z.ZodOptional<z.ZodEnum<{
-        other: "other";
-        mobile: "mobile";
         desktop: "desktop";
+        mobile: "mobile";
         tablet: "tablet";
+        other: "other";
     }>>;
     customStatus: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -321,10 +321,10 @@ export declare const PresenceMessageSchema: z.ZodObject<{
         lastSeen: z.ZodString;
         currentLocation: z.ZodOptional<z.ZodString>;
         device: z.ZodOptional<z.ZodEnum<{
-            other: "other";
-            mobile: "mobile";
             desktop: "desktop";
+            mobile: "mobile";
             tablet: "tablet";
+            other: "other";
         }>>;
         customStatus: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -500,10 +500,10 @@ export declare const WebSocketMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         lastSeen: z.ZodString;
         currentLocation: z.ZodOptional<z.ZodString>;
         device: z.ZodOptional<z.ZodEnum<{
-            other: "other";
-            mobile: "mobile";
             desktop: "desktop";
+            mobile: "mobile";
             tablet: "tablet";
+            other: "other";
         }>>;
         customStatus: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;

package/dist/auth/scim.zod.d.ts

@@ -114,9 +114,9 @@ export declare const SCIMPhoneNumberSchema: z.ZodObject<{
     value: z.ZodString;
     type: z.ZodOptional<z.ZodEnum<{
         home: "home";
+        mobile: "mobile";
         work: "work";
         other: "other";
-        mobile: "mobile";
         fax: "fax";
         pager: "pager";
     }>>;
@@ -215,9 +215,9 @@ export declare const SCIMUserSchema: z.ZodObject<{
         value: z.ZodString;
         type: z.ZodOptional<z.ZodEnum<{
             home: "home";
+            mobile: "mobile";
             work: "work";
             other: "other";
-            mobile: "mobile";
             fax: "fax";
             pager: "pager";
         }>>;
@@ -389,9 +389,9 @@ export declare const SCIMListResponseSchema: z.ZodObject<{
             value: z.ZodString;
             type: z.ZodOptional<z.ZodEnum<{
                 home: "home";
+                mobile: "mobile";
                 work: "work";
                 other: "other";
-                mobile: "mobile";
                 fax: "fax";
                 pager: "pager";
             }>>;

package/dist/automation/flow.zod.d.ts

@@ -11,10 +11,10 @@ export declare const FlowNodeAction: z.ZodEnum<{
     create_record: "create_record";
     update_record: "update_record";
     delete_record: "delete_record";
+    wait: "wait";
     assignment: "assignment";
     get_record: "get_record";
     http_request: "http_request";
-    wait: "wait";
     subflow: "subflow";
 }>;
 /**
@@ -42,10 +42,10 @@ export declare const FlowNodeSchema: z.ZodObject<{
         create_record: "create_record";
         update_record: "update_record";
         delete_record: "delete_record";
+        wait: "wait";
         assignment: "assignment";
         get_record: "get_record";
         http_request: "http_request";
-        wait: "wait";
         subflow: "subflow";
     }>;
     label: z.ZodString;
@@ -110,10 +110,10 @@ export declare const FlowSchema: z.ZodObject<{
             create_record: "create_record";
             update_record: "update_record";
             delete_record: "delete_record";
+            wait: "wait";
             assignment: "assignment";
             get_record: "get_record";
             http_request: "http_request";
-            wait: "wait";
             subflow: "subflow";
         }>;
         label: z.ZodString;

package/dist/contracts/index.d.ts

@@ -11,4 +11,5 @@ export * from './service-registry.js';
 export * from './plugin-validator.js';
 export * from './startup-orchestrator.js';
 export * from './plugin-lifecycle-events.js';
+export * from './schema-driver.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/contracts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC"}

package/dist/contracts/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./service-registry.js"), exports);
 __exportStar(require("./plugin-validator.js"), exports);
 __exportStar(require("./startup-orchestrator.js"), exports);
 __exportStar(require("./plugin-lifecycle-events.js"), exports);
+__exportStar(require("./schema-driver.js"), exports);

package/dist/contracts/schema-driver.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ObjectSchema } from '../data/object.zod.js';
+import { FieldSchema } from '../data/field.zod.js';
+type DataField = z.infer<typeof FieldSchema>;
+type DataObject = z.infer<typeof ObjectSchema>;
+/**
+ * Interface for Data Definition Language (DDL) operations.
+ * Drivers should implement this to support automatic migrations.
+ */
+export interface ISchemaDriver {
+    createCollection(objectName: string, schema?: DataObject): Promise<void>;
+    dropCollection(objectName: string): Promise<void>;
+    addColumn(objectName: string, fieldName: string, field: DataField): Promise<void>;
+    modifyColumn(objectName: string, fieldName: string, field: DataField): Promise<void>;
+    dropColumn(objectName: string, fieldName: string): Promise<void>;
+    createIndex(objectName: string, indexName: string, fields: string[]): Promise<void>;
+    dropIndex(objectName: string, indexName: string): Promise<void>;
+    executeRaw(statement: string): Promise<any>;
+}
+export {};
+//# sourceMappingURL=schema-driver.d.ts.map

package/dist/contracts/schema-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-driver.d.ts","sourceRoot":"","sources":["../../src/contracts/schema-driver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,KAAK,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC7C,KAAK,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzE,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElD,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClF,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpF,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CAC7C"}

package/dist/contracts/schema-driver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hub/composer.zod.d.ts

@@ -276,6 +276,232 @@ export declare const ComposerResponseSchema: z.ZodObject<{
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
         extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        loading: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                lazy: "lazy";
+                parallel: "parallel";
+                eager: "eager";
+                deferred: "deferred";
+                "on-demand": "on-demand";
+            }>>;
+            preload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    metadata: "metadata";
+                    code: "code";
+                    dependencies: "dependencies";
+                    assets: "assets";
+                    services: "services";
+                }>>>;
+                conditions: z.ZodOptional<z.ZodObject<{
+                    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        desktop: "desktop";
+                        mobile: "mobile";
+                        tablet: "tablet";
+                    }>>>;
+                    minNetworkSpeed: z.ZodOptional<z.ZodEnum<{
+                        "slow-2g": "slow-2g";
+                        "2g": "2g";
+                        "3g": "3g";
+                        "4g": "4g";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            codeSplitting: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    custom: "custom";
+                    size: "size";
+                    route: "route";
+                    feature: "feature";
+                }>>;
+                chunkNaming: z.ZodDefault<z.ZodEnum<{
+                    hashed: "hashed";
+                    named: "named";
+                    sequential: "sequential";
+                }>>;
+                maxChunkSize: z.ZodOptional<z.ZodNumber>;
+                sharedDependencies: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    minChunks: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            dynamicImport: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    lazy: "lazy";
+                    async: "async";
+                    eager: "eager";
+                    sync: "sync";
+                }>>;
+                prefetch: z.ZodDefault<z.ZodBoolean>;
+                preload: z.ZodDefault<z.ZodBoolean>;
+                webpackChunkName: z.ZodOptional<z.ZodString>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            initialization: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    async: "async";
+                    parallel: "parallel";
+                    sequential: "sequential";
+                    sync: "sync";
+                }>>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                critical: z.ZodDefault<z.ZodBoolean>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            dependencyResolution: z.ZodOptional<z.ZodObject<{
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    strict: "strict";
+                    compatible: "compatible";
+                    latest: "latest";
+                    pinned: "pinned";
+                }>>;
+                peerDependencies: z.ZodOptional<z.ZodObject<{
+                    resolve: z.ZodDefault<z.ZodBoolean>;
+                    onMissing: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                    onMismatch: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                optionalDependencies: z.ZodOptional<z.ZodObject<{
+                    load: z.ZodDefault<z.ZodBoolean>;
+                    onFailure: z.ZodDefault<z.ZodEnum<{
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                conflictResolution: z.ZodDefault<z.ZodEnum<{
+                    manual: "manual";
+                    latest: "latest";
+                    fail: "fail";
+                    oldest: "oldest";
+                }>>;
+                circularDependencies: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    allow: "allow";
+                }>>;
+            }, z.core.$strip>>;
+            hotReload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    full: "full";
+                    partial: "partial";
+                    "state-preserve": "state-preserve";
+                }>>;
+                watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                debounceMs: z.ZodDefault<z.ZodNumber>;
+                preserveState: z.ZodDefault<z.ZodBoolean>;
+                stateSerialization: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    handler: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                hooks: z.ZodOptional<z.ZodObject<{
+                    beforeReload: z.ZodOptional<z.ZodString>;
+                    afterReload: z.ZodOptional<z.ZodString>;
+                    onError: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            caching: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                storage: z.ZodDefault<z.ZodEnum<{
+                    hybrid: "hybrid";
+                    memory: "memory";
+                    disk: "disk";
+                    indexeddb: "indexeddb";
+                }>>;
+                keyStrategy: z.ZodDefault<z.ZodEnum<{
+                    hash: "hash";
+                    version: "version";
+                    timestamp: "timestamp";
+                }>>;
+                ttl: z.ZodOptional<z.ZodNumber>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    error: "error";
+                    manual: "manual";
+                    "version-change": "version-change";
+                    "dependency-change": "dependency-change";
+                }>>>;
+                compression: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    algorithm: z.ZodDefault<z.ZodEnum<{
+                        gzip: "gzip";
+                        brotli: "brotli";
+                        deflate: "deflate";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sandboxing: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                isolationLevel: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    process: "process";
+                    vm: "vm";
+                    iframe: "iframe";
+                    "web-worker": "web-worker";
+                }>>;
+                allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resourceQuotas: z.ZodOptional<z.ZodObject<{
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                    maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+                    maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                permissions: z.ZodOptional<z.ZodObject<{
+                    allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            monitoring: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    "load-time": "load-time";
+                    "init-time": "init-time";
+                    "memory-usage": "memory-usage";
+                    "cpu-usage": "cpu-usage";
+                    "api-calls": "api-calls";
+                    "error-rate": "error-rate";
+                    "cache-hit-rate": "cache-hit-rate";
+                }>>>;
+                samplingRate: z.ZodDefault<z.ZodNumber>;
+                reportingInterval: z.ZodDefault<z.ZodNumber>;
+                budgets: z.ZodOptional<z.ZodObject<{
+                    maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                onBudgetViolation: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     manifestUrl: z.ZodOptional<z.ZodString>;
     buildId: z.ZodString;

package/dist/hub/composer.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composer.zod.d.ts","sourceRoot":"","sources":["../../src/hub/composer.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;iBAgBtC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;iBAqBhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAM/B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAchC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BjC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC"}
+{"version":3,"file":"composer.zod.d.ts","sourceRoot":"","sources":["../../src/hub/composer.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;iBAgBtC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;iBAqBhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAM/B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAchC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BjC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC"}