@openfeature/server-sdk 1.20.0 → 1.20.2

package/dist/cjs/index.js

@@ -58,11 +58,8 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AggregateError: () => AggregateError,
   AsyncLocalStorageTransactionContextPropagator: () => AsyncLocalStorageTransactionContextPropagator,
-  BaseEvaluationStrategy: () => BaseEvaluationStrategy,
   ComparisonStrategy: () => ComparisonStrategy,
-  ErrorWithCode: () => ErrorWithCode,
   FirstMatchStrategy: () => FirstMatchStrategy,
   FirstSuccessfulStrategy: () => FirstSuccessfulStrategy,
   InMemoryProvider: () => InMemoryProvider,
@@ -73,9 +70,7 @@ __export(index_exports, {
   OpenFeatureAPI: () => OpenFeatureAPI,
   OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
   ProviderEvents: () => import_core6.ServerProviderEvents,
-  ProviderStatus: () => import_core.ServerProviderStatus,
-  constructAggregateError: () => constructAggregateError,
-  throwAggregateErrorFromPromiseResults: () => throwAggregateErrorFromPromiseResults
+  ProviderStatus: () => import_core.ServerProviderStatus
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -204,12 +199,30 @@ var InMemoryProvider = class {
 };
 
 // src/provider/multi-provider/multi-provider.ts
-var import_core9 = require("@openfeature/core");
+var import_core7 = require("@openfeature/core");
 
-// src/events/open-feature-event-emitter.ts
+// src/provider/multi-provider/strategies.ts
 var import_core4 = require("@openfeature/core");
+var FirstMatchStrategy = class extends import_core4.BaseFirstMatchStrategy {
+  constructor() {
+    super(import_core.ServerProviderStatus);
+  }
+};
+var FirstSuccessfulStrategy = class extends import_core4.BaseFirstSuccessfulStrategy {
+  constructor() {
+    super(import_core.ServerProviderStatus);
+  }
+};
+var ComparisonStrategy = class extends import_core4.BaseComparisonStrategy {
+  constructor(fallbackProvider, onMismatch) {
+    super(import_core.ServerProviderStatus, fallbackProvider, onMismatch);
+  }
+};
+
+// src/events/open-feature-event-emitter.ts
+var import_core5 = require("@openfeature/core");
 var import_node_events = require("node:events");
-var OpenFeatureEventEmitter = class extends import_core4.GenericEventEmitter {
+var OpenFeatureEventEmitter = class extends import_core5.GenericEventEmitter {
   constructor() {
     super();
     this.eventEmitter = new import_node_events.EventEmitter({ captureRejections: true });
@@ -220,40 +233,8 @@ var OpenFeatureEventEmitter = class extends import_core4.GenericEventEmitter {
   }
 };
 
-// src/provider/multi-provider/errors.ts
-var import_core5 = require("@openfeature/core");
-var ErrorWithCode = class extends import_core5.OpenFeatureError {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-};
-var AggregateError = class extends import_core5.GeneralError {
-  constructor(message, originalErrors) {
-    super(message);
-    this.originalErrors = originalErrors;
-  }
-};
-var constructAggregateError = (providerErrors) => {
-  const errorsWithSource = providerErrors.map(({ providerName, error }) => {
-    return { source: providerName, error };
-  }).flat();
-  return new AggregateError(
-    `Provider errors occurred: ${errorsWithSource[0].source}: ${errorsWithSource[0].error}`,
-    errorsWithSource
-  );
-};
-var throwAggregateErrorFromPromiseResults = (result, providerEntries) => {
-  const errors = result.map((r, i) => {
-    if (r.status === "rejected") {
-      return { error: r.reason, providerName: providerEntries[i].name };
-    }
-    return null;
-  }).filter((val) => Boolean(val));
-  if (errors.length) {
-    throw constructAggregateError(errors);
-  }
-};
+// src/events/events.ts
+var import_core6 = require("@openfeature/core");
 
 // src/provider/multi-provider/hook-executor.ts
 var HookExecutor = class {
@@ -312,196 +293,9 @@ var HookExecutor = class {
   }
 };
 
-// src/events/events.ts
-var import_core6 = require("@openfeature/core");
-
-// src/provider/multi-provider/status-tracker.ts
-var StatusTracker = class {
-  constructor(events) {
-    this.events = events;
-    this.providerStatuses = {};
-  }
-  wrapEventHandler(providerEntry) {
-    var _a, _b, _c, _d;
-    const provider = providerEntry.provider;
-    (_a = provider.events) == null ? void 0 : _a.addHandler(import_core6.ServerProviderEvents.Error, (details) => {
-      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.ERROR, details);
-    });
-    (_b = provider.events) == null ? void 0 : _b.addHandler(import_core6.ServerProviderEvents.Stale, (details) => {
-      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.STALE, details);
-    });
-    (_c = provider.events) == null ? void 0 : _c.addHandler(import_core6.ServerProviderEvents.ConfigurationChanged, (details) => {
-      this.events.emit(import_core6.ServerProviderEvents.ConfigurationChanged, details);
-    });
-    (_d = provider.events) == null ? void 0 : _d.addHandler(import_core6.ServerProviderEvents.Ready, (details) => {
-      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.READY, details);
-    });
-  }
-  providerStatus(name) {
-    return this.providerStatuses[name];
-  }
-  getStatusFromProviderStatuses() {
-    const statuses = Object.values(this.providerStatuses);
-    if (statuses.includes(import_core.ServerProviderStatus.FATAL)) {
-      return import_core.ServerProviderStatus.FATAL;
-    } else if (statuses.includes(import_core.ServerProviderStatus.NOT_READY)) {
-      return import_core.ServerProviderStatus.NOT_READY;
-    } else if (statuses.includes(import_core.ServerProviderStatus.ERROR)) {
-      return import_core.ServerProviderStatus.ERROR;
-    } else if (statuses.includes(import_core.ServerProviderStatus.STALE)) {
-      return import_core.ServerProviderStatus.STALE;
-    }
-    return import_core.ServerProviderStatus.READY;
-  }
-  changeProviderStatus(name, status, details) {
-    const currentStatus = this.getStatusFromProviderStatuses();
-    this.providerStatuses[name] = status;
-    const newStatus = this.getStatusFromProviderStatuses();
-    if (currentStatus !== newStatus) {
-      if (newStatus === import_core.ServerProviderStatus.FATAL || newStatus === import_core.ServerProviderStatus.ERROR) {
-        this.events.emit(import_core6.ServerProviderEvents.Error, details);
-      } else if (newStatus === import_core.ServerProviderStatus.STALE) {
-        this.events.emit(import_core6.ServerProviderEvents.Stale, details);
-      } else if (newStatus === import_core.ServerProviderStatus.READY) {
-        this.events.emit(import_core6.ServerProviderEvents.Ready, details);
-      }
-    }
-  }
-};
-
-// src/provider/multi-provider/strategies/base-evaluation-strategy.ts
-var BaseEvaluationStrategy = class {
-  constructor() {
-    this.runMode = "sequential";
-  }
-  shouldEvaluateThisProvider(strategyContext, _evalContext) {
-    if (strategyContext.providerStatus === import_core.ServerProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ServerProviderStatus.FATAL) {
-      return false;
-    }
-    return true;
-  }
-  shouldEvaluateNextProvider(_strategyContext, _context, _result) {
-    return true;
-  }
-  shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
-    if (strategyContext.providerStatus === import_core.ServerProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ServerProviderStatus.FATAL) {
-      return false;
-    }
-    return true;
-  }
-  hasError(resolution) {
-    return "thrownError" in resolution || !!resolution.details.errorCode;
-  }
-  hasErrorWithCode(resolution, code) {
-    var _a;
-    return "thrownError" in resolution ? ((_a = resolution.thrownError) == null ? void 0 : _a.code) === code : resolution.details.errorCode === code;
-  }
-  collectProviderErrors(resolutions) {
-    var _a;
-    const errors = [];
-    for (const resolution of resolutions) {
-      if ("thrownError" in resolution) {
-        errors.push({ providerName: resolution.providerName, error: resolution.thrownError });
-      } else if (resolution.details.errorCode) {
-        errors.push({
-          providerName: resolution.providerName,
-          error: new ErrorWithCode(resolution.details.errorCode, (_a = resolution.details.errorMessage) != null ? _a : "unknown error")
-        });
-      }
-    }
-    return { errors };
-  }
-  resolutionToFinalResult(resolution) {
-    return { details: resolution.details, provider: resolution.provider, providerName: resolution.providerName };
-  }
-};
-
-// src/provider/multi-provider/strategies/first-match-strategy.ts
-var import_core7 = require("@openfeature/core");
-var FirstMatchStrategy = class extends BaseEvaluationStrategy {
-  shouldEvaluateNextProvider(strategyContext, context, result) {
-    if (this.hasErrorWithCode(result, import_core7.ErrorCode.FLAG_NOT_FOUND)) {
-      return true;
-    }
-    if (this.hasError(result)) {
-      return false;
-    }
-    return false;
-  }
-  determineFinalResult(strategyContext, context, resolutions) {
-    const finalResolution = resolutions[resolutions.length - 1];
-    if (this.hasError(finalResolution)) {
-      return this.collectProviderErrors(resolutions);
-    }
-    return this.resolutionToFinalResult(finalResolution);
-  }
-};
-
-// src/provider/multi-provider/strategies/first-successful-strategy.ts
-var FirstSuccessfulStrategy = class extends BaseEvaluationStrategy {
-  shouldEvaluateNextProvider(strategyContext, context, result) {
-    return this.hasError(result);
-  }
-  determineFinalResult(strategyContext, context, resolutions) {
-    const finalResolution = resolutions[resolutions.length - 1];
-    if (this.hasError(finalResolution)) {
-      return this.collectProviderErrors(resolutions);
-    }
-    return this.resolutionToFinalResult(finalResolution);
-  }
-};
-
-// src/provider/multi-provider/strategies/comparison-strategy.ts
-var import_core8 = require("@openfeature/core");
-var ComparisonStrategy = class extends BaseEvaluationStrategy {
-  constructor(fallbackProvider, onMismatch) {
-    super();
-    this.fallbackProvider = fallbackProvider;
-    this.onMismatch = onMismatch;
-    this.runMode = "parallel";
-  }
-  determineFinalResult(strategyContext, context, resolutions) {
-    var _a;
-    let value;
-    let fallbackResolution;
-    let finalResolution;
-    let mismatch = false;
-    for (const [i, resolution] of resolutions.entries()) {
-      if (this.hasError(resolution)) {
-        return this.collectProviderErrors(resolutions);
-      }
-      if (resolution.provider === this.fallbackProvider) {
-        fallbackResolution = resolution;
-      }
-      if (i === 0) {
-        finalResolution = resolution;
-      }
-      if (typeof value !== "undefined" && value !== resolution.details.value) {
-        mismatch = true;
-      } else {
-        value = resolution.details.value;
-      }
-    }
-    if (!fallbackResolution) {
-      throw new import_core8.GeneralError("Fallback provider not found in resolution results");
-    }
-    if (!finalResolution) {
-      throw new import_core8.GeneralError("Final resolution not found in resolution results");
-    }
-    if (mismatch) {
-      (_a = this.onMismatch) == null ? void 0 : _a.call(this, resolutions);
-      return {
-        details: fallbackResolution.details,
-        provider: fallbackResolution.provider
-      };
-    }
-    return this.resolutionToFinalResult(finalResolution);
-  }
-};
-
 // src/provider/multi-provider/multi-provider.ts
 var MultiProvider = class _MultiProvider {
-  constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new import_core9.DefaultLogger()) {
+  constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new import_core7.DefaultLogger()) {
     this.constructorProviders = constructorProviders;
     this.evaluationStrategy = evaluationStrategy;
     this.logger = logger;
@@ -511,7 +305,7 @@ var MultiProvider = class _MultiProvider {
     this.hookHints = /* @__PURE__ */ new WeakMap();
     this.providerEntries = [];
     this.providerEntriesByName = {};
-    this.statusTracker = new StatusTracker(this.events);
+    this.statusTracker = new import_core7.StatusTracker(this.events, import_core.ServerProviderStatus, import_core6.ServerProviderEvents);
     this.hookExecutor = new HookExecutor(this.logger);
     this.registerProviders(constructorProviders);
     const aggregateMetadata = Object.keys(this.providerEntriesByName).reduce((acc, name) => {
@@ -553,7 +347,7 @@ var MultiProvider = class _MultiProvider {
           return (_b = (_a = provider.provider).initialize) == null ? void 0 : _b.call(_a, context);
         })
       );
-      throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+      (0, import_core7.throwAggregateErrorFromPromiseResults)(result, this.providerEntries);
     });
   }
   onClose() {
@@ -562,7 +356,7 @@ var MultiProvider = class _MultiProvider {
         var _a, _b;
         return (_b = (_a = provider.provider).onClose) == null ? void 0 : _b.call(_a);
       }));
-      throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+      (0, import_core7.throwAggregateErrorFromPromiseResults)(result, this.providerEntries);
     });
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context) {
@@ -583,7 +377,7 @@ var MultiProvider = class _MultiProvider {
       const hookContext = this.hookContexts.get(context);
       const hookHints = this.hookHints.get(context);
       if (!hookContext || !hookHints) {
-        throw new import_core9.GeneralError("Hook context not available for evaluation");
+        throw new import_core7.GeneralError("Hook context not available for evaluation");
       }
       const tasks = [];
       for (const providerEntry of this.providerEntries) {
@@ -608,10 +402,10 @@ var MultiProvider = class _MultiProvider {
       const resolutions = results.map(([, resolution]) => resolution).filter((r) => Boolean(r));
       const finalResult = this.evaluationStrategy.determineFinalResult({ flagKey, flagType }, context, resolutions);
       if ((_a = finalResult.errors) == null ? void 0 : _a.length) {
-        throw constructAggregateError(finalResult.errors);
+        throw (0, import_core7.constructAggregateError)(finalResult.errors);
       }
       if (!finalResult.details) {
-        throw new import_core9.GeneralError("No result was returned from any provider");
+        throw new import_core7.GeneralError("No result was returned from any provider");
       }
       return finalResult.details;
     });
@@ -690,7 +484,7 @@ var MultiProvider = class _MultiProvider {
         case "boolean":
           return yield provider.resolveBooleanEvaluation(flagKey, defaultValue, context, this.logger);
         default:
-          throw new import_core9.GeneralError("Invalid flag evaluation type");
+          throw new import_core7.GeneralError("Invalid flag evaluation type");
       }
     });
   }
@@ -735,12 +529,12 @@ var MultiProvider = class _MultiProvider {
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || import_core9.ErrorCode.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || import_core7.ErrorCode.GENERAL;
     return {
       errorCode,
       errorMessage,
       value: defaultValue,
-      reason: import_core9.StandardResolutionReasons.ERROR,
+      reason: import_core7.StandardResolutionReasons.ERROR,
       flagMetadata: Object.freeze(flagMetadata),
       flagKey
     };
@@ -748,10 +542,10 @@ var MultiProvider = class _MultiProvider {
 };
 
 // src/open-feature.ts
-var import_core11 = require("@openfeature/core");
+var import_core9 = require("@openfeature/core");
 
 // src/client/internal/open-feature-client.ts
-var import_core10 = require("@openfeature/core");
+var import_core8 = require("@openfeature/core");
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, apiContextAccessor, apiHooksAccessor, transactionContextAccessor, globalLogger, options, context = {}) {
     this.providerAccessor = providerAccessor;
@@ -781,7 +575,7 @@ var OpenFeatureClient = class {
   addHandler(eventType, handler, options) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = (0, import_core10.statusMatchesEvent)(eventType, this._providerStatus);
+    const shouldRunNow = (0, import_core8.statusMatchesEvent)(eventType, this._providerStatus);
     if (shouldRunNow) {
       try {
         handler({
@@ -806,7 +600,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new import_core10.SafeLogger(logger);
+    this._clientLogger = new import_core8.SafeLogger(logger);
     return this;
   }
   setContext(context) {
@@ -916,7 +710,7 @@ var OpenFeatureClient = class {
           providerMetadata: this._provider.metadata,
           context: mergedContext,
           logger: this._logger,
-          hookData: new import_core10.MapHookData()
+          hookData: new import_core8.MapHookData()
         })
       );
       let evaluationDetails;
@@ -929,7 +723,7 @@ var OpenFeatureClient = class {
           flagKey
         });
         if (resolutionDetails.errorCode) {
-          const err = (0, import_core10.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
+          const err = (0, import_core8.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
           yield this.errorHooks(allHooksReversed, hookContexts, err, options);
           evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, err, resolutionDetails.flagMetadata);
         } else {
@@ -947,17 +741,15 @@ var OpenFeatureClient = class {
   beforeHooks(hooks, hookContexts, mergedContext, options) {
     return __async(this, null, function* () {
       var _a;
-      let accumulatedContext = mergedContext;
+      const accumulatedContext = mergedContext;
       for (const [index, hook] of hooks.entries()) {
         const hookContextIndex = hooks.length - 1 - index;
         const hookContext = hookContexts[hookContextIndex];
         Object.assign(hookContext.context, accumulatedContext);
         const hookResult = yield (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints));
         if (hookResult) {
-          accumulatedContext = __spreadValues(__spreadValues({}, accumulatedContext), hookResult);
-          for (let i = 0; i < hooks.length; i++) {
-            Object.assign(hookContexts[hookContextIndex].context, accumulatedContext);
-          }
+          Object.assign(accumulatedContext, hookResult);
+          Object.assign(hookContext.context, accumulatedContext);
         }
       }
       return Object.freeze(accumulatedContext);
@@ -1020,19 +812,19 @@ var OpenFeatureClient = class {
   }
   shortCircuitIfNotReady() {
     if (this.providerStatus === import_core.ServerProviderStatus.NOT_READY) {
-      throw new import_core10.ProviderNotReadyError("provider has not yet initialized");
+      throw new import_core8.ProviderNotReadyError("provider has not yet initialized");
     } else if (this.providerStatus === import_core.ServerProviderStatus.FATAL) {
-      throw new import_core10.ProviderFatalError("provider is in an irrecoverable error state");
+      throw new import_core8.ProviderFatalError("provider is in an irrecoverable error state");
     }
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || import_core10.ErrorCode.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || import_core8.ErrorCode.GENERAL;
     return {
       errorCode,
       errorMessage,
       value: defaultValue,
-      reason: import_core10.StandardResolutionReasons.ERROR,
+      reason: import_core8.StandardResolutionReasons.ERROR,
       flagMetadata: Object.freeze(flagMetadata),
       flagKey
     };
@@ -1068,12 +860,12 @@ var AsyncLocalStorageTransactionContextPropagator = class {
 // src/open-feature.ts
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js-sdk/api");
 var _globalThis = globalThis;
-var OpenFeatureAPI = class _OpenFeatureAPI extends import_core11.OpenFeatureCommonAPI {
+var OpenFeatureAPI = class _OpenFeatureAPI extends import_core9.OpenFeatureCommonAPI {
   constructor() {
     super("server");
     this._statusEnumType = import_core.ServerProviderStatus;
     this._apiEmitter = new OpenFeatureEventEmitter();
-    this._defaultProvider = new import_core11.ProviderWrapper(
+    this._defaultProvider = new import_core9.ProviderWrapper(
       NOOP_PROVIDER,
       import_core.ServerProviderStatus.NOT_READY,
       this._statusEnumType
@@ -1105,14 +897,14 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core11.OpenFeatureComm
   }
   setProviderAndWait(domainOrProvider, providerOrUndefined) {
     return __async(this, null, function* () {
-      const domain = (0, import_core11.stringOrUndefined)(domainOrProvider);
-      const provider = domain ? (0, import_core11.objectOrUndefined)(providerOrUndefined) : (0, import_core11.objectOrUndefined)(domainOrProvider);
+      const domain = (0, import_core9.stringOrUndefined)(domainOrProvider);
+      const provider = domain ? (0, import_core9.objectOrUndefined)(providerOrUndefined) : (0, import_core9.objectOrUndefined)(domainOrProvider);
       yield this.setAwaitableProvider(domain, provider);
     });
   }
   setProvider(clientOrProvider, providerOrUndefined) {
-    const domain = (0, import_core11.stringOrUndefined)(clientOrProvider);
-    const provider = domain ? (0, import_core11.objectOrUndefined)(providerOrUndefined) : (0, import_core11.objectOrUndefined)(clientOrProvider);
+    const domain = (0, import_core9.stringOrUndefined)(clientOrProvider);
+    const provider = domain ? (0, import_core9.objectOrUndefined)(providerOrUndefined) : (0, import_core9.objectOrUndefined)(clientOrProvider);
     const maybePromise = this.setAwaitableProvider(domain, provider);
     Promise.resolve(maybePromise).catch((err) => {
       this._logger.error("Error during provider initialization:", err);
@@ -1131,9 +923,9 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core11.OpenFeatureComm
   }
   getClient(domainOrContext, versionOrContext, contextOrUndefined) {
     var _a, _b;
-    const domain = (0, import_core11.stringOrUndefined)(domainOrContext);
-    const version = (0, import_core11.stringOrUndefined)(versionOrContext);
-    const context = (_b = (_a = (0, import_core11.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core11.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core11.objectOrUndefined)(contextOrUndefined);
+    const domain = (0, import_core9.stringOrUndefined)(domainOrContext);
+    const version = (0, import_core9.stringOrUndefined)(versionOrContext);
+    const context = (_b = (_a = (0, import_core9.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core9.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core9.objectOrUndefined)(contextOrUndefined);
     return new OpenFeatureClient(
       () => this.getProviderForClient(domain),
       () => this.getProviderStatus(domain),
@@ -1184,11 +976,8 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 __reExport(index_exports, require("@openfeature/core"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AggregateError,
   AsyncLocalStorageTransactionContextPropagator,
-  BaseEvaluationStrategy,
   ComparisonStrategy,
-  ErrorWithCode,
   FirstMatchStrategy,
   FirstSuccessfulStrategy,
   InMemoryProvider,
@@ -1200,8 +989,6 @@ __reExport(index_exports, require("@openfeature/core"), module.exports);
   OpenFeatureEventEmitter,
   ProviderEvents,
   ProviderStatus,
-  constructAggregateError,
-  throwAggregateErrorFromPromiseResults,
   ...require("@openfeature/core")
 });
 //# sourceMappingURL=index.js.map