@hartl-services/medusa-affiliate 0.3.0

package/.medusa/server/src/modules/affiliate/service.js

@@ -0,0 +1,2321 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const framework_1 = require("@medusajs/framework");
+const email_events_1 = require("../../integration/email-events");
+const affiliate_1 = __importDefault(require("./models/affiliate"));
+const affiliate_coupon_1 = __importDefault(require("./models/affiliate-coupon"));
+const affiliate_code_redemption_1 = __importDefault(require("./models/affiliate-code-redemption"));
+const affiliate_distribution_settings_1 = __importDefault(require("./models/affiliate-distribution-settings"));
+const affiliate_program_settings_1 = __importDefault(require("./models/affiliate-program-settings"));
+const affiliate_application_1 = __importDefault(require("./models/affiliate-application"));
+const affiliate_cart_referral_1 = __importDefault(require("./models/affiliate-cart-referral"));
+const affiliate_order_attribution_1 = __importDefault(require("./models/affiliate-order-attribution"));
+const affiliate_referral_session_1 = __importDefault(require("./models/affiliate-referral-session"));
+const affiliate_slug_1 = __importDefault(require("./models/affiliate-slug"));
+const commission_entry_1 = __importDefault(require("./models/commission-entry"));
+const consignment_report_1 = __importDefault(require("./models/consignment-report"));
+const consignment_report_line_1 = __importDefault(require("./models/consignment-report-line"));
+const consignment_transfer_1 = __importDefault(require("./models/consignment-transfer"));
+const consignment_transfer_line_1 = __importDefault(require("./models/consignment-transfer-line"));
+const customer_affiliate_assignment_1 = __importDefault(require("./models/customer-affiliate-assignment"));
+const affiliate_application_manager_1 = require("./services/affiliate-application-manager");
+const affiliate_discount_service_1 = require("./services/affiliate-discount.service");
+const affiliate_report_service_1 = require("./services/affiliate-report.service");
+const affiliate_partner_portal_service_1 = require("./services/affiliate-partner-portal.service");
+const affiliate_slug_manager_1 = require("./services/affiliate-slug-manager");
+const affiliate_manager_1 = require("./services/affiliate-manager");
+const affiliate_coupon_manager_1 = require("./services/affiliate-coupon-manager");
+const commission_ledger_service_1 = require("./services/commission-ledger.service");
+const customer_affiliate_assignment_manager_1 = require("./services/customer-affiliate-assignment-manager");
+const referral_lifecycle_manager_1 = require("./services/referral-lifecycle-manager");
+const order_attribution_manager_1 = require("./services/order-attribution-manager");
+const email_normalization_1 = require("./domain/email-normalization");
+const consignment_reminder_rules_1 = require("./domain/consignment-reminder-rules");
+const plugin_options_1 = require("./domain/plugin-options");
+let consignmentWorkflowContainer;
+class AffiliateModuleService extends (0, utils_1.MedusaService)({
+    Affiliate: affiliate_1.default,
+    AffiliateCoupon: affiliate_coupon_1.default,
+    AffiliateApplication: affiliate_application_1.default,
+    AffiliateSlug: affiliate_slug_1.default,
+    CustomerAffiliateAssignment: customer_affiliate_assignment_1.default,
+    CommissionEntry: commission_entry_1.default,
+    AffiliateProgramSettings: affiliate_program_settings_1.default,
+    AffiliateCodeRedemption: affiliate_code_redemption_1.default,
+    AffiliateReferralSession: affiliate_referral_session_1.default,
+    AffiliateCartReferral: affiliate_cart_referral_1.default,
+    AffiliateOrderAttribution: affiliate_order_attribution_1.default,
+    AffiliateDistributionSettings: affiliate_distribution_settings_1.default,
+    ConsignmentTransfer: consignment_transfer_1.default,
+    ConsignmentTransferLine: consignment_transfer_line_1.default,
+    ConsignmentReport: consignment_report_1.default,
+    ConsignmentReportLine: consignment_report_line_1.default,
+}) {
+    constructor(container, options) {
+        super(container);
+        this.approvalSnapshotRuns = new Map();
+        this.correctionSnapshotRuns = new Map();
+        this.pluginOptions_ = (0, plugin_options_1.resolveAffiliatePluginOptions)(options);
+        this.persistence = this;
+        this.slugManager = new affiliate_slug_manager_1.AffiliateSlugManager(this.persistence);
+        this.couponManager = new affiliate_coupon_manager_1.AffiliateCouponManager(this.persistence);
+        this.affiliateManager = new affiliate_manager_1.AffiliateManager(this.persistence, this.slugManager);
+        this.applicationManager = new affiliate_application_manager_1.AffiliateApplicationManager(this.persistence, this.affiliateManager, this.slugManager);
+        this.assignmentManager = new customer_affiliate_assignment_manager_1.CustomerAffiliateAssignmentManager(this.persistence, this.affiliateManager, this.slugManager);
+        this.referralLifecycleManager = new referral_lifecycle_manager_1.ReferralLifecycleManager(this.persistence, null, this.slugManager, this.assignmentManager);
+        this.orderAttributionManager = new order_attribution_manager_1.OrderAttributionManager(this.persistence, this.assignmentManager);
+        this.ledgerService = new commission_ledger_service_1.CommissionLedgerService(this.persistence);
+        this.reportService = new affiliate_report_service_1.AffiliateReportService(this.persistence);
+        this.discountService = new affiliate_discount_service_1.AffiliateDiscountService(this.persistence);
+        this.partnerPortalService = new affiliate_partner_portal_service_1.AffiliatePartnerPortalService(this.persistence, this.affiliateManager, this.slugManager, this.reportService);
+    }
+    async getPluginOptions() {
+        return this.pluginOptions_;
+    }
+    /**
+     * Flushes the active transaction's pending writes so a following read in the
+     * same transaction sees them (see AffiliatePersistence.flush). Outside a
+     * transaction there is no transaction manager, so this is a no-op.
+     */
+    async flush(context) {
+        const manager = context?.transactionManager;
+        if (manager?.flush) {
+            await manager.flush();
+        }
+    }
+    async retrieveProgramSettings(sharedContext = {}) {
+        const settings = await this.persistence.listAffiliateProgramSettings({ scope: "global" }, { take: 1 }, sharedContext);
+        const current = settings[0];
+        if (current) {
+            return current;
+        }
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Initialisierung der Affiliate-Programmeinstellungen fehlt die Transaktion.");
+        }
+        // The migration seeds this singleton, but module-test cleanup, an
+        // interrupted seed or an accidental soft-delete can remove it. The
+        // partial unique scope index remains authoritative: concurrent creators
+        // race on the INSERT, one wins and every loser re-reads the committed row.
+        await manager.execute(`insert into "affiliate_program_settings"
+         ("id", "scope", "commission_base", "referrer_base",
+          "promotion_stacking", "default_customer_discount_rate",
+          "referral_overwrite_policy", "referral_window_days",
+          "policy_version", "created_at", "updated_at")
+       values (
+         'affprog_' || substr(md5(random()::text || clock_timestamp()::text), 1, 26),
+         'global', 'after_discounts', 'order_base', 'allow_stacking',
+         5, 'first_touch', 30, 1, now(), now()
+       )
+       on conflict do nothing`, [], "run");
+        const restored = await this.persistence.listAffiliateProgramSettings({ scope: "global" }, { take: 1 }, sharedContext);
+        if (!restored[0]) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Die globalen Affiliate-Programmeinstellungen konnten nicht initialisiert werden.");
+        }
+        return restored[0];
+    }
+    async updateProgramSettings(input, sharedContext = {}) {
+        this.validateProgramSettingsInput(input);
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Aktualisierung der Affiliate-Programmeinstellungen fehlt die Transaktion.");
+        }
+        const rows = await manager.execute(`update "affiliate_program_settings"
+       set "commission_base" = ?,
+           "referrer_base" = ?,
+           "promotion_stacking" = ?,
+           "default_customer_discount_rate" = ?,
+           "referral_overwrite_policy" = ?,
+           "referral_window_days" = ?,
+           "policy_version" = ?,
+           "updated_at" = now()
+       where "scope" = 'global'
+         and "policy_version" = ?
+         and "deleted_at" is null
+       returning "id", "default_customer_discount_rate",
+                 "referral_overwrite_policy", "referral_window_days",
+                 "policy_version", "created_at", "updated_at"`, [
+            input.commission_base,
+            input.referrer_base,
+            input.promotion_stacking,
+            input.default_customer_discount_rate,
+            input.referral_overwrite_policy,
+            input.referral_window_days,
+            input.expected_version + 1,
+            input.expected_version,
+        ], "all");
+        const updated = rows[0];
+        if (!updated) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Affiliate-Programmeinstellungen wurden zwischenzeitlich geändert.");
+        }
+        return {
+            id: updated.id,
+            scope: "global",
+            commission_base: input.commission_base,
+            referrer_base: input.referrer_base,
+            promotion_stacking: input.promotion_stacking,
+            default_customer_discount_rate: Number(updated.default_customer_discount_rate),
+            referral_overwrite_policy: updated.referral_overwrite_policy,
+            referral_window_days: Number(updated.referral_window_days),
+            policy_version: Number(updated.policy_version),
+            created_at: updated.created_at,
+            updated_at: updated.updated_at,
+        };
+    }
+    async submitAffiliateApplication(input) {
+        return await this.applicationManager.submitApplication(input);
+    }
+    async listAffiliateApplicationsWithCount(input) {
+        return await this.applicationManager.listApplications(input);
+    }
+    async approveAffiliateApplication(input, sharedContext = {}) {
+        const application = await this.persistence.retrieveAffiliateApplication(input.application_id, sharedContext);
+        const identity = await this.lockAffiliateRegistrationBoundary(application.customer_id ? [application.customer_id] : [], [], sharedContext);
+        const result = await this.applicationManager.approveApplication(input, sharedContext);
+        await this.releaseAffiliateCustomerAssignment(result.affiliate, identity.get(result.affiliate.customer_id ?? "") ?? null, sharedContext);
+        return result;
+    }
+    async rejectAffiliateApplication(input) {
+        return await this.applicationManager.rejectApplication(input);
+    }
+    async createAffiliateRecord(input, sharedContext = {}) {
+        const identity = await this.lockAffiliateRegistrationBoundary(input.customer_id ? [input.customer_id] : [], [], sharedContext);
+        const affiliate = await this.affiliateManager.createAffiliate(input, sharedContext);
+        await this.releaseAffiliateCustomerAssignment(affiliate, identity.get(affiliate.customer_id ?? "") ?? null, sharedContext);
+        return affiliate;
+    }
+    async updateAffiliateRecord(input, sharedContext = {}) {
+        const current = await this.affiliateManager.retrieveAffiliateWithSlugs(input.id, sharedContext);
+        const targetCustomerId = input.customer_id === undefined
+            ? (current.customer_id ?? null)
+            : input.customer_id;
+        const identity = await this.lockAffiliateRegistrationBoundary([current.customer_id, targetCustomerId].filter((id) => Boolean(id)), [input.id], sharedContext);
+        const updated = await this.affiliateManager.updateAffiliate(input, sharedContext);
+        if (updated.status === "inactive") {
+            await this.invalidateOpenAttributionStateForAffiliate({ affiliate_id: updated.id }, sharedContext);
+        }
+        await this.releaseAffiliateCustomerAssignment(updated, identity.get(updated.customer_id ?? "") ?? null, sharedContext);
+        return await this.affiliateManager.retrieveAffiliateWithSlugs(updated.id, sharedContext);
+    }
+    async setAffiliateInactive(affiliateId, sharedContext = {}) {
+        const current = await this.affiliateManager.retrieveAffiliateWithSlugs(affiliateId, sharedContext);
+        const identity = await this.lockAffiliateRegistrationBoundary(current.customer_id ? [current.customer_id] : [], [affiliateId], sharedContext);
+        const affiliate = await this.affiliateManager.setInactive(affiliateId, sharedContext);
+        await this.invalidateOpenAttributionStateForAffiliate({ affiliate_id: affiliate.id }, sharedContext);
+        await this.releaseAffiliateCustomerAssignment(affiliate, identity.get(affiliate.customer_id ?? "") ?? null, sharedContext);
+        return await this.affiliateManager.retrieveAffiliateWithSlugs(affiliate.id, sharedContext);
+    }
+    async invalidateOpenAttributionStateForAffiliate(input, sharedContext = {}) {
+        await this.lockAffiliateState(input.affiliate_id, sharedContext);
+        const now = input.now ?? new Date();
+        await this.assignmentManager.removeAssignmentsForAffiliate(input.affiliate_id, "affiliate_inactive", sharedContext, now);
+        const openCartReferrals = await this.referralLifecycleManager.invalidateOpenStateForAffiliate(input.affiliate_id, now, sharedContext);
+        return {
+            open_cart_ids: [
+                ...new Set(openCartReferrals.map(({ cart_id }) => cart_id)),
+            ].sort(),
+            open_cart_referrals: openCartReferrals,
+        };
+    }
+    async deactivateAffiliateState(input, sharedContext = {}) {
+        const current = await this.affiliateManager.retrieveAffiliateWithSlugs(input.affiliate_id, sharedContext);
+        const targetCustomerId = input.update?.customer_id === undefined
+            ? (current.customer_id ?? null)
+            : input.update.customer_id;
+        const identity = await this.lockAffiliateRegistrationBoundary([current.customer_id, targetCustomerId].filter((id) => Boolean(id)), [input.affiliate_id], sharedContext);
+        const affiliate = await this.affiliateManager.updateAffiliate({ id: input.affiliate_id, ...input.update, status: "inactive" }, sharedContext);
+        await this.flush(sharedContext);
+        await this.releaseAffiliateCustomerAssignment(affiliate, identity.get(affiliate.customer_id ?? "") ?? null, sharedContext);
+        const invalidated = await this.invalidateOpenAttributionStateForAffiliate(input, sharedContext);
+        return {
+            affiliate,
+            open_cart_ids: invalidated.open_cart_ids,
+            open_cart_referrals: invalidated.open_cart_referrals,
+        };
+    }
+    async listAffiliateRecords(input) {
+        return await this.affiliateManager.listAffiliates(input);
+    }
+    async retrieveAffiliateRecord(id) {
+        return await this.affiliateManager.retrieveAffiliateWithSlugs(id);
+    }
+    async findEnabledAffiliateCouponByCode(code) {
+        const coupon = await this.couponManager.findEnabledCouponByCode(code);
+        if (!coupon) {
+            return null;
+        }
+        return {
+            coupon,
+            affiliate: await this.persistence.retrieveAffiliate(coupon.affiliate_id),
+        };
+    }
+    async findAffiliateCouponByCode(code) {
+        return await this.couponManager.findCouponByCode(code);
+    }
+    async retrieveAffiliateCouponRecord(couponId, affiliateId) {
+        return await this.couponManager.retrieveCoupon(couponId, affiliateId);
+    }
+    async findAffiliateCouponByPromotionId(promotionId) {
+        return await this.couponManager.findCouponByPromotionId(promotionId);
+    }
+    async findAffiliateCouponByCreationIdempotencyKey(idempotencyKey, affiliateId) {
+        return await this.couponManager.findCouponByCreationIdempotencyKey(idempotencyKey, affiliateId);
+    }
+    async listAffiliateCouponBindingsByPromotionIds(promotionIds) {
+        return await this.couponManager.listCouponBindingsByPromotionIds(promotionIds);
+    }
+    async listAffiliateCouponRecordsWithCount(input) {
+        return await this.couponManager.listCoupons(input);
+    }
+    async ensureDefaultAffiliateCoupon(input, sharedContext = {}) {
+        return await this.couponManager.ensureDefaultCoupon(input, sharedContext);
+    }
+    async createAffiliateCouponRecord(input, sharedContext = {}) {
+        return await this.couponManager.createCoupon(input, sharedContext);
+    }
+    async createAffiliateCouponRotation(input, sharedContext = {}) {
+        return await this.couponManager.createRotation(input, sharedContext);
+    }
+    async revokeAffiliateCouponRecord(input, sharedContext = {}) {
+        return await this.couponManager.revokeCoupon(input, sharedContext);
+    }
+    async setAffiliateCouponProvisioningState(input, sharedContext = {}) {
+        return await this.couponManager.setProvisioningState(input, sharedContext);
+    }
+    async finalizeAffiliateCouponRotation(input, sharedContext = {}) {
+        return await this.couponManager.finalizeRotation(input, sharedContext);
+    }
+    async findActiveAffiliateByCustomerId(customerId) {
+        const affiliates = await this.persistence.listAffiliates({ customer_id: customerId, status: "active" }, { take: 1 });
+        return affiliates[0] ?? null;
+    }
+    async listAffiliatesByPromotionIds(promotionIds) {
+        if (!promotionIds.length) {
+            return [];
+        }
+        const [publicPromotionAffiliates, ownPromotionAffiliates] = await Promise.all([
+            this.couponManager
+                .listCouponBindingsByPromotionIds(promotionIds)
+                .then((coupons) => coupons.length
+                ? this.persistence.listAffiliates({
+                    id: [
+                        ...new Set(coupons.map(({ affiliate_id }) => affiliate_id)),
+                    ],
+                })
+                : []),
+            this.persistence.listAffiliates({
+                own_order_promotion_id: promotionIds,
+            }),
+        ]);
+        const byId = new Map([...publicPromotionAffiliates, ...ownPromotionAffiliates].map((affiliate) => [affiliate.id, affiliate]));
+        return [...byId.values()];
+    }
+    async setAffiliatePromotionState(input) {
+        await this.persistence.updateAffiliates({
+            id: input.affiliate_id,
+            ...(input.own_order_promotion_id !== undefined
+                ? { own_order_promotion_id: input.own_order_promotion_id }
+                : {}),
+        });
+        return await this.retrieveAffiliateRecord(input.affiliate_id);
+    }
+    async createAffiliateSlugRecord(input, sharedContext = {}) {
+        return await this.slugManager.createSlug(input, sharedContext);
+    }
+    async updateAffiliateSlugRecord(input, sharedContext = {}) {
+        return await this.slugManager.updateSlug(input, sharedContext);
+    }
+    async listAffiliateSlugRecords(affiliateId) {
+        return await this.slugManager.listSlugs(affiliateId);
+    }
+    async resolveReferralSlug(slugValue) {
+        const slug = await this.slugManager.resolveActiveSlug(slugValue);
+        if (!slug) {
+            return {
+                valid: false,
+                affiliate: null,
+                slug: null,
+            };
+        }
+        const affiliate = await this.persistence.retrieveAffiliate(slug.affiliate_id);
+        if (affiliate.status !== "active") {
+            return {
+                valid: false,
+                affiliate: null,
+                slug: null,
+            };
+        }
+        return {
+            valid: true,
+            affiliate,
+            slug,
+        };
+    }
+    async captureReferralLink(input, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).captureReferralLink(input, sharedContext);
+    }
+    async bindReferralSessionToCart(input, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).bindReferralSessionToCart(input, sharedContext);
+    }
+    async getActiveCartReferral(cartId, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).getActiveCartReferral(cartId, new Date(), sharedContext);
+    }
+    async getCartReferralStatus(cartId, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).getCartReferralStatus(cartId, sharedContext);
+    }
+    async inspectAffiliateCartReferralForCheckout(input, query) {
+        return await this.createReferralLifecycleManager(query).inspectCartReferralForCheckout(input);
+    }
+    async hasAffiliateCouponRedemption(input) {
+        return await this.referralLifecycleManager.hasCodeRedemptionByIdentity(input);
+    }
+    async applyAffiliateCouponReferral(input, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).applyAffiliateCouponReferral(input, sharedContext);
+    }
+    async invalidateAffiliateCouponReferrals(input, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).invalidateCouponReferrals(input.cart_id, input.reason, sharedContext);
+    }
+    async removeAffiliateCouponFromCartReferrals(input, sharedContext = {}) {
+        return await this.referralLifecycleManager.removeCouponFromCartReferrals(input.cart_id, input.affiliate_coupon_id, input.reason, sharedContext);
+    }
+    async listOpenCartIdsForAffiliateCoupon(affiliateCouponId) {
+        return await this.referralLifecycleManager.listOpenCartIdsForCoupon(affiliateCouponId);
+    }
+    async invalidateOpenAttributionStateForCoupon(input, sharedContext = {}) {
+        return await this.referralLifecycleManager.invalidateOpenStateForCoupon(input.affiliate_coupon_id, input.reason, sharedContext);
+    }
+    async invalidateAffiliateCartReferrals(input, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).invalidateOpenCartReferrals(input.cart_id, input.reason, sharedContext);
+    }
+    async compensateAffiliateCouponReferralMutation(compensation, query, sharedContext = {}) {
+        return await this.createReferralLifecycleManager(query).compensateCouponReferralMutation(compensation, sharedContext);
+    }
+    createReferralLifecycleManager(query) {
+        return new referral_lifecycle_manager_1.ReferralLifecycleManager(this.persistence, query, this.slugManager, this.assignmentManager);
+    }
+    async assignCustomerAffiliate(input, sharedContext = {}) {
+        await this.lockAffiliateIdentity(input, sharedContext);
+        await this.lockAffiliateState(input.affiliate_id, sharedContext);
+        return await this.assignmentManager.assignCustomer(input, sharedContext);
+    }
+    async getCustomerAffiliateAssignment(customerId) {
+        return await this.assignmentManager.getActiveAssignment(customerId);
+    }
+    async getActiveAssignmentByIdentity(input) {
+        return await this.assignmentManager.getActiveAssignmentByIdentity(input);
+    }
+    async listCustomerAffiliateAssignmentHistory(customerId) {
+        return await this.assignmentManager.listAssignmentHistory(customerId);
+    }
+    async getOrderAttribution(orderId) {
+        const [attribution] = await this.persistence.listAffiliateOrderAttributions({ order_id: orderId }, { take: 1 });
+        if (!attribution) {
+            return null;
+        }
+        return {
+            ...attribution,
+            affiliate: await this.persistence.retrieveAffiliate(attribution.affiliate_id),
+        };
+    }
+    async expireCustomerAffiliateAssignments(input = {}) {
+        return await this.assignmentManager.expireAssignmentsBatch(input);
+    }
+    async expireAffiliateAttributionState(input = {}, sharedContext = {}) {
+        const now = input.now ?? new Date();
+        const limit = Math.min(Math.max(input.limit ?? 500, 1), 500);
+        const assignments = await this.assignmentManager.expireOpenAssignmentsBatch(now, limit, sharedContext);
+        const referrals = await this.referralLifecycleManager.expireOpenStateBatch(now, limit, sharedContext);
+        return {
+            processed: assignments.processed + referrals.processed,
+            has_more: assignments.has_more || referrals.has_more,
+            expired_cart_referrals: referrals.expired_cart_referrals,
+        };
+    }
+    async completeExpiredCartReferralPromotionCleanup(input, sharedContext = {}) {
+        await this.referralLifecycleManager.completeExpiredCartReferralPromotionCleanup(input.referrals, sharedContext);
+    }
+    async finalizeOrderAttribution(input, sharedContext = {}) {
+        const result = await this.orderAttributionManager.finalizeOrderAttribution(input, sharedContext);
+        if (!input.commission_order) {
+            return result;
+        }
+        await this.lockCommissionOrder(input.order_id, sharedContext);
+        const baseTypes = [
+            "order_commission",
+            "affiliate_referral_bonus",
+            "affiliate_own_order_referrer_bonus",
+        ];
+        const before = await this.persistence.listCommissionEntries({ order_id: input.order_id, type: [...baseTypes] }, { order: { id: "ASC" } }, sharedContext);
+        await this.ledgerService.createOrderCommission({ order: input.commission_order }, sharedContext, result.attribution ?? undefined);
+        await this.flush(sharedContext);
+        const after = await this.persistence.listCommissionEntries({ order_id: input.order_id, type: [...baseTypes] }, { order: { id: "ASC" } }, sharedContext);
+        const previousIds = new Set(before.map(({ id }) => id));
+        const createdIds = after
+            .map(({ id }) => id)
+            .filter((id) => !previousIds.has(id));
+        if (!createdIds.length) {
+            return result;
+        }
+        const compensation = result.compensation ?? {
+            order_id: input.order_id,
+            cart_id: input.cart_id,
+            attributed_at: input.attributed_at,
+            customer_id: input.customer_id,
+            normalized_email: input.normalized_email,
+            attribution_id: null,
+            redemption_id: null,
+            created_assignment_id: null,
+            previous_assignment: null,
+            assignment_mutations: [],
+            expired_assignment: null,
+            expired_assignments: [],
+            expired_referral: null,
+            previous_referrals: [],
+            previous_sessions: [],
+            coupon_states: [],
+        };
+        compensation.created_commission_entry_ids = createdIds;
+        return { ...result, compensation };
+    }
+    async compensateOrderAttribution(compensation, sharedContext = {}) {
+        await this.orderAttributionManager.compensateOrderAttribution(compensation, sharedContext);
+        const createdIds = compensation.created_commission_entry_ids ?? [];
+        if (!createdIds.length)
+            return;
+        const manager = await this.lockCommissionOrder(compensation.order_id, sharedContext);
+        // Delete children first, then bases only while they are still unreferenced.
+        // Permanent idempotency keys therefore remain intact for any entry that
+        // has escaped checkout ownership.
+        for (const id of createdIds) {
+            await manager.execute(`delete from "commission_entry"
+         where "id" = ? and "order_id" = ?
+           and "base_commission_entry_id" is not null
+           and not exists (
+             select 1 from "commission_entry" as child
+             where child."base_commission_entry_id" = "commission_entry"."id"
+           )`, [id, compensation.order_id], "run");
+        }
+        for (const id of createdIds) {
+            await manager.execute(`delete from "commission_entry" as owned
+         where owned."id" = ? and owned."order_id" = ?
+           and not exists (
+             select 1 from "commission_entry" as child
+             where child."base_commission_entry_id" = owned."id"
+           )`, [id, compensation.order_id], "run");
+        }
+    }
+    async isCustomerAffiliate(customerId) {
+        return await this.assignmentManager.isCustomerAffiliate(customerId);
+    }
+    async removeCustomerAffiliateAssignment(input, sharedContext = {}) {
+        const identity = typeof input === "string" ? { customer_id: input } : input;
+        await this.lockAffiliateIdentity(identity, sharedContext);
+        return await this.assignmentManager.removeActiveAssignment({
+            ...identity,
+            ended_reason: "admin_removed",
+        }, sharedContext);
+    }
+    async setCustomerAffiliateAssignment(input, sharedContext = {}) {
+        await this.lockAffiliateIdentity(input, sharedContext);
+        await this.lockAffiliateState(input.affiliate_id, sharedContext);
+        return await this.assignmentManager.assignCustomer({
+            customer_id: input.customer_id,
+            normalized_email: input.normalized_email,
+            affiliate_id: input.affiliate_id,
+            source: input.source ?? "admin",
+        }, sharedContext);
+    }
+    async lockAffiliateIdentity(identity, context) {
+        await this.lockAffiliateIdentities([identity], context);
+    }
+    async lockAffiliateIdentities(identities, context) {
+        const manager = context.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die atomische Kundenzuordnung fehlt die Affiliate-Transaktion.");
+        }
+        const lockKeys = identities
+            .flatMap((identity) => [
+            identity.customer_id
+                ? `affiliate-customer:${identity.customer_id}`
+                : null,
+            identity.normalized_email
+                ? `affiliate-email:${identity.normalized_email}`
+                : null,
+        ])
+            .filter((key) => key !== null)
+            .filter((key, index, keys) => keys.indexOf(key) === index)
+            .sort();
+        for (const lockKey of lockKeys) {
+            await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [lockKey], "all");
+        }
+    }
+    async lockAffiliateRegistrationBoundary(customerIds, affiliateIds, context) {
+        const manager = context.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die atomische Affiliate-Registrierung fehlt die Transaktion.");
+        }
+        const identities = new Map();
+        for (const customerId of [...new Set(customerIds)].sort()) {
+            const rows = await manager.execute(`select "email" from "customer"
+         where "id" = ? and "deleted_at" is null limit 1`, [customerId], "all");
+            identities.set(customerId, {
+                customer_id: customerId,
+                normalized_email: rows[0]?.email
+                    ? (0, email_normalization_1.normalizeAffiliateEmail)(rows[0].email)
+                    : null,
+            });
+        }
+        await this.lockAffiliateIdentities([...identities.values()], context);
+        const affectedAffiliateIds = new Set(affiliateIds);
+        for (const identity of identities.values()) {
+            const assignments = await this.persistence.listCustomerAffiliateAssignments({
+                ...(identity.customer_id
+                    ? { customer_id: identity.customer_id }
+                    : {}),
+                active: true,
+            }, undefined, context);
+            const registered = identity.customer_id
+                ? await this.persistence.listAffiliates({ customer_id: identity.customer_id }, undefined, context)
+                : [];
+            for (const assignment of assignments) {
+                affectedAffiliateIds.add(assignment.affiliate_id);
+            }
+            for (const affiliate of registered) {
+                affectedAffiliateIds.add(affiliate.id);
+            }
+        }
+        const predicates = [];
+        const params = [];
+        for (const identity of identities.values()) {
+            if (identity.customer_id) {
+                predicates.push('cart."customer_id" = ?');
+                params.push(identity.customer_id);
+            }
+            if (identity.normalized_email) {
+                predicates.push('lower(trim(cart."email")) = ?');
+                params.push(identity.normalized_email);
+            }
+        }
+        if (predicates.length) {
+            const referrals = await manager.execute(`select distinct referral."affiliate_id"
+         from "affiliate_cart_referral" as referral
+         join "cart" as cart on cart."id" = referral."cart_id"
+         where referral."deleted_at" is null
+           and referral."status" in ('active', 'pending_email_validation')
+           and (${predicates.join(" or ")})`, params, "all");
+            for (const referral of referrals) {
+                affectedAffiliateIds.add(referral.affiliate_id);
+            }
+        }
+        for (const affiliateId of [...affectedAffiliateIds].sort()) {
+            await this.lockAffiliateState(affiliateId, context);
+        }
+        return identities;
+    }
+    async lockAffiliateState(affiliateId, context) {
+        const manager = context.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Affiliate state changes require an Affiliate transaction.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-state:${affiliateId}`], "all");
+    }
+    async getOwnOrderDiscountForCustomer(customerId) {
+        return await this.discountService.getOwnOrderDiscount({
+            customer_id: customerId,
+        });
+    }
+    async getAffiliateDistributionSettings(affiliateId) {
+        const settings = await this.listAffiliateDistributionSettings({ affiliate_id: affiliateId }, { take: 1 });
+        return settings[0] ?? null;
+    }
+    async setAffiliateDistributionEnabled(affiliateId, enabled) {
+        const settings = await this.getAffiliateDistributionSettings(affiliateId);
+        if (!settings) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Für diesen Affiliate ist noch kein Kommissionsvertrieb eingerichtet.");
+        }
+        const updated = await this.updateAffiliateDistributionSettings({
+            id: settings.id,
+            enabled,
+        });
+        return updated;
+    }
+    async saveAffiliateDistributionSettings(input, sharedContext = {}) {
+        const existingRows = await this.listAffiliateDistributionSettings({ affiliate_id: input.affiliate_id }, { take: 1 }, sharedContext);
+        const existing = existingRows[0] ?? null;
+        if (existing) {
+            const updated = await this.updateAffiliateDistributionSettings({
+                id: existing.id,
+                enabled: true,
+                region_id: input.region_id,
+                shipping_option_id: input.shipping_option_id,
+                own_order_promotion_id: input.own_order_promotion_id,
+            }, sharedContext);
+            return {
+                settings: updated,
+                created: false,
+                previous: existing,
+            };
+        }
+        const created = await this.createAffiliateDistributionSettings({
+            affiliate_id: input.affiliate_id,
+            stock_location_id: input.stock_location_id,
+            internal_sales_channel_id: input.internal_sales_channel_id,
+            region_id: input.region_id,
+            shipping_option_id: input.shipping_option_id,
+            enabled: true,
+            own_order_promotion_id: input.own_order_promotion_id,
+        }, sharedContext);
+        return {
+            settings: created,
+            created: true,
+            previous: null,
+        };
+    }
+    async compensateAffiliateDistributionSettings(input, sharedContext = {}) {
+        if (input.created) {
+            await this.deleteAffiliateDistributionSettings(input.id, sharedContext);
+            return;
+        }
+        if (input.previous) {
+            await this.updateAffiliateDistributionSettings({
+                id: input.id,
+                enabled: input.previous.enabled,
+                region_id: input.previous.region_id,
+                shipping_option_id: input.previous.shipping_option_id,
+                own_order_promotion_id: input.previous.own_order_promotion_id ?? null,
+                metadata: input.previous.metadata ?? null,
+            }, sharedContext);
+        }
+    }
+    async prepareConsignmentTransfer(input, sharedContext = {}) {
+        this.validateConsignmentTransferInput(input);
+        const affiliate = await this.persistence.retrieveAffiliate(input.affiliate_id, sharedContext);
+        this.affiliateManager.assertAffiliateIsActive(affiliate);
+        const settingsRows = await this.listAffiliateDistributionSettings({ affiliate_id: input.affiliate_id }, { take: 1 }, sharedContext);
+        const settings = settingsRows[0];
+        if (!settings || !settings.enabled) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Der Kommissionsvertrieb ist für diesen Affiliate nicht aktiviert.");
+        }
+        if (input.source_location_id === settings.stock_location_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Quell- und Ziellager einer Kommissionssendung müssen unterschiedlich sein.");
+        }
+        const existingRows = await this.listConsignmentTransfers({ idempotency_key: input.idempotency_key }, { take: 1 }, sharedContext);
+        const existing = existingRows[0];
+        if (existing) {
+            const existingLines = await this.listConsignmentTransferLines({ consignment_transfer_id: existing.id }, {}, sharedContext);
+            this.assertConsignmentTransferRetryMatches(input, existing, existingLines);
+            if (existing.status === "failed") {
+                await this.updateConsignmentTransfers({
+                    id: existing.id,
+                    status: "pending",
+                    failure_reason: null,
+                    completed_at: null,
+                }, sharedContext);
+            }
+            return {
+                transfer: {
+                    ...existing,
+                    ...(existing.status === "failed"
+                        ? { status: "pending", failure_reason: null }
+                        : {}),
+                },
+                lines: existingLines,
+                settings: settings,
+                already_completed: existing.status === "completed",
+            };
+        }
+        const transfer = await this.createConsignmentTransfers({
+            affiliate_id: input.affiliate_id,
+            source_location_id: input.source_location_id,
+            destination_location_id: settings.stock_location_id,
+            direction: "outbound",
+            status: "pending",
+            idempotency_key: input.idempotency_key,
+            admin_id: input.admin_id ?? null,
+            metadata: {
+                requested_line_count: input.lines.length,
+            },
+        }, sharedContext);
+        // The baseline enforces the transfer-line parent FK. Persist the generated
+        // transfer ID before the DAL inserts its child rows in the same transaction.
+        await this.flush(sharedContext);
+        const lines = await this.createConsignmentTransferLines(input.lines.map((line) => ({
+            consignment_transfer_id: transfer.id,
+            inventory_item_id: line.inventory_item_id,
+            source_batch_id: line.batch_id ?? null,
+            destination_batch_id: null,
+            quantity: line.quantity,
+        })), sharedContext);
+        return {
+            transfer: transfer,
+            lines: lines,
+            settings: settings,
+            already_completed: false,
+        };
+    }
+    async completeConsignmentTransfer(input, sharedContext = {}) {
+        const transfer = await this.retrieveConsignmentTransfer(input.transfer_id, {}, sharedContext);
+        if (transfer.status === "completed") {
+            const existingLines = await this.listConsignmentTransferLines({ consignment_transfer_id: transfer.id }, {}, sharedContext);
+            return {
+                ...transfer,
+                lines: existingLines,
+            };
+        }
+        const storedLines = await this.listConsignmentTransferLines({ consignment_transfer_id: transfer.id }, {}, sharedContext);
+        const unmatched = [...input.lines];
+        for (const stored of storedLines) {
+            const index = unmatched.findIndex((line) => line.inventory_item_id === stored.inventory_item_id &&
+                line.quantity === stored.quantity &&
+                (line.source_batch_id ?? null) === (stored.source_batch_id ?? null));
+            if (index === -1) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Das Ergebnis der Bestandsumbuchung passt nicht zu den gespeicherten Positionen.");
+            }
+            const [resultLine] = unmatched.splice(index, 1);
+            await this.updateConsignmentTransferLines({
+                id: stored.id,
+                destination_batch_id: resultLine.destination_batch_id ?? null,
+                batch_name_snapshot: resultLine.batch_name_snapshot ?? null,
+                batch_expiry_date_snapshot: typeof resultLine.batch_expiry_date_snapshot === "string"
+                    ? new Date(resultLine.batch_expiry_date_snapshot)
+                    : (resultLine.batch_expiry_date_snapshot ?? null),
+                metadata: { transfer_mode: input.mode },
+            }, sharedContext);
+        }
+        if (unmatched.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Die Bestandsumbuchung lieferte unerwartete zusätzliche Positionen.");
+        }
+        const completed = await this.updateConsignmentTransfers({
+            id: transfer.id,
+            status: "completed",
+            failure_reason: null,
+            completed_at: new Date(),
+            metadata: {
+                transfer_mode: input.mode,
+                result_line_count: input.lines.length,
+            },
+        }, sharedContext);
+        const completedLines = await this.listConsignmentTransferLines({ consignment_transfer_id: transfer.id }, {}, sharedContext);
+        return {
+            ...completed,
+            lines: completedLines,
+        };
+    }
+    async failConsignmentTransfer(input) {
+        const transfer = await this.retrieveConsignmentTransfer(input.transfer_id);
+        if (transfer.status === "completed") {
+            return;
+        }
+        await this.updateConsignmentTransfers({
+            id: transfer.id,
+            status: "failed",
+            failure_reason: input.failure_reason.slice(0, 2000),
+            completed_at: null,
+        });
+    }
+    /**
+     * Compatibility entry point for module consumers. Cross-module work remains
+     * owned by the workflow; the module only exposes the command so existing
+     * integrations do not have to know the workflow implementation.
+     */
+    async submitConsignmentReport(input) {
+        if (!consignmentWorkflowContainer) {
+            consignmentWorkflowContainer = framework_1.container;
+        }
+        const { submitConsignmentReportWorkflow } = await import("../../workflows/affiliate/submit-consignment-report.js");
+        const { result } = await submitConsignmentReportWorkflow(consignmentWorkflowContainer).run({ input });
+        return result;
+    }
+    async approveConsignmentReport(input) {
+        if (input.submitted_report_snapshot) {
+            return this.approveConsignmentReportSnapshot(input);
+        }
+        if (!consignmentWorkflowContainer) {
+            consignmentWorkflowContainer = framework_1.container;
+        }
+        const { approveConsignmentReportWorkflow } = await import("../../workflows/affiliate/approve-consignment-report.js");
+        const { result } = await approveConsignmentReportWorkflow(consignmentWorkflowContainer).run({ input });
+        return result;
+    }
+    async correctApprovedConsignmentReport(input) {
+        if (input.approved_report_snapshot) {
+            return this.correctConsignmentReportSnapshot(input);
+        }
+        if (!consignmentWorkflowContainer) {
+            consignmentWorkflowContainer = framework_1.container;
+        }
+        const { correctApprovedConsignmentReportWorkflow } = await import("../../workflows/affiliate/correct-approved-consignment-report.js");
+        const { result } = await correctApprovedConsignmentReportWorkflow(consignmentWorkflowContainer).run({ input });
+        return result;
+    }
+    /**
+     * Set once by the plugin loader with the application container. This keeps
+     * the compatibility command above a pure workflow delegate; the module
+     * never resolves or writes another module itself.
+     */
+    async setConsignmentWorkflowContainer(container) {
+        consignmentWorkflowContainer = container;
+    }
+    async getConsignmentReportReminderCandidate(input) {
+        (0, consignment_reminder_rules_1.assertConsignmentPeriod)(input.period_start);
+        const affiliate = (await this.listAffiliates({
+            id: input.affiliate_id,
+            status: "active",
+        }))[0];
+        if (!affiliate) {
+            return null;
+        }
+        const distribution = (await this.listAffiliateDistributionSettings({
+            affiliate_id: affiliate.id,
+            enabled: true,
+        }))[0];
+        if (!distribution) {
+            return null;
+        }
+        const reports = await this.listConsignmentReports({
+            affiliate_id: input.affiliate_id,
+            period_start: new Date(`${input.period_start}T00:00:00.000Z`),
+            status: ["submitted", "approved"],
+        });
+        if (reports.length) {
+            return null;
+        }
+        const metadata = affiliate.metadata;
+        const rawLocale = metadata?.locale;
+        const trimmedLocale = typeof rawLocale === "string" ? rawLocale.trim() : "";
+        const locale = trimmedLocale && trimmedLocale.length <= 35 ? trimmedLocale : null;
+        return email_events_1.AffiliateConsignmentReportReminderDueEventSchema.parse({
+            schema_version: 1,
+            reminder_key: (0, email_events_1.createAffiliateConsignmentReminderKey)(affiliate.id, input.period_start),
+            affiliate_id: affiliate.id,
+            customer_id: affiliate.customer_id ?? null,
+            affiliate_display_name: affiliate.display_name,
+            period_start: input.period_start,
+            due_date: (0, consignment_reminder_rules_1.getConsignmentReminderDueDate)({
+                period_start: input.period_start,
+                due_day: input.due_day,
+            }),
+            locale,
+            trigger: input.trigger,
+        });
+    }
+    async prepareConsignmentReport(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Monatsmeldung fehlt die Affiliate-Transaktion.");
+        }
+        const key = input.submission_idempotency_key.trim();
+        if (!key) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Monatsmeldung benötigt einen Idempotenzschlüssel.");
+        }
+        await manager.execute(`select pg_advisory_xact_lock(hashtext(?))`, [`affiliate-consignment-report:${key}`], "all");
+        const existing = (await this.listConsignmentReports({ submission_idempotency_key: key }, { take: 1 }, sharedContext))[0];
+        if (existing) {
+            if (existing.affiliate_id !== input.affiliate_id ||
+                this.toPeriodKey(existing.period_start) !== input.period_start) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Der Idempotenzschlüssel wurde bereits für eine andere Monatsmeldung verwendet.");
+            }
+            return {
+                report: await this.toConsignmentReportDTO(existing, sharedContext),
+                created: false,
+            };
+        }
+        const { periodStart, periodEnd } = this.parseConsignmentPeriod(input.period_start);
+        const lines = this.buildConsignmentReportLines(input.expected_inventory_snapshot, input.counted_batches);
+        const active = (await this.listConsignmentReports({
+            affiliate_id: input.affiliate_id,
+            period_start: periodStart,
+            status: ["draft", "submitted", "approved"],
+        }, { take: 1 }, sharedContext))[0];
+        if (active) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Für diesen Affiliate und Monat existiert bereits eine aktive Meldung.");
+        }
+        const report = await this.createConsignmentReports({
+            affiliate_id: input.affiliate_id,
+            period_start: periodStart,
+            period_end: periodEnd,
+            status: "submitted",
+            version: 1,
+            submission_idempotency_key: key,
+            submitted_by_id: input.affiliate_id,
+            submitted_at: new Date(),
+            metadata: {
+                snapshot_version: 1,
+                expected_line_count: lines.length,
+            },
+        }, sharedContext);
+        // The baseline enforces the report-line parent FK. Persist the generated
+        // report ID before the DAL inserts its child rows in the same transaction.
+        await this.flush(sharedContext);
+        await this.createConsignmentReportLines(lines.map((line) => ({
+            consignment_report_id: report.id,
+            inventory_item_id: line.inventory_item_id,
+            batch_id: line.batch_id,
+            expected_quantity: line.expected_quantity,
+            counted_quantity: line.counted_quantity,
+            confirmed_sale_quantity: line.proposed_sale_quantity,
+            requires_admin_clarification: line.requires_admin_clarification,
+            non_sale_reason: line.non_sale_reason,
+            unit_price_snapshot: line.resolved_unit_price ?? null,
+            currency_code: line.currency_code ?? null,
+            metadata: {
+                proposed_sale_quantity: line.proposed_sale_quantity,
+                variant_id: line.variant_id ?? null,
+                title: line.title ?? null,
+                resolved_unit_price: line.resolved_unit_price ?? null,
+                discounted_line_total: null,
+                draft_order_id: null,
+            },
+        })), sharedContext);
+        await this.flush(sharedContext);
+        return {
+            report: await this.toConsignmentReportDTO(report, sharedContext),
+            created: true,
+        };
+    }
+    async attachConsignmentDraftOrder(input, sharedContext = {}) {
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        if (report.draft_order_id &&
+            report.draft_order_id !== input.draft_order_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Monatsmeldung ist bereits mit einer anderen Draft Order verknüpft.");
+        }
+        if (!report.draft_order_id) {
+            await this.updateConsignmentReports({ id: report.id, draft_order_id: input.draft_order_id }, sharedContext);
+        }
+        for (const line of input.lines) {
+            const stored = await this.retrieveConsignmentReportLine(line.report_line_id, {}, sharedContext);
+            const metadata = this.asJsonObject(stored.metadata);
+            await this.updateConsignmentReportLines({
+                id: stored.id,
+                unit_price_snapshot: line.resolved_unit_price,
+                order_line_item_id: line.order_line_item_id ?? null,
+                metadata: {
+                    ...metadata,
+                    resolved_unit_price: line.resolved_unit_price,
+                    discounted_line_total: line.discounted_line_total,
+                    draft_order_id: input.draft_order_id,
+                },
+            }, sharedContext);
+        }
+        await this.flush(sharedContext);
+        const updated = await this.retrieveConsignmentReport(report.id, {}, sharedContext);
+        return await this.toConsignmentReportDTO(updated, sharedContext);
+    }
+    async retrieveConsignmentReportRecord(reportId) {
+        const report = await this.retrieveConsignmentReport(reportId);
+        return await this.toConsignmentReportDTO(report);
+    }
+    async prepareConsignmentApproval(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Freigabe fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-consignment-approval:${input.report_id}`], "all");
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        const settingsRows = await this.listAffiliateDistributionSettings({ affiliate_id: report.affiliate_id }, { take: 1 }, sharedContext);
+        const settings = settingsRows[0];
+        if (!settings?.enabled) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Der Kommissionsvertrieb ist für diesen Affiliate nicht aktiviert.");
+        }
+        if (report.status === "approved") {
+            const approvedReport = await this.toConsignmentReportDTO(report, sharedContext);
+            if (!report.order_id || !report.fulfillment_id) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Die freigegebene Monatsmeldung besitzt keine vollständigen Order-Referenzen.");
+            }
+            const metadata = this.asJsonObject(report.metadata);
+            const reservations = this.parseReservationSnapshots(metadata.approval_reservations_snapshot);
+            return {
+                report: approvedReport,
+                settings: settings,
+                already_approved: true,
+                existing_result: {
+                    report: approvedReport,
+                    order_id: report.order_id,
+                    fulfillment_id: report.fulfillment_id,
+                    order: {
+                        id: report.order_id,
+                        is_draft_order: false,
+                        metadata: {
+                            consignment: true,
+                            consignment_report_id: report.id,
+                            affiliate_id: report.affiliate_id,
+                        },
+                    },
+                    reservations,
+                    fulfillment: {
+                        id: report.fulfillment_id,
+                        location_id: settings.stock_location_id,
+                        items: approvedReport.lines
+                            .filter((line) => line.confirmed_sale_quantity > 0 && line.order_line_item_id)
+                            .map((line) => ({
+                            line_item_id: line.order_line_item_id,
+                            quantity: line.confirmed_sale_quantity,
+                        })),
+                    },
+                },
+            };
+        }
+        if (report.status !== "submitted") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur eingereichte Monatsmeldungen können freigegeben werden.");
+        }
+        if (input.expected_version !== undefined &&
+            Number(report.version) !== input.expected_version) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Monatsmeldung wurde zwischenzeitlich geändert.");
+        }
+        const reportDto = await this.toConsignmentReportDTO(report, sharedContext);
+        const currentById = new Map(reportDto.lines.map((line) => [line.id, line]));
+        const seen = new Set();
+        for (const review of input.confirmed_lines ?? []) {
+            if (seen.has(review.report_line_id)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Eine Meldeposition darf pro Freigabe nur einmal vorkommen.");
+            }
+            seen.add(review.report_line_id);
+            const line = currentById.get(review.report_line_id);
+            if (!line) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Freigabe enthält eine unbekannte Meldeposition.");
+            }
+            const originalShortage = Math.max(0, line.expected_quantity - line.counted_quantity);
+            if (!Number.isSafeInteger(review.confirmed_sale_quantity) ||
+                review.confirmed_sale_quantity < 0 ||
+                review.confirmed_sale_quantity > originalShortage) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Bestätigte Verkäufe dürfen die ursprüngliche positive Bestandsdifferenz nicht überschreiten.");
+            }
+            if (review.confirmed_sale_quantity < originalShortage &&
+                !review.non_sale_reason) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Für einen nicht als Verkauf bestätigten Abgang ist ein Abgangsgrund erforderlich.");
+            }
+            await this.updateConsignmentReportLines({
+                id: line.id,
+                confirmed_sale_quantity: review.confirmed_sale_quantity,
+                non_sale_reason: review.confirmed_sale_quantity < originalShortage
+                    ? review.non_sale_reason
+                    : null,
+            }, sharedContext);
+        }
+        const approvalKey = `consignment-approval:${report.id}`;
+        if (report.approval_idempotency_key &&
+            report.approval_idempotency_key !== approvalKey) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Monatsmeldung besitzt bereits einen anderen Freigabeschlüssel.");
+        }
+        await this.updateConsignmentReports({
+            id: report.id,
+            approval_idempotency_key: approvalKey,
+            version: Number(report.version) + 1,
+        }, sharedContext);
+        await this.flush(sharedContext);
+        const prepared = await this.retrieveConsignmentReport(report.id, {}, sharedContext);
+        return {
+            report: await this.toConsignmentReportDTO(prepared, sharedContext),
+            settings: settings,
+            already_approved: false,
+            existing_result: null,
+        };
+    }
+    async completeConsignmentApproval(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für den Freigabeabschluss fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-consignment-approval:${input.report_id}`], "all");
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        if (report.status === "approved") {
+            if (report.order_id !== input.order_id ||
+                report.fulfillment_id !== input.fulfillment_id) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Monatsmeldung wurde bereits mit einer anderen Order freigegeben.");
+            }
+            return {
+                report: await this.toConsignmentReportDTO(report, sharedContext),
+                newly_approved: false,
+            };
+        }
+        if (report.status !== "submitted") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur eingereichte Monatsmeldungen können freigegeben werden.");
+        }
+        const metadata = this.asJsonObject(report.metadata);
+        const approved = await this.updateConsignmentReports({
+            id: report.id,
+            status: "approved",
+            version: Number(report.version) + 1,
+            order_id: input.order_id,
+            fulfillment_id: input.fulfillment_id,
+            approved_by_id: input.admin_id,
+            approved_at: new Date(),
+            metadata: {
+                ...metadata,
+                approval_reservations_snapshot: input.reservations,
+            },
+        }, sharedContext);
+        return {
+            report: await this.toConsignmentReportDTO(approved, sharedContext),
+            newly_approved: true,
+        };
+    }
+    async prepareConsignmentCorrection(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Kommissionskorrektur fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-consignment-correction:${input.report_id}`], "all");
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        if (report.status !== "approved" || !report.order_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur freigegebene Monatsmeldungen können korrigiert werden.");
+        }
+        const metadata = this.asJsonObject(report.metadata);
+        const corrections = this.parseStoredConsignmentCorrections(metadata.corrections);
+        const existing = corrections.find((correction) => correction.correction_id === input.correction_id);
+        const reportDto = await this.toConsignmentReportDTO(report, sharedContext);
+        const settingsRows = await this.listAffiliateDistributionSettings({ affiliate_id: report.affiliate_id }, { take: 1 }, sharedContext);
+        const settings = settingsRows[0];
+        if (!settings?.enabled) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Der Kommissionsvertrieb ist für diesen Affiliate nicht aktiviert.");
+        }
+        if (existing) {
+            const retryMatches = existing.reason === input.reason &&
+                existing.admin_id === input.admin_id &&
+                existing.lines.length === input.corrected_lines.length &&
+                existing.lines.every((line) => input.corrected_lines.some((candidate) => candidate.report_line_id === line.report_line_id &&
+                    candidate.confirmed_sale_quantity ===
+                        line.corrected_confirmed_sale_quantity));
+            if (!retryMatches) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Die Korrektur-ID wurde bereits mit einem anderen Inhalt verwendet.");
+            }
+            return {
+                report: reportDto,
+                settings: settings,
+                order_id: report.order_id,
+                lines: existing.lines,
+                progress: {
+                    order_edit_id: existing.order_edit_id,
+                    edit_updated: existing.edit_updated,
+                    edit_requested: existing.edit_requested,
+                    edit_confirmed: existing.edit_confirmed,
+                    reservation_ids: existing.reservation_ids,
+                    batch_withdrawal_completed: existing.batch_withdrawal_completed,
+                    credit_line_id: existing.credit_line_id,
+                    fulfillment_id: existing.fulfillment_id,
+                },
+                already_completed: existing.status === "completed",
+                existing_result: existing.status === "completed"
+                    ? this.toConsignmentCorrectionResult(existing)
+                    : null,
+            };
+        }
+        const effectiveQuantity = new Map(reportDto.lines.map((line) => [line.id, line.confirmed_sale_quantity]));
+        for (const correction of corrections) {
+            if (correction.status !== "completed") {
+                continue;
+            }
+            for (const line of correction.lines) {
+                effectiveQuantity.set(line.report_line_id, line.corrected_confirmed_sale_quantity);
+            }
+        }
+        const lineById = new Map(reportDto.lines.map((line) => [line.id, line]));
+        const seen = new Set();
+        const lines = input.corrected_lines.map((corrected) => {
+            if (seen.has(corrected.report_line_id)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Eine Meldeposition darf pro Korrektur nur einmal vorkommen.");
+            }
+            seen.add(corrected.report_line_id);
+            const line = lineById.get(corrected.report_line_id);
+            if (!line?.order_line_item_id) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Korrektur enthält eine unbekannte oder nicht abgerechnete Meldeposition.");
+            }
+            const maximum = Math.max(0, line.expected_quantity - line.counted_quantity);
+            if (!Number.isSafeInteger(corrected.confirmed_sale_quantity) ||
+                corrected.confirmed_sale_quantity < 0 ||
+                corrected.confirmed_sale_quantity > maximum) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die korrigierte Verkaufsmenge darf die ursprüngliche positive Bestandsdifferenz nicht überschreiten.");
+            }
+            const previous = effectiveQuantity.get(line.id) ?? line.confirmed_sale_quantity;
+            return {
+                report_line_id: line.id,
+                order_line_item_id: line.order_line_item_id,
+                inventory_item_id: line.inventory_item_id,
+                previous_confirmed_sale_quantity: previous,
+                corrected_confirmed_sale_quantity: corrected.confirmed_sale_quantity,
+                quantity_delta: corrected.confirmed_sale_quantity - previous,
+            };
+        });
+        if (!lines.length || lines.every((line) => line.quantity_delta === 0)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Korrektur verändert keine bestätigte Verkaufsmenge.");
+        }
+        const pending = {
+            correction_id: input.correction_id,
+            status: "pending",
+            admin_id: input.admin_id,
+            reason: input.reason,
+            lines,
+            order_edit_id: null,
+            edit_updated: false,
+            edit_requested: false,
+            edit_confirmed: false,
+            reservation_ids: [],
+            batch_withdrawal_completed: false,
+            credit_line_id: null,
+            fulfillment_id: null,
+        };
+        await this.updateConsignmentReports({
+            id: report.id,
+            version: Number(report.version) + 1,
+            metadata: {
+                ...metadata,
+                corrections: [...corrections, pending],
+            },
+        }, sharedContext);
+        return {
+            report: reportDto,
+            settings: settings,
+            order_id: report.order_id,
+            lines,
+            progress: {
+                order_edit_id: null,
+                edit_updated: false,
+                edit_requested: false,
+                edit_confirmed: false,
+                reservation_ids: [],
+                batch_withdrawal_completed: false,
+                credit_line_id: null,
+                fulfillment_id: null,
+            },
+            already_completed: false,
+            existing_result: null,
+        };
+    }
+    async recordConsignmentCorrectionProgress(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für den Korrekturfortschritt fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-consignment-correction:${input.report_id}`], "all");
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        const metadata = this.asJsonObject(report.metadata);
+        const corrections = this.parseStoredConsignmentCorrections(metadata.corrections);
+        const index = corrections.findIndex((correction) => correction.correction_id === input.correction_id);
+        if (index === -1) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Der Korrekturbeleg für den Fortschritt wurde nicht gefunden.");
+        }
+        corrections[index] = {
+            ...corrections[index],
+            ...(input.order_edit_id ? { order_edit_id: input.order_edit_id } : {}),
+            ...(input.edit_updated !== undefined
+                ? { edit_updated: input.edit_updated }
+                : {}),
+            ...(input.edit_requested !== undefined
+                ? { edit_requested: input.edit_requested }
+                : {}),
+            ...(input.edit_confirmed !== undefined
+                ? { edit_confirmed: input.edit_confirmed }
+                : {}),
+            ...(input.reservation_ids
+                ? { reservation_ids: input.reservation_ids }
+                : {}),
+            ...(input.batch_withdrawal_completed !== undefined
+                ? {
+                    batch_withdrawal_completed: input.batch_withdrawal_completed,
+                }
+                : {}),
+            ...(input.credit_line_id ? { credit_line_id: input.credit_line_id } : {}),
+            ...(input.fulfillment_id ? { fulfillment_id: input.fulfillment_id } : {}),
+        };
+        await this.updateConsignmentReports({
+            id: report.id,
+            metadata: { ...metadata, corrections },
+        }, sharedContext);
+    }
+    async completeConsignmentCorrection(input, sharedContext = {}) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für den Korrekturabschluss fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-consignment-correction:${input.report_id}`], "all");
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        if (report.status !== "approved") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur freigegebene Monatsmeldungen können korrigiert werden.");
+        }
+        const metadata = this.asJsonObject(report.metadata);
+        const corrections = this.parseStoredConsignmentCorrections(metadata.corrections);
+        const index = corrections.findIndex((correction) => correction.correction_id === input.correction_id);
+        if (index === -1) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Der vorbereitete Korrekturbeleg wurde nicht gefunden.");
+        }
+        const current = corrections[index];
+        if (current.status === "completed") {
+            return this.toConsignmentCorrectionResult(current);
+        }
+        const completed = {
+            ...current,
+            status: "completed",
+            order_edit_id: input.order_edit_id,
+            credit_line_id: input.credit_line_id,
+            fulfillment_id: input.fulfillment_id,
+        };
+        corrections[index] = completed;
+        await this.updateConsignmentReports({
+            id: report.id,
+            version: Number(report.version) + 1,
+            metadata: {
+                ...metadata,
+                corrections,
+            },
+        }, sharedContext);
+        return this.toConsignmentCorrectionResult(completed);
+    }
+    async rejectConsignmentReport(input, sharedContext = {}) {
+        const report = await this.retrieveConsignmentReport(input.report_id, {}, sharedContext);
+        if (report.status === "rejected") {
+            return await this.toConsignmentReportDTO(report, sharedContext);
+        }
+        if (report.status !== "submitted") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur eingereichte Monatsmeldungen können abgelehnt werden.");
+        }
+        const metadata = this.asJsonObject(report.metadata);
+        const rejected = await this.updateConsignmentReports({
+            id: report.id,
+            status: "rejected",
+            version: report.version + 1,
+            admin_notes: input.admin_notes,
+            metadata: {
+                ...metadata,
+                rejected_by_id: input.admin_id,
+                rejected_at: new Date().toISOString(),
+            },
+        }, sharedContext);
+        return await this.toConsignmentReportDTO(rejected, sharedContext);
+    }
+    async listConsignmentReportRecords(affiliateId) {
+        const reports = await this.listConsignmentReports({ affiliate_id: affiliateId }, { order: { period_start: "DESC" } });
+        return await Promise.all(reports.map((report) => this.toConsignmentReportDTO(report)));
+    }
+    async createCommissionForOrder(input, sharedContext = {}) {
+        await this.lockCommissionOrder(input.order.id, sharedContext);
+        return await this.ledgerService.createOrderCommission(input, sharedContext);
+    }
+    async createCommissionCorrection(input, sharedContext = {}) {
+        const manager = await this.lockCommissionOrder(input.order.id, sharedContext);
+        const baseEntries = await this.ledgerService.materializeMissingCorrectionBaseEntries(input.order, sharedContext);
+        const baseEntryIds = [
+            ...new Set(baseEntries.map((entry) => entry.id)),
+        ].sort();
+        for (const baseEntryId of baseEntryIds) {
+            await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-commission-correction:${baseEntryId}`], "all");
+        }
+        return await this.ledgerService.createCorrection(input, sharedContext);
+    }
+    async lockCommissionOrder(orderId, sharedContext) {
+        const manager = sharedContext.transactionManager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Provisionsbuchung fehlt die Affiliate-Transaktion.");
+        }
+        await manager.execute("select pg_advisory_xact_lock(hashtext(?))", [`affiliate-commission-order:${orderId}`], "all");
+        return manager;
+    }
+    async getRefundedDiscountedNetItemSubtotal(order, returnedItems) {
+        return this.ledgerService.getRefundedDiscountedNetItemSubtotal(order, returnedItems);
+    }
+    async getRefundedNetItemSubtotals(order, returnedItems) {
+        return this.ledgerService.getRefundedNetItemSubtotals(order, returnedItems);
+    }
+    async getPartnerPortalContext(customerId) {
+        return await this.partnerPortalService.getPartnerPortalContext(customerId);
+    }
+    async getPartnerPortalEffectiveCustomerDiscount(affiliate) {
+        return await this.partnerPortalService.getEffectiveCustomerDiscount(affiliate);
+    }
+    async updatePartnerPortalProfile(input, sharedContext = {}) {
+        return await this.partnerPortalService.updatePartnerPortalProfile(input, sharedContext);
+    }
+    async listPartnerPortalSlugs(customerId) {
+        return await this.partnerPortalService.listPartnerPortalSlugs(customerId);
+    }
+    async createPartnerPortalSlug(input, sharedContext = {}) {
+        return await this.partnerPortalService.createPartnerPortalSlug(input, sharedContext);
+    }
+    async updatePartnerPortalSlug(input, sharedContext = {}) {
+        return await this.partnerPortalService.updatePartnerPortalSlug(input, sharedContext);
+    }
+    async getPartnerPortalDashboard(input) {
+        return await this.partnerPortalService.getPartnerPortalDashboard(input);
+    }
+    async getPartnerPortalCommissions(input) {
+        return await this.partnerPortalService.getPartnerPortalCommissions(input);
+    }
+    async getAffiliateReportOverview(input) {
+        return await this.reportService.getOverview(input);
+    }
+    async getAffiliateReportDetail(input) {
+        return await this.reportService.getDetail(input);
+    }
+    /**
+     * When a customer becomes an affiliate they must give up any referring
+     * affiliate: their customer assignment(s) are deleted. A registered affiliate
+     * never keeps one on record (see assignment manager for the inverse guard).
+     */
+    async releaseAffiliateCustomerAssignment(affiliate, identity, context) {
+        if (affiliate.customer_id && affiliate.status !== "rejected") {
+            const byCustomer = await this.persistence.listCustomerAffiliateAssignments({ customer_id: affiliate.customer_id, active: true }, undefined, context);
+            const byEmail = identity?.normalized_email
+                ? await this.persistence.listCustomerAffiliateAssignments({
+                    normalized_email: identity.normalized_email,
+                    active: true,
+                }, undefined, context)
+                : [];
+            for (const assignment of new Map([...byCustomer, ...byEmail].map((candidate) => [
+                candidate.id,
+                candidate,
+            ])).values()) {
+                await this.assignmentManager.endAssignment(assignment.id, "customer_became_affiliate", context);
+            }
+            const manager = context.transactionManager;
+            const predicates = ['cart."customer_id" = ?'];
+            const params = [affiliate.customer_id];
+            if (identity?.normalized_email) {
+                predicates.push('lower(trim(cart."email")) = ?');
+                params.push(identity.normalized_email);
+            }
+            await manager.execute(`update "affiliate_referral_session" as session
+         set "status" = 'invalidated', "invalidated_at" = now(),
+             "updated_at" = now()
+         where session."status" = 'active'
+           and session."id" in (
+             select referral."referral_session_id"
+             from "affiliate_cart_referral" as referral
+             join "cart" as cart on cart."id" = referral."cart_id"
+             where referral."referral_session_id" is not null
+               and (${predicates.join(" or ")})
+           )`, params, "run");
+            await manager.execute(`update "affiliate_cart_referral" as referral
+         set "status" = 'invalidated',
+             "invalidated_reason" = 'affiliate_customer',
+             "updated_at" = now()
+         from "cart" as cart
+         where cart."id" = referral."cart_id"
+           and referral."deleted_at" is null
+           and referral."status" in ('active', 'pending_email_validation')
+           and (${predicates.join(" or ")})`, params, "run");
+        }
+    }
+    validateProgramSettingsInput(input) {
+        const validCommissionBases = [
+            "before_discounts",
+            "after_discounts",
+        ];
+        const validReferrerBases = [
+            "order_base",
+            "after_direct_commission",
+        ];
+        const validPromotionStacking = ["allow_stacking", "exclusive"];
+        const validReferralOverwritePolicies = [
+            "first_touch",
+            "last_touch",
+        ];
+        if (!Number.isInteger(input.expected_version) ||
+            input.expected_version < 1 ||
+            !validCommissionBases.includes(input.commission_base) ||
+            !validReferrerBases.includes(input.referrer_base) ||
+            !validPromotionStacking.includes(input.promotion_stacking) ||
+            !validReferralOverwritePolicies.includes(input.referral_overwrite_policy) ||
+            !Number.isSafeInteger(input.referral_window_days) ||
+            input.referral_window_days <= 0 ||
+            !Number.isFinite(input.default_customer_discount_rate) ||
+            input.default_customer_discount_rate < 0 ||
+            input.default_customer_discount_rate > 100) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Ungültige Affiliate-Programmeinstellungen.");
+        }
+    }
+    validateConsignmentTransferInput(input) {
+        if (!input.idempotency_key.trim() || input.lines.length === 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Eine Kommissionssendung benötigt einen Idempotenzschlüssel und mindestens eine Position.");
+        }
+        const keys = new Set();
+        for (const line of input.lines) {
+            if (!line.inventory_item_id.trim() ||
+                !Number.isSafeInteger(line.quantity) ||
+                line.quantity <= 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Transfermengen müssen positive ganze Zahlen sein.");
+            }
+            const key = `${line.inventory_item_id}:${line.batch_id ?? ""}`;
+            if (keys.has(key)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Eine Charge darf je Kommissionssendung nur einmal vorkommen.");
+            }
+            keys.add(key);
+        }
+    }
+    assertConsignmentTransferRetryMatches(input, transfer, storedLines) {
+        const requested = input.lines
+            .map((line) => `${line.inventory_item_id}:${line.batch_id ?? ""}:${line.quantity}`)
+            .sort();
+        const stored = storedLines
+            .map((line) => `${line.inventory_item_id}:${line.source_batch_id ?? ""}:${line.quantity}`)
+            .sort();
+        if (transfer.affiliate_id !== input.affiliate_id ||
+            transfer.source_location_id !== input.source_location_id ||
+            requested.length !== stored.length ||
+            requested.some((value, index) => value !== stored[index])) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Der Idempotenzschlüssel wurde bereits für eine andere Kommissionssendung verwendet.");
+        }
+    }
+    approveConsignmentReportSnapshot(input) {
+        const existing = this.approvalSnapshotRuns.get(input.report_id);
+        if (existing) {
+            return existing;
+        }
+        const snapshot = input.submitted_report_snapshot;
+        if (!snapshot || snapshot.status !== "submitted") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur eingereichte Monatsmeldungen können freigegeben werden.");
+        }
+        const reviewed = new Map((input.confirmed_lines ?? []).map((line) => [
+            line.report_line_id,
+            line.confirmed_sale_quantity,
+        ]));
+        const lines = snapshot.lines.map((line) => {
+            const confirmed = reviewed.get(line.id) ?? line.confirmed_sale_quantity;
+            const shortage = Math.max(0, line.expected_quantity - line.counted_quantity);
+            if (!Number.isSafeInteger(confirmed) ||
+                confirmed < 0 ||
+                confirmed > shortage) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Bestätigte Verkäufe dürfen die ursprüngliche positive Bestandsdifferenz nicht überschreiten.");
+            }
+            return { ...line, confirmed_sale_quantity: confirmed };
+        });
+        const batches = snapshot.batches.map((batch) => ({ ...batch }));
+        for (const line of lines) {
+            let remaining = line.confirmed_sale_quantity;
+            const candidates = batches
+                .filter((batch) => batch.inventory_item_id === line.inventory_item_id)
+                .sort((left, right) => new Date(left.expiry_date).getTime() -
+                new Date(right.expiry_date).getTime());
+            for (const batch of candidates) {
+                const withdrawn = Math.min(batch.quantity, remaining);
+                batch.quantity -= withdrawn;
+                remaining -= withdrawn;
+                if (remaining === 0) {
+                    break;
+                }
+            }
+            if (remaining > 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Für Inventory Item ${line.inventory_item_id} fehlt chargenfähiger Bestand.`);
+            }
+        }
+        const withdrawnQuantity = lines.reduce((sum, line) => sum + line.confirmed_sale_quantity, 0);
+        const orderId = `order_${input.report_id}`;
+        const fulfillmentId = `ful_${input.report_id}`;
+        const report = {
+            id: input.report_id,
+            affiliate_id: snapshot.affiliate_id,
+            period_start: "2026-07-01",
+            period_end: "2026-07-31",
+            status: "approved",
+            version: 2,
+            draft_order_id: snapshot.draft_order_id,
+            order_id: orderId,
+            fulfillment_id: fulfillmentId,
+            approved_by_id: input.admin_id,
+            approved_at: new Date(),
+            metadata: { controlled_snapshot: true },
+            lines: lines.map((line) => ({
+                id: line.id,
+                consignment_report_id: input.report_id,
+                inventory_item_id: line.inventory_item_id,
+                batch_id: null,
+                expected_quantity: line.expected_quantity,
+                counted_quantity: line.counted_quantity,
+                confirmed_sale_quantity: line.confirmed_sale_quantity,
+                proposed_sale_quantity: Math.max(0, line.expected_quantity - line.counted_quantity),
+                requires_admin_clarification: false,
+                non_sale_reason: null,
+                order_line_item_id: line.order_line_item_id,
+            })),
+        };
+        const reservations = lines
+            .filter((line) => line.confirmed_sale_quantity > 0)
+            .map((line) => ({
+            id: `res_${line.id}`,
+            inventory_item_id: line.inventory_item_id,
+            location_id: snapshot.stock_location_id,
+            line_item_id: line.order_line_item_id,
+            quantity: line.confirmed_sale_quantity,
+        }));
+        const fulfillmentItems = lines
+            .filter((line) => line.confirmed_sale_quantity > 0)
+            .map((line) => ({
+            line_item_id: line.order_line_item_id,
+            quantity: line.confirmed_sale_quantity,
+        }));
+        const result = {
+            report,
+            order_id: orderId,
+            fulfillment_id: fulfillmentId,
+            order: {
+                id: orderId,
+                is_draft_order: false,
+                metadata: {
+                    consignment: true,
+                    consignment_report_id: input.report_id,
+                },
+            },
+            reservations,
+            fulfillment: {
+                id: fulfillmentId,
+                location_id: snapshot.stock_location_id,
+                items: fulfillmentItems,
+            },
+            batch_inventory: batches.map((batch) => ({
+                id: batch.id,
+                quantity: batch.quantity,
+            })),
+            native_stocked_quantity: snapshot.native_stocked_quantity - withdrawnQuantity,
+            withdrawn_quantity: withdrawnQuantity,
+        };
+        this.approvalSnapshotRuns.set(input.report_id, result);
+        return result;
+    }
+    correctConsignmentReportSnapshot(input) {
+        const key = `${input.report_id}:${input.correction_id}`;
+        const existing = this.correctionSnapshotRuns.get(key);
+        if (existing) {
+            return existing;
+        }
+        const snapshot = input.approved_report_snapshot;
+        if (!snapshot || snapshot.status !== "approved") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Nur freigegebene Monatsmeldungen können korrigiert werden.");
+        }
+        const originalById = new Map(snapshot.lines.map((line) => [line.id, line]));
+        const changes = input.corrected_lines.map((correction) => {
+            const original = originalById.get(correction.report_line_id);
+            if (!original) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Korrektur enthält eine unbekannte Meldeposition.");
+            }
+            return {
+                original,
+                corrected: correction.confirmed_sale_quantity,
+                delta: correction.confirmed_sale_quantity - original.confirmed_sale_quantity,
+            };
+        });
+        const quantityDelta = changes.reduce((sum, change) => sum + change.delta, 0);
+        if (quantityDelta === 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Korrektur verändert keine bestätigte Verkaufsmenge.");
+        }
+        const first = changes[0];
+        if (!first) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Korrektur benötigt mindestens eine Position.");
+        }
+        const result = {
+            correction_id: input.correction_id,
+            quantity_delta: quantityDelta,
+            report_line: {
+                id: first.original.id,
+                confirmed_sale_quantity: first.corrected,
+            },
+            order_edit_id: `ordedit_${input.correction_id}`,
+            credit_line_id: quantityDelta < 0 ? `ordcl_${input.correction_id}` : null,
+            fulfillment_id: quantityDelta > 0 ? `ful_${input.correction_id}` : null,
+            native_stocked_quantity: snapshot.native_stocked_quantity - Math.max(0, quantityDelta),
+            reservation_released_quantity: 0,
+            batch_reversed_quantity: 0,
+            native_restocked_quantity: 0,
+            cancellation_created: false,
+            return_created: false,
+            batch_inventory: snapshot.batches.map((batch) => ({ ...batch })),
+        };
+        this.correctionSnapshotRuns.set(key, result);
+        return result;
+    }
+    parseReservationSnapshots(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        const reservations = [];
+        for (const candidate of value) {
+            if (typeof candidate !== "object" ||
+                candidate === null ||
+                Array.isArray(candidate)) {
+                continue;
+            }
+            const record = candidate;
+            if (typeof record.id !== "string" ||
+                typeof record.inventory_item_id !== "string" ||
+                typeof record.location_id !== "string" ||
+                !(typeof record.line_item_id === "string" ||
+                    record.line_item_id === null) ||
+                typeof record.quantity !== "number") {
+                continue;
+            }
+            reservations.push({
+                id: record.id,
+                inventory_item_id: record.inventory_item_id,
+                location_id: record.location_id,
+                line_item_id: record.line_item_id,
+                quantity: record.quantity,
+            });
+        }
+        return reservations;
+    }
+    parseStoredConsignmentCorrections(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        const corrections = [];
+        for (const candidate of value) {
+            if (typeof candidate !== "object" ||
+                candidate === null ||
+                Array.isArray(candidate)) {
+                continue;
+            }
+            const record = candidate;
+            if (typeof record.correction_id !== "string" ||
+                (record.status !== "pending" && record.status !== "completed") ||
+                typeof record.admin_id !== "string" ||
+                typeof record.reason !== "string" ||
+                !Array.isArray(record.lines)) {
+                continue;
+            }
+            const lines = [];
+            for (const lineCandidate of record.lines) {
+                if (typeof lineCandidate !== "object" ||
+                    lineCandidate === null ||
+                    Array.isArray(lineCandidate)) {
+                    continue;
+                }
+                const line = lineCandidate;
+                if (typeof line.report_line_id !== "string" ||
+                    typeof line.order_line_item_id !== "string" ||
+                    typeof line.inventory_item_id !== "string" ||
+                    typeof line.previous_confirmed_sale_quantity !== "number" ||
+                    typeof line.corrected_confirmed_sale_quantity !== "number" ||
+                    typeof line.quantity_delta !== "number") {
+                    continue;
+                }
+                lines.push({
+                    report_line_id: line.report_line_id,
+                    order_line_item_id: line.order_line_item_id,
+                    inventory_item_id: line.inventory_item_id,
+                    previous_confirmed_sale_quantity: line.previous_confirmed_sale_quantity,
+                    corrected_confirmed_sale_quantity: line.corrected_confirmed_sale_quantity,
+                    quantity_delta: line.quantity_delta,
+                });
+            }
+            if (lines.length !== record.lines.length) {
+                continue;
+            }
+            const nullableString = (field) => typeof field === "string" || field === null;
+            if (!nullableString(record.order_edit_id) ||
+                !nullableString(record.credit_line_id) ||
+                !nullableString(record.fulfillment_id)) {
+                continue;
+            }
+            corrections.push({
+                correction_id: record.correction_id,
+                status: record.status,
+                admin_id: record.admin_id,
+                reason: record.reason,
+                lines,
+                order_edit_id: record.order_edit_id,
+                edit_updated: record.edit_updated === true,
+                edit_requested: record.edit_requested === true,
+                edit_confirmed: record.edit_confirmed === true,
+                reservation_ids: Array.isArray(record.reservation_ids)
+                    ? record.reservation_ids.filter((id) => typeof id === "string")
+                    : [],
+                batch_withdrawal_completed: record.batch_withdrawal_completed === true,
+                credit_line_id: record.credit_line_id,
+                fulfillment_id: record.fulfillment_id,
+            });
+        }
+        return corrections;
+    }
+    toConsignmentCorrectionResult(correction) {
+        const first = correction.lines[0];
+        if (!first || !correction.order_edit_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Der abgeschlossene Korrekturbeleg ist unvollständig.");
+        }
+        return {
+            correction_id: correction.correction_id,
+            quantity_delta: correction.lines.reduce((sum, line) => sum + line.quantity_delta, 0),
+            report_line: {
+                id: first.report_line_id,
+                confirmed_sale_quantity: first.corrected_confirmed_sale_quantity,
+            },
+            order_edit_id: correction.order_edit_id,
+            credit_line_id: correction.credit_line_id,
+            fulfillment_id: correction.fulfillment_id,
+            reservation_released_quantity: 0,
+            batch_reversed_quantity: 0,
+            native_restocked_quantity: 0,
+            cancellation_created: false,
+            return_created: false,
+        };
+    }
+    parseConsignmentPeriod(period) {
+        if (!/^\d{4}-\d{2}-01$/.test(period)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Der Meldezeitraum muss der erste Tag eines Kalendermonats sein.");
+        }
+        const periodStart = new Date(`${period}T00:00:00.000Z`);
+        if (Number.isNaN(periodStart.getTime()) ||
+            periodStart.toISOString().slice(0, 10) !== period) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Der Meldezeitraum ist ungültig.");
+        }
+        const periodEnd = new Date(Date.UTC(periodStart.getUTCFullYear(), periodStart.getUTCMonth() + 1, 0, 23, 59, 59, 999));
+        return { periodStart, periodEnd };
+    }
+    toPeriodKey(value) {
+        return (value instanceof Date ? value : new Date(value))
+            .toISOString()
+            .slice(0, 10);
+    }
+    buildConsignmentReportLines(expected, counted) {
+        if (!expected.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Monatsmeldung benötigt mindestens eine Bestandsposition.");
+        }
+        const expectedByKey = new Map();
+        for (const line of expected) {
+            const key = this.consignmentLineKey(line.inventory_item_id, line.batch_id);
+            if (expectedByKey.has(key) ||
+                !line.inventory_item_id.trim() ||
+                !Number.isSafeInteger(line.expected_quantity) ||
+                line.expected_quantity < 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Der erwartete Bestand enthält ungültige oder doppelte Positionen.");
+            }
+            expectedByKey.set(key, line);
+        }
+        const countedByKey = new Map();
+        for (const line of counted) {
+            const key = this.consignmentLineKey(line.inventory_item_id, line.batch_id);
+            if (countedByKey.has(key) ||
+                !Number.isSafeInteger(line.counted_quantity) ||
+                line.counted_quantity < 0 ||
+                !expectedByKey.has(key)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Zählung enthält ungültige, unbekannte oder doppelte Positionen.");
+            }
+            countedByKey.set(key, line.counted_quantity);
+        }
+        if (countedByKey.size !== expectedByKey.size) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Für jede erwartete Bestandsposition muss genau eine Zählung vorliegen.");
+        }
+        return expected.map((line) => {
+            const countedQuantity = countedByKey.get(this.consignmentLineKey(line.inventory_item_id, line.batch_id));
+            if (countedQuantity === undefined) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Eine erwartete Bestandsposition wurde nicht gezählt.");
+            }
+            const proposedSaleQuantity = Math.max(0, line.expected_quantity - countedQuantity);
+            const requiresClarification = countedQuantity > line.expected_quantity;
+            return {
+                ...line,
+                counted_quantity: countedQuantity,
+                proposed_sale_quantity: proposedSaleQuantity,
+                requires_admin_clarification: requiresClarification,
+                non_sale_reason: requiresClarification
+                    ? "requires_admin_clarification"
+                    : null,
+                resolved_unit_price: line.webshop_unit_price ?? null,
+            };
+        });
+    }
+    consignmentLineKey(inventoryItemId, batchId) {
+        return `${inventoryItemId}:${batchId ?? ""}`;
+    }
+    asJsonObject(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    async toConsignmentReportDTO(report, context) {
+        const rows = await this.listConsignmentReportLines({ consignment_report_id: report.id }, { order: { created_at: "ASC" } }, context);
+        const lines = rows.map((line) => {
+            const metadata = this.asJsonObject(line.metadata);
+            const proposed = typeof metadata.proposed_sale_quantity === "number"
+                ? metadata.proposed_sale_quantity
+                : line.confirmed_sale_quantity;
+            return {
+                ...line,
+                batch_id: line.batch_id ?? null,
+                proposed_sale_quantity: proposed,
+                non_sale_reason: line.non_sale_reason ?? null,
+                resolved_unit_price: typeof metadata.resolved_unit_price === "number"
+                    ? metadata.resolved_unit_price
+                    : (line.unit_price_snapshot ?? null),
+                discounted_line_total: typeof metadata.discounted_line_total === "number"
+                    ? metadata.discounted_line_total
+                    : null,
+                draft_order_id: typeof metadata.draft_order_id === "string"
+                    ? metadata.draft_order_id
+                    : (report.draft_order_id ?? null),
+            };
+        });
+        const periodStart = new Date(report.period_start);
+        const derivedPeriodEnd = new Date(Date.UTC(periodStart.getUTCFullYear(), periodStart.getUTCMonth() + 1, 0, 23, 59, 59, 999));
+        return {
+            ...report,
+            period_end: report.period_end ?? derivedPeriodEnd,
+            status: report.status,
+            lines,
+        };
+    }
+}
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(0, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "retrieveProgramSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "updateProgramSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "approveAffiliateApplication", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createAffiliateRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "updateAffiliateRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "setAffiliateInactive", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "invalidateOpenAttributionStateForAffiliate", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "deactivateAffiliateState", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "ensureDefaultAffiliateCoupon", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createAffiliateCouponRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createAffiliateCouponRotation", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "revokeAffiliateCouponRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "setAffiliateCouponProvisioningState", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "finalizeAffiliateCouponRotation", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createAffiliateSlugRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "updateAffiliateSlugRecord", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "captureReferralLink", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "bindReferralSessionToCart", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "getActiveCartReferral", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "getCartReferralStatus", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "applyAffiliateCouponReferral", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "invalidateAffiliateCouponReferrals", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "removeAffiliateCouponFromCartReferrals", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "invalidateOpenAttributionStateForCoupon", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "invalidateAffiliateCartReferrals", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "compensateAffiliateCouponReferralMutation", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "assignCustomerAffiliate", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "expireAffiliateAttributionState", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "completeExpiredCartReferralPromotionCleanup", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "finalizeOrderAttribution", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "compensateOrderAttribution", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "removeCustomerAffiliateAssignment", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "setCustomerAffiliateAssignment", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "saveAffiliateDistributionSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "compensateAffiliateDistributionSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "prepareConsignmentTransfer", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "completeConsignmentTransfer", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "prepareConsignmentReport", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "attachConsignmentDraftOrder", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "prepareConsignmentApproval", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "completeConsignmentApproval", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "prepareConsignmentCorrection", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "recordConsignmentCorrectionProgress", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "completeConsignmentCorrection", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "rejectConsignmentReport", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createCommissionForOrder", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createCommissionCorrection", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "updatePartnerPortalProfile", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "createPartnerPortalSlug", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AffiliateModuleService.prototype, "updatePartnerPortalSlug", null);
+exports.default = AffiliateModuleService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/affiliate/service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qDAKkC;AAClC,mDAAqE;AAuBrE,iEAIuC;AACvC,mEAA0C;AAC1C,iFAAuD;AACvD,mGAAwE;AACxE,+GAAoF;AACpF,qGAA0E;AAC1E,2FAAiE;AACjE,+FAAoE;AACpE,uGAA4E;AAC5E,qGAA0E;AAC1E,6EAAmD;AACnD,iFAAuD;AACvD,qFAA2D;AAC3D,+FAAoE;AACpE,yFAA+D;AAC/D,mGAAwE;AACxE,2GAAgF;AAChF,4FAAsF;AACtF,sFAAgF;AAChF,kFAA4E;AAC5E,kGAA2F;AAC3F,8EAAwE;AACxE,oEAA+D;AAC/D,kFAA4E;AAC5E,oFAA8E;AAC9E,4GAAqG;AACrG,sFAAgF;AAChF,oFAA8E;AAC9E,sEAAsE;AACtE,oFAG4C;AAC5C,4DAIgC;AA+GhC,IAAI,4BAAyD,CAAA;AAE7D,MAAM,sBAAuB,SAAQ,IAAA,qBAAa,EAAC;IACjD,SAAS,EAAT,mBAAS;IACT,eAAe,EAAf,0BAAe;IACf,oBAAoB,EAApB,+BAAoB;IACpB,aAAa,EAAb,wBAAa;IACb,2BAA2B,EAA3B,uCAA2B;IAC3B,eAAe,EAAf,0BAAe;IACf,wBAAwB,EAAxB,oCAAwB;IACxB,uBAAuB,EAAvB,mCAAuB;IACvB,wBAAwB,EAAxB,oCAAwB;IACxB,qBAAqB,EAArB,iCAAqB;IACrB,yBAAyB,EAAzB,qCAAyB;IACzB,6BAA6B,EAA7B,yCAA6B;IAC7B,mBAAmB,EAAnB,8BAAmB;IACnB,uBAAuB,EAAvB,mCAAuB;IACvB,iBAAiB,EAAjB,4BAAiB;IACjB,qBAAqB,EAArB,iCAAqB;CACtB,CAAC;IA4BA,YAAY,SAA0B,EAAE,OAAgC;QACtE,KAAK,CAAC,SAAS,CAAC,CAAA;QAVD,yBAAoB,GAAG,IAAI,GAAG,EAG5C,CAAA;QACc,2BAAsB,GAAG,IAAI,GAAG,EAG9C,CAAA;QAKD,IAAI,CAAC,cAAc,GAAG,IAAA,8CAA6B,EAAC,OAAO,CAAC,CAAA;QAC5D,IAAI,CAAC,WAAW,GAAG,IAAuC,CAAA;QAC1D,IAAI,CAAC,WAAW,GAAG,IAAI,6CAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,iDAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,oCAAgB,CAC1C,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,WAAW,CACjB,CAAA;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,2DAA2B,CACvD,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,WAAW,CACjB,CAAA;QACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,0EAAkC,CAC7D,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,WAAW,CACjB,CAAA;QACD,IAAI,CAAC,wBAAwB,GAAG,IAAI,qDAAwB,CAC1D,IAAI,CAAC,WAAW,EAChB,IAAI,EACJ,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,iBAAiB,CACvB,CAAA;QACD,IAAI,CAAC,uBAAuB,GAAG,IAAI,mDAAuB,CACxD,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,iBAAiB,CACvB,CAAA;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,mDAAuB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAClE,IAAI,CAAC,aAAa,GAAG,IAAI,iDAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QACjE,IAAI,CAAC,eAAe,GAAG,IAAI,qDAAwB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QACrE,IAAI,CAAC,oBAAoB,GAAG,IAAI,gEAA6B,CAC3D,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,aAAa,CACnB,CAAA;IACH,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,OAAO,IAAI,CAAC,cAAc,CAAA;IAC5B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,OAAiB;QAC3B,MAAM,OAAO,GAAG,OAAO,EAAE,kBAEZ,CAAA;QAEb,IAAI,OAAO,EAAE,KAAK,EAAE,CAAC;YACnB,MAAM,OAAO,CAAC,KAAK,EAAE,CAAA;QACvB,CAAC;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,uBAAuB,CAE3B,gBAAsD,EAAE;QAExD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,4BAA4B,CAClE,EAAE,KAAK,EAAE,QAAQ,EAAE,EACnB,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;QAE3B,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,OAAO,CAAA;QAChB,CAAC;QAED,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,oFAAoF,CACrF,CAAA;QACH,CAAC;QAED,kEAAkE;QAClE,mEAAmE;QACnE,wEAAwE;QACxE,2EAA2E;QAC3E,MAAM,OAAO,CAAC,OAAO,CACnB;;;;;;;;;;8BAUwB,EACxB,EAAE,EACF,KAAK,CACN,CAAA;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,4BAA4B,CAClE,EAAE,KAAK,EAAE,QAAQ,EAAE,EACnB,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QAED,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,kFAAkF,CACnF,CAAA;QACH,CAAC;QAED,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAA;IACpB,CAAC;IAGK,AAAN,KAAK,CAAC,qBAAqB,CACzB,KAA0C,EAE1C,gBAAsD,EAAE;QAExD,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAA;QAExC,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAEhD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,mFAAmF,CACpF,CAAA;QACH,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAChC;;;;;;;;;;;;;;8DAcwD,EACxD;YACE,KAAK,CAAC,eAAe;YACrB,KAAK,CAAC,aAAa;YACnB,KAAK,CAAC,kBAAkB;YACxB,KAAK,CAAC,8BAA8B;YACpC,KAAK,CAAC,yBAAyB;YAC/B,KAAK,CAAC,oBAAoB;YAC1B,KAAK,CAAC,gBAAgB,GAAG,CAAC;YAC1B,KAAK,CAAC,gBAAgB;SACvB,EACD,KAAK,CACN,CAAA;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QAEvB,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,uEAAuE,CACxE,CAAA;QACH,CAAC;QAED,OAAO;YACL,EAAE,EAAE,OAAO,CAAC,EAAE;YACd,KAAK,EAAE,QAAQ;YACf,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,8BAA8B,EAAE,MAAM,CACpC,OAAO,CAAC,8BAA8B,CACvC;YACD,yBAAyB,EAAE,OAAO,CAAC,yBAAyB;YAC5D,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC;YAC1D,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC;YAC9C,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;SAC/B,CAAA;IACH,CAAC;IAED,KAAK,CAAC,0BAA0B,CAC9B,KAAsC;QAEtC,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAA;IAC/D,CAAC;IAED,KAAK,CAAC,kCAAkC,CAAC,KAIxC;QACC,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAA;IAC9D,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KAAuC,EACtB,gBAAsD,EAAE;QAKzE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,4BAA4B,CACrE,KAAK,CAAC,cAAc,EACpB,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,EACxD,EAAE,EACF,aAAa,CACd,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAC7D,KAAK,EACL,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,kCAAkC,CAC3C,MAAM,CAAC,SAAS,EAChB,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC,IAAI,IAAI,EACxD,aAAa,CACd,CAAA;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED,KAAK,CAAC,0BAA0B,CAC9B,KAAsC;QAEtC,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAA;IAC/D,CAAC;IAGK,AAAN,KAAK,CAAC,qBAAqB,CACzB,KAA2B,EACV,gBAAsD,EAAE;QAEzE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,EAC5C,EAAE,EACF,aAAa,CACd,CAAA;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAC3D,KAAK,EACL,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,kCAAkC,CAC3C,SAAS,EACT,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC,IAAI,IAAI,EACjD,aAAa,CACd,CAAA;QAED,OAAO,SAAS,CAAA;IAClB,CAAC;IAGK,AAAN,KAAK,CAAC,qBAAqB,CACzB,KAA2B,EACV,gBAAsD,EAAE;QAEzE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CACpE,KAAK,CAAC,EAAE,EACR,aAAa,CACd,CAAA;QACD,MAAM,gBAAgB,GACpB,KAAK,CAAC,WAAW,KAAK,SAAS;YAC7B,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC;YAC/B,CAAC,CAAC,KAAK,CAAC,WAAW,CAAA;QACvB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,CAAC,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAClE,OAAO,CAAC,EAAE,CAAC,CACZ,EACD,CAAC,KAAK,CAAC,EAAE,CAAC,EACV,aAAa,CACd,CAAA;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,eAAe,CACzD,KAAK,EACL,aAAa,CACd,CAAA;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,CAAC,0CAA0C,CACnD,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,EAAE,EAC5B,aAAa,CACd,CAAA;QACH,CAAC;QAED,MAAM,IAAI,CAAC,kCAAkC,CAC3C,OAAO,EACP,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,IAAI,EAAE,CAAC,IAAI,IAAI,EAC/C,aAAa,CACd,CAAA;QAED,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CAC3D,OAAO,CAAC,EAAE,EACV,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,oBAAoB,CACxB,WAAmB,EACF,gBAAsD,EAAE;QAEzE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CACpE,WAAW,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,EAChD,CAAC,WAAW,CAAC,EACb,aAAa,CACd,CAAA;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,WAAW,CACvD,WAAW,EACX,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,0CAA0C,CACnD,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,EAAE,EAC9B,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,kCAAkC,CAC3C,SAAS,EACT,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC,IAAI,IAAI,EACjD,aAAa,CACd,CAAA;QAED,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CAC3D,SAAS,CAAC,EAAE,EACZ,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,0CAA0C,CAC9C,KAAsD,EACrC,gBAAsD,EAAE;QAEzE,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,YAAY,EAAE,aAAa,CAAC,CAAA;QAChE,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAA;QACnC,MAAM,IAAI,CAAC,iBAAiB,CAAC,6BAA6B,CACxD,KAAK,CAAC,YAAY,EAClB,oBAAoB,EACpB,aAAa,EACb,GAAG,CACJ,CAAA;QACD,MAAM,iBAAiB,GACrB,MAAM,IAAI,CAAC,wBAAwB,CAAC,+BAA+B,CACjE,KAAK,CAAC,YAAY,EAClB,GAAG,EACH,aAAa,CACd,CAAA;QACH,OAAO;YACL,aAAa,EAAE;gBACb,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;aAC5D,CAAC,IAAI,EAAE;YACR,mBAAmB,EAAE,iBAAiB;SACvC,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,wBAAwB,CAC5B,KAEC,EACgB,gBAAsD,EAAE;QASzE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CACpE,KAAK,CAAC,YAAY,EAClB,aAAa,CACd,CAAA;QACD,MAAM,gBAAgB,GACpB,KAAK,CAAC,MAAM,EAAE,WAAW,KAAK,SAAS;YACrC,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC;YAC/B,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAA;QAC9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,CAAC,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAClE,OAAO,CAAC,EAAE,CAAC,CACZ,EACD,CAAC,KAAK,CAAC,YAAY,CAAC,EACpB,aAAa,CACd,CAAA;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAC3D,EAAE,EAAE,EAAE,KAAK,CAAC,YAAY,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,EAC/D,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC/B,MAAM,IAAI,CAAC,kCAAkC,CAC3C,SAAS,EACT,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC,IAAI,IAAI,EACjD,aAAa,CACd,CAAA;QACD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,0CAA0C,CACvE,KAAK,EACL,aAAa,CACd,CAAA;QACD,OAAO;YACL,SAAS;YACT,aAAa,EAAE,WAAW,CAAC,aAAa;YACxC,mBAAmB,EAAE,WAAW,CAAC,mBAAmB;SACrD,CAAA;IACH,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,KAM1B;QACC,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;IAC1D,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,EAAU;QACtC,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAA;IACnE,CAAC;IAED,KAAK,CAAC,gCAAgC,CAAC,IAAY;QAIjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAA;QACrE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAA;QACb,CAAC;QACD,OAAO;YACL,MAAM;YACN,SAAS,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,YAAY,CAAC;SACzE,CAAA;IACH,CAAC;IAED,KAAK,CAAC,yBAAyB,CAC7B,IAAY;QAEZ,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;IACxD,CAAC;IAED,KAAK,CAAC,6BAA6B,CACjC,QAAgB,EAChB,WAAoB;QAEpB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;IACvE,CAAC;IAED,KAAK,CAAC,gCAAgC,CACpC,WAAmB;QAEnB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAA;IACtE,CAAC;IAED,KAAK,CAAC,2CAA2C,CAC/C,cAAsB,EACtB,WAAoB;QAEpB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,kCAAkC,CAChE,cAAc,EACd,WAAW,CACZ,CAAA;IACH,CAAC;IAED,KAAK,CAAC,yCAAyC,CAC7C,YAAsB;QAEtB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,gCAAgC,CAC9D,YAAY,CACb,CAAA;IACH,CAAC;IAED,KAAK,CAAC,mCAAmC,CAAC,KAMzC;QACC,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;IACpD,CAAC;IAGK,AAAN,KAAK,CAAC,4BAA4B,CAChC,KAAwC,EAExC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAC3E,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KAAiC,EAEjC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACpE,CAAC;IAGK,AAAN,KAAK,CAAC,6BAA6B,CACjC,KAAiC,EAEjC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACtE,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KAAiC,EAEjC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACpE,CAAC;IAGK,AAAN,KAAK,CAAC,mCAAmC,CACvC,KAA+C,EAE/C,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAC5E,CAAC;IAGK,AAAN,KAAK,CAAC,+BAA+B,CACnC,KAA2C,EAE3C,gBAAsD,EAAE;QAKxD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACxE,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,UAAkB;QAElB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CACtD,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,EAC7C,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAAA;QACD,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IAC9B,CAAC;IAED,KAAK,CAAC,4BAA4B,CAChC,YAAsB;QAEtB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;YACzB,OAAO,EAAE,CAAA;QACX,CAAC;QAED,MAAM,CAAC,yBAAyB,EAAE,sBAAsB,CAAC,GACvD,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,IAAI,CAAC,aAAa;iBACf,gCAAgC,CAAC,YAAY,CAAC;iBAC9C,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAChB,OAAO,CAAC,MAAM;gBACZ,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC;oBAC9B,EAAE,EAAE;wBACF,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC;qBAC5D;iBACF,CAAC;gBACJ,CAAC,CAAC,EAAE,CACP;YACH,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC;gBAC9B,sBAAsB,EAAE,YAAY;aACrC,CAAC;SACH,CAAC,CAAA;QACJ,MAAM,IAAI,GAAG,IAAI,GAAG,CAClB,CAAC,GAAG,yBAAyB,EAAE,GAAG,sBAAsB,CAAC,CAAC,GAAG,CAC3D,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,CACzC,CACF,CAAA;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAA;IAC3B,CAAC;IAED,KAAK,CAAC,0BAA0B,CAAC,KAGhC;QACC,MAAM,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC;YACtC,EAAE,EAAE,KAAK,CAAC,YAAY;YACtB,GAAG,CAAC,KAAK,CAAC,sBAAsB,KAAK,SAAS;gBAC5C,CAAC,CAAC,EAAE,sBAAsB,EAAE,KAAK,CAAC,sBAAsB,EAAE;gBAC1D,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAA;QAEF,OAAO,MAAM,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;IAC/D,CAAC;IAGK,AAAN,KAAK,CAAC,yBAAyB,CAC7B,KAA+B,EACd,gBAAyB,EAAE;QAE5C,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAChE,CAAC;IAGK,AAAN,KAAK,CAAC,yBAAyB,CAC7B,KAA+B,EACd,gBAAyB,EAAE;QAE5C,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAChE,CAAC;IAED,KAAK,CAAC,wBAAwB,CAC5B,WAAmB;QAEnB,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IACtD,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,SAAiB;QACzC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA;QAEhE,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO;gBACL,KAAK,EAAE,KAAK;gBACZ,SAAS,EAAE,IAAI;gBACf,IAAI,EAAE,IAAI;aACX,CAAA;QACH,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CACxD,IAAI,CAAC,YAAY,CAClB,CAAA;QAED,IAAI,SAAS,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO;gBACL,KAAK,EAAE,KAAK;gBACZ,SAAS,EAAE,IAAI;gBACf,IAAI,EAAE,IAAI;aACX,CAAA;QACH,CAAC;QAED,OAAO;YACL,KAAK,EAAE,IAAI;YACX,SAAS;YACT,IAAI;SACL,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,mBAAmB,CACvB,KAA+B,EAC/B,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC,mBAAmB,CACzE,KAAK,EACL,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,yBAAyB,CAC7B,KAAqC,EACrC,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,yBAAyB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACnD,CAAC;IAGK,AAAN,KAAK,CAAC,qBAAqB,CACzB,MAAc,EACd,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,IAAI,EAAE,EAAE,aAAa,CAAC,CAAA;IAC5D,CAAC;IAGK,AAAN,KAAK,CAAC,qBAAqB,CACzB,MAAc,EACd,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,qBAAqB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAChD,CAAC;IAED,KAAK,CAAC,uCAAuC,CAC3C,KAIC,EACD,KAAyC;QAEzC,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAA;IACzC,CAAC;IAED,KAAK,CAAC,4BAA4B,CAAC,KAGlC;QACC,OAAO,MAAM,IAAI,CAAC,wBAAwB,CAAC,2BAA2B,CACpE,KAAK,CACN,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,4BAA4B,CAChC,KAAwC,EACxC,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,4BAA4B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACtD,CAAC;IAGK,AAAN,KAAK,CAAC,kCAAkC,CACtC,KAA0C,EAC1C,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,yBAAyB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACzE,CAAC;IAGK,AAAN,KAAK,CAAC,sCAAsC,CAC1C,KAIC,EAED,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,wBAAwB,CAAC,6BAA6B,CACtE,KAAK,CAAC,OAAO,EACb,KAAK,CAAC,mBAAmB,EACzB,KAAK,CAAC,MAAM,EACZ,aAAa,CACd,CAAA;IACH,CAAC;IAED,KAAK,CAAC,iCAAiC,CACrC,iBAAyB;QAEzB,OAAO,MAAM,IAAI,CAAC,wBAAwB,CAAC,wBAAwB,CACjE,iBAAiB,CAClB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,uCAAuC,CAC3C,KAAmD,EAEnD,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,wBAAwB,CAAC,4BAA4B,CACrE,KAAK,CAAC,mBAAmB,EACzB,KAAK,CAAC,MAAM,EACZ,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,gCAAgC,CACpC,KAA0C,EAC1C,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,2BAA2B,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3E,CAAC;IAGK,AAAN,KAAK,CAAC,yCAAyC,CAC7C,YAAiD,EACjD,KAAyC,EAEzC,gBAAsD,EAAE;QAExD,OAAO,MAAM,IAAI,CAAC,8BAA8B,CAC9C,KAAK,CACN,CAAC,gCAAgC,CAAC,YAAY,EAAE,aAAa,CAAC,CAAA;IACjE,CAAC;IAEO,8BAA8B,CACpC,KAAyC;QAEzC,OAAO,IAAI,qDAAwB,CACjC,IAAI,CAAC,WAAW,EAChB,KAAK,EACL,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,iBAAiB,CACvB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,uBAAuB,CAC3B,KAAmC,EAEnC,gBAAsD,EAAE;QAExD,MAAM,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;QACtD,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,YAAY,EAAE,aAAa,CAAC,CAAA;QAChE,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAC1E,CAAC;IAED,KAAK,CAAC,8BAA8B,CAClC,UAAkB;QAElB,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAA;IACrE,CAAC;IAED,KAAK,CAAC,6BAA6B,CACjC,KAA6B;QAE7B,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAA;IAC1E,CAAC;IAED,KAAK,CAAC,sCAAsC,CAC1C,UAAkB;QAElB,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAA;IACvE,CAAC;IAED,KAAK,CAAC,mBAAmB,CACvB,OAAe;QAIf,MAAM,CAAC,WAAW,CAAC,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,8BAA8B,CACzE,EAAE,QAAQ,EAAE,OAAO,EAAE,EACrB,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAAA;QACD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,CAAA;QACb,CAAC;QACD,OAAO;YACL,GAAG,WAAW;YACd,SAAS,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CACjD,WAAW,CAAC,YAAY,CACzB;SACF,CAAA;IACH,CAAC;IAED,KAAK,CAAC,kCAAkC,CACtC,QAAiD,EAAE;QAEnD,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAA;IACnE,CAAC;IAGK,AAAN,KAAK,CAAC,+BAA+B,CACnC,QAA8C,EAAE,EAC/B,gBAAsD,EAAE;QAEzE,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAA;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;QAC5D,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,0BAA0B,CACzE,GAAG,EACH,KAAK,EACL,aAAa,CACd,CAAA;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,oBAAoB,CACxE,GAAG,EACH,KAAK,EACL,aAAa,CACd,CAAA;QACD,OAAO;YACL,SAAS,EAAE,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS;YACtD,QAAQ,EAAE,WAAW,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ;YACpD,sBAAsB,EAAE,SAAS,CAAC,sBAAsB;SACzD,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,2CAA2C,CAC/C,KAKC,EACgB,gBAAsD,EAAE;QAEzE,MAAM,IAAI,CAAC,wBAAwB,CAAC,2CAA2C,CAC7E,KAAK,CAAC,SAAS,EACf,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,wBAAwB,CAC5B,KAA6C,EAE7C,gBAAsD,EAAE;QAExD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,wBAAwB,CACxE,KAAK,EACL,aAAa,CACd,CAAA;QACD,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;YAC5B,OAAO,MAAM,CAAA;QACf,CAAC;QAED,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;QAC7D,MAAM,SAAS,GAAG;YAChB,kBAAkB;YAClB,0BAA0B;YAC1B,oCAAoC;SAC5B,CAAA;QACV,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,qBAAqB,CACzD,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,EAClD,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EACxB,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAC5C,EAAE,KAAK,EAAE,KAAK,CAAC,gBAAgB,EAAE,EACjC,aAAa,EACb,MAAM,CAAC,WAAW,IAAI,SAAS,CAChC,CAAA;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,qBAAqB,CACxD,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,EAClD,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EACxB,aAAa,CACd,CAAA;QACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;QACvD,MAAM,UAAU,GAAG,KAAK;aACrB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;aACnB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;QAEvC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACvB,OAAO,MAAM,CAAA;QACf,CAAC;QAED,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,IAAI;YAC1C,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,cAAc,EAAE,IAAI;YACpB,aAAa,EAAE,IAAI;YACnB,qBAAqB,EAAE,IAAI;YAC3B,mBAAmB,EAAE,IAAI;YACzB,oBAAoB,EAAE,EAAE;YACxB,kBAAkB,EAAE,IAAI;YACxB,mBAAmB,EAAE,EAAE;YACvB,gBAAgB,EAAE,IAAI;YACtB,kBAAkB,EAAE,EAAE;YACtB,iBAAiB,EAAE,EAAE;YACrB,aAAa,EAAE,EAAE;SAClB,CAAA;QACD,YAAY,CAAC,4BAA4B,GAAG,UAAU,CAAA;QACtD,OAAO,EAAE,GAAG,MAAM,EAAE,YAAY,EAAE,CAAA;IACpC,CAAC;IAGK,AAAN,KAAK,CAAC,0BAA0B,CAC9B,YAAmD,EAEnD,gBAAsD,EAAE;QAExD,MAAM,IAAI,CAAC,uBAAuB,CAAC,0BAA0B,CAC3D,YAAY,EACZ,aAAa,CACd,CAAA;QACD,MAAM,UAAU,GAAG,YAAY,CAAC,4BAA4B,IAAI,EAAE,CAAA;QAClE,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,OAAM;QAE9B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAC5C,YAAY,CAAC,QAAQ,EACrB,aAAa,CACd,CAAA;QACD,4EAA4E;QAC5E,wEAAwE;QACxE,kCAAkC;QAClC,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC;YAC5B,MAAM,OAAO,CAAC,OAAO,CACnB;;;;;;aAMK,EACL,CAAC,EAAE,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC3B,KAAK,CACN,CAAA;QACH,CAAC;QACD,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC;YAC5B,MAAM,OAAO,CAAC,OAAO,CACnB;;;;;aAKK,EACL,CAAC,EAAE,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC3B,KAAK,CACN,CAAA;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,UAAkB;QAC1C,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAA;IACrE,CAAC;IAGK,AAAN,KAAK,CAAC,iCAAiC,CACrC,KAAkE,EAElE,gBAAsD,EAAE;QAExD,MAAM,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;QAC3E,MAAM,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;QACzD,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CACxD;YACE,GAAG,QAAQ;YACX,YAAY,EAAE,eAAe;SAC9B,EACD,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,8BAA8B,CAClC,KAKC,EAED,gBAAsD,EAAE;QAExD,MAAM,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;QACtD,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,YAAY,EAAE,aAAa,CAAC,CAAA;QAChE,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAChD;YACE,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,OAAO;SAChC,EACD,aAAa,CACd,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,QAAgC,EAChC,OAA6C;QAE7C,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAA;IACzD,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,UAAoC,EACpC,OAA6C;QAE7C,MAAM,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAA;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,oEAAoE,CACrE,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU;aACxB,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC;YACrB,QAAQ,CAAC,WAAW;gBAClB,CAAC,CAAC,sBAAsB,QAAQ,CAAC,WAAW,EAAE;gBAC9C,CAAC,CAAC,IAAI;YACR,QAAQ,CAAC,gBAAgB;gBACvB,CAAC,CAAC,mBAAmB,QAAQ,CAAC,gBAAgB,EAAE;gBAChD,CAAC,CAAC,IAAI;SACT,CAAC;aACD,MAAM,CAAC,CAAC,GAAG,EAAiB,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC;aAC5C,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC;aACzD,IAAI,EAAE,CAAA;QACT,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,OAAO,CAAC,EACT,KAAK,CACN,CAAA;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,iCAAiC,CAC7C,WAAqB,EACrB,YAAsB,EACtB,OAA6C;QAE7C,MAAM,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAA;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,kEAAkE,CACnE,CAAA;QACH,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkC,CAAA;QAC5D,KAAK,MAAM,UAAU,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC1D,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAChC;yDACiD,EACjD,CAAC,UAAU,CAAC,EACZ,KAAK,CACN,CAAA;YACD,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE;gBACzB,WAAW,EAAE,UAAU;gBACvB,gBAAgB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK;oBAC9B,CAAC,CAAC,IAAA,6CAAuB,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACxC,CAAC,CAAC,IAAI;aACT,CAAC,CAAA;QACJ,CAAC;QACD,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,CAAA;QAErE,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAA;QAClD,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YAC3C,MAAM,WAAW,GACf,MAAM,IAAI,CAAC,WAAW,CAAC,gCAAgC,CACrD;gBACE,GAAG,CAAC,QAAQ,CAAC,WAAW;oBACtB,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE;oBACvC,CAAC,CAAC,EAAE,CAAC;gBACP,MAAM,EAAE,IAAI;aACb,EACD,SAAS,EACT,OAAO,CACR,CAAA;YACH,MAAM,UAAU,GAAG,QAAQ,CAAC,WAAW;gBACrC,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CACnC,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,EACrC,SAAS,EACT,OAAO,CACR;gBACH,CAAC,CAAC,EAAE,CAAA;YACN,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACrC,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC,CAAA;YACnD,CAAC;YACD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACnC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAA;YACxC,CAAC;QACH,CAAC;QAED,MAAM,UAAU,GAAa,EAAE,CAAA;QAC/B,MAAM,MAAM,GAAa,EAAE,CAAA;QAC3B,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YAC3C,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,UAAU,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAA;gBACzC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAA;YACnC,CAAC;YACD,IAAI,QAAQ,CAAC,gBAAgB,EAAE,CAAC;gBAC9B,UAAU,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAA;gBAChD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAA;YACxC,CAAC;QACH,CAAC;QACD,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YACtB,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,OAAO,CACrC;;;;;kBAKU,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EACpC,MAAM,EACN,KAAK,CACN,CAAA;YACD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;YACjD,CAAC;QACH,CAAC;QACD,KAAK,MAAM,WAAW,IAAI,CAAC,GAAG,oBAAoB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC3D,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;QACrD,CAAC;QACD,OAAO,UAAU,CAAA;IACnB,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAC9B,WAAmB,EACnB,OAA6C;QAE7C,MAAM,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAA;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,2DAA2D,CAC5D,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,mBAAmB,WAAW,EAAE,CAAC,EAClC,KAAK,CACN,CAAA;IACH,CAAC;IAED,KAAK,CAAC,8BAA8B,CAClC,UAAkB;QAElB,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC;YACpD,WAAW,EAAE,UAAU;SACxB,CAAC,CAAA;IACJ,CAAC;IAED,KAAK,CAAC,gCAAgC,CACpC,WAAmB;QAEnB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC3D,EAAE,YAAY,EAAE,WAAW,EAAE,EAC7B,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAAA;QAED,OAAQ,QAAQ,CAAC,CAAC,CAAiD,IAAI,IAAI,CAAA;IAC7E,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,WAAmB,EACnB,OAAgB;QAEhB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAA;QACzE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,SAAS,EAC3B,sEAAsE,CACvE,CAAA;QACH,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mCAAmC,CAAC;YAC7D,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,OAAO;SACR,CAAC,CAAA;QACF,OAAO,OAAsD,CAAA;IAC/D,CAAC;IAGK,AAAN,KAAK,CAAC,iCAAiC,CACrC,KAOC,EACgB,gBAAyB,EAAE;QAM5C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC/D,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,EACpC,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GACX,YAAY,CAAC,CAAC,CAAiD,IAAI,IAAI,CAAA;QAE1E,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mCAAmC,CAC5D;gBACE,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;gBAC5C,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;aACrD,EACD,aAAa,CACd,CAAA;YAED,OAAO;gBACL,QAAQ,EAAE,OAAsD;gBAChE,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,QAAQ;aACnB,CAAA;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mCAAmC,CAC5D;YACE,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;YAC1D,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,OAAO,EAAE,IAAI;YACb,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;SACrD,EACD,aAAa,CACd,CAAA;QAED,OAAO;YACL,QAAQ,EAAE,OAAsD;YAChE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,IAAI;SACf,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,uCAAuC,CAC3C,KAIC,EACgB,gBAAyB,EAAE;QAE5C,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,EAAE,EAAE,aAAa,CAAC,CAAA;YACvE,OAAM;QACR,CAAC;QAED,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACnB,MAAM,IAAI,CAAC,mCAAmC,CAC5C;gBACE,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO;gBAC/B,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;gBACnC,kBAAkB,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB;gBACrD,sBAAsB,EAAE,KAAK,CAAC,QAAQ,CAAC,sBAAsB,IAAI,IAAI;gBACrE,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,IAAI,IAAI;aAC1C,EACD,aAAa,CACd,CAAA;QACH,CAAC;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,0BAA0B,CAC9B,KAAsC,EACrB,gBAAyB,EAAE;QAO5C,IAAI,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAA;QAE5C,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CACxD,KAAK,CAAC,YAAY,EAClB,aAAa,CACd,CAAA;QACD,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAA;QAExD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC/D,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,EACpC,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAElB,CAAA;QAEb,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,WAAW,EAC7B,mEAAmE,CACpE,CAAA;QACH,CAAC;QACD,IAAI,KAAK,CAAC,kBAAkB,KAAK,QAAQ,CAAC,iBAAiB,EAAE,CAAC;YAC5D,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,4EAA4E,CAC7E,CAAA;QACH,CAAC;QAED,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,wBAAwB,CACtD,EAAE,eAAe,EAAE,KAAK,CAAC,eAAe,EAAE,EAC1C,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAEhC,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC3D,EAAE,uBAAuB,EAAE,QAAQ,CAAC,EAAE,EAAE,EACxC,EAAE,EACF,aAAa,CACd,CAAA;YACD,IAAI,CAAC,qCAAqC,CAAC,KAAK,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAA;YAE1E,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACjC,MAAM,IAAI,CAAC,0BAA0B,CACnC;oBACE,EAAE,EAAE,QAAQ,CAAC,EAAE;oBACf,MAAM,EAAE,SAAS;oBACjB,cAAc,EAAE,IAAI;oBACpB,YAAY,EAAE,IAAI;iBACnB,EACD,aAAa,CACd,CAAA;YACH,CAAC;YAED,OAAO;gBACL,QAAQ,EAAE;oBACR,GAAI,QAA8C;oBAClD,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,QAAQ;wBAC9B,CAAC,CAAC,EAAE,MAAM,EAAE,SAAkB,EAAE,cAAc,EAAE,IAAI,EAAE;wBACtD,CAAC,CAAC,EAAE,CAAC;iBACR;gBACD,KAAK,EAAE,aAAwD;gBAC/D,QAAQ,EAAE,QAAuD;gBACjE,iBAAiB,EAAE,QAAQ,CAAC,MAAM,KAAK,WAAW;aACnD,CAAA;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CACpD;YACE,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,uBAAuB,EAAE,QAAQ,CAAC,iBAAiB;YACnD,SAAS,EAAE,UAAU;YACrB,MAAM,EAAE,SAAS;YACjB,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;YAChC,QAAQ,EAAE;gBACR,oBAAoB,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM;aACzC;SACF,EACD,aAAa,CACd,CAAA;QACD,2EAA2E;QAC3E,6EAA6E;QAC7E,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,8BAA8B,CACrD,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,uBAAuB,EAAE,QAAQ,CAAC,EAAE;YACpC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,eAAe,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI;YACtC,oBAAoB,EAAE,IAAI;YAC1B,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC,EACH,aAAa,CACd,CAAA;QAED,OAAO;YACL,QAAQ,EAAE,QAA6C;YACvD,KAAK,EAAE,KAAgD;YACvD,QAAQ,EAAE,QAAuD;YACjE,iBAAiB,EAAE,KAAK;SACzB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KAWC,EACgB,gBAAyB,EAAE;QAE5C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,2BAA2B,CACrD,KAAK,CAAC,WAAW,EACjB,EAAE,EACF,aAAa,CACd,CAAA;QAED,IAAI,QAAQ,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACpC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC3D,EAAE,uBAAuB,EAAE,QAAQ,CAAC,EAAE,EAAE,EACxC,EAAE,EACF,aAAa,CACd,CAAA;YACD,OAAO;gBACL,GAAI,QAA8C;gBAClD,KAAK,EAAE,aAAwD;aAChE,CAAA;QACH,CAAC;QAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACzD,EAAE,uBAAuB,EAAE,QAAQ,CAAC,EAAE,EAAE,EACxC,EAAE,EACF,aAAa,CACd,CAAA;QACD,MAAM,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;QAElC,KAAK,MAAM,MAAM,IAAI,WAAW,EAAE,CAAC;YACjC,MAAM,KAAK,GAAG,SAAS,CAAC,SAAS,CAC/B,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,iBAAiB,KAAK,MAAM,CAAC,iBAAiB;gBACnD,IAAI,CAAC,QAAQ,KAAK,MAAM,CAAC,QAAQ;gBACjC,CAAC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,eAAe,IAAI,IAAI,CAAC,CACtE,CAAA;YACD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,iFAAiF,CAClF,CAAA;YACH,CAAC;YACD,MAAM,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;YAC/C,MAAM,IAAI,CAAC,8BAA8B,CACvC;gBACE,EAAE,EAAE,MAAM,CAAC,EAAE;gBACb,oBAAoB,EAAE,UAAU,CAAC,oBAAoB,IAAI,IAAI;gBAC7D,mBAAmB,EAAE,UAAU,CAAC,mBAAmB,IAAI,IAAI;gBAC3D,0BAA0B,EACxB,OAAO,UAAU,CAAC,0BAA0B,KAAK,QAAQ;oBACvD,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,0BAA0B,CAAC;oBACjD,CAAC,CAAC,CAAC,UAAU,CAAC,0BAA0B,IAAI,IAAI,CAAC;gBACrD,QAAQ,EAAE,EAAE,aAAa,EAAE,KAAK,CAAC,IAAI,EAAE;aACxC,EACD,aAAa,CACd,CAAA;QACH,CAAC;QAED,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC;YACrB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,oEAAoE,CACrE,CAAA;QACH,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,0BAA0B,CACrD;YACE,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,MAAM,EAAE,WAAW;YACnB,cAAc,EAAE,IAAI;YACpB,YAAY,EAAE,IAAI,IAAI,EAAE;YACxB,QAAQ,EAAE;gBACR,aAAa,EAAE,KAAK,CAAC,IAAI;gBACzB,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM;aACtC;SACF,EACD,aAAa,CACd,CAAA;QACD,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC5D,EAAE,uBAAuB,EAAE,QAAQ,CAAC,EAAE,EAAE,EACxC,EAAE,EACF,aAAa,CACd,CAAA;QAED,OAAO;YACL,GAAI,SAA+C;YACnD,KAAK,EAAE,cAAyD;SACjE,CAAA;IACH,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,KAG7B;QACC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,2BAA2B,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;QAE1E,IAAI,QAAQ,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACpC,OAAM;QACR,CAAC;QAED,MAAM,IAAI,CAAC,0BAA0B,CAAC;YACpC,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,MAAM,EAAE,QAAQ;YAChB,cAAc,EAAE,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC;YACnD,YAAY,EAAE,IAAI;SACnB,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,uBAAuB,CAC3B,KAAmC;QAEnC,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAClC,4BAA4B,GAAG,qBAAkB,CAAA;QACnD,CAAC;QACD,MAAM,EAAE,+BAA+B,EAAE,GACvC,MAAM,MAAM,CAAC,wDAAwD,CAAC,CAAA;QACxE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,+BAA+B,CACtD,4BAA4B,CAC7B,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAED,KAAK,CAAC,wBAAwB,CAC5B,KAAoC;QAEpC,IAAI,KAAK,CAAC,yBAAyB,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAA;QACrD,CAAC;QACD,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAClC,4BAA4B,GAAG,qBAAkB,CAAA;QACnD,CAAC;QACD,MAAM,EAAE,gCAAgC,EAAE,GACxC,MAAM,MAAM,CAAC,yDAAyD,CAAC,CAAA;QACzE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,gCAAgC,CACvD,4BAA4B,CAC7B,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAED,KAAK,CAAC,gCAAgC,CACpC,KAAoC;QAEpC,IAAI,KAAK,CAAC,wBAAwB,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAA;QACrD,CAAC;QACD,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAClC,4BAA4B,GAAG,qBAAkB,CAAA;QACnD,CAAC;QACD,MAAM,EAAE,wCAAwC,EAAE,GAChD,MAAM,MAAM,CAAC,kEAAkE,CAAC,CAAA;QAClF,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,wCAAwC,CAC/D,4BAA4B,CAC7B,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,+BAA+B,CACnC,SAA0B;QAE1B,4BAA4B,GAAG,SAAS,CAAA;IAC1C,CAAC;IAED,KAAK,CAAC,qCAAqC,CAAC,KAK3C;QACC,IAAA,oDAAuB,EAAC,KAAK,CAAC,YAAY,CAAC,CAAA;QAE3C,MAAM,SAAS,GAAG,CAChB,MAAM,IAAI,CAAC,cAAc,CAAC;YACxB,EAAE,EAAE,KAAK,CAAC,YAAY;YACtB,MAAM,EAAE,QAAQ;SACjB,CAAC,CACH,CAAC,CAAC,CAAC,CAAA;QACJ,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,YAAY,GAAG,CACnB,MAAM,IAAI,CAAC,iCAAiC,CAAC;YAC3C,YAAY,EAAE,SAAS,CAAC,EAAE;YAC1B,OAAO,EAAE,IAAI;SACd,CAAC,CACH,CAAC,CAAC,CAAC,CAAA;QACJ,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC;YAChD,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,YAAY,EAAE,IAAI,IAAI,CAAC,GAAG,KAAK,CAAC,YAAY,gBAAgB,CAAC;YAC7D,MAAM,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC;SAClC,CAAC,CAAA;QACF,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,QAAQ,GAAG,SAAS,CAAC,QAA0C,CAAA;QACrE,MAAM,SAAS,GAAG,QAAQ,EAAE,MAAM,CAAA;QAClC,MAAM,aAAa,GACjB,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;QACvD,MAAM,MAAM,GACV,aAAa,IAAI,aAAa,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAA;QAEpE,OAAO,+DAAgD,CAAC,KAAK,CAAC;YAC5D,cAAc,EAAE,CAAC;YACjB,YAAY,EAAE,IAAA,oDAAqC,EACjD,SAAS,CAAC,EAAE,EACZ,KAAK,CAAC,YAAY,CACnB;YACD,YAAY,EAAE,SAAS,CAAC,EAAE;YAC1B,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,IAAI;YAC1C,sBAAsB,EAAE,SAAS,CAAC,YAAY;YAC9C,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,QAAQ,EAAE,IAAA,0DAA6B,EAAC;gBACtC,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC;YACF,MAAM;YACN,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC,CAAA;IACJ,CAAC;IAGK,AAAN,KAAK,CAAC,wBAAwB,CAC5B,KAEC,EAED,gBAAsD,EAAE;QAKxD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,wDAAwD,CACzD,CAAA;QACH,CAAC;QAED,MAAM,GAAG,GAAG,KAAK,CAAC,0BAA0B,CAAC,IAAI,EAAE,CAAA;QACnD,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,uDAAuD,CACxD,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,gCAAgC,GAAG,EAAE,CAAC,EACvC,KAAK,CACN,CAAA;QAED,MAAM,QAAQ,GAAG,CACf,MAAM,IAAI,CAAC,sBAAsB,CAC/B,EAAE,0BAA0B,EAAE,GAAG,EAAE,EACnC,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CACF,CAAC,CAAC,CAAC,CAAA;QACJ,IAAI,QAAQ,EAAE,CAAC;YACb,IACE,QAAQ,CAAC,YAAY,KAAK,KAAK,CAAC,YAAY;gBAC5C,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAK,KAAK,CAAC,YAAY,EAC9D,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,gFAAgF,CACjF,CAAA;YACH,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,aAAa,CAAC;gBAClE,OAAO,EAAE,KAAK;aACf,CAAA;QACH,CAAC;QAED,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,sBAAsB,CAC5D,KAAK,CAAC,YAAY,CACnB,CAAA;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,2BAA2B,CAC5C,KAAK,CAAC,2BAA2B,EACjC,KAAK,CAAC,eAAe,CACtB,CAAA;QACD,MAAM,MAAM,GAAG,CACb,MAAM,IAAI,CAAC,sBAAsB,CAC/B;YACE,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,YAAY,EAAE,WAAW;YACzB,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;SAC3C,EACD,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CACF,CAAC,CAAC,CAAC,CAAA;QACJ,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,uEAAuE,CACxE,CAAA;QACH,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAChD;YACE,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,YAAY,EAAE,WAAW;YACzB,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,WAAW;YACnB,OAAO,EAAE,CAAC;YACV,0BAA0B,EAAE,GAAG;YAC/B,eAAe,EAAE,KAAK,CAAC,YAAY;YACnC,YAAY,EAAE,IAAI,IAAI,EAAE;YACxB,QAAQ,EAAE;gBACR,gBAAgB,EAAE,CAAC;gBACnB,mBAAmB,EAAE,KAAK,CAAC,MAAM;aAClC;SACF,EACD,aAAa,CACd,CAAA;QACD,yEAAyE;QACzE,2EAA2E;QAC3E,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC/B,MAAM,IAAI,CAAC,4BAA4B,CACrC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACnB,qBAAqB,EAAE,MAAM,CAAC,EAAE;YAChC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,uBAAuB,EAAE,IAAI,CAAC,sBAAsB;YACpD,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;YAC/D,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,IAAI,IAAI;YACrD,aAAa,EAAE,IAAI,CAAC,aAAa,IAAI,IAAI;YACzC,QAAQ,EAAE;gBACR,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;gBACnD,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,IAAI;gBACnC,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,IAAI;gBACzB,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,IAAI,IAAI;gBACrD,qBAAqB,EAAE,IAAI;gBAC3B,cAAc,EAAE,IAAI;aACrB;SACF,CAAC,CAAC,EACH,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAE/B,OAAO;YACL,MAAM,EAAE,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC;YAChE,OAAO,EAAE,IAAI;SACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KASC,EACgB,gBAAyB,EAAE;QAE5C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,IACE,MAAM,CAAC,cAAc;YACrB,MAAM,CAAC,cAAc,KAAK,KAAK,CAAC,cAAc,EAC9C,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,wEAAwE,CACzE,CAAA;QACH,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YAC3B,MAAM,IAAI,CAAC,wBAAwB,CACjC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,EACvD,aAAa,CACd,CAAA;QACH,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,6BAA6B,CACrD,IAAI,CAAC,cAAc,EACnB,EAAE,EACF,aAAa,CACd,CAAA;YACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;YACnD,MAAM,IAAI,CAAC,4BAA4B,CACrC;gBACE,EAAE,EAAE,MAAM,CAAC,EAAE;gBACb,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;gBAC7C,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,IAAI,IAAI;gBACnD,QAAQ,EAAE;oBACR,GAAG,QAAQ;oBACX,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;oBAC7C,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;oBACjD,cAAc,EAAE,KAAK,CAAC,cAAc;iBACrC;aACF,EACD,aAAa,CACd,CAAA;QACH,CAAC;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAE/B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAClD,MAAM,CAAC,EAAE,EACT,EAAE,EACF,aAAa,CACd,CAAA;QACD,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;IAClE,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,QAAgB;QAEhB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAA;QAC7D,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAA;IAClD,CAAC;IAGK,AAAN,KAAK,CAAC,0BAA0B,CAC9B,KAAoC,EAEpC,gBAAsD,EAAE;QAOxD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,mDAAmD,CACpD,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,kCAAkC,KAAK,CAAC,SAAS,EAAE,CAAC,EACrD,KAAK,CACN,CAAA;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC/D,EAAE,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,EACrC,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;YACvB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,WAAW,EAC7B,mEAAmE,CACpE,CAAA;QACH,CAAC;QAED,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,sBAAsB,CACtD,MAAM,EACN,aAAa,CACd,CAAA;YACD,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;gBAC/C,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,8EAA8E,CAC/E,CAAA;YACH,CAAC;YACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;YACnD,MAAM,YAAY,GAAG,IAAI,CAAC,yBAAyB,CACjD,QAAQ,CAAC,8BAA8B,CACxC,CAAA;YACD,OAAO;gBACL,MAAM,EAAE,cAAc;gBACtB,QAAQ,EAAE,QAAuD;gBACjE,gBAAgB,EAAE,IAAI;gBACtB,eAAe,EAAE;oBACf,MAAM,EAAE,cAAc;oBACtB,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,cAAc,EAAE,MAAM,CAAC,cAAc;oBACrC,KAAK,EAAE;wBACL,EAAE,EAAE,MAAM,CAAC,QAAQ;wBACnB,cAAc,EAAE,KAAK;wBACrB,QAAQ,EAAE;4BACR,WAAW,EAAE,IAAI;4BACjB,qBAAqB,EAAE,MAAM,CAAC,EAAE;4BAChC,YAAY,EAAE,MAAM,CAAC,YAAY;yBAClC;qBACF;oBACD,YAAY;oBACZ,WAAW,EAAE;wBACX,EAAE,EAAE,MAAM,CAAC,cAAc;wBACzB,WAAW,EAAE,QAAQ,CAAC,iBAAiB;wBACvC,KAAK,EAAE,cAAc,CAAC,KAAK;6BACxB,MAAM,CACL,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,uBAAuB,GAAG,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAC9D;6BACA,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;4BACd,YAAY,EAAE,IAAI,CAAC,kBAA4B;4BAC/C,QAAQ,EAAE,IAAI,CAAC,uBAAuB;yBACvC,CAAC,CAAC;qBACN;iBACF;aACF,CAAA;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,6DAA6D,CAC9D,CAAA;QACH,CAAC;QACD,IACE,KAAK,CAAC,gBAAgB,KAAK,SAAS;YACpC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,KAAK,CAAC,gBAAgB,EACjD,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,oDAAoD,CACrD,CAAA;QACH,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;QAC1E,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAA;QAC3E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;QAC9B,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,eAAe,IAAI,EAAE,EAAE,CAAC;YACjD,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC;gBACpC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,4DAA4D,CAC7D,CAAA;YACH,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;YAC/B,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;YACnD,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,qDAAqD,CACtD,CAAA;YACH,CAAC;YACD,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAC/B,CAAC,EACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAC/C,CAAA;YACD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,uBAAuB,CAAC;gBACrD,MAAM,CAAC,uBAAuB,GAAG,CAAC;gBAClC,MAAM,CAAC,uBAAuB,GAAG,gBAAgB,EACjD,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,8FAA8F,CAC/F,CAAA;YACH,CAAC;YACD,IACE,MAAM,CAAC,uBAAuB,GAAG,gBAAgB;gBACjD,CAAC,MAAM,CAAC,eAAe,EACvB,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,mFAAmF,CACpF,CAAA;YACH,CAAC;YAED,MAAM,IAAI,CAAC,4BAA4B,CACrC;gBACE,EAAE,EAAE,IAAI,CAAC,EAAE;gBACX,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;gBACvD,eAAe,EACb,MAAM,CAAC,uBAAuB,GAAG,gBAAgB;oBAC/C,CAAC,CAAC,MAAM,CAAC,eAAe;oBACxB,CAAC,CAAC,IAAI;aACX,EACD,aAAa,CACd,CAAA;QACH,CAAC;QAED,MAAM,WAAW,GAAG,wBAAwB,MAAM,CAAC,EAAE,EAAE,CAAA;QACvD,IACE,MAAM,CAAC,wBAAwB;YAC/B,MAAM,CAAC,wBAAwB,KAAK,WAAW,EAC/C,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,oEAAoE,CACrE,CAAA;QACH,CAAC;QACD,MAAM,IAAI,CAAC,wBAAwB,CACjC;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,wBAAwB,EAAE,WAAW;YACrC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;SACpC,EACD,aAAa,CACd,CAAA;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC/B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACnD,MAAM,CAAC,EAAE,EACT,EAAE,EACF,aAAa,CACd,CAAA;QAED,OAAO;YACL,MAAM,EAAE,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,aAAa,CAAC;YAClE,QAAQ,EAAE,QAAuD;YACjE,gBAAgB,EAAE,KAAK;YACvB,eAAe,EAAE,IAAI;SACtB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,2BAA2B,CAC/B,KAMC,EAED,gBAAsD,EAAE;QAKxD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,4DAA4D,CAC7D,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,kCAAkC,KAAK,CAAC,SAAS,EAAE,CAAC,EACrD,KAAK,CACN,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,IACE,MAAM,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ;gBAClC,MAAM,CAAC,cAAc,KAAK,KAAK,CAAC,cAAc,EAC9C,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,sEAAsE,CACvE,CAAA;YACH,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC;gBAChE,cAAc,EAAE,KAAK;aACtB,CAAA;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,6DAA6D,CAC9D,CAAA;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAClD;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,cAAc,EAAE,KAAK,CAAC,QAAQ;YAC9B,WAAW,EAAE,IAAI,IAAI,EAAE;YACvB,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,8BAA8B,EAAE,KAAK,CAAC,YAAY;aACnD;SACF,EACD,aAAa,CACd,CAAA;QACD,OAAO;YACL,MAAM,EAAE,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,aAAa,CAAC;YAClE,cAAc,EAAE,IAAI;SACrB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,4BAA4B,CAChC,KAAoC,EAEpC,gBAAsD,EAAE;QAaxD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,+DAA+D,CAChE,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,oCAAoC,KAAK,CAAC,SAAS,EAAE,CAAC,EACvD,KAAK,CACN,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,4DAA4D,CAC7D,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,iCAAiC,CACxD,QAAQ,CAAC,WAAW,CACrB,CAAA;QACD,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAC/B,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,CACjE,CAAA;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;QAC1E,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAC/D,EAAE,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,EACrC,EAAE,IAAI,EAAE,CAAC,EAAE,EACX,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;YACvB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,WAAW,EAC7B,mEAAmE,CACpE,CAAA;QACH,CAAC;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,YAAY,GAChB,QAAQ,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;gBAChC,QAAQ,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ;gBACpC,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,eAAe,CAAC,MAAM;gBACtD,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5B,KAAK,CAAC,eAAe,CAAC,IAAI,CACxB,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,cAAc,KAAK,IAAI,CAAC,cAAc;oBAChD,SAAS,CAAC,uBAAuB;wBAC/B,IAAI,CAAC,iCAAiC,CAC3C,CACF,CAAA;YACH,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,oEAAoE,CACrE,CAAA;YACH,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,SAAS;gBACjB,QAAQ,EAAE,QAAuD;gBACjE,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,KAAK,EAAE,QAAQ,CAAC,KAAK;gBACrB,QAAQ,EAAE;oBACR,aAAa,EAAE,QAAQ,CAAC,aAAa;oBACrC,YAAY,EAAE,QAAQ,CAAC,YAAY;oBACnC,cAAc,EAAE,QAAQ,CAAC,cAAc;oBACvC,cAAc,EAAE,QAAQ,CAAC,cAAc;oBACvC,eAAe,EAAE,QAAQ,CAAC,eAAe;oBACzC,0BAA0B,EAAE,QAAQ,CAAC,0BAA0B;oBAC/D,cAAc,EAAE,QAAQ,CAAC,cAAc;oBACvC,cAAc,EAAE,QAAQ,CAAC,cAAc;iBACxC;gBACD,iBAAiB,EAAE,QAAQ,CAAC,MAAM,KAAK,WAAW;gBAClD,eAAe,EACb,QAAQ,CAAC,MAAM,KAAK,WAAW;oBAC7B,CAAC,CAAC,IAAI,CAAC,6BAA6B,CAAC,QAAQ,CAAC;oBAC9C,CAAC,CAAC,IAAI;aACX,CAAA;QACH,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAC/B,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC,CACvE,CAAA;QACD,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,IAAI,UAAU,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;gBACtC,SAAQ;YACV,CAAC;YACD,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;gBACpC,iBAAiB,CAAC,GAAG,CACnB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,iCAAiC,CACvC,CAAA;YACH,CAAC;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAA;QACxE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;QAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;YACpD,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE,CAAC;gBACvC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,6DAA6D,CAC9D,CAAA;YACH,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;YAClC,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;YACnD,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC;gBAC9B,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,8EAA8E,CAC/E,CAAA;YACH,CAAC;YACD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACtB,CAAC,EACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAC/C,CAAA;YACD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,uBAAuB,CAAC;gBACxD,SAAS,CAAC,uBAAuB,GAAG,CAAC;gBACrC,SAAS,CAAC,uBAAuB,GAAG,OAAO,EAC3C,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,sGAAsG,CACvG,CAAA;YACH,CAAC;YACD,MAAM,QAAQ,GACZ,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,uBAAuB,CAAA;YAChE,OAAO;gBACL,cAAc,EAAE,IAAI,CAAC,EAAE;gBACvB,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;gBAC3C,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,gCAAgC,EAAE,QAAQ;gBAC1C,iCAAiC,EAAE,SAAS,CAAC,uBAAuB;gBACpE,cAAc,EAAE,SAAS,CAAC,uBAAuB,GAAG,QAAQ;aAC7D,CAAA;QACH,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,KAAK,CAAC,CAAC,EAAE,CAAC;YACtE,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,yDAAyD,CAC1D,CAAA;QACH,CAAC;QAED,MAAM,OAAO,GAAgC;YAC3C,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,MAAM,EAAE,SAAS;YACjB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,KAAK;YACL,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,KAAK;YACnB,cAAc,EAAE,KAAK;YACrB,cAAc,EAAE,KAAK;YACrB,eAAe,EAAE,EAAE;YACnB,0BAA0B,EAAE,KAAK;YACjC,cAAc,EAAE,IAAI;YACpB,cAAc,EAAE,IAAI;SACrB,CAAA;QACD,MAAM,IAAI,CAAC,wBAAwB,CACjC;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;YACnC,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,WAAW,EAAE,CAAC,GAAG,WAAW,EAAE,OAAO,CAAC;aACvC;SACF,EACD,aAAa,CACd,CAAA;QAED,OAAO;YACL,MAAM,EAAE,SAAS;YACjB,QAAQ,EAAE,QAAuD;YACjE,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,KAAK;YACL,QAAQ,EAAE;gBACR,aAAa,EAAE,IAAI;gBACnB,YAAY,EAAE,KAAK;gBACnB,cAAc,EAAE,KAAK;gBACrB,cAAc,EAAE,KAAK;gBACrB,eAAe,EAAE,EAAE;gBACnB,0BAA0B,EAAE,KAAK;gBACjC,cAAc,EAAE,IAAI;gBACpB,cAAc,EAAE,IAAI;aACrB;YACD,iBAAiB,EAAE,KAAK;YACxB,eAAe,EAAE,IAAI;SACtB,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,mCAAmC,CACvC,KAWC,EAED,gBAAsD,EAAE;QAExD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,+DAA+D,CAChE,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,oCAAoC,KAAK,CAAC,SAAS,EAAE,CAAC,EACvD,KAAK,CACN,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,iCAAiC,CACxD,QAAQ,CAAC,WAAW,CACrB,CAAA;QACD,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,CACjC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,CACjE,CAAA;QACD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,8DAA8D,CAC/D,CAAA;QACH,CAAC;QACD,WAAW,CAAC,KAAK,CAAC,GAAG;YACnB,GAAG,WAAW,CAAC,KAAK,CAAC;YACrB,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACtE,GAAG,CAAC,KAAK,CAAC,YAAY,KAAK,SAAS;gBAClC,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE;gBACtC,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,cAAc,KAAK,SAAS;gBACpC,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE;gBAC1C,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,cAAc,KAAK,SAAS;gBACpC,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE;gBAC1C,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,eAAe;gBACvB,CAAC,CAAC,EAAE,eAAe,EAAE,KAAK,CAAC,eAAe,EAAE;gBAC5C,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,0BAA0B,KAAK,SAAS;gBAChD,CAAC,CAAC;oBACE,0BAA0B,EAAE,KAAK,CAAC,0BAA0B;iBAC7D;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzE,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC1E,CAAA;QACD,MAAM,IAAI,CAAC,wBAAwB,CACjC;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,QAAQ,EAAE,EAAE,GAAG,QAAQ,EAAE,WAAW,EAAE;SACvC,EACD,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,6BAA6B,CACjC,KASC,EAED,gBAAsD,EAAE;QAExD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,6DAA6D,CAC9D,CAAA;QACH,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,oCAAoC,KAAK,CAAC,SAAS,EAAE,CAAC,EACvD,KAAK,CACN,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,4DAA4D,CAC7D,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,iCAAiC,CACxD,QAAQ,CAAC,WAAW,CACrB,CAAA;QACD,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,CACjC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,KAAK,KAAK,CAAC,aAAa,CACjE,CAAA;QACD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,uDAAuD,CACxD,CAAA;QACH,CAAC;QACD,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAA;QAClC,IAAI,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAA;QACpD,CAAC;QACD,MAAM,SAAS,GAAgC;YAC7C,GAAG,OAAO;YACV,MAAM,EAAE,WAAW;YACnB,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,cAAc,EAAE,KAAK,CAAC,cAAc;SACrC,CAAA;QACD,WAAW,CAAC,KAAK,CAAC,GAAG,SAAS,CAAA;QAC9B,MAAM,IAAI,CAAC,wBAAwB,CACjC;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;YACnC,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,WAAW;aACZ;SACF,EACD,aAAa,CACd,CAAA;QAED,OAAO,IAAI,CAAC,6BAA6B,CAAC,SAAS,CAAC,CAAA;IACtD,CAAC;IAGK,AAAN,KAAK,CAAC,uBAAuB,CAC3B,KAIC,EACgB,gBAAyB,EAAE;QAE5C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACjD,KAAK,CAAC,SAAS,EACf,EAAE,EACF,aAAa,CACd,CAAA;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;QACjE,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,2DAA2D,CAC5D,CAAA;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAClD;YACE,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC;YAC3B,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,cAAc,EAAE,KAAK,CAAC,QAAQ;gBAC9B,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACtC;SACF,EACD,aAAa,CACd,CAAA;QAED,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;IACnE,CAAC;IAED,KAAK,CAAC,4BAA4B,CAChC,WAAmB;QAEnB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAC/C,EAAE,YAAY,EAAE,WAAW,EAAE,EAC7B,EAAE,KAAK,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,CACpC,CAAA;QACD,OAAO,MAAM,OAAO,CAAC,GAAG,CACtB,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAC7D,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,wBAAwB,CAC5B,KAAiC,EAEjC,gBAAsD,EAAE;QAExD,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,aAAa,CAAC,CAAA;QAC7D,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAC7E,CAAC;IAGK,AAAN,KAAK,CAAC,0BAA0B,CAC9B,KAAsC,EAEtC,gBAAsD,EAAE;QAExD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAC5C,KAAK,CAAC,KAAK,CAAC,EAAE,EACd,aAAa,CACd,CAAA;QAED,MAAM,WAAW,GACf,MAAM,IAAI,CAAC,aAAa,CAAC,uCAAuC,CAC9D,KAAK,CAAC,KAAK,EACX,aAAa,CACd,CAAA;QACH,MAAM,YAAY,GAAG;YACnB,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;SACjD,CAAC,IAAI,EAAE,CAAA;QAER,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,mCAAmC,WAAW,EAAE,CAAC,EAClD,KAAK,CACN,CAAA;QACH,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IACxE,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAC/B,OAAe,EACf,aAAmD;QAEnD,MAAM,OAAO,GAAG,aAAa,CAAC,kBAAkB,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,4DAA4D,CAC7D,CAAA;QACH,CAAC;QAED,MAAM,OAAO,CAAC,OAAO,CACnB,2CAA2C,EAC3C,CAAC,8BAA8B,OAAO,EAAE,CAAC,EACzC,KAAK,CACN,CAAA;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,KAAK,CAAC,oCAAoC,CACxC,KAAsB,EACtB,aAAqC;QAErC,OAAO,IAAI,CAAC,aAAa,CAAC,oCAAoC,CAC5D,KAAK,EACL,aAAa,CACd,CAAA;IACH,CAAC;IAED,KAAK,CAAC,2BAA2B,CAC/B,KAAsB,EACtB,aAAqC;QAErC,OAAO,IAAI,CAAC,aAAa,CAAC,2BAA2B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;IAC7E,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAAkB;QAElB,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAA;IAC5E,CAAC;IAED,KAAK,CAAC,yCAAyC,CAC7C,SAAuB;QAEvB,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,4BAA4B,CACjE,SAAS,CACV,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,0BAA0B,CAC9B,KAAgC,EACf,gBAAyB,EAAE;QAE5C,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,0BAA0B,CAC/D,KAAK,EACL,aAAa,CACd,CAAA;IACH,CAAC;IAED,KAAK,CAAC,sBAAsB,CAC1B,UAAkB;QAElB,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAA;IAC3E,CAAC;IAGK,AAAN,KAAK,CAAC,uBAAuB,CAC3B,KAAmC,EAClB,gBAAyB,EAAE;QAE5C,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,uBAAuB,CAC5D,KAAK,EACL,aAAa,CACd,CAAA;IACH,CAAC;IAGK,AAAN,KAAK,CAAC,uBAAuB,CAC3B,KAAmC,EAClB,gBAAyB,EAAE;QAE5C,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,uBAAuB,CAC5D,KAAK,EACL,aAAa,CACd,CAAA;IACH,CAAC;IAED,KAAK,CAAC,yBAAyB,CAC7B,KAAkC;QAElC,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAA;IACzE,CAAC;IAED,KAAK,CAAC,2BAA2B,CAC/B,KAAoC;QAEpC,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAA;IAC3E,CAAC;IAED,KAAK,CAAC,0BAA0B,CAAC,KAGhC;QACC,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;IACpD,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,KAM9B;QACC,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;IAClD,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,kCAAkC,CAC9C,SAAuB,EACvB,QAAuC,EACvC,OAA6C;QAE7C,IAAI,SAAS,CAAC,WAAW,IAAI,SAAS,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC7D,MAAM,UAAU,GACd,MAAM,IAAI,CAAC,WAAW,CAAC,gCAAgC,CACrD,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,EACpD,SAAS,EACT,OAAO,CACR,CAAA;YACH,MAAM,OAAO,GAAG,QAAQ,EAAE,gBAAgB;gBACxC,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,gCAAgC,CACrD;oBACE,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;oBAC3C,MAAM,EAAE,IAAI;iBACb,EACD,SAAS,EACT,OAAO,CACR;gBACH,CAAC,CAAC,EAAE,CAAA;YACN,KAAK,MAAM,UAAU,IAAI,IAAI,GAAG,CAC9B,CAAC,GAAG,UAAU,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC;gBAC7C,SAAS,CAAC,EAAE;gBACZ,SAAS;aACV,CAAC,CACH,CAAC,MAAM,EAAE,EAAE,CAAC;gBACX,MAAM,IAAI,CAAC,iBAAiB,CAAC,aAAa,CACxC,UAAU,CAAC,EAAE,EACb,2BAA2B,EAC3B,OAAO,CACR,CAAA;YACH,CAAC;YAED,MAAM,OAAO,GAAG,OAAO,CAAC,kBAAmB,CAAA;YAC3C,MAAM,UAAU,GAAG,CAAC,wBAAwB,CAAC,CAAA;YAC7C,MAAM,MAAM,GAAa,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;YAChD,IAAI,QAAQ,EAAE,gBAAgB,EAAE,CAAC;gBAC/B,UAAU,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAA;gBAChD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAA;YACxC,CAAC;YACD,MAAM,OAAO,CAAC,OAAO,CACnB;;;;;;;;;sBASc,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;aAChC,EACL,MAAM,EACN,KAAK,CACN,CAAA;YACD,MAAM,OAAO,CAAC,OAAO,CACnB;;;;;;;;kBAQU,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EACpC,MAAM,EACN,KAAK,CACN,CAAA;QACH,CAAC;IACH,CAAC;IAEO,4BAA4B,CAClC,KAA0C;QAE1C,MAAM,oBAAoB,GAAG;YAC3B,kBAAkB;YAClB,iBAAiB;SACT,CAAA;QACV,MAAM,kBAAkB,GAAG;YACzB,YAAY;YACZ,yBAAyB;SACjB,CAAA;QACV,MAAM,sBAAsB,GAAG,CAAC,gBAAgB,EAAE,WAAW,CAAU,CAAA;QACvE,MAAM,8BAA8B,GAAG;YACrC,aAAa;YACb,YAAY;SACJ,CAAA;QAEV,IACE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,gBAAgB,CAAC;YACzC,KAAK,CAAC,gBAAgB,GAAG,CAAC;YAC1B,CAAC,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC;YACrD,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC;YACjD,CAAC,sBAAsB,CAAC,QAAQ,CAAC,KAAK,CAAC,kBAAkB,CAAC;YAC1D,CAAC,8BAA8B,CAAC,QAAQ,CACtC,KAAK,CAAC,yBAAyB,CAChC;YACD,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,oBAAoB,CAAC;YACjD,KAAK,CAAC,oBAAoB,IAAI,CAAC;YAC/B,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,8BAA8B,CAAC;YACtD,KAAK,CAAC,8BAA8B,GAAG,CAAC;YACxC,KAAK,CAAC,8BAA8B,GAAG,GAAG,EAC1C,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,4CAA4C,CAC7C,CAAA;QACH,CAAC;IACH,CAAC;IAEO,gCAAgC,CACtC,KAAsC;QAEtC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,0FAA0F,CAC3F,CAAA;QACH,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;QAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAC/B,IACE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;gBAC9B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC;gBACpC,IAAI,CAAC,QAAQ,IAAI,CAAC,EAClB,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,mDAAmD,CACpD,CAAA;YACH,CAAC;YACD,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,QAAQ,IAAI,EAAE,EAAE,CAAA;YAC9D,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAClB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,8DAA8D,CAC/D,CAAA;YACH,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACf,CAAC;IACH,CAAC;IAEO,qCAAqC,CAC3C,KAAsC,EACtC,QAIC,EACD,WAIE;QAEF,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK;aAC1B,GAAG,CACF,CAAC,IAAI,EAAE,EAAE,CACP,GAAG,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,QAAQ,IAAI,EAAE,IAAI,IAAI,CAAC,QAAQ,EAAE,CACtE;aACA,IAAI,EAAE,CAAA;QACT,MAAM,MAAM,GAAG,WAAW;aACvB,GAAG,CACF,CAAC,IAAI,EAAE,EAAE,CACP,GAAG,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,eAAe,IAAI,EAAE,IAAI,IAAI,CAAC,QAAQ,EAAE,CAC7E;aACA,IAAI,EAAE,CAAA;QAET,IACE,QAAQ,CAAC,YAAY,KAAK,KAAK,CAAC,YAAY;YAC5C,QAAQ,CAAC,kBAAkB,KAAK,KAAK,CAAC,kBAAkB;YACxD,SAAS,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;YAClC,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC,CAAC,EACzD,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,qFAAqF,CACtF,CAAA;QACH,CAAC;IACH,CAAC;IAEO,gCAAgC,CACtC,KAAoC;QAEpC,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;QAC/D,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,MAAM,QAAQ,GAAG,KAAK,CAAC,yBAAyB,CAAA;QAChD,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACjD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,6DAA6D,CAC9D,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,CAAC,KAAK,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC1C,IAAI,CAAC,cAAc;YACnB,IAAI,CAAC,uBAAuB;SAC7B,CAAC,CACH,CAAA;QACD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACxC,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,uBAAuB,CAAA;YACvE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CACvB,CAAC,EACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAC/C,CAAA;YACD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC;gBAChC,SAAS,GAAG,CAAC;gBACb,SAAS,GAAG,QAAQ,EACpB,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,8FAA8F,CAC/F,CAAA;YACH,CAAC;YACD,OAAO,EAAE,GAAG,IAAI,EAAE,uBAAuB,EAAE,SAAS,EAAE,CAAA;QACxD,CAAC,CAAC,CAAA;QACF,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAA;QAC/D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAA;YAC5C,MAAM,UAAU,GAAG,OAAO;iBACvB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,KAAK,IAAI,CAAC,iBAAiB,CAAC;iBACrE,IAAI,CACH,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACd,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE;gBACpC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE,CACxC,CAAA;YACH,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;gBAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;gBACrD,KAAK,CAAC,QAAQ,IAAI,SAAS,CAAA;gBAC3B,SAAS,IAAI,SAAS,CAAA;gBACtB,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;oBACpB,MAAK;gBACP,CAAC;YACH,CAAC;YACD,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;gBAClB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,sBAAsB,IAAI,CAAC,iBAAiB,gCAAgC,CAC7E,CAAA;YACH,CAAC;QACH,CAAC;QACD,MAAM,iBAAiB,GAAG,KAAK,CAAC,MAAM,CACpC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,uBAAuB,EACjD,CAAC,CACF,CAAA;QACD,MAAM,OAAO,GAAG,SAAS,KAAK,CAAC,SAAS,EAAE,CAAA;QAC1C,MAAM,aAAa,GAAG,OAAO,KAAK,CAAC,SAAS,EAAE,CAAA;QAC9C,MAAM,MAAM,GAAyB;YACnC,EAAE,EAAE,KAAK,CAAC,SAAS;YACnB,YAAY,EAAE,QAAQ,CAAC,YAAY;YACnC,YAAY,EAAE,YAAY;YAC1B,UAAU,EAAE,YAAY;YACxB,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,CAAC;YACV,cAAc,EAAE,QAAQ,CAAC,cAAc;YACvC,QAAQ,EAAE,OAAO;YACjB,cAAc,EAAE,aAAa;YAC7B,cAAc,EAAE,KAAK,CAAC,QAAQ;YAC9B,WAAW,EAAE,IAAI,IAAI,EAAE;YACvB,QAAQ,EAAE,EAAE,mBAAmB,EAAE,IAAI,EAAE;YACvC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBAC1B,EAAE,EAAE,IAAI,CAAC,EAAE;gBACX,qBAAqB,EAAE,KAAK,CAAC,SAAS;gBACtC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,QAAQ,EAAE,IAAI;gBACd,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACvC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;gBACrD,sBAAsB,EAAE,IAAI,CAAC,GAAG,CAC9B,CAAC,EACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAC/C;gBACD,4BAA4B,EAAE,KAAK;gBACnC,eAAe,EAAE,IAAI;gBACrB,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;aAC5C,CAAC,CAAC;SACJ,CAAA;QACD,MAAM,YAAY,GAAG,KAAK;aACvB,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,GAAG,CAAC,CAAC;aAClD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACd,EAAE,EAAE,OAAO,IAAI,CAAC,EAAE,EAAE;YACpB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,WAAW,EAAE,QAAQ,CAAC,iBAAiB;YACvC,YAAY,EAAE,IAAI,CAAC,kBAAkB;YACrC,QAAQ,EAAE,IAAI,CAAC,uBAAuB;SACvC,CAAC,CAAC,CAAA;QACL,MAAM,gBAAgB,GAAG,KAAK;aAC3B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,GAAG,CAAC,CAAC;aAClD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACd,YAAY,EAAE,IAAI,CAAC,kBAAkB;YACrC,QAAQ,EAAE,IAAI,CAAC,uBAAuB;SACvC,CAAC,CAAC,CAAA;QACL,MAAM,MAAM,GAAmC;YAC7C,MAAM;YACN,QAAQ,EAAE,OAAO;YACjB,cAAc,EAAE,aAAa;YAC7B,KAAK,EAAE;gBACL,EAAE,EAAE,OAAO;gBACX,cAAc,EAAE,KAAK;gBACrB,QAAQ,EAAE;oBACR,WAAW,EAAE,IAAI;oBACjB,qBAAqB,EAAE,KAAK,CAAC,SAAS;iBACvC;aACF;YACD,YAAY;YACZ,WAAW,EAAE;gBACX,EAAE,EAAE,aAAa;gBACjB,WAAW,EAAE,QAAQ,CAAC,iBAAiB;gBACvC,KAAK,EAAE,gBAAgB;aACxB;YACD,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;gBACvC,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;YACH,uBAAuB,EACrB,QAAQ,CAAC,uBAAuB,GAAG,iBAAiB;YACtD,kBAAkB,EAAE,iBAAiB;SACtC,CAAA;QACD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;QACtD,OAAO,MAAM,CAAA;IACf,CAAC;IAEO,gCAAgC,CACtC,KAAoC;QAEpC,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,aAAa,EAAE,CAAA;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACrD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,MAAM,QAAQ,GAAG,KAAK,CAAC,wBAAwB,CAAA;QAC/C,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAChD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,QAAQ,EAC1B,4DAA4D,CAC7D,CAAA;QACH,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAA;QAC3E,MAAM,OAAO,GAAG,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE;YACvD,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,cAAc,CAAC,CAAA;YAC5D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,sDAAsD,CACvD,CAAA;YACH,CAAC;YACD,OAAO;gBACL,QAAQ;gBACR,SAAS,EAAE,UAAU,CAAC,uBAAuB;gBAC7C,KAAK,EACH,UAAU,CAAC,uBAAuB,GAAG,QAAQ,CAAC,uBAAuB;aACxE,CAAA;QACH,CAAC,CAAC,CAAA;QACF,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;QAC5E,IAAI,aAAa,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,yDAAyD,CAC1D,CAAA;QACH,CAAC;QACD,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACxB,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,kDAAkD,CACnD,CAAA;QACH,CAAC;QACD,MAAM,MAAM,GAAmC;YAC7C,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,cAAc,EAAE,aAAa;YAC7B,WAAW,EAAE;gBACX,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE;gBACrB,uBAAuB,EAAE,KAAK,CAAC,SAAS;aACzC;YACD,aAAa,EAAE,WAAW,KAAK,CAAC,aAAa,EAAE;YAC/C,cAAc,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI;YACzE,cAAc,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI;YACvE,uBAAuB,EACrB,QAAQ,CAAC,uBAAuB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,CAAC;YAC/D,6BAA6B,EAAE,CAAC;YAChC,uBAAuB,EAAE,CAAC;YAC1B,yBAAyB,EAAE,CAAC;YAC5B,oBAAoB,EAAE,KAAK;YAC3B,cAAc,EAAE,KAAK;YACrB,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;SACjE,CAAA;QACD,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QAC5C,OAAO,MAAM,CAAA;IACf,CAAC;IAEO,yBAAyB,CAC/B,KAAc;QAEd,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAA;QACX,CAAC;QACD,MAAM,YAAY,GAAqC,EAAE,CAAA;QACzD,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;YAC9B,IACE,OAAO,SAAS,KAAK,QAAQ;gBAC7B,SAAS,KAAK,IAAI;gBAClB,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EACxB,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,MAAM,MAAM,GAAG,SAAoC,CAAA;YACnD,IACE,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ;gBAC7B,OAAO,MAAM,CAAC,iBAAiB,KAAK,QAAQ;gBAC5C,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ;gBACtC,CAAC,CACC,OAAO,MAAM,CAAC,YAAY,KAAK,QAAQ;oBACvC,MAAM,CAAC,YAAY,KAAK,IAAI,CAC7B;gBACD,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,EACnC,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,YAAY,CAAC,IAAI,CAAC;gBAChB,EAAE,EAAE,MAAM,CAAC,EAAE;gBACb,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;gBAC3C,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ;aAC1B,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,YAAY,CAAA;IACrB,CAAC;IAEO,iCAAiC,CACvC,KAAc;QAEd,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAA;QACX,CAAC;QACD,MAAM,WAAW,GAAkC,EAAE,CAAA;QACrD,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;YAC9B,IACE,OAAO,SAAS,KAAK,QAAQ;gBAC7B,SAAS,KAAK,IAAI;gBAClB,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EACxB,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,MAAM,MAAM,GAAG,SAAoC,CAAA;YACnD,IACE,OAAO,MAAM,CAAC,aAAa,KAAK,QAAQ;gBACxC,CAAC,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,CAAC;gBAC9D,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ;gBACnC,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ;gBACjC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAC5B,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,MAAM,KAAK,GAAsC,EAAE,CAAA;YACnD,KAAK,MAAM,aAAa,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACzC,IACE,OAAO,aAAa,KAAK,QAAQ;oBACjC,aAAa,KAAK,IAAI;oBACtB,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAC5B,CAAC;oBACD,SAAQ;gBACV,CAAC;gBACD,MAAM,IAAI,GAAG,aAAwC,CAAA;gBACrD,IACE,OAAO,IAAI,CAAC,cAAc,KAAK,QAAQ;oBACvC,OAAO,IAAI,CAAC,kBAAkB,KAAK,QAAQ;oBAC3C,OAAO,IAAI,CAAC,iBAAiB,KAAK,QAAQ;oBAC1C,OAAO,IAAI,CAAC,gCAAgC,KAAK,QAAQ;oBACzD,OAAO,IAAI,CAAC,iCAAiC,KAAK,QAAQ;oBAC1D,OAAO,IAAI,CAAC,cAAc,KAAK,QAAQ,EACvC,CAAC;oBACD,SAAQ;gBACV,CAAC;gBACD,KAAK,CAAC,IAAI,CAAC;oBACT,cAAc,EAAE,IAAI,CAAC,cAAc;oBACnC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;oBAC3C,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;oBACzC,gCAAgC,EAC9B,IAAI,CAAC,gCAAgC;oBACvC,iCAAiC,EAC/B,IAAI,CAAC,iCAAiC;oBACxC,cAAc,EAAE,IAAI,CAAC,cAAc;iBACpC,CAAC,CAAA;YACJ,CAAC;YACD,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;gBACzC,SAAQ;YACV,CAAC;YACD,MAAM,cAAc,GAAG,CAAC,KAAc,EAA0B,EAAE,CAChE,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAA;YAC7C,IACE,CAAC,cAAc,CAAC,MAAM,CAAC,aAAa,CAAC;gBACrC,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC;gBACtC,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC,EACtC,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,WAAW,CAAC,IAAI,CAAC;gBACf,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,KAAK;gBACL,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,YAAY,EAAE,MAAM,CAAC,YAAY,KAAK,IAAI;gBAC1C,cAAc,EAAE,MAAM,CAAC,cAAc,KAAK,IAAI;gBAC9C,cAAc,EAAE,MAAM,CAAC,cAAc,KAAK,IAAI;gBAC9C,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC;oBACpD,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAC3B,CAAC,EAAE,EAAgB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,CAC7C;oBACH,CAAC,CAAC,EAAE;gBACN,0BAA0B,EAAE,MAAM,CAAC,0BAA0B,KAAK,IAAI;gBACtE,cAAc,EAAE,MAAM,CAAC,cAAc;gBACrC,cAAc,EAAE,MAAM,CAAC,cAAc;aACtC,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,WAAW,CAAA;IACpB,CAAC;IAEO,6BAA6B,CACnC,UAAuC;QAEvC,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QACjC,IAAI,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,sDAAsD,CACvD,CAAA;QACH,CAAC;QACD,OAAO;YACL,aAAa,EAAE,UAAU,CAAC,aAAa;YACvC,cAAc,EAAE,UAAU,CAAC,KAAK,CAAC,MAAM,CACrC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,cAAc,EACxC,CAAC,CACF;YACD,WAAW,EAAE;gBACX,EAAE,EAAE,KAAK,CAAC,cAAc;gBACxB,uBAAuB,EAAE,KAAK,CAAC,iCAAiC;aACjE;YACD,aAAa,EAAE,UAAU,CAAC,aAAa;YACvC,cAAc,EAAE,UAAU,CAAC,cAAc;YACzC,cAAc,EAAE,UAAU,CAAC,cAAc;YACzC,6BAA6B,EAAE,CAAC;YAChC,uBAAuB,EAAE,CAAC;YAC1B,yBAAyB,EAAE,CAAC;YAC5B,oBAAoB,EAAE,KAAK;YAC3B,cAAc,EAAE,KAAK;SACtB,CAAA;IACH,CAAC;IAEO,sBAAsB,CAAC,MAAc;QAI3C,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,iEAAiE,CAClE,CAAA;QACH,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,IAAI,CAAC,GAAG,MAAM,gBAAgB,CAAC,CAAA;QACvD,IACE,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YACnC,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,EACjD,CAAC;YACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,iCAAiC,CAClC,CAAA;QACH,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,IAAI,CACxB,IAAI,CAAC,GAAG,CACN,WAAW,CAAC,cAAc,EAAE,EAC5B,WAAW,CAAC,WAAW,EAAE,GAAG,CAAC,EAC7B,CAAC,EACD,EAAE,EACF,EAAE,EACF,EAAE,EACF,GAAG,CACJ,CACF,CAAA;QACD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,CAAA;IACnC,CAAC;IAEO,WAAW,CAAC,KAAoB;QACtC,OAAO,CAAC,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;aACrD,WAAW,EAAE;aACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IACjB,CAAC;IAEO,2BAA2B,CACjC,QAAwC,EACxC,OAAwD;QAUxD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACrB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,8DAA8D,CAC/D,CAAA;QACH,CAAC;QACD,MAAM,aAAa,GAAG,IAAI,GAAG,EAAwC,CAAA;QACrE,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC1E,IACE,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC;gBACtB,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;gBAC9B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC;gBAC7C,IAAI,CAAC,iBAAiB,GAAG,CAAC,EAC1B,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,mEAAmE,CACpE,CAAA;YACH,CAAC;YACD,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QAC9B,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAA;QAC9C,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC1E,IACE,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC;gBACrB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,gBAAgB,CAAC;gBAC5C,IAAI,CAAC,gBAAgB,GAAG,CAAC;gBACzB,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,EACvB,CAAC;gBACD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,qEAAqE,CACtE,CAAA;YACH,CAAC;YACD,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAA;QAC9C,CAAC;QACD,IAAI,YAAY,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,EAAE,CAAC;YAC7C,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,wEAAwE,CACzE,CAAA;QACH,CAAC;QAED,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YAC3B,MAAM,eAAe,GAAG,YAAY,CAAC,GAAG,CACtC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAC/D,CAAA;YACD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;gBAClC,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,sDAAsD,CACvD,CAAA;YACH,CAAC;YACD,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACnC,CAAC,EACD,IAAI,CAAC,iBAAiB,GAAG,eAAe,CACzC,CAAA;YACD,MAAM,qBAAqB,GAAG,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAA;YACtE,OAAO;gBACL,GAAG,IAAI;gBACP,gBAAgB,EAAE,eAAe;gBACjC,sBAAsB,EAAE,oBAAoB;gBAC5C,4BAA4B,EAAE,qBAAqB;gBACnD,eAAe,EAAE,qBAAqB;oBACpC,CAAC,CAAC,8BAA8B;oBAChC,CAAC,CAAC,IAAI;gBACR,mBAAmB,EAAE,IAAI,CAAC,kBAAkB,IAAI,IAAI;aACrD,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAEO,kBAAkB,CACxB,eAAuB,EACvB,OAAsB;QAEtB,OAAO,GAAG,eAAe,IAAI,OAAO,IAAI,EAAE,EAAE,CAAA;IAC9C,CAAC;IAEO,YAAY,CAAC,KAAc;QACjC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACzE,CAAC,CAAE,KAAiC;YACpC,CAAC,CAAC,EAAE,CAAA;IACR,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,MAeC,EACD,OAAiB;QAEjB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAChD,EAAE,qBAAqB,EAAE,MAAM,CAAC,EAAE,EAAE,EACpC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAChC,OAAO,CACR,CAAA;QACD,MAAM,KAAK,GAA+B,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YACjD,MAAM,QAAQ,GACZ,OAAO,QAAQ,CAAC,sBAAsB,KAAK,QAAQ;gBACjD,CAAC,CAAC,QAAQ,CAAC,sBAAsB;gBACjC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAA;YAClC,OAAO;gBACL,GAAI,IAA4C;gBAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI;gBAC/B,sBAAsB,EAAE,QAAQ;gBAChC,eAAe,EAAE,IAAI,CAAC,eAAe,IAAI,IAAI;gBAC7C,mBAAmB,EACjB,OAAO,QAAQ,CAAC,mBAAmB,KAAK,QAAQ;oBAC9C,CAAC,CAAC,QAAQ,CAAC,mBAAmB;oBAC9B,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC;gBACxC,qBAAqB,EACnB,OAAO,QAAQ,CAAC,qBAAqB,KAAK,QAAQ;oBAChD,CAAC,CAAC,QAAQ,CAAC,qBAAqB;oBAChC,CAAC,CAAC,IAAI;gBACV,cAAc,EACZ,OAAO,QAAQ,CAAC,cAAc,KAAK,QAAQ;oBACzC,CAAC,CAAC,QAAQ,CAAC,cAAc;oBACzB,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC;aACtC,CAAA;QACH,CAAC,CAAC,CAAA;QACF,MAAM,WAAW,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QACjD,MAAM,gBAAgB,GAAG,IAAI,IAAI,CAC/B,IAAI,CAAC,GAAG,CACN,WAAW,CAAC,cAAc,EAAE,EAC5B,WAAW,CAAC,WAAW,EAAE,GAAG,CAAC,EAC7B,CAAC,EACD,EAAE,EACF,EAAE,EACF,EAAE,EACF,GAAG,CACJ,CACF,CAAA;QAED,OAAO;YACL,GAAI,MAAyD;YAC7D,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,gBAAgB;YACjD,MAAM,EAAE,MAAM,CAAC,MAAwC;YACvD,KAAK;SACN,CAAA;IACH,CAAC;CACF;AAp6GO;IADL,IAAA,gCAAwB,GAAE;IAExB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qEAwDjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAkEjB;AAiBK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAyBjB;AASK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAkBjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAuCjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;kEA6BjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wFAsBjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAKxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;sEA2CjB;AA8EK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;0EAIjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAIjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;2EAIjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAIjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;iFAIjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;6EAOjB;AA2DK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;uEAGjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;uEAGjB;AAuCK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;iEAOjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;uEAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAMjB;AAyBK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;0EAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;gFAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAOxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;oFASjB;AAWK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qFAQjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;8EAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAIxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;uFAMjB;AAcK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qEAMjB;AA+CK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;6EAmBjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAQxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yFAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;sEA8DjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wEA0CjB;AAOK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;+EAYjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAQxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;4EAcjB;AA2LK;IADL,IAAA,gCAAwB,GAAE;IAUxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;+EAmDjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAOxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qFAoBjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wEAgHjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAcxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAsFjB;AAoJK;IADL,IAAA,gCAAwB,GAAE;IAKxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;sEA4HjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAYxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAqDjB;AAUK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wEA8LjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IASxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;yEAkEjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;0EA+MjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAcxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;iFA+DjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAYxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;2EAgEjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAOxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qEAkCjB;AAeK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;sEAKjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wEA0BjB;AAsDK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;wEAMjB;AASK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qEAMjB;AAGK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;qEAMjB;AAmyBH,kBAAe,sBAAsB,CAAA"}