@substrat-run/contract-tests 0.142.0 → 0.144.0

package/dist/derived-module.d.ts

@@ -0,0 +1,690 @@
+/**
+ * The fixture behind `derivedHandlersContractSuite` (#1773): one module whose get, list, update
+ * and delete are DERIVED — declared with `derive` and handed no handler — bound through
+ * `operationsFor`, the path a vertical takes. So the suite holds the handlers the platform writes,
+ * on each adapter's SQL, to the behaviour a hand-written one owes: the check first, `not_found`,
+ * the partial PATCH, the 412, the event and its payload, the paged walk scoped to its parent.
+ *
+ * - `dfolder` — the parent a page is scoped to.
+ * - `dnote` — its child: derived get / list / update / delete. The writes that seed it, and the
+ *   read of its history, are authored — none of them is a derivable shape.
+ * - `dtag` — another child of `dfolder`, made by a derived CREATE (#2157): keyed per folder, its
+ *   time and author stamped, linked to the folder it was checked on; read and changed derived too.
+ * - `dlabel` — a scope-wide derived create, with no parent and no natural key.
+ * - `dshelf` — archivable and trashable, each under its own key (#119): derived archive /
+ *   unarchive / trash / restore, the bin page, and a list with the archive view.
+ */
+import { z } from 'zod';
+import { type ModuleRegistration } from '@substrat-run/kernel';
+export declare const DERIVED_MODULE_ID = "@test/derived";
+export declare const derivedEntities: {
+    readonly dfolder: {
+        readonly table: "derived_folders";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly dnote: {
+        readonly table: "derived_notes";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodNullable<z.ZodString>;
+            rank: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly parents: readonly ["dfolder"];
+    };
+    readonly dtag: {
+        readonly table: "derived_tags";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            label: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly parents: readonly ["dfolder"];
+        readonly key: readonly ["dfolder_id", "label"];
+        readonly stamps: {
+            readonly created_at: "createdAt";
+            readonly created_by: "createdBy";
+        };
+    };
+    readonly dlabel: {
+        readonly table: "derived_labels";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly dshelf: {
+        readonly table: "derived_shelves";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly archive: {
+            readonly permission: "dshelf:archive";
+        };
+        readonly trash: {
+            readonly permission: "dshelf:trash";
+        };
+    };
+};
+export declare const derivedOperations: {
+    readonly 'derived/add-folder': {
+        readonly summary: "Add a folder";
+        readonly permission: "dnote:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'derived/add-note': {
+        readonly summary: "Add a note — authored, and emitting, so the note has a version to hold";
+        readonly permission: "dnote:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            folderId: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodNullable<z.ZodString>;
+            rank: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: "dnote";
+            readonly entityIdFrom: "id";
+            readonly type: "dnote.added";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+    readonly 'derived/get-note': {
+        readonly summary: "One note";
+        readonly derive: "get";
+        readonly permission: {
+            readonly key: "dnote:read" | "dnote:write" | "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dnote';
+            readonly idFrom: 'noteId';
+        };
+        readonly input: z.ZodObject<{
+            noteId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodNullable<z.ZodString>;
+            rank: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/notes/{noteId}";
+        };
+    };
+    readonly 'derived/list-notes': {
+        readonly summary: "A folder's notes";
+        readonly derive: "list";
+        readonly permission: {
+            readonly key: "dnote:read";
+            readonly entity: "dfolder";
+            readonly idFrom: "dfolderId";
+        };
+        readonly input: z.ZodObject<{
+            dfolderId: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodNullable<z.ZodString>;
+            rank: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly paged: {
+            readonly over: {
+                readonly entity: "dnote";
+                readonly sortable: readonly ["rank"];
+                readonly filterable: readonly ["dfolder_id", "title"];
+            };
+            readonly total: true;
+        };
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/folders/{dfolderId}/notes";
+        };
+    };
+    readonly 'derived/update-note': {
+        readonly summary: "Change a note";
+        readonly derive: "update";
+        readonly permission: {
+            readonly key: "dnote:read" | "dnote:write" | "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dnote';
+            readonly idFrom: 'noteId';
+        };
+        readonly input: z.ZodObject<{
+            noteId: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            rank: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodNullable<z.ZodString>;
+            rank: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "PATCH";
+            readonly path: "/notes/{noteId}";
+        };
+        readonly concurrency: {
+            readonly over: "dnote";
+            readonly idFrom: "noteId";
+        };
+        readonly emits: {
+            readonly entity: "dnote";
+            readonly entityIdFrom: "id";
+            readonly type: "dnote.updated";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "title", "body", "rank"];
+        };
+    };
+    readonly 'derived/delete-note': {
+        readonly summary: "Remove a note";
+        readonly derive: "delete";
+        readonly permission: {
+            readonly key: "dnote:read" | "dnote:write" | "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dnote';
+            readonly idFrom: 'noteId';
+        };
+        readonly input: z.ZodObject<{
+            noteId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            deleted: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "DELETE";
+            readonly path: "/notes/{noteId}";
+        };
+        readonly emits: {
+            readonly entity: "dnote";
+            readonly entityIdFrom: "id";
+            readonly type: "dnote.deleted";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+    readonly 'derived/create-tag': {
+        readonly summary: "Tag a folder";
+        readonly derive: "create";
+        readonly permission: {
+            readonly key: "dnote:write";
+            readonly entity: "dfolder";
+            readonly idFrom: "dfolderId";
+        };
+        readonly input: z.ZodObject<{
+            dfolderId: z.ZodString;
+            label: z.ZodString;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            label: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/folders/{dfolderId}/tags";
+        };
+        readonly emits: {
+            readonly entity: "dtag";
+            readonly entityIdFrom: "id";
+            readonly type: "dtag.created";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "dfolder_id", "label", "created_at", "created_by"];
+        };
+    };
+    readonly 'derived/get-tag': {
+        readonly summary: "One tag — narrowed to the tag, so a grant on its folder reaches it only through the link";
+        readonly derive: "get";
+        readonly permission: {
+            readonly key: "dnote:read";
+            readonly entity: "dtag";
+            readonly idFrom: "tagId";
+        };
+        readonly input: z.ZodObject<{
+            tagId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            label: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/tags/{tagId}";
+        };
+    };
+    readonly 'derived/update-tag': {
+        readonly summary: "Change a tag's note";
+        readonly derive: "update";
+        readonly permission: {
+            readonly key: "dnote:write";
+            readonly entity: "dtag";
+            readonly idFrom: "tagId";
+        };
+        readonly input: z.ZodObject<{
+            tagId: z.ZodString;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            dfolder_id: z.ZodString;
+            label: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "PATCH";
+            readonly path: "/tags/{tagId}";
+        };
+        readonly concurrency: {
+            readonly over: "dtag";
+            readonly idFrom: "tagId";
+        };
+        readonly emits: {
+            readonly entity: "dtag";
+            readonly entityIdFrom: "id";
+            readonly type: "dtag.updated";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "note", "created_by"];
+        };
+    };
+    readonly 'derived/create-label': {
+        readonly summary: "Add a label";
+        readonly derive: "create";
+        readonly permission: "dnote:write";
+        readonly input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/labels";
+        };
+        readonly emits: {
+            readonly entity: "dlabel";
+            readonly entityIdFrom: "id";
+            readonly type: "dlabel.created";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "name"];
+        };
+    };
+    readonly 'derived/add-shelf': {
+        readonly summary: "Add a shelf";
+        readonly permission: "dnote:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'derived/create-shelf': {
+        readonly summary: "Add a shelf, its id minted";
+        readonly derive: "create";
+        readonly permission: "dnote:write";
+        readonly input: z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/shelves";
+        };
+        readonly emits: {
+            readonly entity: "dshelf";
+            readonly entityIdFrom: "id";
+            readonly type: "dshelf.created";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "label"];
+        };
+    };
+    readonly 'derived/list-shelves': {
+        readonly summary: "The shelves, active unless the archive is asked for";
+        readonly derive: "list";
+        readonly permission: "dnote:read";
+        readonly input: z.ZodObject<{
+            view: z.ZodOptional<z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+            }>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly paged: {
+            readonly over: {
+                readonly entity: "dshelf";
+                readonly sortable: readonly ["label"];
+            };
+        };
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/shelves";
+        };
+    };
+    readonly 'derived/archive-shelf': {
+        readonly summary: "File a shelf away";
+        readonly derive: "archive";
+        readonly permission: {
+            readonly key: "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dshelf';
+            readonly idFrom: 'shelfId';
+        };
+        readonly input: z.ZodObject<{
+            shelfId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+                trashed: "trashed";
+            }>;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/shelves/{shelfId}/archive";
+        };
+    };
+    readonly 'derived/unarchive-shelf': {
+        readonly summary: "Bring a shelf back from the archive";
+        readonly derive: "unarchive";
+        readonly permission: {
+            readonly key: "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dshelf';
+            readonly idFrom: 'shelfId';
+        };
+        readonly input: z.ZodObject<{
+            shelfId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+                trashed: "trashed";
+            }>;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/shelves/{shelfId}/unarchive";
+        };
+    };
+    readonly 'derived/trash-shelf': {
+        readonly summary: "Bin a shelf";
+        readonly derive: "trash";
+        readonly permission: {
+            readonly key: "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dshelf';
+            readonly idFrom: 'shelfId';
+        };
+        readonly input: z.ZodObject<{
+            shelfId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+                trashed: "trashed";
+            }>;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/shelves/{shelfId}/trash";
+        };
+    };
+    readonly 'derived/restore-shelf': {
+        readonly summary: "Take a shelf out of the bin";
+        readonly derive: "restore";
+        readonly permission: {
+            readonly key: "dshelf:archive" | "dshelf:trash";
+            readonly entity: 'dshelf';
+            readonly idFrom: 'shelfId';
+        };
+        readonly trashed: "admits";
+        readonly input: z.ZodObject<{
+            shelfId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+                trashed: "trashed";
+            }>;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/shelves/{shelfId}/restore";
+        };
+    };
+    readonly 'derived/trashed-shelves': {
+        readonly summary: "The bin";
+        readonly derive: "trashed";
+        readonly narrows: {
+            readonly reason: "Only the binned shelves the caller may restore";
+            readonly checks: readonly ["dshelf:trash"];
+        };
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        readonly paged: {
+            readonly over: {
+                readonly entity: "dshelf";
+                readonly sortable: readonly ["label"];
+            };
+        };
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/shelves/trash";
+        };
+    };
+    readonly 'derived/history': {
+        readonly summary: "A note's events, after it is gone too";
+        readonly permission: "dnote:read";
+        readonly input: z.ZodObject<{
+            noteId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            entries: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+};
+export declare const derivedModManifest: {
+    id: string & z.$brand<"ModuleId">;
+    version: string;
+    kernelContract: string;
+    permissions: {
+        key: string & z.$brand<"PermissionKey">;
+        description: string;
+    }[];
+    events: {
+        emits: {
+            type: string;
+            schemaVersion: number;
+        }[];
+        consumes: {
+            type: string;
+            schemaVersion: number;
+            from?: string | undefined;
+        }[];
+        exports?: {
+            type: string;
+            schemaVersion: number;
+            readPermission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    };
+    migrations: {
+        journalDir: string;
+        compatibleFrom: string;
+    };
+    attachmentTargets: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+        writePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+    }[];
+    liveTargets?: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+    }[] | undefined;
+    entityRelations?: {
+        entityType: string;
+        parentType: string;
+    }[] | undefined;
+    guards?: {
+        before: string;
+        predicate: string;
+        config: Record<string, unknown>;
+    }[] | undefined;
+    schedules?: {
+        operation: string;
+        cadence: {
+            everyMinutes: number;
+        };
+        input?: Record<string, unknown> | undefined;
+        permissions: (string & z.$brand<"PermissionKey">)[];
+        purge?: {
+            entityType: string;
+        } | undefined;
+    }[] | undefined;
+    peers?: {
+        vertical: string;
+        operations: string[];
+        permissions: (string & z.$brand<"PermissionKey">)[];
+    }[] | undefined;
+    freshness?: {
+        eventType: string;
+        within: {
+            hours: number;
+        };
+    }[] | undefined;
+    withdraws?: string[] | undefined;
+    entitlementKey: string;
+    envSpec?: {
+        key: string;
+        label?: string | undefined;
+        description: string;
+        placeholder?: string | undefined;
+        required: boolean;
+        secret: boolean;
+        default?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    ownerGrants?: (string & z.$brand<"PermissionKey">)[] | undefined;
+    entitlements?: string[] | undefined;
+    provides?: string[] | undefined;
+    requires?: string[] | undefined;
+    api?: string | undefined;
+    searchables?: {
+        entityType: string;
+        fields: string[];
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        tokenizer?: "prefix" | "substring" | undefined;
+    }[] | undefined;
+    lists?: {
+        entityType: string;
+        sortable: string[];
+        filterable?: string[] | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+    }[] | undefined;
+    entityStates?: {
+        archivePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        trashPermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        purgeAfterDays?: number | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        entityType: string;
+    }[] | undefined;
+    erasure?: {
+        tables: string[];
+        entities: {
+            entityType: string;
+            table: string;
+            mode: "blank" | "custom" | "delete" | "unreached";
+            subjects?: string[] | undefined;
+            fields: {
+                name: string;
+                blank: "" | null;
+            }[];
+        }[];
+    } | undefined;
+    ui?: {
+        routes?: {
+            path: string;
+            screen: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        nav?: {
+            label: string;
+            icon?: string | undefined;
+            to: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        entityViews?: {
+            entityType: string;
+            view: string;
+        }[] | undefined;
+        widgets?: {
+            slot: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        settingsPanels?: {
+            label: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    } | undefined;
+};
+export declare const derivedMod: ModuleRegistration;
+//# sourceMappingURL=derived-module.d.ts.map

package/dist/derived-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived-module.d.ts","sourceRoot":"","sources":["../src/derived-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,OAAO,EAA6C,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1G,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AAEjD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC1B,CAAC;AAQH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAHsC,OAAO;6BAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAFnB,QAAQ;6BAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8LnG,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB7B,CAAC;AAMH,eAAO,MAAM,UAAU,EAAE,kBAkDxB,CAAC"}