@stigg/cache-runtime 2.0.0

package/dist/services/entitlementsService.js

@@ -0,0 +1,423 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementsService = void 0;
+const nanoid_1 = require("nanoid");
+const cache_core_1 = require("@stigg/cache-core");
+const lodash_1 = require("lodash");
+class EntitlementsService {
+    constructor(entitlementsApi, loggerService, cacheService, entitlementsTimeout, evaluator, offline, errorHandler) {
+        this.entitlementsApi = entitlementsApi;
+        this.loggerService = loggerService;
+        this.cacheService = cacheService;
+        this.entitlementsTimeout = entitlementsTimeout;
+        this.evaluator = evaluator;
+        this.offline = offline;
+        this.errorHandler = errorHandler;
+        this.isInitialized = false;
+    }
+    async getBooleanEntitlement(customerId, featureRefId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get boolean entitlement, using fallback entitlement', () => this.readBooleanEntitlement(customerId, featureRefId, resourceId, options), () => this.evaluator.fallbacks.forBoolean(featureRefId, options));
+    }
+    async readBooleanEntitlement(customerId, featureRefId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forBoolean(featureRefId, options);
+        }
+        const query = { type: cache_core_1.EntitlementType.Feature, id: featureRefId };
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, 'getBooleanEntitlement');
+        const evaluation = this.evaluator.evaluateBoolean(query, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement for boolean feature found`, {
+                customerId,
+                resourceId,
+                featureRefId,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getNumericEntitlement(customerId, featureRefId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get numeric entitlement, using fallback entitlement', () => this.readNumericEntitlement(customerId, featureRefId, resourceId, options), () => this.evaluator.fallbacks.forNumeric(featureRefId, options));
+    }
+    async readNumericEntitlement(customerId, featureRefId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forNumeric(featureRefId, options);
+        }
+        const query = { type: cache_core_1.EntitlementType.Feature, id: featureRefId };
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, 'getNumericEntitlement');
+        const evaluation = this.evaluator.evaluateNumeric(query, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement for numeric feature found`, {
+                customerId,
+                resourceId,
+                featureRefId,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getMeteredEntitlement(customerId, featureRefId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get metered entitlement, using fallback entitlement', () => this.readMeteredEntitlement(customerId, featureRefId, resourceId, options), () => this.evaluator.fallbacks.forMetered(featureRefId, options));
+    }
+    async readMeteredEntitlement(customerId, featureRefId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forMetered(featureRefId, options);
+        }
+        const query = { type: cache_core_1.EntitlementType.Feature, id: featureRefId };
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, 'getMeteredEntitlement');
+        const evaluation = this.evaluator.evaluateMetered(query, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement for metered feature found`, {
+                customerId,
+                resourceId,
+                featureRefId,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getEnumEntitlement(customerId, featureRefId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get enum entitlement, using fallback entitlement', () => this.readEnumEntitlement(customerId, featureRefId, resourceId, options), () => this.evaluator.fallbacks.forEnum(featureRefId, options));
+    }
+    async readEnumEntitlement(customerId, featureRefId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forEnum(featureRefId, options);
+        }
+        const query = { type: cache_core_1.EntitlementType.Feature, id: featureRefId };
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, 'getEnumEntitlement');
+        const evaluation = this.evaluator.evaluateEnum(query, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement for enum feature found`, {
+                customerId,
+                resourceId,
+                featureRefId,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getCreditEntitlement(customerId, currencyId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get credit entitlement, using fallback entitlement', () => this.readCreditEntitlement(customerId, currencyId, resourceId, options), () => this.evaluator.fallbacks.forCredit(currencyId, options));
+    }
+    async readCreditEntitlement(customerId, currencyId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forCredit(currencyId, options);
+        }
+        const query = { type: cache_core_1.EntitlementType.Credit, id: currencyId };
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, 'getCreditEntitlement');
+        const evaluation = this.evaluator.evaluateCredit(query, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement for credit currency found`, {
+                customerId,
+                resourceId,
+                currencyId,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getEntitlement(entitlementReference, customerRefId, resourceId, options) {
+        return this.errorHandler.readOrFallback('Failed to get entitlement, using fallback entitlement', () => this.readEntitlement(entitlementReference, customerRefId, resourceId, options), () => this.evaluator.fallbacks.forQuery(entitlementReference, options));
+    }
+    async readEntitlement(entitlementReference, customerRefId, resourceId, options) {
+        if (this.offline) {
+            return this.evaluator.fallbacks.forQuery(entitlementReference, options);
+        }
+        const { entitlement, accessDeniedReason } = await this.getCustomerAndEntitlementFromCacheOrRefetch(entitlementReference, customerRefId, resourceId, 'getEntitlement');
+        const evaluation = this.evaluator.evaluate(entitlementReference, entitlement, accessDeniedReason, options);
+        if (!entitlement) {
+            this.loggerService.log(`No entitlement found for reference`, {
+                customerRefId,
+                resourceId,
+                entitlementReference,
+                accessDeniedReason: evaluation.accessDeniedReason,
+            });
+        }
+        return evaluation;
+    }
+    async getCustomerAndEntitlementFromCacheOrRefetch(query, customerId, resourceId, triggeredBy) {
+        var _a, _b;
+        const result = await this.cacheService.getCustomerEntitlement({ query, customerId, resourceId });
+        let { entitlement, accessDeniedReason } = result;
+        const shouldRefetch = result.cacheMiss || !this.isInitialized || this.isEntitlementExpired(entitlement);
+        if (shouldRefetch) {
+            const postMissResult = await this.refetchEntitlementsAfterCacheMiss({
+                customerId,
+                resourceId,
+                refetchGlobalCustomer: result.globalCustomerMissing,
+                triggeredBy,
+            });
+            entitlement = (_b = (_a = postMissResult.entitlements) === null || _a === void 0 ? void 0 : _a.get(query)) !== null && _b !== void 0 ? _b : null;
+            accessDeniedReason = postMissResult.accessDeniedReason;
+        }
+        return { entitlement, accessDeniedReason };
+    }
+    async getCustomerEntitlements(customerId, resourceId) {
+        return this.errorHandler.readOrFallback('Failed to get customer entitlements, using fallback entitlements', () => this.readCustomerEntitlements(customerId, resourceId), () => ({ entitlements: this.evaluator.fallbacks.forAllConfigured(), accessDeniedReason: null }));
+    }
+    async readCustomerEntitlements(customerId, resourceId) {
+        if (this.offline) {
+            return { entitlements: this.evaluator.fallbacks.forAllConfigured(), accessDeniedReason: null };
+        }
+        const result = await this.cacheService.getCustomerEntitlements({ customerId, resourceId });
+        let { entitlements, accessDeniedReason } = result;
+        const shouldRefetch = result.cacheMiss || !this.isInitialized || this.areEntitlementsExpired(entitlements);
+        if (shouldRefetch) {
+            ({ entitlements, accessDeniedReason } = await this.refetchEntitlementsAfterCacheMiss({
+                customerId,
+                resourceId,
+                refetchGlobalCustomer: result.globalCustomerMissing,
+                triggeredBy: 'getCustomerEntitlements',
+            }));
+        }
+        if (!entitlements) {
+            return { entitlements: [], accessDeniedReason: accessDeniedReason !== null && accessDeniedReason !== void 0 ? accessDeniedReason : null };
+        }
+        return {
+            entitlements: entitlements
+                .values()
+                .map((value) => this.evaluator.evaluate(value.getEntitlementQuery(), value, accessDeniedReason)),
+            accessDeniedReason: accessDeniedReason !== null && accessDeniedReason !== void 0 ? accessDeniedReason : null,
+        };
+    }
+    /** Offline never reaches the API, so the measurement is acknowledged locally instead. */
+    offlineMeasurement({ customerId, resourceId, featureId }) {
+        return { id: (0, nanoid_1.nanoid)(), customerId, resourceId, featureId, timestamp: Date.now() };
+    }
+    async reportUsage(input) {
+        if (this.offline) {
+            return this.offlineMeasurement(input);
+        }
+        return this.errorHandler.runOrThrow('Failed to report usage', async () => {
+            const result = await this.entitlementsApi.reportUsage(input);
+            await this.updateFeatureUsage(result);
+            return result;
+        });
+    }
+    async reportUsageBulk(input) {
+        if (this.offline) {
+            return input.usages.map((usage) => this.offlineMeasurement(usage));
+        }
+        return this.errorHandler.runOrThrow('Failed to bulk report usage', async () => {
+            const results = await this.entitlementsApi.reportUsageBulk(input);
+            for (const measurement of results) {
+                await this.updateFeatureUsage(measurement);
+            }
+            return results;
+        });
+    }
+    /** Passes through: an event has no cache state to maintain, unlike a usage measurement. */
+    async reportEvent(events) {
+        if (this.offline) {
+            return;
+        }
+        await this.errorHandler.runOrThrow('Failed to report usage event', () => this.entitlementsApi.reportEvent(events));
+    }
+    /** Passes through: the balance is settled server-side, so there is nothing to write through. */
+    async consumeCreditsAsync(consumptions) {
+        if (this.offline) {
+            return;
+        }
+        await this.errorHandler.runOrThrow('Failed to consume credits', () => this.entitlementsApi.consumeCreditsAsync(consumptions));
+    }
+    async consumeCredits(input) {
+        if (this.offline) {
+            const { customerId, currencyId, resourceId, amount } = input;
+            return { customerId, currencyId, resourceId, amount, timestamp: Date.now() };
+        }
+        return this.errorHandler.runOrThrow('Failed to consume credits', async () => {
+            const result = await this.entitlementsApi.consumeCredits(input);
+            if (result.credit) {
+                await this.updateCreditBalance({
+                    customerId: result.customerId,
+                    resourceId: result.resourceId,
+                    credit: result.credit,
+                });
+            }
+            return result;
+        });
+    }
+    async refetchEntitlementsAfterCacheMiss(params) {
+        const { customerId, resourceId, triggeredBy, refetchGlobalCustomer } = params;
+        const refetchPromise = this.refetchEntityEntitlementsAfterCacheMiss(params);
+        if ((0, lodash_1.isNil)(resourceId) || !refetchGlobalCustomer) {
+            return refetchPromise;
+        }
+        const globalCustomerRefetchPromise = this.refetchEntityEntitlementsAfterCacheMiss({
+            customerId,
+            resourceId: undefined,
+            triggeredBy,
+        });
+        const [resourceResult] = await Promise.all([refetchPromise, globalCustomerRefetchPromise]);
+        return resourceResult;
+    }
+    /**
+     * Force a refetch and report whether the entitled entity exists at all. `NoActiveSubscription`
+     * still counts as existing — the customer is known, they just have nothing active.
+     *
+     * A failure answers `false` rather than throwing: not knowing and knowing there is nothing are
+     * the same answer to the caller, and both hosts wanted it.
+     */
+    async reloadEntitlements(customerId, resourceId) {
+        if (this.offline) {
+            return { entitledEntityExists: true };
+        }
+        return this.errorHandler.readOrFallback('Failed to reload customer entitlements', async () => {
+            if (!customerId || typeof customerId !== 'string') {
+                throw new Error('Invalid argument: customerId');
+            }
+            const response = await this.refetchEntitlements({
+                customerId,
+                resourceId,
+                skipEdge: true,
+                triggeredBy: 'reloadEntitlements',
+            });
+            if (response == null) {
+                return { entitledEntityExists: false };
+            }
+            return {
+                entitledEntityExists: response.accessDeniedReason == null ||
+                    response.accessDeniedReason === cache_core_1.AccessDeniedReason.NoActiveSubscription,
+            };
+        }, () => ({ entitledEntityExists: false }));
+    }
+    async refetchEntitlements({ customerId, resourceId, skipEdge, triggeredBy, }) {
+        this.loggerService.log(`Re-fetching entitlements`, {
+            customerId,
+            resourceId,
+            skipEdge,
+            triggeredBy,
+        });
+        const { entitlements, accessDeniedReason } = await this.entitlementsApi.getEntitlementsState(customerId, resourceId, skipEdge, this.entitlementsTimeout);
+        // State-level and entitlement-level reasons are distinct vocabularies; the cache stores
+        // the former and answers reads with the latter.
+        const localAccessDeniedReason = (0, cache_core_1.mapAccessDeniedReason)(accessDeniedReason);
+        const updatedEntitlements = await this.setEntitlements({
+            entitlements,
+            accessDeniedReason,
+            customerId,
+            resourceId,
+        });
+        return cache_core_1.entitlementsResponseMapper.cacheHit(updatedEntitlements, localAccessDeniedReason);
+    }
+    async setEntitlementsIfExists(options) {
+        const { entitlements } = options, rest = __rest(options, ["entitlements"]);
+        if ((0, lodash_1.isNil)(entitlements)) {
+            return Promise.resolve(null);
+        }
+        return this.setEntitlements(Object.assign({ entitlements, accessDeniedReason: null }, rest));
+    }
+    async setEntitlements(params) {
+        const { entitlements, accessDeniedReason, customerId, resourceId } = params;
+        const entitlementsUpdatedAtTimestamp = this.getEntitlementsUpdatedAtTimestamp({
+            entitlements,
+            customerId,
+            resourceId,
+        });
+        return this.cacheService.setCustomer({
+            customerId,
+            resourceId,
+            entitlements,
+            accessDeniedReason,
+            entitlementsTimestamp: entitlementsUpdatedAtTimestamp.getTime(),
+        });
+    }
+    getEntitlementsUpdatedAtTimestamp({ entitlements, customerId, resourceId, }) {
+        if ((0, lodash_1.isEmpty)(entitlements)) {
+            // empty entitlements means we don't have a timestamp
+            return cache_core_1.DATE_IN_FAR_PAST;
+        }
+        const entitlementsUpdatedAt = entitlements
+            .map(({ entitlementUpdatedAt }) => entitlementUpdatedAt)
+            // Cast preserves today's quirk: isValidDate(null) is true (epoch 0), so a null here is
+            // "found" and then rejected by the falsy check below, while undefined is skipped outright.
+            // Both land on new Date(); narrowing it properly is a behaviour change, so not here.
+            .find((entitlementUpdatedAt) => (0, cache_core_1.isValidDate)(entitlementUpdatedAt));
+        if (!entitlementsUpdatedAt) {
+            this.loggerService.error(`Failed to find entitlements updated at timestamp for customer`, {
+                customerId,
+                resourceId,
+            });
+            return new Date();
+        }
+        return new Date(entitlementsUpdatedAt);
+    }
+    async updateFeatureUsage({ featureId, customerId, resourceId, currentUsage, usagePeriodStart, usagePeriodEnd, credit, timestamp, }) {
+        var _a;
+        if (!(0, lodash_1.isNil)(currentUsage)) {
+            await this.cacheService.updateUsage({
+                customerId,
+                resourceId,
+                entitlementReference: {
+                    type: cache_core_1.EntitlementType.Feature,
+                    id: featureId,
+                },
+                usageTimestamp: (_a = (0, cache_core_1.mapDate)(timestamp)) !== null && _a !== void 0 ? _a : new Date(),
+                usage: {
+                    currentUsage,
+                    usagePeriodStart: (0, cache_core_1.toEpochMs)(usagePeriodStart),
+                    usagePeriodEnd: (0, cache_core_1.toEpochMs)(usagePeriodEnd),
+                },
+            });
+        }
+        // For credit-backed features, also update the optimistic balance of the credit entitlement,
+        // keyed by its currency and reconciled by the credit's own grant-version timestamp.
+        if (credit) {
+            await this.updateCreditBalance({ customerId, resourceId, credit });
+        }
+    }
+    // Writes the optimistic credit balance into the cache, keyed by its currency and reconciled
+    // by the credit's own grant-version timestamp. Shared by reportUsage (credit-backed features)
+    // and direct credit consumption.
+    async updateCreditBalance({ customerId, resourceId, credit, }) {
+        var _a;
+        await this.cacheService.updateUsage({
+            customerId,
+            resourceId: resourceId !== null && resourceId !== void 0 ? resourceId : undefined,
+            entitlementReference: {
+                type: cache_core_1.EntitlementType.Credit,
+                id: credit.currencyId,
+            },
+            usageTimestamp: (_a = (0, cache_core_1.mapDate)(credit.timestamp)) !== null && _a !== void 0 ? _a : new Date(),
+            usage: {
+                currentUsage: credit.currentUsage,
+                // Credits have no period start; carry the reset date through so the cached
+                // credit entitlement's usagePeriodEnd isn't wiped by the usage update.
+                usagePeriodStart: null,
+                usagePeriodEnd: (0, cache_core_1.toEpochMs)(credit.usagePeriodEnd),
+            },
+        });
+    }
+    /**
+     * Reports only whether the cache store is readable. `CacheRuntime`'s method of the same name is
+     * the one that reports whether startup as a whole succeeded.
+     */
+    async waitForInitialization() {
+        await this.cacheService.waitForInitialization();
+    }
+    isEntitlementExpired(entitlement) {
+        if (!entitlement) {
+            return false;
+        }
+        const { validUntil } = entitlement.calculatedEntitlement;
+        return validUntil ? validUntil <= new Date().valueOf() : false;
+    }
+    areEntitlementsExpired(entitlements) {
+        if (!entitlements) {
+            return false;
+        }
+        return entitlements.values().some((entitlement) => this.isEntitlementExpired(entitlement));
+    }
+}
+exports.EntitlementsService = EntitlementsService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entitlementsService.js","sourceRoot":"","sources":["../../src/services/entitlementsService.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,mCAAgC;AAWhC,kDAiB2B;AAC3B,mCAAwC;AAqBxC,MAAsB,mBAAmB;IAGvC,YACqB,eAAgE,EAChE,aAAyB,EACzB,YAAiC,EACnC,mBAA2B,EACzB,SAA+B,EACjC,OAAgB,EAChB,YAAiC;QAN/B,oBAAe,GAAf,eAAe,CAAiD;QAChE,kBAAa,GAAb,aAAa,CAAY;QACzB,iBAAY,GAAZ,YAAY,CAAqB;QACnC,wBAAmB,GAAnB,mBAAmB,CAAQ;QACzB,cAAS,GAAT,SAAS,CAAsB;QACjC,YAAO,GAAP,OAAO,CAAS;QAChB,iBAAY,GAAZ,YAAY,CAAqB;QAT1C,kBAAa,GAAG,KAAK,CAAC;IAU7B,CAAC;IAEJ,KAAK,CAAC,qBAAqB,CACzB,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,+DAA+D,EAC/D,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,EAChF,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CACjE,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,sBAAsB,CACpC,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,4BAAe,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;QAElE,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,KAAK,EACL,UAAU,EACV,UAAU,EACV,uBAAuB,CACxB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAEnG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,0CAA0C,EAAE;gBACjE,UAAU;gBACV,UAAU;gBACV,YAAY;gBACZ,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,qBAAqB,CACzB,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,+DAA+D,EAC/D,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,EAChF,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CACjE,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,sBAAsB,CACpC,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,4BAAe,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;QAClE,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,KAAK,EACL,UAAU,EACV,UAAU,EACV,uBAAuB,CACxB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAEnG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,0CAA0C,EAAE;gBACjE,UAAU;gBACV,UAAU;gBACV,YAAY;gBACZ,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,qBAAqB,CACzB,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,+DAA+D,EAC/D,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,EAChF,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CACjE,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,sBAAsB,CACpC,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAmC;QAEnC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,4BAAe,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;QAClE,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,KAAK,EACL,UAAU,EACV,UAAU,EACV,uBAAuB,CACxB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAEnG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,0CAA0C,EAAE;gBACjE,UAAU;gBACV,UAAU;gBACV,YAAY;gBACZ,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,kBAAkB,CACtB,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,4DAA4D,EAC5D,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,EAC7E,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,CAC9D,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,mBAAmB,CACjC,UAAkB,EAClB,YAAoB,EACpB,UAAmB,EACnB,OAAgC;QAEhC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,4BAAe,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;QAClE,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,KAAK,EACL,UAAU,EACV,UAAU,EACV,oBAAoB,CACrB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAEhG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,uCAAuC,EAAE;gBAC9D,UAAU;gBACV,UAAU;gBACV,YAAY;gBACZ,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,oBAAoB,CACxB,UAAkB,EAClB,UAAkB,EAClB,UAAmB,EACnB,OAAkC;QAElC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,8DAA8D,EAC9D,GAAG,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,EAC7E,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,CAC9D,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,qBAAqB,CACnC,UAAkB,EAClB,UAAkB,EAClB,UAAmB,EACnB,OAAkC;QAElC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,4BAAe,CAAC,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC;QAC/D,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,KAAK,EACL,UAAU,EACV,UAAU,EACV,sBAAsB,CACvB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAElG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,0CAA0C,EAAE;gBACjE,UAAU;gBACV,UAAU;gBACV,UAAU;gBACV,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,cAAc,CAClB,oBAA6C,EAC7C,aAAqB,EACrB,UAA8B,EAC9B,OAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,uDAAuD,EACvD,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,oBAAoB,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,CAAC,EACpF,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC,CACvE,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,eAAe,CAC7B,oBAA6C,EAC7C,aAAqB,EACrB,UAA8B,EAC9B,OAAgC;QAEhC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;QAC1E,CAAC;QAED,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,2CAA2C,CAChG,oBAAoB,EACpB,aAAa,EACb,UAAU,EACV,gBAAgB,CACjB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;QAE3G,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,oCAAoC,EAAE;gBAC3D,aAAa;gBACb,UAAU;gBACV,oBAAoB;gBACpB,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;aAClD,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,KAAK,CAAC,2CAA2C,CACvD,KAA0B,EAC1B,UAAkB,EAClB,UAA8B,EAC9B,WAAsC;;QAEtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;QACjG,IAAI,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAAC;QAEjD,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAExG,IAAI,aAAa,EAAE,CAAC;YAClB,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAAC;gBAClE,UAAU;gBACV,UAAU;gBACV,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;gBACnD,WAAW;aACZ,CAAC,CAAC;YAEH,WAAW,GAAG,MAAA,MAAA,cAAc,CAAC,YAAY,0CAAE,GAAG,CAAC,KAAK,CAAC,mCAAI,IAAI,CAAC;YAC9D,kBAAkB,GAAG,cAAc,CAAC,kBAAkB,CAAC;QACzD,CAAC;QAED,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAAkB,EAClB,UAA8B;QAE9B,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,kEAAkE,EAClE,GAAG,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,UAAU,CAAC,EAC3D,GAAG,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAChG,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,wBAAwB,CACtC,UAAkB,EAClB,UAA8B;QAE9B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;QACjG,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;QAC3F,IAAI,EAAE,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAAC;QAElD,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;QAE3G,IAAI,aAAa,EAAE,CAAC;YAClB,CAAC,EAAE,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,iCAAiC,CAAC;gBACnF,UAAU;gBACV,UAAU;gBACV,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;gBACnD,WAAW,EAAE,yBAAyB;aACvC,CAAC,CAAC,CAAC;QACN,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,kBAAkB,EAAE,kBAAkB,aAAlB,kBAAkB,cAAlB,kBAAkB,GAAI,IAAI,EAAE,CAAC;QAC9E,CAAC;QAED,OAAO;YACL,YAAY,EAAE,YAAY;iBACvB,MAAM,EAAE;iBACR,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAC;YAClG,kBAAkB,EAAE,kBAAkB,aAAlB,kBAAkB,cAAlB,kBAAkB,GAAI,IAAI;SAC/C,CAAC;IACJ,CAAC;IAMD,yFAAyF;IACjF,kBAAkB,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAyB;QACrF,OAAO,EAAE,EAAE,EAAE,IAAA,eAAM,GAAE,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;IACpF,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,KAA4B;QAC5C,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;YACvE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAC7D,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;YACtC,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,KAAgC;QACpD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,6BAA6B,EAAE,KAAK,IAAI,EAAE;YAC5E,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YAElE,KAAK,MAAM,WAAW,IAAI,OAAO,EAAE,CAAC;gBAClC,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;YAC7C,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,2FAA2F;IAC3F,KAAK,CAAC,WAAW,CAAC,MAAyB;QACzC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,8BAA8B,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;IACrH,CAAC;IAED,gGAAgG;IAChG,KAAK,CAAC,mBAAmB,CAAC,YAAsC;QAC9D,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,2BAA2B,EAAE,GAAG,EAAE,CACnE,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,YAAY,CAAC,CACvD,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,KAA6B;QAChD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;YAC7D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAC/E,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;YAC1E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAEhE,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAClB,MAAM,IAAI,CAAC,mBAAmB,CAAC;oBAC7B,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,MAAM,EAAE,MAAM,CAAC,MAAM;iBACtB,CAAC,CAAC;YACL,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAES,KAAK,CAAC,iCAAiC,CAC/C,MAA+C;QAE/C,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,qBAAqB,EAAE,GAAG,MAAM,CAAC;QAE9E,MAAM,cAAc,GAAG,IAAI,CAAC,uCAAuC,CAAC,MAAM,CAAC,CAAC;QAC5E,IAAI,IAAA,cAAK,EAAC,UAAU,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAChD,OAAO,cAAc,CAAC;QACxB,CAAC;QAED,MAAM,4BAA4B,GAAG,IAAI,CAAC,uCAAuC,CAAC;YAChF,UAAU;YACV,UAAU,EAAE,SAAS;YACrB,WAAW;SACZ,CAAC,CAAC;QAEH,MAAM,CAAC,cAAc,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,cAAc,EAAE,4BAA4B,CAAC,CAAC,CAAC;QAC3F,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,kBAAkB,CAAC,UAAkB,EAAE,UAAmB;QAC9D,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;QACxC,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CACrC,wCAAwC,EACxC,KAAK,IAAI,EAAE;YACT,IAAI,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;gBAClD,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;YAClD,CAAC;YAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC;gBAC9C,UAAU;gBACV,UAAU;gBACV,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,oBAAoB;aAClC,CAAC,CAAC;YAEH,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;gBACrB,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC;YACzC,CAAC;YAED,OAAO;gBACL,oBAAoB,EAClB,QAAQ,CAAC,kBAAkB,IAAI,IAAI;oBACnC,QAAQ,CAAC,kBAAkB,KAAK,+BAAkB,CAAC,oBAAoB;aAC1E,CAAC;QACJ,CAAC,EACD,GAAG,EAAE,CAAC,CAAC,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAMD,KAAK,CAAC,mBAAmB,CAAC,EACxB,UAAU,EACV,UAAU,EACV,QAAQ,EACR,WAAW,GACe;QAC1B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,0BAA0B,EAAE;YACjD,UAAU;YACV,UAAU;YACV,QAAQ;YACR,WAAW;SACZ,CAAC,CAAC;QAEH,MAAM,EAAE,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAC1F,UAAU,EACV,UAAU,EACV,QAAQ,EACR,IAAI,CAAC,mBAAmB,CACzB,CAAC;QAEF,wFAAwF;QACxF,gDAAgD;QAChD,MAAM,uBAAuB,GAAG,IAAA,kCAAqB,EAAC,kBAAkB,CAAC,CAAC;QAE1E,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC;YACrD,YAAY;YACZ,kBAAkB;YAClB,UAAU;YACV,UAAU;SACX,CAAC,CAAC;QAEH,OAAO,uCAA0B,CAAC,QAAQ,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,CAAC;IAC3F,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,OAI7B;QACC,MAAM,EAAE,YAAY,KAAc,OAAO,EAAhB,IAAI,UAAK,OAAO,EAAnC,gBAAyB,CAAU,CAAC;QAC1C,IAAI,IAAA,cAAK,EAAC,YAAY,CAAC,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,IAAI,CAAC,eAAe,iBACzB,YAAY,EACZ,kBAAkB,EAAE,IAAI,IACrB,IAAI,EACP,CAAC;IACL,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,MAKrB;QACC,MAAM,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QAE5E,MAAM,8BAA8B,GAAG,IAAI,CAAC,iCAAiC,CAAC;YAC5E,YAAY;YACZ,UAAU;YACV,UAAU;SACX,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;YACnC,UAAU;YACV,UAAU;YACV,YAAY;YACZ,kBAAkB;YAClB,qBAAqB,EAAE,8BAA8B,CAAC,OAAO,EAAE;SAChE,CAAC,CAAC;IACL,CAAC;IAES,iCAAiC,CAAC,EAC1C,YAAY,EACZ,UAAU,EACV,UAAU,GAKX;QACC,IAAI,IAAA,gBAAO,EAAC,YAAY,CAAC,EAAE,CAAC;YAC1B,qDAAqD;YACrD,OAAO,6BAAgB,CAAC;QAC1B,CAAC;QAED,MAAM,qBAAqB,GAAG,YAAY;aACvC,GAAG,CAAC,CAAC,EAAE,oBAAoB,EAAE,EAAE,EAAE,CAAC,oBAAoB,CAAC;YACxD,uFAAuF;YACvF,2FAA2F;YAC3F,qFAAqF;aACpF,IAAI,CAAC,CAAC,oBAAoB,EAAE,EAAE,CAAC,IAAA,wBAAW,EAAC,oBAA8B,CAAC,CAAC,CAAC;QAE/E,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,+DAA+D,EAAE;gBACxF,UAAU;gBACV,UAAU;aACX,CAAC,CAAC;YACH,OAAO,IAAI,IAAI,EAAE,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,EACvB,SAAS,EACT,UAAU,EACV,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,MAAM,EACN,SAAS,GACc;;QACvB,IAAI,CAAC,IAAA,cAAK,EAAC,YAAY,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;gBAClC,UAAU;gBACV,UAAU;gBACV,oBAAoB,EAAE;oBACpB,IAAI,EAAE,4BAAe,CAAC,OAAO;oBAC7B,EAAE,EAAE,SAAS;iBACd;gBACD,cAAc,EAAE,MAAA,IAAA,oBAAO,EAAC,SAAS,CAAC,mCAAI,IAAI,IAAI,EAAE;gBAChD,KAAK,EAAE;oBACL,YAAY;oBACZ,gBAAgB,EAAE,IAAA,sBAAS,EAAC,gBAAgB,CAAC;oBAC7C,cAAc,EAAE,IAAA,sBAAS,EAAC,cAAc,CAAC;iBAC1C;aACF,CAAC,CAAC;QACL,CAAC;QAED,4FAA4F;QAC5F,oFAAoF;QACpF,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,IAAI,CAAC,mBAAmB,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,4FAA4F;IAC5F,8FAA8F;IAC9F,iCAAiC;IACzB,KAAK,CAAC,mBAAmB,CAAC,EAChC,UAAU,EACV,UAAU,EACV,MAAM,GAKP;;QACC,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;YAClC,UAAU;YACV,UAAU,EAAE,UAAU,aAAV,UAAU,cAAV,UAAU,GAAI,SAAS;YACnC,oBAAoB,EAAE;gBACpB,IAAI,EAAE,4BAAe,CAAC,MAAM;gBAC5B,EAAE,EAAE,MAAM,CAAC,UAAU;aACtB;YACD,cAAc,EAAE,MAAA,IAAA,oBAAO,EAAC,MAAM,CAAC,SAAS,CAAC,mCAAI,IAAI,IAAI,EAAE;YACvD,KAAK,EAAE;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,2EAA2E;gBAC3E,uEAAuE;gBACvE,gBAAgB,EAAE,IAAI;gBACtB,cAAc,EAAE,IAAA,sBAAS,EAAC,MAAM,CAAC,cAAc,CAAC;aACjD;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,qBAAqB;QACzB,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,EAAE,CAAC;IAClD,CAAC;IAEO,oBAAoB,CAAC,WAA4E;QACvG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,qBAAqB,CAAC;QACzD,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACjE,CAAC;IAEO,sBAAsB,CAAC,YAAoC;QACjE,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,YAAY,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC7F,CAAC;CACF;AAlrBD,kDAkrBC"}

package/dist/services/entitlementsService.utils.d.ts

@@ -0,0 +1,16 @@
+export type GetEntitlementsOperations = 'getBooleanEntitlement' | 'getNumericEntitlement' | 'getMeteredEntitlement' | 'getEnumEntitlement' | 'getCreditEntitlement' | 'getEntitlement' | 'getCustomerEntitlements';
+export type RefetchEntitlementsTriggeredBy = GetEntitlementsOperations | 'updateSubscription' | 'cancelSubscription' | 'createSubscription' | 'reloadEntitlements';
+export type RefetchEntityEntitlementsAfterCacheMissParams = {
+    customerId: string;
+    resourceId: string | undefined;
+    triggeredBy: GetEntitlementsOperations;
+};
+export type RefetchEntitlementsAfterCacheMissParams = RefetchEntityEntitlementsAfterCacheMissParams & {
+    refetchGlobalCustomer: boolean;
+};
+export type RefetchEntitlementsParams = {
+    customerId: string;
+    resourceId: string | undefined;
+    skipEdge?: boolean;
+    triggeredBy: RefetchEntitlementsTriggeredBy;
+};

package/dist/services/entitlementsService.utils.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXRsZW1lbnRzU2VydmljZS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJ2aWNlcy9lbnRpdGxlbWVudHNTZXJ2aWNlLnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/services/inMemoryEntitlementsService.d.ts

@@ -0,0 +1,23 @@
+import { RuntimeErrorHandler } from './runtimeErrorHandler';
+import { EntitlementsService } from './entitlementsService';
+import { InMemoryCacheService, SlimLogger } from '@stigg/cache-core';
+import { EntitlementEvaluator } from '@stigg/entitlements-runtime';
+import { CacheableInput, EntitlementsRuntimeHooks, EntitlementsTransport } from '../types/transport';
+import { RefetchEntityEntitlementsAfterCacheMissParams } from './entitlementsService.utils';
+export declare class InMemoryEntitlementsService<Input extends CacheableInput, TPackagePublished = unknown> extends EntitlementsService<Input, TPackagePublished> {
+    protected readonly cacheService: InMemoryCacheService<Input>;
+    private readonly hooks;
+    private entitlementsSubscription;
+    private usageSubscription;
+    private packagePublishedSubscription;
+    constructor(cacheService: InMemoryCacheService<Input>, entitlementsApi: EntitlementsTransport<Input, TPackagePublished>, hooks: EntitlementsRuntimeHooks<Input, TPackagePublished>, loggerService: SlimLogger, entitlementsTimeout: number, evaluator: EntitlementEvaluator, offline: boolean, errorHandler: RuntimeErrorHandler);
+    init(): void;
+    private websocketErrorHandling;
+    cleanup(): void;
+    private onEntitlementsUpdated;
+    private onUsageUpdated;
+    private isErrorRecoverable;
+    clearCache(): void;
+    private onPackagePublished;
+    protected refetchEntityEntitlementsAfterCacheMiss(params: RefetchEntityEntitlementsAfterCacheMissParams): Promise<import("@stigg/cache-core").EntitlementsResponseCacheHit>;
+}