@voyant-travel/inventory 0.1.0

package/dist/action-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-ledger.d.ts","sourceRoot":"","sources":["../src/action-ledger.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gCAAgC,EAEtC,MAAM,8CAA8C,CAAA;AAErD,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,uCAAuC,CAAA;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAG1C,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;GAAwC,CAAA;AAEnF,MAAM,MAAM,+BAA+B,GAAG,8BAA8B,CAAA;AAC5E,MAAM,MAAM,2BAA2B,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEtF,wBAAgB,oCAAoC,CAClD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GACd,gCAAgC,CAgBlC;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,EACvB,MAAM,EAAE,OAAO,GAAG,IAAI,EACtB,KAAK,EAAE,OAAO,GAAG,IAAI,GACpB,MAAM,EAAE,CAEV;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACpC,MAAM,EAAE,CAKV;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,2BAA2B,EACnC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,SAAY,UASpB;AAED,wBAAsB,gCAAgC,CACpD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EACf,KAAK,EAAE;IACL,MAAM,EAAE,2BAA2B,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,yFAgBF;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAmC5D;AAcD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;CAKpB,CAAA"}

package/dist/action-ledger.js

@@ -0,0 +1,100 @@
+import { appendActionLedgerMutation, } from "@voyant-travel/action-ledger/request-context";
+import { actionLedgerService } from "@voyant-travel/action-ledger/service";
+import { actionLedgerTargetTimelineQuerySchema, buildActionLedgerTargetTimelinePage, } from "@voyant-travel/action-ledger/timeline";
+import { parseQuery } from "@voyant-travel/hono";
+import { productsService } from "./service.js";
+export const productActionLedgerQuerySchema = actionLedgerTargetTimelineQuerySchema;
+export function getProductActionLedgerRequestContext(c) {
+    return {
+        userId: c.get("userId") ?? null,
+        agentId: c.get("agentId") ?? null,
+        workflowPrincipalId: c.get("workflowPrincipalId") ?? null,
+        principalSubtype: c.get("principalSubtype") ?? null,
+        sessionId: c.get("sessionId") ?? null,
+        apiTokenId: c.get("apiTokenId") ?? c.get("apiKeyId") ?? null,
+        callerType: c.get("callerType") ?? null,
+        actor: c.get("actor") ?? null,
+        isInternalRequest: c.get("isInternalRequest") ?? false,
+        organizationId: c.get("organizationId") ?? null,
+        workflowRunId: c.get("workflowRunId") ?? null,
+        workflowStepId: c.get("workflowStepId") ?? null,
+        correlationId: c.req.header("x-correlation-id") ?? c.req.header("x-request-id") ?? null,
+    };
+}
+export function changedProductFields(input, before, after) {
+    return changedMutationFields(input, before, after);
+}
+export function changedMutationFields(input, before, after) {
+    const fields = Object.keys(input).filter((field) => !ignoredMutationFields.has(field));
+    if (!before || !after)
+        return fields.sort();
+    return fields.filter((field) => !productValuesEqual(before[field], after[field])).sort();
+}
+export function productMutationSummary(action, fields, subject = "product") {
+    const formattedSubject = subject.trim() || "product";
+    if (action === "delete")
+        return `Deleted ${formattedSubject}`;
+    if (action === "duplicate")
+        return `Duplicated ${formattedSubject}`;
+    if (fields.length === 0)
+        return action === "create" ? `Created ${formattedSubject}` : `Updated ${formattedSubject}`;
+    const verb = action === "create" ? "Created" : "Updated";
+    return `${verb} ${formattedSubject} fields: ${fields.join(", ")}`;
+}
+export async function appendProductMutationLedgerEntry(c, input) {
+    return appendActionLedgerMutation(c.get("db"), {
+        context: getProductActionLedgerRequestContext(c),
+        actionName: input.actionName ?? `product.${input.action}`,
+        actionKind: input.action === "duplicate" ? "create" : input.action,
+        evaluatedRisk: "medium",
+        targetType: "product",
+        targetId: input.productId,
+        routeOrToolName: input.routeOrToolName ?? `products.${input.action}`,
+        mutationDetail: {
+            summary: input.summary ?? productMutationSummary(input.action, input.changedFields, input.subject),
+            reversalKind: "none",
+        },
+    });
+}
+export async function listProductActionLedger(c) {
+    const productId = c.req.param("id");
+    if (!productId)
+        return c.json({ error: "Product not found" }, 404);
+    const product = await productsService.getProductById(c.get("db"), productId);
+    if (!product)
+        return c.json({ error: "Product not found" }, 404);
+    const query = parseQuery(c, productActionLedgerQuerySchema);
+    const limit = query.limit ?? 50;
+    const result = await actionLedgerService.listEntries(c.get("db"), {
+        targetType: "product",
+        targetId: product.id,
+        cursor: query.cursor,
+        limit: limit + 1,
+    });
+    const page = buildActionLedgerTargetTimelinePage({
+        entries: result.entries,
+        limit,
+    });
+    const details = await Promise.all(page.data.map((entry) => actionLedgerService.getEntry(c.get("db"), entry.id)));
+    const summariesByActionId = new Map(details.flatMap((detail) => detail ? [[detail.entry.id, detail.mutationDetail?.summary ?? null]] : []));
+    return c.json(buildActionLedgerTargetTimelinePage({
+        entries: result.entries,
+        limit,
+        mutationSummariesByActionId: summariesByActionId,
+    }));
+}
+function productValuesEqual(left, right) {
+    if (left instanceof Date || right instanceof Date) {
+        const leftTime = left instanceof Date ? left.getTime() : new Date(String(left)).getTime();
+        const rightTime = right instanceof Date ? right.getTime() : new Date(String(right)).getTime();
+        return leftTime === rightTime;
+    }
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+const ignoredMutationFields = new Set(["updatedAt", "createdAt"]);
+export const __test__ = {
+    changedMutationFields,
+    changedProductFields,
+    productMutationSummary,
+    productActionLedgerQuerySchema,
+};

package/dist/authoring/builder.d.ts

@@ -0,0 +1,37 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ProductGraphSpec } from "./spec.js";
+export interface BuildProductGraphOptions {
+    /** Author of the initial `product_versions` snapshot. When omitted, no snapshot is taken. */
+    userId?: string;
+    /**
+     * Catalog every option price rule resolves to when the spec rule omits its own
+     * `priceCatalogId`. Clone leaves rule catalogs populated (so this is unused);
+     * compose passes the operator's default. A rule with neither errors.
+     */
+    defaultCatalogId?: string;
+}
+export interface BuiltOptionUnit {
+    ref: string;
+    id: string;
+}
+export interface BuiltOption {
+    ref: string;
+    id: string;
+    units: BuiltOptionUnit[];
+}
+export interface BuildProductGraphResult {
+    productId: string;
+    options: BuiltOption[];
+}
+/**
+ * Writes a {@link ProductGraphSpec} as a fresh product graph. MUST run inside a
+ * transaction (`db.transaction(async (tx) => buildProductGraph(tx, …))`) so a
+ * mid-build failure leaves nothing behind — the half-built-product problem this
+ * whole effort exists to kill.
+ *
+ * Never writes `availability_slots`: departures are date-specific and added
+ * separately. Local `ref`/`unitRef` keys in the spec are resolved to the
+ * freshly-minted ids here and never touch the database.
+ */
+export declare function buildProductGraph(tx: PostgresJsDatabase, spec: ProductGraphSpec, options?: BuildProductGraphOptions): Promise<BuildProductGraphResult>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/authoring/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/authoring/builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAYjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAEjD,MAAM,WAAW,wBAAwB;IACvC,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,EAAE,EAAE,MAAM,CAAA;CACX;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,eAAe,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,WAAW,EAAE,CAAA;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA+PlC"}

package/dist/authoring/builder.js

@@ -0,0 +1,248 @@
+import { optionPriceRules, optionUnitPriceRules, optionUnitTiers } from "@voyant-travel/commerce";
+import { optionUnits, productDayServices, productDays, productItineraries, productOptions, productPaxPricingTiers, products, } from "../schema.js";
+import { productsService } from "../service.js";
+import { AuthoringValidationError } from "./errors.js";
+/**
+ * Writes a {@link ProductGraphSpec} as a fresh product graph. MUST run inside a
+ * transaction (`db.transaction(async (tx) => buildProductGraph(tx, …))`) so a
+ * mid-build failure leaves nothing behind — the half-built-product problem this
+ * whole effort exists to kill.
+ *
+ * Never writes `availability_slots`: departures are date-specific and added
+ * separately. Local `ref`/`unitRef` keys in the spec are resolved to the
+ * freshly-minted ids here and never touch the database.
+ */
+export async function buildProductGraph(tx, spec, options = {}) {
+    const { userId, defaultCatalogId } = options;
+    // --- product row -----------------------------------------------------------
+    const [productRow] = await tx
+        .insert(products)
+        .values({
+        name: spec.product.name,
+        status: spec.product.status,
+        description: spec.product.description,
+        inclusionsHtml: spec.product.inclusionsHtml,
+        exclusionsHtml: spec.product.exclusionsHtml,
+        termsHtml: spec.product.termsHtml,
+        termsShowOnContract: spec.product.termsShowOnContract,
+        bookingMode: spec.product.bookingMode,
+        capacityMode: spec.product.capacityMode,
+        timezone: spec.product.timezone,
+        defaultLanguageTag: spec.product.defaultLanguageTag,
+        visibility: spec.product.visibility,
+        sellCurrency: spec.product.sellCurrency,
+        sellAmountCents: spec.product.sellAmountCents,
+        costAmountCents: spec.product.costAmountCents,
+        marginPercent: spec.product.marginPercent,
+        reservationTimeoutMinutes: spec.product.reservationTimeoutMinutes,
+        facilityId: spec.product.facilityId,
+        supplierId: spec.product.supplierId,
+        startDate: spec.product.startDate,
+        endDate: spec.product.endDate,
+        pax: spec.product.pax,
+        productTypeId: spec.product.productTypeId,
+        contractTemplateId: spec.product.contractTemplateId,
+        taxClassId: spec.product.taxClassId,
+        customerPaymentPolicy: spec.product.customerPaymentPolicy,
+        tags: spec.product.tags,
+    })
+        .returning({ id: products.id });
+    if (!productRow)
+        throw new Error("Failed to insert product");
+    const productId = productRow.id;
+    // Global ref → new-id maps. Refs are unique across the whole spec (clone uses
+    // source ids; compose uses caller-chosen keys), so unit refs from any option
+    // resolve here — covering both unit-price-rule unitRef and pax-tier unitRef.
+    const unitIdByRef = new Map();
+    const builtOptions = [];
+    // --- options + units -------------------------------------------------------
+    for (const option of spec.options) {
+        const [optionRow] = await tx
+            .insert(productOptions)
+            .values({
+            productId,
+            name: option.name,
+            code: option.code,
+            description: option.description,
+            status: option.status,
+            isDefault: option.isDefault,
+            sortOrder: option.sortOrder,
+            availableFrom: option.availableFrom,
+            availableTo: option.availableTo,
+        })
+            .returning({ id: productOptions.id });
+        if (!optionRow)
+            throw new Error("Failed to insert product option");
+        const optionId = optionRow.id;
+        const builtUnits = [];
+        for (const unit of option.units) {
+            const [unitRow] = await tx
+                .insert(optionUnits)
+                .values({
+                optionId,
+                name: unit.name,
+                code: unit.code,
+                description: unit.description,
+                unitType: unit.unitType,
+                minQuantity: unit.minQuantity,
+                maxQuantity: unit.maxQuantity,
+                minAge: unit.minAge,
+                maxAge: unit.maxAge,
+                occupancyMin: unit.occupancyMin,
+                occupancyMax: unit.occupancyMax,
+                isRequired: unit.isRequired,
+                isHidden: unit.isHidden,
+                sortOrder: unit.sortOrder,
+            })
+                .returning({ id: optionUnits.id });
+            if (!unitRow)
+                throw new Error("Failed to insert option unit");
+            unitIdByRef.set(unit.ref, unitRow.id);
+            builtUnits.push({ ref: unit.ref, id: unitRow.id });
+        }
+        // --- pricing: option rules → unit rules → tiers --------------------------
+        for (const rule of option.priceRules) {
+            const priceCatalogId = rule.priceCatalogId ?? defaultCatalogId;
+            if (!priceCatalogId) {
+                throw new AuthoringValidationError([
+                    {
+                        code: "no_price_catalog",
+                        field: `options[].priceRules[].priceCatalogId`,
+                        message: `Price rule "${rule.name}" has no priceCatalogId and no default catalog was resolved.`,
+                        fix: "Supply priceCatalogId on the rule, or ensure a default price catalog exists.",
+                    },
+                ]);
+            }
+            const [ruleRow] = await tx
+                .insert(optionPriceRules)
+                .values({
+                productId,
+                optionId,
+                priceCatalogId,
+                priceScheduleId: rule.priceScheduleId,
+                cancellationPolicyId: rule.cancellationPolicyId,
+                code: rule.code,
+                name: rule.name,
+                description: rule.description,
+                pricingMode: rule.pricingMode,
+                baseSellAmountCents: rule.baseSellAmountCents,
+                baseCostAmountCents: rule.baseCostAmountCents,
+                minPerBooking: rule.minPerBooking,
+                maxPerBooking: rule.maxPerBooking,
+                allPricingCategories: rule.allPricingCategories,
+                isDefault: rule.isDefault,
+                active: rule.active,
+                notes: rule.notes,
+                metadata: rule.metadata,
+            })
+                .returning({ id: optionPriceRules.id });
+            if (!ruleRow)
+                throw new Error("Failed to insert option price rule");
+            for (const unitRule of rule.unitPriceRules) {
+                const unitId = unitIdByRef.get(unitRule.unitRef);
+                if (!unitId) {
+                    throw new AuthoringValidationError([
+                        {
+                            code: "unknown_unit_ref",
+                            field: "options[].priceRules[].unitPriceRules[].unitRef",
+                            message: `Unit price rule references unit "${unitRule.unitRef}", which is not defined in the spec.`,
+                            fix: "Point unitRef at a unit declared under one of the options.",
+                        },
+                    ]);
+                }
+                const [unitRuleRow] = await tx
+                    .insert(optionUnitPriceRules)
+                    .values({
+                    optionPriceRuleId: ruleRow.id,
+                    optionId,
+                    unitId,
+                    pricingCategoryId: unitRule.pricingCategoryId,
+                    pricingMode: unitRule.pricingMode,
+                    sellAmountCents: unitRule.sellAmountCents,
+                    costAmountCents: unitRule.costAmountCents,
+                    minQuantity: unitRule.minQuantity,
+                    maxQuantity: unitRule.maxQuantity,
+                    active: unitRule.active,
+                    sortOrder: unitRule.sortOrder,
+                    notes: unitRule.notes,
+                    metadata: unitRule.metadata,
+                })
+                    .returning({ id: optionUnitPriceRules.id });
+                if (!unitRuleRow)
+                    throw new Error("Failed to insert option unit price rule");
+                if (unitRule.tiers.length) {
+                    await tx.insert(optionUnitTiers).values(unitRule.tiers.map((tier) => ({
+                        optionUnitPriceRuleId: unitRuleRow.id,
+                        minQuantity: tier.minQuantity,
+                        maxQuantity: tier.maxQuantity,
+                        sellAmountCents: tier.sellAmountCents,
+                        costAmountCents: tier.costAmountCents,
+                        active: tier.active,
+                        sortOrder: tier.sortOrder,
+                    })));
+                }
+            }
+        }
+        builtOptions.push({ ref: option.ref, id: optionId, units: builtUnits });
+    }
+    // --- pax pricing tiers -----------------------------------------------------
+    if (spec.paxPricingTiers.length) {
+        await tx.insert(productPaxPricingTiers).values(spec.paxPricingTiers.map((tier) => ({
+            productId,
+            optionUnitId: tier.unitRef ? (unitIdByRef.get(tier.unitRef) ?? null) : null,
+            tierPax: tier.tierPax,
+            pricePerPaxCents: tier.pricePerPaxCents,
+            promoPricePerPaxCents: tier.promoPricePerPaxCents,
+            effectiveFrom: tier.effectiveFrom,
+            effectiveTo: tier.effectiveTo,
+        })));
+    }
+    // --- itineraries → days → services -----------------------------------------
+    for (const itinerary of spec.itineraries) {
+        const [itineraryRow] = await tx
+            .insert(productItineraries)
+            .values({
+            productId,
+            name: itinerary.name,
+            isDefault: itinerary.isDefault,
+            sortOrder: itinerary.sortOrder,
+        })
+            .returning({ id: productItineraries.id });
+        if (!itineraryRow)
+            throw new Error("Failed to insert product itinerary");
+        for (const day of itinerary.days) {
+            const [dayRow] = await tx
+                .insert(productDays)
+                .values({
+                itineraryId: itineraryRow.id,
+                dayNumber: day.dayNumber,
+                title: day.title,
+                description: day.description,
+                location: day.location,
+            })
+                .returning({ id: productDays.id });
+            if (!dayRow)
+                throw new Error("Failed to insert product day");
+            if (day.services.length) {
+                await tx.insert(productDayServices).values(day.services.map((service) => ({
+                    dayId: dayRow.id,
+                    supplierServiceId: service.supplierServiceId,
+                    serviceType: service.serviceType,
+                    name: service.name,
+                    description: service.description,
+                    countryCode: service.countryCode,
+                    costCurrency: service.costCurrency,
+                    costAmountCents: service.costAmountCents,
+                    quantity: service.quantity,
+                    sortOrder: service.sortOrder,
+                    notes: service.notes,
+                })));
+            }
+        }
+    }
+    // --- initial version snapshot ----------------------------------------------
+    if (userId) {
+        await productsService.createVersion(tx, productId, userId, {});
+    }
+    return { productId, options: builtOptions };
+}

package/dist/authoring/clone-content.d.ts

@@ -0,0 +1,38 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+/** Shared, mutable state threaded across the clone copy phases (id remaps). */
+export interface CloneContext {
+    tx: PostgresJsDatabase;
+    sourceId: string;
+    targetId: string;
+    copyDepartures: boolean;
+    optionIdMap: Map<string, string>;
+    unitIdMap: Map<string, string>;
+    unitsByNewOption: Map<string, {
+        id: string;
+    }[]>;
+    itineraryIdMap: Map<string, string>;
+    dayIdMap: Map<string, string>;
+    startTimeIdMap: Map<string, string>;
+    ruleIdMap: Map<string, string>;
+    slotIdMap: Map<string, string>;
+    optionPriceRuleIdMap: Map<string, string>;
+    optionUnitPriceRuleIdMap: Map<string, string>;
+    pricingCategoryIdMap: Map<string, string>;
+    productExtraIdMap: Map<string, string>;
+    optionExtraConfigIdMap: Map<string, string>;
+}
+type SystemColumns = {
+    id?: unknown;
+    createdAt?: unknown;
+    updatedAt?: unknown;
+};
+export declare function withoutSystemColumns<T extends SystemColumns>(row: T): Omit<T, "id" | "createdAt" | "updatedAt">;
+/**
+ * Copies the product's content graph: per-product settings, options + units
+ * (with translations + resource templates), pricing categories (+ dependencies,
+ * remapped), itineraries/days/services, media, and extras. Populates the id
+ * remaps in {@link CloneContext} for the pricing/operations phase.
+ */
+export declare function copyProductContent(ctx: CloneContext): Promise<void>;
+export {};
+//# sourceMappingURL=clone-content.d.ts.map

package/dist/authoring/clone-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-content.d.ts","sourceRoot":"","sources":["../../src/authoring/clone-content.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AA0BjE,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,kBAAkB,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,OAAO,CAAA;IACvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAA;IAC/C,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7C,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC5C;AAED,KAAK,aAAa,GAAG;IACnB,EAAE,CAAC,EAAE,OAAO,CAAA;IACZ,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EAAE,CAAC,6CAGnE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6HzE"}