@orthacms/webhooks-server 0.5.0

package/dist/lib/infrastructure/schema/webhook-endpoints.d.ts

@@ -0,0 +1,330 @@
+/**
+ * One configured destination for outgoing webhooks.
+ *
+ * Global rather than workspace-scoped: an endpoint spans whichever workspaces
+ * it was pointed at, holds a signing secret, and is deployment configuration
+ * rather than editorial content — the same reasoning that puts API tokens in
+ * the directory section instead of inside a workspace.
+ *
+ * **The secret is stored in the clear.** That is a decision, not an oversight:
+ * an API token is only ever *verified*, so a hash is enough, but a webhook
+ * secret is used to *sign*, and a signing key that cannot be read back cannot
+ * sign anything. What is done instead is to show it exactly once on mint, never
+ * return it from the API again (`secretHint` is what the UI shows), and let a
+ * deployment encrypt the column at rest.
+ *
+ * `createdBy` is a plain uuid with no FK, like `alarm_rules.createdBy`: the
+ * person who added the endpoint may be deleted and the endpoint must outlive
+ * them.
+ */
+export declare const webhookEndpoints: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_endpoints";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        url: import("drizzle-orm/pg-core").PgColumn<{
+            name: "url";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secretHint: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret_hint";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "webhook_endpoints";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventKinds: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_kinds";
+            tableName: "webhook_endpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentTypes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_types";
+            tableName: "webhook_endpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        allWorkspaces: import("drizzle-orm/pg-core").PgColumn<{
+            name: "all_workspaces";
+            tableName: "webhook_endpoints";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        headers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "headers";
+            tableName: "webhook_endpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        disabledReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "disabled_reason";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consecutiveFailures: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consecutive_failures";
+            tableName: "webhook_endpoints";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "webhook_endpoints";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "webhook_endpoints";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * The workspaces an endpoint subscribes to, when it does not take them all.
+ *
+ * No FK on `workspaceId`: the `workspaces` table belongs to another plugin, and
+ * cross-plugin foreign keys are not how this codebase scopes rows — the same
+ * convention as `api_token_workspaces` and the generated content tables.
+ */
+export declare const webhookEndpointWorkspaces: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_endpoint_workspaces";
+    schema: undefined;
+    columns: {
+        endpointId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endpoint_id";
+            tableName: "webhook_endpoint_workspaces";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "webhook_endpoint_workspaces";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=webhook-endpoints.d.ts.map

package/dist/lib/infrastructure/schema/webhook-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-endpoints.d.ts","sourceRoot":"","sources":["../../../../src/lib/infrastructure/schema/webhook-endpoints.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyD5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAarC,CAAC"}

package/dist/lib/infrastructure/schema/webhook-endpoints.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookEndpointWorkspaces = exports.webhookEndpoints = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+/**
+ * One configured destination for outgoing webhooks.
+ *
+ * Global rather than workspace-scoped: an endpoint spans whichever workspaces
+ * it was pointed at, holds a signing secret, and is deployment configuration
+ * rather than editorial content — the same reasoning that puts API tokens in
+ * the directory section instead of inside a workspace.
+ *
+ * **The secret is stored in the clear.** That is a decision, not an oversight:
+ * an API token is only ever *verified*, so a hash is enough, but a webhook
+ * secret is used to *sign*, and a signing key that cannot be read back cannot
+ * sign anything. What is done instead is to show it exactly once on mint, never
+ * return it from the API again (`secretHint` is what the UI shows), and let a
+ * deployment encrypt the column at rest.
+ *
+ * `createdBy` is a plain uuid with no FK, like `alarm_rules.createdBy`: the
+ * person who added the endpoint may be deleted and the endpoint must outlive
+ * them.
+ */
+exports.webhookEndpoints = (0, pg_core_1.pgTable)('webhook_endpoints', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    /** Human label shown in the list, e.g. "Rebuild the storefront". */
+    name: (0, pg_core_1.text)('name').notNull(),
+    /** Where deliveries are POSTed. Re-checked against the URL policy on
+     * every send, not only when it was saved. */
+    url: (0, pg_core_1.text)('url').notNull(),
+    /** The HMAC signing key. See the note above on why it is not hashed. */
+    secret: (0, pg_core_1.text)('secret').notNull(),
+    /** The last few characters, so the UI can tell two secrets apart after
+     * a rotation without ever showing one again. */
+    secretHint: (0, pg_core_1.text)('secret_hint').notNull(),
+    /** The manual switch. Auto-disabling clears this too. */
+    enabled: (0, pg_core_1.boolean)('enabled').notNull().default(true),
+    /**
+     * Subscribed event kinds. **Empty means every kind**, including ones
+     * added to the catalogue later — an endpoint that asked for everything
+     * should not silently stop covering a new event.
+     */
+    eventKinds: (0, pg_core_1.jsonb)('event_kinds').notNull().default([]),
+    /** Subscribed content types. **Empty means every type.** */
+    contentTypes: (0, pg_core_1.jsonb)('content_types').notNull().default([]),
+    /**
+     * Whether the endpoint takes every workspace.
+     *
+     * Stored explicitly rather than inferred from an empty
+     * {@link webhookEndpointWorkspaces} set: fan-out runs on every event
+     * and must never have to disambiguate "no rows" between "all" and
+     * "none".
+     */
+    allWorkspaces: (0, pg_core_1.boolean)('all_workspaces').notNull().default(false),
+    /** Extra static headers, filtered through the reserved-name allow-list. */
+    headers: (0, pg_core_1.jsonb)('headers').notNull().default({}),
+    /** Why the endpoint was switched off automatically; null otherwise. */
+    disabledReason: (0, pg_core_1.text)('disabled_reason'),
+    /** Consecutive dead deliveries; any success resets it to zero. */
+    consecutiveFailures: (0, pg_core_1.integer)('consecutive_failures')
+        .notNull()
+        .default(0),
+    /** Who created it. No FK — the endpoint outlives its author. */
+    createdBy: (0, pg_core_1.uuid)('created_by'),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+}, (table) => [
+    // Fan-out's only query is "every enabled endpoint", run once per
+    // content write. The table is small enough that this index mostly
+    // documents the access path — it earns its keep on an install with
+    // many endpoints, most of them switched off.
+    (0, pg_core_1.index)('webhook_endpoints_enabled_idx').on(table.enabled)
+]);
+/**
+ * The workspaces an endpoint subscribes to, when it does not take them all.
+ *
+ * No FK on `workspaceId`: the `workspaces` table belongs to another plugin, and
+ * cross-plugin foreign keys are not how this codebase scopes rows — the same
+ * convention as `api_token_workspaces` and the generated content tables.
+ */
+exports.webhookEndpointWorkspaces = (0, pg_core_1.pgTable)('webhook_endpoint_workspaces', {
+    endpointId: (0, pg_core_1.uuid)('endpoint_id')
+        .notNull()
+        .references(() => exports.webhookEndpoints.id, { onDelete: 'cascade' }),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull()
+}, (table) => [
+    (0, pg_core_1.primaryKey)({ columns: [table.endpointId, table.workspaceId] }),
+    // "Which endpoints take this workspace" — the fan-out lookup.
+    (0, pg_core_1.index)('webhook_endpoint_workspaces_workspace_idx').on(table.workspaceId)
+]);

package/dist/lib/infrastructure/webhook-delivery.repository.d.ts

@@ -0,0 +1,99 @@
+import { type Database } from '@orthacms/database';
+import type { DeliveryStatus } from '@orthacms/webhooks-domain';
+import type { WebhookDeliveryDetailView, WebhookDeliveryPage } from '../domain/webhook-views';
+/** A row to queue. */
+export interface DeliveryToQueue {
+    /**
+     * Generated by the caller, not by the database.
+     *
+     * The envelope frozen in `payload` carries this id and so does the
+     * `X-Ortha-Delivery` header, so it has to exist before the row is written
+     * or the body and the header would name different deliveries.
+     */
+    id: string;
+    endpointId: string;
+    eventId: string;
+    eventKind: string;
+    workspaceId: string | null;
+    contentType: string | null;
+    payload: unknown;
+    /** The delivery this one repeats, for a redelivery; null otherwise. */
+    redeliveryOf?: string | null;
+}
+/** A claimed row, as the worker needs it. */
+export interface ClaimedDelivery {
+    id: string;
+    endpointId: string;
+    eventId: string;
+    eventKind: string;
+    workspaceId: string | null;
+    payload: unknown;
+    attempts: number;
+}
+/** What one attempt produced. */
+export interface AttemptOutcome {
+    statusCode: number | null;
+    error: string | null;
+    responseSnippet: string | null;
+    durationMs: number;
+}
+/** Filters the delivery log accepts. */
+export interface DeliveryListQuery {
+    status?: DeliveryStatus;
+    eventKind?: string;
+    page: number;
+    pageSize: number;
+}
+/** The queue and the log, over one table. */
+export declare class WebhookDeliveryRepository {
+    private readonly db;
+    constructor(db: Database);
+    /**
+     * Queues one delivery per endpoint, ignoring rows that already exist.
+     *
+     * `ON CONFLICT DO NOTHING` against `unique(endpoint_id, event_id)` is the
+     * whole idempotency story for fan-out: outbox delivery is at-least-once, so
+     * this subscriber may be handed the same event twice, and the second pass
+     * must be a no-op rather than a duplicate POST.
+     */
+    enqueue(deliveries: DeliveryToQueue[]): Promise<number>;
+    /** Queues a single delivery and returns its id (used by redelivery). */
+    enqueueOne(delivery: DeliveryToQueue): Promise<string>;
+    /**
+     * Claims up to `limit` deliveries and marks them `delivering`.
+     *
+     * The transaction covers **only the claim**. That is the point of the whole
+     * design: the HTTP request happens after this returns, with nothing open,
+     * so a slow receiver cannot hold a database transaction or a pool client.
+     *
+     * `FOR UPDATE SKIP LOCKED` lets several API processes claim disjoint rows
+     * without blocking each other, exactly as the outbox drain does.
+     *
+     * Rows stuck in `delivering` past `claimTimeoutMs` are reclaimed here
+     * rather than by a separate reaper: a worker that died mid-request left the
+     * row with no error, no retry and no way out, and folding the recovery into
+     * the claim means there is one query to get right instead of two.
+     */
+    claim(limit: number, claimTimeoutMs: number): Promise<ClaimedDelivery[]>;
+    /** Records a successful attempt. */
+    markSucceeded(id: string, outcome: AttemptOutcome): Promise<void>;
+    /** Records a failed attempt that will be tried again at `nextAttemptAt`. */
+    markRetrying(id: string, outcome: AttemptOutcome, nextAttemptAt: Date): Promise<void>;
+    /** Records a final failure — no further attempt will be made. */
+    markDead(id: string, outcome: AttemptOutcome): Promise<void>;
+    /** One page of an endpoint's delivery log, newest first. */
+    list(endpointId: string, query: DeliveryListQuery): Promise<WebhookDeliveryPage>;
+    /**
+     * One delivery with its bodies — scoped to its endpoint so an id from
+     * another endpoint reads as "not found" rather than leaking across.
+     */
+    findDetail(endpointId: string, deliveryId: string): Promise<WebhookDeliveryDetailView | null>;
+    /**
+     * Deletes completed rows older than `before`.
+     *
+     * Only `succeeded` and `dead` are eligible: a `failed` row is still
+     * scheduled, and a `delivering` row may be in flight.
+     */
+    pruneCompletedBefore(before: Date): Promise<number>;
+}
+//# sourceMappingURL=webhook-delivery.repository.d.ts.map

package/dist/lib/infrastructure/webhook-delivery.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery.repository.d.ts","sourceRoot":"","sources":["../../../src/lib/infrastructure/webhook-delivery.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAahE,OAAO,KAAK,EACR,yBAAyB,EACzB,mBAAmB,EAEtB,MAAM,yBAAyB,CAAC;AAGjC,sBAAsB;AACtB,MAAM,WAAW,eAAe;IAC5B;;;;;;OAMG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,iCAAiC;AACjC,MAAM,WAAW,cAAc;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAC9B,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,6CAA6C;AAC7C,qBACa,yBAAyB;IACJ,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ;IAE3D;;;;;;;OAOG;IACG,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAgC7D,wEAAwE;IAClE,UAAU,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAkB5D;;;;;;;;;;;;;;OAcG;IACG,KAAK,CACP,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC;IAsD7B,oCAAoC;IAC9B,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBvE,4EAA4E;IACtE,YAAY,CACd,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,cAAc,EACvB,aAAa,EAAE,IAAI,GACpB,OAAO,CAAC,IAAI,CAAC;IAgBhB,iEAAiE;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlE,4DAA4D;IACtD,IAAI,CACN,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,iBAAiB,GACzB,OAAO,CAAC,mBAAmB,CAAC;IAsC/B;;;OAGG;IACG,UAAU,CACZ,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAoB5C;;;;;OAKG;IACG,oBAAoB,CAAC,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;CAa5D"}