@pilotiq/pilotiq 0.1.0

package/dist/orm/modelDefaults.d.ts

@@ -0,0 +1,347 @@
+import type { Table, TableRecordsHandler } from '../elements/Table.js';
+import type { SaveHandler, LoadRecordHandler } from '../elements/Form.js';
+/**
+ * SQL-style operators understood by `ModelLike.query()`. Mirrors the
+ * `WhereOperator` set from `@rudderjs/contracts` so any rudder Model is
+ * structurally assignable to `ModelLike` — but pilotiq doesn't import
+ * `@rudderjs/contracts` here to keep this file dependency-light.
+ */
+export type ModelWhereOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'LIKE' | 'IN' | 'NOT IN';
+/**
+ * Context passed into `Resource.query(ctx)`. Carries the resolved user so
+ * tenant-scoping / role-driven default ordering / etc. can branch on it.
+ * Optional everywhere; bare `R.query()` calls receive `undefined`.
+ */
+export interface QueryContext {
+    /** Whatever `Pilotiq.user(req => …)` returned for the current request.
+     * `undefined` for anonymous routes or when no user resolver is set. */
+    user?: unknown;
+}
+/**
+ * Minimal structural shape of a `Resource` class as far as the ORM helpers
+ * here need to see it — `name` for diagnostics, `model` for the default
+ * branch, and `query(ctx?)` for the override hook. Declared here (instead
+ * of importing `ResourceClass` from `../Resource.js`) to avoid a
+ * `Resource → modelDefaults → Resource` import cycle. The real
+ * `Resource` static class is structurally assignable to this shape.
+ */
+export interface ResourceLike {
+    name: string;
+    model?: ModelLike;
+    query(ctx?: QueryContext): ModelQuery;
+}
+/**
+ * Eloquent-style query builder pilotiq drives when it auto-generates
+ * `Table.records()` / `Form.save()` / `Form.loadRecord()` from a
+ * Resource's `static model`. Any query builder that satisfies this shape
+ * works — the rudder `QueryBuilder<T>` from `@rudderjs/contracts` does,
+ * and so does anything user-supplied with the same method names.
+ */
+export interface ModelQuery {
+    where(column: string, value: unknown): ModelQuery;
+    where(column: string, operator: ModelWhereOperator, value: unknown): ModelQuery;
+    orWhere(column: string, value: unknown): ModelQuery;
+    orWhere(column: string, operator: ModelWhereOperator, value: unknown): ModelQuery;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): ModelQuery;
+    paginate(page: number, perPage?: number): Promise<{
+        data: unknown[];
+        total: number;
+    }>;
+    /**
+     * Plan #13 — soft-delete query scopes. Optional on the structural
+     * shape; the `@rudderjs/orm-prisma` QueryBuilder ships them when
+     * `Model.softDeletes = true`. Pilotiq's `TrashedFilter` checks for
+     * presence at runtime and no-ops when missing (so non-soft-delete
+     * resources don't pay the cost).
+     */
+    withTrashed?(): ModelQuery;
+    onlyTrashed?(): ModelQuery;
+    /**
+     * Optional `IS NULL` clause used by `TernaryFilter`'s `'blank'` value.
+     * When absent, `TernaryFilter` falls back to `where(name, null)` —
+     * accurate against rudder's QueryBuilder, less reliable against bare
+     * Knex/raw drivers. The rudder ORM ships this; the structural shape
+     * keeps it optional so test stubs don't need to implement it.
+     */
+    whereNull?(column: string): ModelQuery;
+    /**
+     * M2M pivot-extra projection — declares which pivot-table columns to
+     * surface on each loaded related row under `row.pivot = { col: val }`.
+     * Used by `Repeater.relationship.pivotColumns([...])`. No-op (or
+     * irrelevant) on hasMany / morphMany queries; the rudder ORM
+     * implements this only on the M2M deferred-QB family. Optional on
+     * the structural shape so test stubs don't need to implement it.
+     */
+    withPivot?(...columns: string[]): ModelQuery;
+    /**
+     * Wrap a chain of `where`/`orWhere` (and nested `whereGroup`s) in a
+     * single AND-grouped clause. Used by `QueryBuilderFilter` v2 to
+     * translate nested AND/OR trees into parenthesized SQL groups. The
+     * callback receives a fresh sub-builder and may return it explicitly
+     * or implicitly (`void`); in either case the clauses recorded inside
+     * are spliced back into this builder as one composite clause.
+     *
+     * Optional on the structural shape — when missing, `applyTreeToQuery`
+     * falls back to flat AND chaining (v1 behaviour). The rudder ORM ships
+     * this on every QueryBuilder; test stubs don't have to.
+     */
+    whereGroup?(fn: (q: ModelQuery) => ModelQuery | void): ModelQuery;
+    /** OR-rooted variant of {@link whereGroup}. */
+    orWhereGroup?(fn: (q: ModelQuery) => ModelQuery | void): ModelQuery;
+}
+/**
+ * Structural shape pilotiq calls to wire ORM defaults. A class extending
+ * `@rudderjs/orm`'s `Model` satisfies this automatically via its static
+ * methods. Users with a different ORM can build their own object.
+ */
+export interface ModelLike {
+    /** Primary-key column name. Defaults to `'id'`. */
+    primaryKey?: string;
+    find(id: string | number): Promise<unknown>;
+    create(data: Record<string, unknown>): Promise<unknown>;
+    update(id: string | number, data: Record<string, unknown>): Promise<unknown>;
+    delete(id: string | number): Promise<void>;
+    query(): ModelQuery;
+    /**
+     * Plan #11 — return a `ModelQuery` scoped to the given parent record's
+     * relation. Optional. When absent, pilotiq falls back to the rudder ORM
+     * convention `parent.related(relationName)`. Override when your ORM
+     * doesn't follow that convention or when you need a custom join shape.
+     */
+    relatedQuery?(parent: unknown, relationName: string): ModelQuery;
+    /**
+     * Plan #13 — restore a soft-deleted record. Optional on the structural
+     * shape; rudder's `Model.restore` ships when `softDeletes = true`. Pilotiq
+     * detects presence at boot when `Resource.softDeletes = true` and throws
+     * a clear error pointing at the rudder upgrade if absent.
+     */
+    restore?(id: string | number): Promise<unknown>;
+    /**
+     * Plan #13 — permanently delete a record (bypassing soft-delete).
+     * Optional on the structural shape; same boot-time check as `restore`.
+     */
+    forceDelete?(id: string | number): Promise<void>;
+    /**
+     * Reorderable rows — write a new explicit ordering for the rows whose
+     * primary keys are in `ids`. The implementation overwrites the
+     * configured sort column (`Table.reorderable(col)`) so each id's value
+     * matches its position in the array (1..n). Optional on the structural
+     * shape; pilotiq throws a clear boot error when `Table.reorderable()`
+     * is set but this is missing.
+     */
+    reorder?(ids: Array<string | number>): Promise<void>;
+}
+/** Read the configured primary key (default `'id'`) off a `ModelLike`. */
+export declare function getPrimaryKey(M: ModelLike): string;
+/**
+ * Default `Form.save` handler for resources with `static model = …`.
+ * Discriminates create vs update by reading the primary-key off
+ * `ctx.record` (set by the route handler in edit mode after `loadRecord`
+ * + `fillFromRecord`). Create mode has no `ctx.record`, so we hit
+ * `model.create(data)`.
+ */
+export declare function modelSave(M: ModelLike): SaveHandler;
+/**
+ * Default `Form.loadRecord` handler for resources with `static model = …`.
+ * Routes through `R.query(ctx)` so tenant scopes / default-ordering hooks
+ * the user installed on `Resource.query(ctx)` ALSO scope the per-record
+ * load — without this, a tampered `:id` URL could load a record outside
+ * the user's scope and pass it to the form for editing. Falls back to the
+ * bare `M.find(id)` only when `R.query()` is missing — defensive against
+ * test stubs that hand-roll a partial Resource shape.
+ */
+export declare function modelLoadRecord(R: ResourceLike): LoadRecordHandler;
+/**
+ * Default `Form.loadRecord` handler for the singular-record settings
+ * pattern — one row in a table, auto-loaded on every page render.
+ * `Global` subclasses with `static model = M` set get this wired
+ * automatically by `defaultGlobalEditPage`.
+ *
+ * Default strategy: paginate(1, 1) — i.e. "the first row". Pass
+ * `findSingular` to switch to a fixed-id lookup
+ * (`(q) => q.where('id', '=', 1)`) or a slug-style lookup
+ * (`(q) => q.where('key', '=', 'site')`).
+ *
+ * Returns `null` when no row exists yet — the paired `modelSave(M)`
+ * handler will then run `M.create(data)` on the first POST so the
+ * record auto-creates on first save.
+ */
+export declare function loadSingularRecord(M: ModelLike, opts?: {
+    findSingular?: (q: ModelQuery) => ModelQuery;
+}): LoadRecordHandler;
+/**
+ * Find a record by primary key through `R.query(ctx)`. The standard
+ * "load record for edit / view / policy" path — replaces direct
+ * `R.model.find(id)` calls so user `Resource.query` overrides scope the
+ * lookup too. Returns `undefined` when no row matches (or no `R.model`
+ * is set), letting callers convert to 404 / fail closed.
+ *
+ * Soft-delete restore / force-delete deliberately bypass this helper —
+ * those paths build their own `query().withTrashed().where(pk, id)` so a
+ * record's own user-installed scope (which typically excludes trashed
+ * rows) doesn't hide a row the operator is trying to recover.
+ */
+export declare function findRecord<T = unknown>(R: ResourceLike, id: string | number, ctx?: QueryContext): Promise<T | undefined>;
+/**
+ * Build a default `Table.records` handler from a `Resource` class plus
+ * the `Table` instance the page just configured. Reads the column
+ * children to drive search (any `Column.searchable()` joins via
+ * `LIKE`/`orWhere`) and sort fallback (`Table.defaultSort()` when the
+ * URL didn't override).
+ *
+ * The handler hits `R.query(ctx).paginate(page, perPage)` once per page
+ * render — search/sort/pagination all push down to the ORM rather than
+ * loading everything and slicing in memory. Going through `R.query(ctx)`
+ * (instead of `R.model.query()` directly) means user-installed scopes
+ * — tenant filters, default ordering, soft-delete-default behavior —
+ * apply to list pages out of the box.
+ */
+export declare function modelTableRecords(R: ResourceLike, table: Table): TableRecordsHandler;
+/**
+ * Structural shape of a single entry in the parent model's
+ * `static relations` map (rudder ORM convention). The `model` thunk
+ * defers child-class resolution to call time so circular imports
+ * between sibling models still work.
+ *
+ * Pilotiq doesn't import this from `@rudderjs/orm` — keeping the
+ * shape duck-typed lets users stub a relations map for tests without
+ * pulling in the full ORM.
+ */
+export interface ParentRelationDescriptor {
+    /** Relation type. v1 of `Repeater.relationship` only handles `'hasMany'`. */
+    type: string;
+    /** Thunk returning the child model class (a `ModelLike`). */
+    model: () => ModelLike;
+    /** FK column on the child pointing back at the parent. */
+    foreignKey: string;
+}
+/**
+ * Read a single entry off a parent model's `static relations` map.
+ * Returns `undefined` when the map is missing, the named relation is
+ * absent, or the entry doesn't have the required `model` thunk +
+ * `foreignKey` string. Callers (e.g. `Repeater.relationship`'s save
+ * pipeline) throw a clear error from outside to surface configuration
+ * problems eagerly.
+ */
+export declare function getParentRelationDescriptor(parentModel: ModelLike, name: string): ParentRelationDescriptor | undefined;
+/**
+ * Read just the `type` field off a parent's `static relations[name]`.
+ * Returns `'hasMany'` when the relations map is missing the entry or
+ * doesn't expose a string `type` — same lenient default as
+ * `getParentRelationDescriptor`. Used by `relationManagerData` to set
+ * `RelationManagerContext.mode` for action injection / factory short-
+ * circuiting under M2M. Doesn't require the `foreignKey` field that
+ * `getParentRelationDescriptor` insists on, because M2M relations
+ * don't carry one (they have pivot keys instead).
+ */
+export declare function getRelationType(parentModel: ModelLike, name: string): string;
+/**
+ * Many-to-many relation descriptor read off a parent's `static
+ * relations[name]`. Returned by `getM2MRelationDescriptor` for the
+ * three M2M variants (`belongsToMany`, `morphToMany`, `morphedByMany`).
+ *
+ * Shape is intentionally minimal — pilotiq's M2M dispatch uses the
+ * `parent[rel]()` accessor for pivot writes, so neither `pivotTable`
+ * nor `morphName` need to surface here. The `model` thunk is the only
+ * field consumed by `Repeater.relationship`'s save pipeline (for
+ * `M.create` / `M.update` calls on the related child).
+ */
+export interface M2MRelationDescriptor {
+    /** Relation type. Discriminator for the `Repeater.relationship` M2M
+     *  branches; all three share the same persist-side dispatch but the
+     *  type round-trips into error messages and tests. */
+    type: 'belongsToMany' | 'morphToMany' | 'morphedByMany';
+    /** Thunk returning the related (child) model class. */
+    model: () => ModelLike;
+}
+/**
+ * Read a many-to-many relation entry off a parent model's `static
+ * relations[name]`. Returns `undefined` when the entry is missing,
+ * isn't an M2M type, or doesn't carry a `model` thunk. Lenient on
+ * the structural shape so test stubs can supply just `{ type, model }`.
+ *
+ * Caller responsibility: the lookup checks `relations[name].type`
+ * against the three M2M variants. Other relation types (hasMany,
+ * morphMany, etc.) return `undefined` so callers (e.g.
+ * `resolveChildAndAttachment`) can fall through to the corresponding
+ * descriptor lookup.
+ */
+export declare function getM2MRelationDescriptor(parentModel: ModelLike, name: string): M2MRelationDescriptor | undefined;
+/**
+ * Polymorphic relation descriptor read off a parent's `static relations[name]`.
+ * Returned by `getMorphRelationDescriptor` for `morphMany` / `morphOne` (where
+ * the parent IS the polymorphic owner — `Post.comments`). For `morphTo`, the
+ * `model` thunk is missing on the rudder side (the child has a `types: () =>
+ * [...]` list instead) — `getMorphRelationDescriptor` returns `undefined` in
+ * that case because `RelationManager` on the morphTo side requires
+ * `M.relatedResource` to be set anyway (auto-discovery is impossible).
+ */
+export interface MorphRelationDescriptor {
+    /** Polymorphic relation name. Drives column names: `{morphName}Id`,
+     *  `{morphName}Type`. e.g. `'commentable'` → `commentableId` / `commentableType`. */
+    morphName: string;
+    /** Override for the discriminator value persisted in `{morphName}Type`.
+     *  Defaults to `parent.constructor.morphAlias ?? parent.constructor.name`
+     *  when missing. */
+    morphType?: string;
+    /** Thunk returning the related (child) model class — present for
+     *  `morphMany` / `morphOne`, absent for `morphTo`. */
+    model?: () => ModelLike;
+}
+/**
+ * Read a polymorphic-relation entry off a parent model's `static
+ * relations[name]`. Returns `undefined` when the entry is missing,
+ * isn't a polymorphic type, or doesn't carry a string `morphName`.
+ * Lenient on the structural shape so test stubs can supply just the
+ * fields the consumer needs.
+ *
+ * Caller responsibility: the lookup checks
+ * `relations[name].type === 'morphMany' | 'morphOne'`. For `morphTo` —
+ * which has no `model` thunk on the rudder side — this returns
+ * `undefined`. The consumer (relation-create POST handler) only uses
+ * this for the morphMany auto-injection path; morphTo managers don't
+ * need it (they require `static relatedResource` and don't auto-fill
+ * any columns).
+ */
+export declare function getMorphRelationDescriptor(parentModel: ModelLike, name: string): MorphRelationDescriptor | undefined;
+/**
+ * Compute the `{ <morphName>Id, <morphName>Type }` payload for a
+ * polymorphic write. Mirrors rudder's `Model.morph(name, parent)` but
+ * lives here so pilotiq stays free of a runtime `@rudderjs/orm` dep.
+ *
+ * Resolution rules:
+ * - `<morphName>Id` ← `parent[parent.constructor.primaryKey ?? 'id']`
+ * - `<morphName>Type` ← `descriptor.morphType` if set, else
+ *   `parent.constructor.morphAlias ?? parent.constructor.name`
+ *
+ * Throws when the parent's primary key is unset (matches rudder's
+ * `Model.morph` behavior — a parent must be saved before a child can
+ * be linked).
+ */
+export declare function computeMorphPayload(parent: unknown, descriptor: MorphRelationDescriptor): Record<string, unknown>;
+/**
+ * Default relation-query resolver. Calls `parent.related(relationName)`
+ * — the rudder ORM convention — and returns the resulting `ModelQuery`.
+ * Throws a clear error when the parent record doesn't expose `.related()`,
+ * pointing the user at `ModelLike.relatedQuery` as the override slot.
+ */
+export declare function defaultRelatedQuery(parent: unknown, relationName: string): ModelQuery;
+/**
+ * Resolve a relation query by preferring the parent model's
+ * `relatedQuery` override and falling back to the rudder convention.
+ * The single entry point pilotiq's manager code calls.
+ */
+export declare function resolveRelatedQuery(M: ModelLike, parent: unknown, relationName: string): ModelQuery;
+/**
+ * Sibling of `modelTableRecords` for `RelationManager` tables. Drives
+ * pagination/search/sort/filters against `parent.related(relationName)`
+ * (or the parent model's `relatedQuery` override) instead of the related
+ * model's bare `query()`. Used by the page-data builder when a manager's
+ * `Table.records()` hasn't been set explicitly.
+ *
+ * `parentModel` is the **parent's** ModelLike (where `relatedQuery` lives
+ * if a custom override was set); `parent` is the resolved parent record
+ * instance the manager is scoped under.
+ */
+export declare function modelRelationTableRecords(parentModel: ModelLike, parent: unknown, relationName: string, table: Table): TableRecordsHandler;
+//# sourceMappingURL=modelDefaults.d.ts.map

package/dist/orm/modelDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelDefaults.d.ts","sourceRoot":"","sources":["../../src/orm/modelDefaults.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,mBAAmB,EAAsB,MAAM,sBAAsB,CAAA;AAC1F,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAe,MAAM,qBAAqB,CAAA;AAEtF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAA;AAEhG;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;2EACuE;IACvE,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAK,MAAM,CAAA;IACf,KAAK,CAAC,EAAG,SAAS,CAAA;IAClB,KAAK,CAAC,GAAG,CAAC,EAAE,YAAY,GAAG,UAAU,CAAA;CACtC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IACjD,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC/E,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IACnD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IACjF,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,UAAU,CAAA;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAErF;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,UAAU,CAAA;IAC1B,WAAW,CAAC,IAAI,UAAU,CAAA;IAE1B;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAA;IAEtC;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,UAAU,CAAA;IAE5C;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,GAAG,IAAI,GAAG,UAAU,CAAA;IAEjE,+CAA+C;IAC/C,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,GAAG,IAAI,GAAG,UAAU,CAAA;CACpE;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAmC,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3E,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAuB,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAiC,OAAO,CAAC,IAAI,CAAC,CAAA;IACxE,KAAK,IAAsD,UAAU,CAAA;IAErE;;;;;OAKG;IACH,YAAY,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,UAAU,CAAA;IAEhE;;;;;OAKG;IACH,OAAO,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE/C;;;OAGG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhD;;;;;;;OAOG;IACH,OAAO,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACrD;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,WAAW,CAUnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,GAAG,iBAAiB,CAMlE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAM,SAAS,EAChB,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,CAAA;CAAE,GACtD,iBAAiB,CAQnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,OAAO,EAC1C,CAAC,EAAI,YAAY,EACjB,EAAE,EAAG,MAAM,GAAG,MAAM,EACpB,GAAG,CAAC,EAAE,YAAY,GACjB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAOxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,GAAG,mBAAmB,CAuDpF;AAID;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,IAAI,EAAS,MAAM,CAAA;IACnB,6DAA6D;IAC7D,KAAK,EAAQ,MAAM,SAAS,CAAA;IAC5B,0DAA0D;IAC1D,UAAU,EAAG,MAAM,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,SAAS,EACtB,IAAI,EAAS,MAAM,GAClB,wBAAwB,GAAG,SAAS,CAetC;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,SAAS,EACtB,IAAI,EAAS,MAAM,GAClB,MAAM,CAOR;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC;;0DAEsD;IACtD,IAAI,EAAG,eAAe,GAAG,aAAa,GAAG,eAAe,CAAA;IACxD,uDAAuD;IACvD,KAAK,EAAE,MAAM,SAAS,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,SAAS,EACtB,IAAI,EAAS,MAAM,GAClB,qBAAqB,GAAG,SAAS,CAanC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC;yFACqF;IACrF,SAAS,EAAE,MAAM,CAAA;IACjB;;wBAEoB;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;0DACsD;IACtD,KAAK,CAAC,EAAE,MAAM,SAAS,CAAA;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,SAAS,EACtB,IAAI,EAAS,MAAM,GAClB,uBAAuB,GAAG,SAAS,CAcrC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAM,OAAO,EACnB,UAAU,EAAE,uBAAuB,GAClC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsBzB;AAUD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,UAAU,CASrF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAY,SAAS,EACtB,MAAM,EAAO,OAAO,EACpB,YAAY,EAAE,MAAM,GACnB,UAAU,CAKZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAG,SAAS,EACvB,MAAM,EAAQ,OAAO,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAS,KAAK,GAClB,mBAAmB,CA4CrB"}