@ganju/utils 0.0.14 → 0.0.16

package/dist/dataApi.d.ts

@@ -0,0 +1,511 @@
+import { z } from 'zod';
+export declare const DATA_API_BASE = "/organization/:organizationId/project/:projectId/artifact/data";
+export type DataApiMethod = 'get' | 'post' | 'patch' | 'delete';
+export interface DataApiRoute {
+    method: DataApiMethod;
+    path: string;
+    summary: string;
+    description?: string;
+    tag: 'Database' | 'Tables' | 'Rows' | 'History and export';
+    body?: z.ZodType;
+    query?: z.ZodObject;
+    returns: string;
+    status?: 200 | 201;
+    file?: boolean;
+}
+export declare const DATA_API_ROUTES: {
+    readonly getDatabase: {
+        readonly method: "get";
+        readonly path: "";
+        readonly tag: "Database";
+        readonly summary: "The project's database";
+        readonly description: "Its status and size, and its tables when it is ready. `database` is null when the project has none.";
+        readonly returns: "{ database }";
+    };
+    readonly create: {
+        readonly method: "post";
+        readonly path: "";
+        readonly tag: "Database";
+        readonly summary: "Create the database";
+        readonly description: "Pro and Enterprise. Safe to repeat: a second call returns the same database. `name` defaults to the project's slug. While a deleted database is in its grace period this is refused unless `replaceDeleted` is true: the deleted one can then no longer be restored or exported, and is emptied when its grace period ends.";
+        readonly body: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            replaceDeleted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly returns: "{ database }";
+        readonly status: 201;
+    };
+    readonly remove: {
+        readonly method: "delete";
+        readonly path: "";
+        readonly tag: "Database";
+        readonly summary: "Delete the database";
+        readonly description: "Needs `confirmName`, the database name typed out. It can be restored for 7 days.";
+        readonly body: z.ZodObject<{
+            confirmName: z.ZodString;
+        }, z.core.$strip>;
+        readonly returns: "{ database }";
+    };
+    readonly restore: {
+        readonly method: "post";
+        readonly path: "/restore";
+        readonly tag: "Database";
+        readonly summary: "Undo a delete";
+        readonly description: "Within the 7-day grace period.";
+        readonly returns: "{ database }";
+    };
+    readonly restorePoint: {
+        readonly method: "post";
+        readonly path: "/restore-point";
+        readonly tag: "Database";
+        readonly summary: "Restore to a point in time";
+        readonly description: "Replaces everything with the database as it was at `timestamp` (within 30 days), or at the `bookmark` a checkpoint, a dropped table or column, a type change or an earlier restore answered with. The answer carries `undoBookmark`, which undoes the restore. Calls in flight while it restarts fail.";
+        readonly body: z.ZodUnion<readonly [z.ZodObject<{
+            timestamp: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodNumber]>;
+        }, z.core.$strict>, z.ZodObject<{
+            bookmark: z.ZodString;
+        }, z.core.$strict>]>;
+        readonly returns: "{ bookmark, undoBookmark }";
+    };
+    readonly checkpoint: {
+        readonly method: "post";
+        readonly path: "/checkpoint";
+        readonly tag: "Database";
+        readonly summary: "Take a restore point";
+        readonly description: "Answers with the `bookmark` of the database as it is right now, which `POST /restore-point` accepts. Take one before a large change, such as replacing a table's rows, to undo exactly that change: a time is not that precise.";
+        readonly returns: "{ bookmark }";
+    };
+    readonly dismissCopy: {
+        readonly method: "delete";
+        readonly path: "/copy";
+        readonly tag: "Tables";
+        readonly summary: "Dismiss a failed table copy";
+        readonly description: "A column change on a table over 100,000 rows copies it in the background; table changes, and writes that would change its rows, wait until it finishes (`copy` on `GET` shows how far it got). A copy that failed left the table as it was and stays in `copy` with its `error` until dismissed, or until the next column change.";
+        readonly returns: "{ copy: null }";
+    };
+    readonly listTables: {
+        readonly method: "get";
+        readonly path: "/table";
+        readonly tag: "Tables";
+        readonly summary: "Tables and their columns";
+        readonly returns: "{ tables }";
+    };
+    readonly createTable: {
+        readonly method: "post";
+        readonly path: "/table";
+        readonly tag: "Tables";
+        readonly summary: "Create a table";
+        readonly body: z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            displayColumn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            access: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                read: "read";
+                add: "add";
+                full: "full";
+            }>>;
+            customerScoped: z.ZodOptional<z.ZodBoolean>;
+            history: z.ZodOptional<z.ZodBoolean>;
+            columns: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    email: "email";
+                    json: "json";
+                    text: "text";
+                    long_text: "long_text";
+                    integer: "integer";
+                    decimal: "decimal";
+                    date: "date";
+                    datetime: "datetime";
+                    enum: "enum";
+                    url: "url";
+                    phone: "phone";
+                    relation: "relation";
+                    file: "file";
+                }>;
+                label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+                filterable: z.ZodOptional<z.ZodBoolean>;
+                searchable: z.ZodOptional<z.ZodBoolean>;
+                personal: z.ZodOptional<z.ZodBoolean>;
+                values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                table: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    restrict: "restrict";
+                    cascade: "cascade";
+                    set_null: "set_null";
+                }>>;
+                min: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly returns: "{ table }";
+        readonly status: 201;
+    };
+    readonly updateTable: {
+        readonly method: "patch";
+        readonly path: "/table/:table";
+        readonly tag: "Tables";
+        readonly summary: "Rename a table or change its settings";
+        readonly body: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            displayColumn: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            access: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                read: "read";
+                add: "add";
+                full: "full";
+            }>>>;
+            customerScoped: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            history: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strict>;
+        readonly returns: "{ table }";
+    };
+    readonly dropTable: {
+        readonly method: "delete";
+        readonly path: "/table/:table";
+        readonly tag: "Tables";
+        readonly summary: "Drop a table";
+        readonly description: "Needs `confirmName`, the table name typed out. The answer carries a `bookmark`: restoring to it brings the table back.";
+        readonly body: z.ZodObject<{
+            confirmName: z.ZodString;
+        }, z.core.$strict>;
+        readonly returns: "{ dropped, bookmark }";
+    };
+    readonly addColumn: {
+        readonly method: "post";
+        readonly path: "/table/:table/column";
+        readonly tag: "Tables";
+        readonly summary: "Add a column";
+        readonly body: z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                email: "email";
+                json: "json";
+                text: "text";
+                long_text: "long_text";
+                integer: "integer";
+                decimal: "decimal";
+                date: "date";
+                datetime: "datetime";
+                enum: "enum";
+                url: "url";
+                phone: "phone";
+                relation: "relation";
+                file: "file";
+            }>;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            unique: z.ZodOptional<z.ZodBoolean>;
+            filterable: z.ZodOptional<z.ZodBoolean>;
+            searchable: z.ZodOptional<z.ZodBoolean>;
+            personal: z.ZodOptional<z.ZodBoolean>;
+            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            table: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                restrict: "restrict";
+                cascade: "cascade";
+                set_null: "set_null";
+            }>>;
+            min: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        }, z.core.$strict>;
+        readonly returns: "{ table }";
+        readonly status: 201;
+    };
+    readonly updateColumn: {
+        readonly method: "patch";
+        readonly path: "/table/:table/column/:column";
+        readonly tag: "Tables";
+        readonly summary: "Rename a column or change it";
+        readonly description: "A type change copies the table and lists the first rows that would not fit. When it copies, the answer carries a `bookmark` from just before. Over 100,000 rows the copy runs in the background: the answer carries `copy`, the table keeps its old columns until it finishes, and meanwhile table changes, and writes that would change its rows, are refused.";
+        readonly body: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodEnum<{
+                boolean: "boolean";
+                email: "email";
+                json: "json";
+                text: "text";
+                long_text: "long_text";
+                integer: "integer";
+                decimal: "decimal";
+                date: "date";
+                datetime: "datetime";
+                enum: "enum";
+                url: "url";
+                phone: "phone";
+                relation: "relation";
+                file: "file";
+            }>>;
+            label: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            required: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            unique: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            filterable: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            searchable: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            personal: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            values: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            table: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            onDelete: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                restrict: "restrict";
+                cascade: "cascade";
+                set_null: "set_null";
+            }>>>;
+            min: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+            default: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        }, z.core.$strict>;
+        readonly returns: "{ table, bookmark, copy }";
+    };
+    readonly dropColumn: {
+        readonly method: "delete";
+        readonly path: "/table/:table/column/:column";
+        readonly tag: "Tables";
+        readonly summary: "Drop a column";
+        readonly description: "The answer carries a `bookmark`: restoring to it brings the column back. Dropping a relation column copies the table, in the background over 100,000 rows, as for a type change.";
+        readonly returns: "{ table, bookmark, copy }";
+    };
+    readonly listRows: {
+        readonly method: "get";
+        readonly path: "/table/:table/row";
+        readonly tag: "Rows";
+        readonly summary: "List, filter and search rows";
+        readonly description: "Up to 500 rows or 1 MB a page; `nextCursor` reads the next. `where` is JSON, e.g. `{\"status\":\"open\",\"price\":{\"lt\":30000}}`. `sort` is a list of columns, `-` for descending. `q` searches the searchable columns.";
+        readonly query: z.ZodObject<{
+            where: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<unknown, string>>>;
+            sort: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+            include: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodString>;
+            q: z.ZodOptional<z.ZodString>;
+            timeZone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly returns: "{ table, rows, total?, nextCursor? }";
+    };
+    readonly createRows: {
+        readonly method: "post";
+        readonly path: "/table/:table/row";
+        readonly tag: "Rows";
+        readonly summary: "Insert one row, or up to 500";
+        readonly body: z.ZodUnion<readonly [z.ZodObject<{
+            values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>]>;
+        readonly returns: "{ ids }";
+        readonly status: 201;
+    };
+    readonly getRow: {
+        readonly method: "get";
+        readonly path: "/table/:table/row/:id";
+        readonly tag: "Rows";
+        readonly summary: "One row";
+        readonly query: z.ZodObject<{
+            timeZone: z.ZodOptional<z.ZodString>;
+            include: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        }, z.core.$strict>;
+        readonly returns: "{ row }";
+    };
+    readonly updateRow: {
+        readonly method: "patch";
+        readonly path: "/table/:table/row/:id";
+        readonly tag: "Rows";
+        readonly summary: "Change a row";
+        readonly description: "Send the `version` you read: if the row changed since, the answer is 409 with the current row and who changed it.";
+        readonly body: z.ZodObject<{
+            set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            version: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly returns: "{ row }";
+    };
+    readonly deleteRow: {
+        readonly method: "delete";
+        readonly path: "/table/:table/row/:id";
+        readonly tag: "Rows";
+        readonly summary: "Delete a row";
+        readonly description: "Send the `version` you read, as for a change.";
+        readonly body: z.ZodObject<{
+            version: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly returns: "{ deleted }";
+    };
+    readonly deletePreview: {
+        readonly method: "post";
+        readonly path: "/table/:table/delete-preview";
+        readonly tag: "Rows";
+        readonly summary: "What deleting rows would do";
+        readonly description: "For `ids`, or every row without them: each relation column pointing at a row the delete removes, with how many rows it would delete (cascade), clear (set null) or that refuse the delete (restrict). Cascades are followed all the way down. `blocked` says a restrict would refuse it. Past 200,000 affected rows `truncated` is true and the counts are lower bounds. Nothing is deleted.";
+        readonly body: z.ZodObject<{
+            ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>;
+        readonly returns: "{ table, rows, effects, blocked, truncated }";
+    };
+    readonly rowHistory: {
+        readonly method: "get";
+        readonly path: "/table/:table/row/:id/history";
+        readonly tag: "History and export";
+        readonly summary: "A row's history";
+        readonly description: "Newest first, kept 90 days, with who made each change.";
+        readonly query: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            timeZone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly returns: "{ entries, nextCursor? }";
+    };
+    readonly write: {
+        readonly method: "post";
+        readonly path: "/write";
+        readonly tag: "Rows";
+        readonly summary: "Several writes, all or nothing";
+        readonly description: "Inserts, updates and deletes across tables in one transaction. A guard (`where` plus `expect`) that fails rolls everything back. A later step uses an earlier single-row insert's id as `{ \"$ref\": <step> }`, in its values or as the `id` it updates or deletes.";
+        readonly body: z.ZodObject<{
+            operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"insert">;
+                table: z.ZodString;
+                values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                rows: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                table: z.ZodString;
+                id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    $ref: z.ZodNumber;
+                }, z.core.$strict>]>>;
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                expect: z.ZodOptional<z.ZodNumber>;
+                version: z.ZodOptional<z.ZodNumber>;
+                op: z.ZodLiteral<"update">;
+            }, z.core.$strict>, z.ZodObject<{
+                table: z.ZodString;
+                id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    $ref: z.ZodNumber;
+                }, z.core.$strict>]>>;
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                expect: z.ZodOptional<z.ZodNumber>;
+                version: z.ZodOptional<z.ZodNumber>;
+                op: z.ZodLiteral<"delete">;
+            }, z.core.$strict>], "op">>;
+        }, z.core.$strict>;
+        readonly returns: "{ results }";
+    };
+    readonly startExport: {
+        readonly method: "post";
+        readonly path: "/export";
+        readonly tag: "History and export";
+        readonly summary: "Start an export";
+        readonly description: "Writes a copy in the background: schema.json and one JSONL or CSV file per table. Poll `GET /export` until `status` is `done`. Works during the 7-day grace period after a delete too.";
+        readonly body: z.ZodObject<{
+            format: z.ZodOptional<z.ZodEnum<{
+                csv: "csv";
+                jsonl: "jsonl";
+            }>>;
+        }, z.core.$strict>;
+        readonly returns: "{ exportId, status }";
+        readonly status: 201;
+    };
+    readonly exportStatus: {
+        readonly method: "get";
+        readonly path: "/export";
+        readonly tag: "History and export";
+        readonly summary: "The latest export";
+        readonly query: z.ZodObject<{
+            exportId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>;
+        readonly returns: "{ export }";
+    };
+    readonly exportFile: {
+        readonly method: "get";
+        readonly path: "/export/file";
+        readonly tag: "History and export";
+        readonly summary: "Download one of an export's files";
+        readonly description: "A table's file, or schema.json without `table`.";
+        readonly query: z.ZodObject<{
+            exportId: z.ZodUUID;
+            table: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly returns: "The file";
+        readonly file: true;
+    };
+    readonly listChanges: {
+        readonly method: "get";
+        readonly path: "/change";
+        readonly tag: "History and export";
+        readonly summary: "The schema change log";
+        readonly description: "Newest first: tables and columns changed, restores, exports, deletes.";
+        readonly query: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>;
+        readonly returns: "{ changes, nextCursor? }";
+    };
+};
+export type DataApiRouteId = keyof typeof DATA_API_ROUTES;
+/**
+ * The OpenAPI 3.1 document for the Data API, served by apps/api at
+ * /openapi/data.json.
+ */
+export declare const dataOpenApi: (serverUrl: string) => {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    security: {
+        bearer: never[];
+    }[];
+    tags: {
+        name: string;
+    }[];
+    paths: Record<string, Record<string, unknown>>;
+    components: {
+        securitySchemes: {
+            bearer: {
+                type: string;
+                scheme: string;
+            };
+        };
+        schemas: {
+            Error: {
+                type: string;
+                properties: {
+                    error: {
+                        type: string;
+                    };
+                    code: {
+                        type: string;
+                    };
+                    details: {
+                        type: string;
+                    };
+                    errors: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                path: {
+                                    type: string;
+                                };
+                                message: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=dataApi.d.ts.map

package/dist/dataApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataApi.d.ts","sourceRoot":"","sources":["../src/dataApi.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa,mEACwC,CAAC;AAEnE,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEhE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,aAAa,CAAC;IAEtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,oBAAoB,CAAC;IAC3D,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC;IAEpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IAEnB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAyBD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmPqB,CAAC;AAElD,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC;AAmB1D;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4G5C,CAAC"}