@substrat-run/connector-planima 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -0,0 +1,429 @@
+import { z } from 'zod';
+import { type ConnectionActivity, type ConnectionCredential, type ConnectionProbe, type ConnectionId } from '@substrat-run/contracts';
+import type { FetchLike, ScopeHost } from '@substrat-run/kernel';
+export { PlanimaApi, PlanimaApiError, PLANIMA_API_BASE, PLANIMA_ACCEPT, PLANIMA_MAX_PAGE, PLANIMA_ACTION_STATUSES, planimaSecret, type PlanimaAction, type PlanimaApiOptions, type PlanimaBuilding, type PlanimaComponent, type PlanimaFacility, type PlanimaOrganization, type PlanimaSecret, } from './api.js';
+export { decimalOf, planimaActionFact, planimaBuildingFact, planimaComponentFact, planimaDecimal, planimaFacilityFact, type PlanimaActionFact, type PlanimaBuildingFact, type PlanimaComponentFact, type PlanimaFacilityFact, } from './plan.js';
+export { PlanimaMock, type PlanimaMockOptions } from './mock.js';
+/**
+ * The Planima connector — the INBOUND half of maintenance-plan integration.
+ *
+ * [Planima](https://planima.se/) is a Swedish web application for planned facility
+ * maintenance (sv. *underhållsplan*). A plan is a tree — organization → facility →
+ * building → component — with **actions** hanging off it: dated, priced, categorized
+ * work a property owner intends to do in a given year.
+ *
+ * ## Poll-only, and that is a design fact rather than an omission
+ *
+ * Like `connector-fortnox` and unlike `connector-scrive`, this connector registers no
+ * event handler at all, because nothing inside a scope initiates the work. A vertical
+ * does not *ask* for next year's maintenance plan the way it asks for a signature; the
+ * plan changes in Planima — a surveyor walks a roof and moves an action from 2031 to
+ * 2027 — and the platform finds out by looking.
+ *
+ * So there is no `registerPlanimaConnector`. {@link sweepPlanimaPlan} is the whole
+ * trigger surface, and a deployment binds it into the platform sweeper exactly as it
+ * binds Fortnox's.
+ *
+ * ## Read-only, and the credential is why
+ *
+ * Planima's API can create and update organizations, facilities, buildings and
+ * components. This connector uses none of it. A Planima token carries the full access
+ * of the user who minted it — there are no scopes to narrow — so the narrowing that
+ * matters is operational: hand this connector a **read-only user's token** and the
+ * blast radius of a leaked credential is a maintenance plan someone could already see.
+ * A write path would forfeit that, and no vertical has asked for one; when one does,
+ * it belongs behind an event and a dispatch, in the shape `connector-scrive` already
+ * has.
+ *
+ * ## Where the data lands, and why the connector does not decide
+ *
+ * A sweep has no delivered event, so it has neither a scope to write to nor authority
+ * to write with. That is declared **once**, explicitly, by {@link bindPlanimaScope}:
+ * which scope, which operation to land the plan through, and which permission that
+ * operation checks.
+ *
+ * The operation is the *consumer's*, and that is deliberate. What comes out of Planima
+ * is neutral fact — a component, a year, a price, a status string. What a business
+ * *means* by them (which status counts as committed spend, which category rolls into
+ * which budget line, whether a deferred action still books) is vocabulary, and
+ * vocabulary is the vertical's layer.
+ */
+/**
+ * The standing grants this connector requires — deliberately EMPTY, with a mechanism
+ * in place of a declaration.
+ *
+ * The reasoning is `FORTNOX_CONNECTION_GRANTS`'s, and it applies here for the same
+ * reason: the permission this connector needs is whatever the *consumer's* landing
+ * operation checks, which differs per vertical and is unknown at this package's build
+ * time. So the check moves from build time to bind time — {@link bindPlanimaScope}
+ * verifies the connection actually holds the named permission in the named scope and
+ * **refuses the binding otherwise**, naming what is missing. A sweep can therefore
+ * never be configured into a state where it fetches a whole maintenance plan and
+ * cannot write it down.
+ */
+export declare const PLANIMA_CONNECTION_GRANTS: readonly [];
+/**
+ * The currency a Planima plan's prices are in — a DECLARED fact, because the API does
+ * not carry one.
+ *
+ * Planima sends `unit_price: 1200` and nothing else: no currency field on the action,
+ * the facility, the organization or the account. The product is Swedish and its prices
+ * are kronor, so `SEK` is the right default — but it is a default this connector chose,
+ * not a value it read, and Substrat money is a `{ amount, currency }` pair that cannot
+ * be built without one. Naming it on the binding is what keeps that choice visible and
+ * overridable instead of hard-coded three files down.
+ */
+export declare const PLANIMA_DEFAULT_CURRENCY = "SEK";
+/**
+ * How many years past the current one a sweep reads when a binding names no window.
+ *
+ * A Swedish maintenance plan is conventionally drawn 30 years out, and almost nothing
+ * consumes all of it: the far years are placeholders that move every time a surveyor
+ * revisits. Ten years is the horizon a budget actually uses, and — because the window
+ * is part of the sync's identity — a shorter one also means the far-future churn does
+ * not make every sweep look like a change.
+ */
+export declare const PLANIMA_DEFAULT_HORIZON_YEARS = 10;
+/**
+ * What the connector remembers about one scope it syncs into.
+ *
+ * Directory-side (`putConnectorState`) for the same reason Fortnox's binding is: this
+ * is a connector's own bookkeeping, it must survive across sweeps, and it must be
+ * readable without entering a scope.
+ */
+export interface PlanimaBinding {
+    scopeId: string;
+    tenantId: string;
+    /** The scope's vertical — half the key that reopens the connection to poll. */
+    vertical: string;
+    /**
+     * The operation the plan is landed through, e.g. `'maintenance/record-plan'`.
+     *
+     * Named by whoever binds, never defaulted. A default here would be a name this
+     * package invented for an operation it does not implement — so the first deployment
+     * to get it wrong would find out at sweep time, from an `unknown operation` error
+     * three layers down, rather than at bind time from this function.
+     */
+    operation: string;
+    /**
+     * The permission `operation` checks, which the connection must hold on `scopeId`.
+     *
+     * Recorded so the sweep can re-verify cheaply and so an operator can read the whole
+     * authority of this binding without opening the vertical's source.
+     */
+    permission: string;
+    /**
+     * WHICH Planima organization this scope syncs, or `null` for every one the token can
+     * see.
+     *
+     * A token belongs to a Planima customer account, and an account may hold several
+     * organizations — a municipality with one per administration, say. `null` is the
+     * right default for the common case of one organization per account, and naming an id
+     * is what keeps two scopes on one token from each landing the other's buildings.
+     */
+    organizationId: number | null;
+    /** The currency the plan's prices are read as — see {@link PLANIMA_DEFAULT_CURRENCY}. */
+    currency: string;
+    /**
+     * A FIXED year window, or `null` to read a rolling one from `horizonYears`.
+     *
+     * Fixed is for a back-fill or a frozen budget year; rolling is what a standing sync
+     * wants, because "the next ten years" should still mean that in January.
+     */
+    window: {
+        fromYear: number;
+        toYear: number;
+    } | null;
+    /** Years past the current one, when `window` is `null`. */
+    horizonYears: number;
+    boundAt: string;
+    /** Set after the first successful sync — the cursor that makes a re-sync cheap. */
+    lastSync?: {
+        syncedAt: string;
+        /**
+         * SHA-256 of the assembled plan AND the window it was read through. Unchanged ⇒
+         * the sync is skipped without landing.
+         *
+         * The window is in here for the reason Fortnox's is: what lands is the plan
+         * *filtered to* the window, so the same rows read through a different window are a
+         * different result, and hashing the rows alone would make an explicit back-fill
+         * over an already-synced organization a silent no-op. It matters more here than
+         * there, because this window MOVES on its own — a rolling horizon crosses a new
+         * year every January, and without the window in the hash that year's actions would
+         * not land until something else about the plan happened to change.
+         */
+        contentHash: string;
+        facilities: number;
+        actions: number;
+    };
+}
+/**
+ * One page of a maintenance plan, as it crosses into a scope.
+ *
+ * Parsed with this schema on the way OUT, before every `invoke`. The engine-seam rule
+ * (`returns()`) exists because a value crossing a version boundary must be pinned to a
+ * published shape rather than to whatever the code currently produces, and a connector
+ * seam is the same boundary with a network in the middle: a vertical compiled against
+ * one version of this package and running against another must get a throw, never a
+ * silently-reshaped plan on a screen.
+ *
+ * ## The paging shape, and how a consumer reads it
+ *
+ * Pages are global across one sync and each page names exactly one facility. A
+ * facility's buildings and components ride its **first** page only (`facilityHead`) —
+ * they are the same on every page of that facility, and repeating a component list
+ * across ten pages of actions is bytes through a clone pipe for nothing. So a consumer
+ * upserts on `facilityHead`, appends actions on every page, and commits or swaps when
+ * `final` arrives.
+ */
+export declare const planimaPlanPage: z.ZodObject<{
+    syncId: z.ZodString;
+    connectionId: z.ZodString;
+    organization: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    facility: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        address: z.ZodNullable<z.ZodString>;
+        zipCode: z.ZodNullable<z.ZodString>;
+        region: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        residentialArea: z.ZodNullable<z.ZodString>;
+        nonResidentialArea: z.ZodNullable<z.ZodString>;
+        yearOfConstruction: z.ZodNullable<z.ZodNumber>;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    window: z.ZodObject<{
+        fromYear: z.ZodNumber;
+        toYear: z.ZodNumber;
+    }, z.core.$strip>;
+    currency: z.ZodString;
+    page: z.ZodNumber;
+    pageCount: z.ZodNumber;
+    final: z.ZodBoolean;
+    facilityHead: z.ZodBoolean;
+    buildings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        facilityId: z.ZodNumber;
+        name: z.ZodString;
+        address: z.ZodNullable<z.ZodString>;
+        zipCode: z.ZodNullable<z.ZodString>;
+        region: z.ZodNullable<z.ZodString>;
+        yearOfConstruction: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        facilityId: z.ZodNumber;
+        buildingId: z.ZodNullable<z.ZodNumber>;
+        name: z.ZodString;
+        component: z.ZodNullable<z.ZodString>;
+        category: z.ZodNullable<z.ZodString>;
+        type: z.ZodNullable<z.ZodString>;
+        amount: z.ZodNullable<z.ZodString>;
+        unit: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    actions: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        facilityId: z.ZodNumber;
+        buildingId: z.ZodNullable<z.ZodNumber>;
+        componentId: z.ZodNullable<z.ZodNumber>;
+        projectId: z.ZodNullable<z.ZodNumber>;
+        name: z.ZodString;
+        year: z.ZodNumber;
+        status: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        amount: z.ZodNullable<z.ZodString>;
+        unit: z.ZodNullable<z.ZodString>;
+        unitPrice: z.ZodNullable<z.ZodObject<{
+            amount: z.core.$ZodBranded<z.ZodString, "MoneyAmount", "out">;
+            currency: z.core.$ZodBranded<z.ZodString, "CurrencyCode", "out">;
+        }, z.core.$strip>>;
+        totalPrice: z.ZodNullable<z.ZodObject<{
+            amount: z.core.$ZodBranded<z.ZodString, "MoneyAmount", "out">;
+            currency: z.core.$ZodBranded<z.ZodString, "CurrencyCode", "out">;
+        }, z.core.$strip>>;
+        totalPriceInclVat: z.ZodNullable<z.ZodObject<{
+            amount: z.core.$ZodBranded<z.ZodString, "MoneyAmount", "out">;
+            currency: z.core.$ZodBranded<z.ZodString, "CurrencyCode", "out">;
+        }, z.core.$strip>>;
+        finalCost: z.ZodNullable<z.ZodObject<{
+            amount: z.core.$ZodBranded<z.ZodString, "MoneyAmount", "out">;
+            currency: z.core.$ZodBranded<z.ZodString, "CurrencyCode", "out">;
+        }, z.core.$strip>>;
+        vatRate: z.ZodNullable<z.ZodString>;
+        investmentRate: z.ZodNullable<z.ZodString>;
+        isEnergySaving: z.ZodBoolean;
+        co2EquivalentKg: z.ZodNullable<z.ZodString>;
+        category: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodString>;
+        building: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        updatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlanimaPlanPage = z.infer<typeof planimaPlanPage>;
+export interface PlanimaConnectorOptions {
+    fetch: FetchLike;
+    apiBase?: string;
+    timeoutMs?: number;
+    /** Injected so a test can assert elapsed time without sleeping. */
+    now?: () => number;
+    /** Injected for the same reason — the rate-limit throttle waits through this. */
+    sleep?: (ms: number) => Promise<void>;
+    /**
+     * A sliding rate-limit window shared by every client built during one sweep.
+     *
+     * `sweepPlanimaPlan` creates one and threads it through, because Planima meters per
+     * TOKEN: without it, each bound scope's client starts with an empty window and the
+     * second scope's requests pile on top of the first's.
+     */
+    rateWindow?: number[];
+}
+/**
+ * Declare that a connection should sync one scope — the one-time setup a poll-only
+ * connector needs in place of a dispatch.
+ *
+ * **Refuses a binding whose grant is missing**, which is the whole reason this is a
+ * function rather than a config object. The alternative — write the binding, discover
+ * at sweep time that the connection cannot invoke the operation — fails in the worst
+ * possible place: after a whole maintenance plan has been fetched against a
+ * 10-request-per-10-seconds budget, in a background timer nobody is watching. Here it
+ * fails in the operator's hands, naming the permission to grant.
+ */
+export declare function bindPlanimaScope(host: ScopeHost, input: {
+    connectionId: ConnectionId;
+    tenantId: string;
+    scopeId: string;
+    vertical: string;
+    operation: string;
+    permission: string;
+    organizationId?: number | null;
+    currency?: string;
+    window?: {
+        fromYear: number;
+        toYear: number;
+    } | null;
+    horizonYears?: number;
+    now?: () => number;
+}): Promise<PlanimaBinding>;
+/** Every scope this connection syncs into. */
+export declare function listPlanimaBindings(host: ScopeHost, connectionId: ConnectionId): Promise<PlanimaBinding[]>;
+/**
+ * Stop syncing one scope. The binding row is replaced with a tombstone rather than
+ * removed, because `putConnectorState` is the only verb this surface has — and an
+ * unbound scope that a later sweep silently re-adopts would be worse than a visible
+ * dead row.
+ */
+export declare function unbindPlanimaScope(host: ScopeHost, connectionId: ConnectionId, scopeId: string): Promise<void>;
+/** What one scope's sync did. */
+export interface PlanimaSyncResult {
+    scopeId: string;
+    /** False when the plan was identical to the last sync — nothing was landed. */
+    changed: boolean;
+    syncId: string;
+    window: {
+        fromYear: number;
+        toYear: number;
+    };
+    facilities: number;
+    actions: number;
+    pages: number;
+}
+/** The window a binding reads through, resolved against the clock for a rolling one. */
+export declare function windowFor(binding: PlanimaBinding, nowMs: number): {
+    fromYear: number;
+    toYear: number;
+};
+/**
+ * Sync ONE bound scope: read the plan, hash it, and land it through the binding's
+ * operation as the connection itself (#97).
+ *
+ * Idempotent and cheap to re-land on a no-op. The assembled plan is hashed before
+ * anything is landed, and an unchanged hash returns `changed: false` without a single
+ * `invoke` — which matters because a sweep runs on a timer and most passes find a plan
+ * nobody has touched.
+ *
+ * Note what that does NOT save: the provider reads still happen, because Planima offers
+ * no collection-level `updated_at` or ETag to ask "has anything changed" cheaply. The
+ * skip saves the writes and the events, not the round trips. Being straight about that
+ * is what makes the sweep interval a real decision — every pass costs
+ * `1 + 3 × facilities` requests against a 10-per-10-second budget.
+ */
+export declare function syncPlanimaScope(host: ScopeHost, connectionId: ConnectionId, binding: PlanimaBinding, options: PlanimaConnectorOptions & {
+    window?: {
+        fromYear: number;
+        toYear: number;
+    };
+}): Promise<PlanimaSyncResult>;
+/** What one sweep pass over a connection did. */
+export interface PlanimaSweepResult {
+    found: number;
+    synced: PlanimaSyncResult[];
+    unchanged: number;
+    failed: {
+        scopeId: string;
+        error: string;
+    }[];
+}
+/**
+ * Poll Planima for every scope this connection is bound to — the sweeper a deployment
+ * schedules.
+ *
+ * A timer calls this; it holds no timer itself. That keeps the trigger a deployment
+ * concern (`startPlatformSweeper` on node, `definePlatformSweeperDO`'s alarm on
+ * Cloudflare) and this a plain, testable function.
+ *
+ * Robust the way a poller must be: an unchanged plan is skipped without landing
+ * anything, and a failure on one scope is recorded and stepped over rather than sinking
+ * the pass — one vertical's missing grant must not stop another tenant's plan syncing.
+ */
+export declare function sweepPlanimaPlan(host: ScopeHost, connectionId: ConnectionId, options: PlanimaConnectorOptions & {
+    window?: {
+        fromYear: number;
+        toYear: number;
+    };
+}): Promise<PlanimaSweepResult>;
+/**
+ * Probe a credential that is not stored yet — the connect-time check (#605).
+ *
+ * Takes the candidate secret directly, touches no connection and no store, and records
+ * no health: there may be no connection to record against, and a candidate's failure is
+ * not a fact about a live one.
+ *
+ * The probe reads `/organizations`, which is both the cheapest authenticated read
+ * Planima offers and the one that answers the question an operator actually has: not
+ * "is this token valid" but "does this token see the customer account I meant". A token
+ * from the wrong Planima login is perfectly valid and syncs somebody else's buildings.
+ */
+export declare function probePlanimaSecret(secret: Record<string, string>, options: PlanimaConnectorOptions): Promise<ConnectionProbe>;
+/** Probe the credential a live connection already holds. Verifying is itself a use. */
+export declare function probePlanimaConnection(host: ScopeHost, connection: {
+    tenantId: string;
+    vertical: string;
+}, options: PlanimaConnectorOptions): Promise<ConnectionProbe>;
+/**
+ * What this connection has been doing, for a console — one entry per bound scope.
+ *
+ * Reads the binding ledger rather than the provider: this answers "what has the platform
+ * synced", which is the question an operator asks when a plan looks stale, and it
+ * answers it without spending a provider round trip against a 10-per-10-second budget.
+ */
+export declare function planimaConnectionActivity(host: ScopeHost, connectionId: ConnectionId): Promise<ConnectionActivity>;
+/**
+ * The stored credential, REDUCED (#605) — and for this provider that is one masked
+ * field and nothing else.
+ *
+ * There is no identifier half to show. Fortnox can display its client id and
+ * DatabaseNumber unmasked because they name the integration and the company; a Planima
+ * credential is a single opaque token and every character of it is secret. So this
+ * surface is honest rather than useful, and the useful answer — *which* Planima account
+ * this is — comes from {@link probePlanimaConnection}, which reads the organization
+ * names back from the provider.
+ */
+export declare function planimaCredentialSummary(host: ScopeHost, connection: {
+    tenantId: string;
+    vertical: string;
+}): Promise<ConnectionCredential>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAML,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAuB,SAAS,EAAa,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAmBjG,OAAO,EACL,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,aAAc,CAAC;AAMrD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAKhD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,yFAAyF;IACzF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACpD,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,QAAQ,CAAC,EAAE;QACT,QAAQ,EAAE,MAAM,CAAC;QACjB;;;;;;;;;;;WAWG;QACH,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,iFAAiF;IACjF,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE;IACL,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,GACA,OAAO,CAAC,cAAc,CAAC,CA6CzB;AAED,8CAA8C;AAC9C,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,cAAc,EAAE,CAAC,CAS3B;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAgBD,wFAAwF;AACxF,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAItG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,uBAAuB,GAAG;IAAE,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACnF,OAAO,CAAC,iBAAiB,CAAC,CAoK5B;AAED,iDAAiD;AACjD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,uBAAuB,GAAG;IAAE,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACnF,OAAO,CAAC,kBAAkB,CAAC,CA2B7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,uFAAuF;AACvF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,SAAS,EACf,UAAU,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAClD,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC,CAS1B;AA8DD;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,kBAAkB,CAAC,CA6C7B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,SAAS,EACf,UAAU,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjD,OAAO,CAAC,oBAAoB,CAAC,CAe/B"}