@stigg/cache-runtime 2.0.0

package/dist/configuration.d.ts

@@ -0,0 +1,31 @@
+import { LogConfiguration } from './services/loggerService';
+import { CreditEntitlementsFallback, EntitlementsFallback } from '@stigg/entitlements-runtime';
+import { SlimLogger } from '@stigg/cache-core';
+import { StiggRedisOptions } from '@stigg/cache-redis-store';
+export declare const DEFAULT_TIMEOUT: number;
+export declare const DEFAULT_ENTITLEMENTS_TIMEOUT: number;
+type ClientConfiguration = {
+    apiKey: string;
+    baseUri?: string;
+    baseEdgeUri?: string;
+    wsUrl?: string;
+    logConfiguration?: LogConfiguration;
+    realtimeUpdatesEnabled?: boolean;
+    enableEdge?: boolean;
+    redis?: StiggRedisOptions;
+    entitlementsFallback?: EntitlementsFallback;
+    creditEntitlementsFallback?: CreditEntitlementsFallback;
+    memoryCacheMaxSizeBytes?: number;
+    clientName?: string;
+    clientVersion?: string;
+    enableRemoteConfig?: boolean;
+    timeout?: number;
+    entitlementsTimeout?: number;
+    offline?: boolean;
+};
+declare function getConfiguration(configuration: Partial<ClientConfiguration>): Required<ClientConfiguration>;
+/**
+ * We are validating here configuration that is required in order to initiate a new client, otherwise we return error
+ */
+declare function validateConfiguration(configuration: Partial<ClientConfiguration>, loggerService: SlimLogger): void;
+export { getConfiguration, ClientConfiguration, validateConfiguration };

package/dist/configuration.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENTITLEMENTS_TIMEOUT = exports.DEFAULT_TIMEOUT = void 0;
+exports.getConfiguration = getConfiguration;
+exports.validateConfiguration = validateConfiguration;
+const loggerService_1 = require("./services/loggerService");
+const lodash_1 = require("lodash");
+const v8_1 = __importDefault(require("v8"));
+exports.DEFAULT_TIMEOUT = 60 * 1000;
+exports.DEFAULT_ENTITLEMENTS_TIMEOUT = 10 * 1000;
+const LOCALHOST_IPS = ['localhost', '127.0.0.1', '::1'];
+function getDefaultMemoryCacheMaxSizeBytes() {
+    return v8_1.default.getHeapStatistics().total_available_size * 0.75;
+}
+const defaults = () => {
+    const baseUri = 'https://api.stigg.io';
+    return {
+        baseUri,
+        wsUrl: getWsUrl(baseUri),
+        baseEdgeUri: getBaseEdgeApiUri(baseUri),
+        logConfiguration: {
+            logger: console,
+            logLevel: loggerService_1.LogLevel.ERROR,
+        },
+        timeout: exports.DEFAULT_TIMEOUT,
+        entitlementsTimeout: exports.DEFAULT_ENTITLEMENTS_TIMEOUT,
+        realtimeUpdatesEnabled: true,
+        enableEdge: true,
+        memoryCacheMaxSizeBytes: getDefaultMemoryCacheMaxSizeBytes(),
+        enableRemoteConfig: true,
+    };
+};
+const defaultRedisOptions = () => ({
+    commandTimeout: 60000,
+    retryStrategy: (times) => {
+        const baseDelay = Math.min(2 ** times * 100, 8000);
+        const jitter = Math.floor(Math.random() * 500);
+        return baseDelay + jitter;
+    },
+});
+function getConfiguration(configuration) {
+    const defaultConfig = defaults();
+    const wsUrl = configuration.wsUrl
+        ? configuration.wsUrl
+        : configuration.baseUri
+            ? getWsUrl(configuration.baseUri)
+            : defaultConfig.wsUrl;
+    const baseEdgeUri = configuration.baseEdgeUri
+        ? configuration.baseEdgeUri
+        : configuration.baseUri
+            ? getBaseEdgeApiUri(configuration.baseUri)
+            : defaultConfig.baseEdgeUri;
+    const redis = configuration.redis ? (0, lodash_1.merge)(defaultRedisOptions(), configuration.redis) : undefined;
+    return (0, lodash_1.merge)(defaultConfig, configuration, { wsUrl, baseEdgeUri, redis });
+}
+function getWsUrl(apiUrl) {
+    const url = new URL(apiUrl);
+    if (url.protocol === 'http:') {
+        url.protocol = 'ws:';
+    }
+    else if (url.protocol === 'https:') {
+        url.protocol = 'wss:';
+    }
+    // Remove last char since URL.toString() adds a redundant backslash
+    return url.toString().slice(0, -1);
+}
+function getBaseEdgeApiUri(apiUrl) {
+    const url = new URL(apiUrl);
+    if (LOCALHOST_IPS.includes(url.hostname)) {
+        url.port = '3060';
+    }
+    else {
+        url.hostname = `edge.${url.hostname}`;
+    }
+    // Remove last char since URL.toString() adds a redundant backslash
+    return url.toString().slice(0, -1);
+}
+/**
+ * We are validating here configuration that is required in order to initiate a new client, otherwise we return error
+ */
+function validateConfiguration(configuration, loggerService) {
+    if (!configuration.apiKey) {
+        const error = 'You must configure the client with an API key';
+        loggerService.error(error);
+        throw new Error(error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { EntitlementsService } from './services/entitlementsService';
+export { InMemoryEntitlementsService } from './services/inMemoryEntitlementsService';
+export { InMemoryLruCacheService } from './services/inMemoryLruCacheService';
+export { InitializationHooks } from './services/initializationStateTracker';
+export { buildEntitlementsCache, CacheRuntime } from './services/cacheRuntime';
+export { CreditConsumptionInput, CreditConsumptionResult, EntitlementsRuntimeHooks, EntitlementsState, EntitlementsTransport, EntitlementsUpdatedEvent, PackagePublishedEvent, TransportObservable, UsageEventInput, UsageMeasurementBulkInput, UsageMeasurementInput, UsageMeasurementResult, UsageUpdatedEvent, } from './types/transport';
+export { ClassifiedError, TransportErrorClassifier } from './types/errors';
+export { toEntitlementQuery } from './utils/entitlementQuery';
+export { RuntimeError, RuntimeErrorHandler, RuntimeErrorHooks } from './services/runtimeErrorHandler';
+export { ClientConfiguration, getConfiguration, validateConfiguration } from './configuration';
+export { LogConfiguration, Logger, LoggerService, LogLevel } from './services/loggerService';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = exports.LoggerService = exports.validateConfiguration = exports.getConfiguration = exports.RuntimeErrorHandler = exports.RuntimeError = exports.toEntitlementQuery = exports.CacheRuntime = exports.buildEntitlementsCache = exports.InMemoryLruCacheService = exports.InMemoryEntitlementsService = exports.EntitlementsService = void 0;
+var entitlementsService_1 = require("./services/entitlementsService");
+Object.defineProperty(exports, "EntitlementsService", { enumerable: true, get: function () { return entitlementsService_1.EntitlementsService; } });
+var inMemoryEntitlementsService_1 = require("./services/inMemoryEntitlementsService");
+Object.defineProperty(exports, "InMemoryEntitlementsService", { enumerable: true, get: function () { return inMemoryEntitlementsService_1.InMemoryEntitlementsService; } });
+var inMemoryLruCacheService_1 = require("./services/inMemoryLruCacheService");
+Object.defineProperty(exports, "InMemoryLruCacheService", { enumerable: true, get: function () { return inMemoryLruCacheService_1.InMemoryLruCacheService; } });
+var cacheRuntime_1 = require("./services/cacheRuntime");
+Object.defineProperty(exports, "buildEntitlementsCache", { enumerable: true, get: function () { return cacheRuntime_1.buildEntitlementsCache; } });
+Object.defineProperty(exports, "CacheRuntime", { enumerable: true, get: function () { return cacheRuntime_1.CacheRuntime; } });
+var entitlementQuery_1 = require("./utils/entitlementQuery");
+Object.defineProperty(exports, "toEntitlementQuery", { enumerable: true, get: function () { return entitlementQuery_1.toEntitlementQuery; } });
+var runtimeErrorHandler_1 = require("./services/runtimeErrorHandler");
+Object.defineProperty(exports, "RuntimeError", { enumerable: true, get: function () { return runtimeErrorHandler_1.RuntimeError; } });
+Object.defineProperty(exports, "RuntimeErrorHandler", { enumerable: true, get: function () { return runtimeErrorHandler_1.RuntimeErrorHandler; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "getConfiguration", { enumerable: true, get: function () { return configuration_1.getConfiguration; } });
+Object.defineProperty(exports, "validateConfiguration", { enumerable: true, get: function () { return configuration_1.validateConfiguration; } });
+var loggerService_1 = require("./services/loggerService");
+Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return loggerService_1.LoggerService; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return loggerService_1.LogLevel; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0VBQXFFO0FBQTVELDBIQUFBLG1CQUFtQixPQUFBO0FBQzVCLHNGQUFxRjtBQUE1RSwwSUFBQSwyQkFBMkIsT0FBQTtBQUNwQyw4RUFBNkU7QUFBcEUsa0lBQUEsdUJBQXVCLE9BQUE7QUFFaEMsd0RBQStFO0FBQXRFLHNIQUFBLHNCQUFzQixPQUFBO0FBQUUsNEdBQUEsWUFBWSxPQUFBO0FBb0I3Qyw2REFBOEQ7QUFBckQsc0hBQUEsa0JBQWtCLE9BQUE7QUFFM0Isc0VBQXNHO0FBQTdGLG1IQUFBLFlBQVksT0FBQTtBQUFFLDBIQUFBLG1CQUFtQixPQUFBO0FBRTFDLGlEQUErRjtBQUFqRSxpSEFBQSxnQkFBZ0IsT0FBQTtBQUFFLHNIQUFBLHFCQUFxQixPQUFBO0FBRXJFLDBEQUE2RjtBQUExRCw4R0FBQSxhQUFhLE9BQUE7QUFBRSx5R0FBQSxRQUFRLE9BQUEifQ==

package/dist/services/cacheRuntime.d.ts

@@ -0,0 +1,66 @@
+import { CacheInstrumentation, CacheMapper, SlimLogger } from '@stigg/cache-core';
+import { RedisCacheService } from '@stigg/cache-redis-store';
+import { EntitlementFallbacks } from '@stigg/entitlements-runtime';
+import { ClientConfiguration } from '../configuration';
+import { CacheableInput, EntitlementsRuntimeHooks, EntitlementsTransport } from '../types/transport';
+import { EntitlementsService } from './entitlementsService';
+import { InitializationHooks } from './initializationStateTracker';
+import { RuntimeErrorHooks } from './runtimeErrorHandler';
+import { InMemoryLruCacheService } from './inMemoryLruCacheService';
+/**
+ * Discriminated so the caller cannot land on a cache/service mismatch: only the in-memory store
+ * takes runtime hooks, and only it has anything to clear when the transport reconnects.
+ */
+export type EntitlementsCache<Input> = {
+    onTransportConnected: () => void;
+} & ({
+    kind: 'redis';
+    cacheService: RedisCacheService<Input>;
+} | {
+    kind: 'memory';
+    cacheService: InMemoryLruCacheService<Input>;
+});
+export type EntitlementsCacheParams<Input> = {
+    configuration: Required<ClientConfiguration>;
+    loggerService: SlimLogger;
+    instrumentation: CacheInstrumentation;
+    cacheMapper: CacheMapper<Input>;
+};
+/**
+ * Built before the transport, because a reconnecting transport has to clear the in-memory store.
+ */
+export declare function buildEntitlementsCache<Input>({ configuration, loggerService, instrumentation, cacheMapper, }: EntitlementsCacheParams<Input>): EntitlementsCache<Input>;
+export type CacheRuntimeParams<Input extends CacheableInput, TPackagePublished> = {
+    configuration: Required<ClientConfiguration>;
+    loggerService: SlimLogger;
+    cache: EntitlementsCache<Input>;
+    transport: EntitlementsTransport<Input, TPackagePublished>;
+    hooks: EntitlementsRuntimeHooks<Input, TPackagePublished>;
+    errorHooks: RuntimeErrorHooks;
+    initializationHooks: InitializationHooks;
+};
+/** A class rather than a returned pair: the lifecycle shares the transport and error handler the reads use. */
+export declare class CacheRuntime<Input extends CacheableInput, TPackagePublished = unknown> {
+    readonly entitlementsService: EntitlementsService<Input, TPackagePublished>;
+    readonly fallbacks: EntitlementFallbacks;
+    private readonly errorHandler;
+    private readonly initializationTracker;
+    private readonly loggerService;
+    private readonly offline;
+    private readonly transport;
+    /** Both gates fold in `offline`, which reaches the network for nothing. */
+    private readonly validatesApiKey;
+    private readonly subscribesToUpdates;
+    constructor({ configuration, loggerService, cache, transport, hooks, errorHooks, initializationHooks, }: CacheRuntimeParams<Input, TPackagePublished>);
+    /**
+     * Void because the outcome is observed through `waitForInitialization`. Subscribing precedes the
+     * awaits so it is neither deferred behind a round-trip nor skipped when startup fails.
+     */
+    initialize(): void;
+    /**
+     * The runtime's own readiness: startup finished. Distinct from `EntitlementsService`'s method of
+     * the same name, which reports only that the cache store is ready to be read.
+     */
+    waitForInitialization(): Promise<void>;
+    cleanup(): Promise<void>;
+}

package/dist/services/cacheRuntime.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheRuntime = void 0;
+exports.buildEntitlementsCache = buildEntitlementsCache;
+const lodash_1 = require("lodash");
+const cache_redis_store_1 = require("@stigg/cache-redis-store");
+const entitlements_runtime_1 = require("@stigg/entitlements-runtime");
+const initializationStateTracker_1 = require("./initializationStateTracker");
+const runtimeErrorHandler_1 = require("./runtimeErrorHandler");
+const inMemoryEntitlementsService_1 = require("./inMemoryEntitlementsService");
+const inMemoryLruCacheService_1 = require("./inMemoryLruCacheService");
+const redisEntitlementsService_1 = require("./redisEntitlementsService");
+/**
+ * Built before the transport, because a reconnecting transport has to clear the in-memory store.
+ */
+function buildEntitlementsCache({ configuration, loggerService, instrumentation, cacheMapper, }) {
+    if (!(0, lodash_1.isEmpty)(configuration.redis)) {
+        return {
+            kind: 'redis',
+            cacheService: new cache_redis_store_1.RedisCacheService(configuration, loggerService, instrumentation, cacheMapper),
+            onTransportConnected: () => undefined,
+        };
+    }
+    const cacheService = new inMemoryLruCacheService_1.InMemoryLruCacheService(configuration.memoryCacheMaxSizeBytes, instrumentation, cacheMapper);
+    return { kind: 'memory', cacheService, onTransportConnected: cacheService.clearCache };
+}
+/** A class rather than a returned pair: the lifecycle shares the transport and error handler the reads use. */
+class CacheRuntime {
+    constructor({ configuration, loggerService, cache, transport, hooks, errorHooks, initializationHooks, }) {
+        const { entitlementsTimeout, entitlementsFallback, creditEntitlementsFallback, offline, enableRemoteConfig, realtimeUpdatesEnabled, } = configuration;
+        this.loggerService = loggerService;
+        this.offline = offline;
+        this.transport = transport;
+        this.validatesApiKey = enableRemoteConfig && !offline;
+        this.subscribesToUpdates = realtimeUpdatesEnabled && !offline;
+        this.fallbacks = new entitlements_runtime_1.EntitlementFallbacks({ entitlementsFallback, creditEntitlementsFallback });
+        this.errorHandler = new runtimeErrorHandler_1.RuntimeErrorHandler(loggerService, errorHooks, transport.classifier);
+        this.initializationTracker = new initializationStateTracker_1.InitializationStateTracker(initializationHooks);
+        const evaluator = new entitlements_runtime_1.EntitlementEvaluator(this.fallbacks);
+        this.entitlementsService =
+            cache.kind === 'redis'
+                ? new redisEntitlementsService_1.RedisEntitlementsService(cache.cacheService, transport, loggerService, entitlementsTimeout, evaluator, offline, this.errorHandler)
+                : new inMemoryEntitlementsService_1.InMemoryEntitlementsService(cache.cacheService, transport, hooks, loggerService, entitlementsTimeout, evaluator, offline, this.errorHandler);
+    }
+    /**
+     * Void because the outcome is observed through `waitForInitialization`. Subscribing precedes the
+     * awaits so it is neither deferred behind a round-trip nor skipped when startup fails.
+     */
+    initialize() {
+        if (this.offline) {
+            this.loggerService.log('Initialized in offline mode, only fallback entitlements are being used.');
+        }
+        this.errorHandler
+            .runOrThrow('Failed to load sdk configuration', async () => {
+            // Inside the chain so a synchronous throw from subscribing still reaches the tracker,
+            // rather than leaving waitForInitialization() pending forever.
+            if (this.subscribesToUpdates) {
+                this.entitlementsService.init();
+            }
+            return Promise.all([
+                this.entitlementsService.waitForInitialization(),
+                this.validatesApiKey ? this.transport.validateApiKey() : undefined,
+            ]);
+        })
+            .then(() => this.initializationTracker.signalSuccessInit())
+            .catch((err) => this.initializationTracker.signalFailedInit(err));
+    }
+    /**
+     * The runtime's own readiness: startup finished. Distinct from `EntitlementsService`'s method of
+     * the same name, which reports only that the cache store is ready to be read.
+     */
+    waitForInitialization() {
+        return this.initializationTracker.getInitializationPromise();
+    }
+    cleanup() {
+        return Promise.resolve(this.entitlementsService.cleanup());
+    }
+}
+exports.CacheRuntime = CacheRuntime;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/entitlementsService.d.ts

@@ -0,0 +1,81 @@
+import { BooleanEntitlementOptions, CreditEntitlementOptions, EntitlementEvaluation, EntitlementEvaluator, EntitlementReadOptions, EnumEntitlementOptions, MeteredEntitlementOptions, NumericEntitlementOptions } from '@stigg/entitlements-runtime';
+import { CacheService, EntitlementQuery, EntitlementType, EntitlementsMap, EntitlementsResponse, EntitlementsResponseCacheHit, EntitlementsStateAccessDeniedReason, Maybe, SlimLogger } from '@stigg/cache-core';
+import { RuntimeErrorHandler } from './runtimeErrorHandler';
+import { RefetchEntitlementsAfterCacheMissParams, RefetchEntitlementsParams, RefetchEntityEntitlementsAfterCacheMissParams } from './entitlementsService.utils';
+import { CacheableInput, CreditConsumptionInput, CreditConsumptionResult, CustomerEntitlementsEvaluation, EntitlementsTransport, UsageEventInput, UsageMeasurementBulkInput, UsageMeasurementInput, UsageMeasurementResult } from '../types/transport';
+export declare abstract class EntitlementsService<Input extends CacheableInput, TPackagePublished = unknown> {
+    protected readonly entitlementsApi: EntitlementsTransport<Input, TPackagePublished>;
+    protected readonly loggerService: SlimLogger;
+    protected readonly cacheService: CacheService<Input>;
+    private readonly entitlementsTimeout;
+    protected readonly evaluator: EntitlementEvaluator;
+    private readonly offline;
+    private readonly errorHandler;
+    protected isInitialized: boolean;
+    protected constructor(entitlementsApi: EntitlementsTransport<Input, TPackagePublished>, loggerService: SlimLogger, cacheService: CacheService<Input>, entitlementsTimeout: number, evaluator: EntitlementEvaluator, offline: boolean, errorHandler: RuntimeErrorHandler);
+    getBooleanEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: BooleanEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    protected readBooleanEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: BooleanEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    getNumericEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: NumericEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    protected readNumericEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: NumericEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    getMeteredEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: MeteredEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    protected readMeteredEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: MeteredEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    getEnumEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: EnumEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    protected readEnumEntitlement(customerId: string, featureRefId: string, resourceId?: string, options?: EnumEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Feature>>;
+    getCreditEntitlement(customerId: string, currencyId: string, resourceId?: string, options?: CreditEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Credit>>;
+    protected readCreditEntitlement(customerId: string, currencyId: string, resourceId?: string, options?: CreditEntitlementOptions): Promise<EntitlementEvaluation<EntitlementType.Credit>>;
+    getEntitlement<TType extends EntitlementType>(entitlementReference: EntitlementQuery<TType>, customerRefId: string, resourceId: string | undefined, options?: EntitlementReadOptions): Promise<EntitlementEvaluation<TType>>;
+    protected readEntitlement<TType extends EntitlementType>(entitlementReference: EntitlementQuery<TType>, customerRefId: string, resourceId: string | undefined, options?: EntitlementReadOptions): Promise<EntitlementEvaluation<TType>>;
+    private getCustomerAndEntitlementFromCacheOrRefetch;
+    getCustomerEntitlements(customerId: string, resourceId: string | undefined): Promise<CustomerEntitlementsEvaluation>;
+    protected readCustomerEntitlements(customerId: string, resourceId: string | undefined): Promise<CustomerEntitlementsEvaluation>;
+    abstract clearCache(): void | Promise<void>;
+    abstract init(): void | Promise<void>;
+    abstract cleanup(): void | Promise<void>;
+    /** Offline never reaches the API, so the measurement is acknowledged locally instead. */
+    private offlineMeasurement;
+    reportUsage(input: UsageMeasurementInput): Promise<UsageMeasurementResult>;
+    reportUsageBulk(input: UsageMeasurementBulkInput): Promise<UsageMeasurementResult[]>;
+    /** Passes through: an event has no cache state to maintain, unlike a usage measurement. */
+    reportEvent(events: UsageEventInput[]): Promise<void>;
+    /** Passes through: the balance is settled server-side, so there is nothing to write through. */
+    consumeCreditsAsync(consumptions: CreditConsumptionInput[]): Promise<void>;
+    consumeCredits(input: CreditConsumptionInput): Promise<CreditConsumptionResult>;
+    protected refetchEntitlementsAfterCacheMiss(params: RefetchEntitlementsAfterCacheMissParams): Promise<EntitlementsResponse>;
+    /**
+     * 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.
+     */
+    reloadEntitlements(customerId: string, resourceId?: string): Promise<{
+        entitledEntityExists: boolean;
+    }>;
+    protected abstract refetchEntityEntitlementsAfterCacheMiss(params: RefetchEntityEntitlementsAfterCacheMissParams): Promise<EntitlementsResponse>;
+    refetchEntitlements({ customerId, resourceId, skipEdge, triggeredBy, }: RefetchEntitlementsParams): Promise<EntitlementsResponseCacheHit>;
+    setEntitlementsIfExists(options: {
+        entitlements?: Input[] | null;
+        customerId: string;
+        resourceId: string | undefined;
+    }): Promise<EntitlementsMap | null>;
+    setEntitlements(params: {
+        entitlements: Input[];
+        accessDeniedReason: Maybe<EntitlementsStateAccessDeniedReason>;
+        customerId: string;
+        resourceId: string | undefined;
+    }): Promise<EntitlementsMap>;
+    protected getEntitlementsUpdatedAtTimestamp({ entitlements, customerId, resourceId, }: {
+        entitlements: Input[];
+        customerId: string;
+        resourceId: Maybe<string>;
+    }): Date;
+    updateFeatureUsage({ featureId, customerId, resourceId, currentUsage, usagePeriodStart, usagePeriodEnd, credit, timestamp, }: UsageMeasurementResult): Promise<void>;
+    private updateCreditBalance;
+    /**
+     * 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.
+     */
+    waitForInitialization(): Promise<void>;
+    private isEntitlementExpired;
+    private areEntitlementsExpired;
+}