@openfeature/server-sdk 1.20.1 → 1.21.0

package/dist/types.d.ts

@@ -1,10 +1,11 @@
-import { BaseHook, FlagValue, EvaluationContext, HookHints, EvaluationDetails, JsonValue, CommonProvider, ServerProviderStatus, Logger, ResolutionDetails, GenericEventEmitter, ServerProviderEvents, FlagValueType, TrackingEventDetails, ErrorCode, ProviderMetadata, OpenFeatureError, GeneralError, EvaluationLifeCycle, ManageContext, ManageLogger, Eventing, ClientMetadata, OpenFeatureCommonAPI, ProviderWrapper } from '@openfeature/core';
+import { BaseHook, FlagValue, EvaluationContext, BooleanFlagKey, HookHints, EvaluationDetails, StringFlagKey, NumberFlagKey, ObjectFlagKey, JsonValue, CommonProvider, ServerProviderStatus, Logger, ResolutionDetails, GenericEventEmitter, ServerProviderEvents, ProviderEntryInput, ProviderMetadata, RegisteredProvider, BaseEvaluationStrategy, TrackingEventDetails, BaseStrategyProviderContext, BaseStrategyPerProviderContext, BaseProviderResolutionResult, BaseProviderResolutionSuccessResult, BaseProviderResolutionErrorResult, BaseFinalResult, BaseFirstMatchStrategy, BaseFirstSuccessfulStrategy, BaseComparisonStrategy, EvaluationLifeCycle, ManageContext, ManageLogger, Eventing, ClientMetadata, OpenFeatureCommonAPI, ProviderWrapper } from '@openfeature/core';
 export * from '@openfeature/core';
-export { ServerProviderEvents as ProviderEvents, ServerProviderStatus as ProviderStatus } from '@openfeature/core';
+export { ServerProviderEvents as ProviderEvents, ServerProviderStatus as ProviderStatus, StrategyEvaluationContext } from '@openfeature/core';
 import { EventEmitter } from 'node:events';
 
 type Hook<TData = Record<string, unknown>> = BaseHook<FlagValue, TData, Promise<EvaluationContext | void> | EvaluationContext | void, Promise<void> | void>;
 
+type ConstrainedFlagKey<T> = T extends boolean ? BooleanFlagKey : T extends number ? NumberFlagKey : T extends string ? StringFlagKey : T extends JsonValue ? ObjectFlagKey : never;
 interface FlagEvaluationOptions {
     hooks?: Hook[];
     hookHints?: HookHints;
@@ -12,88 +13,88 @@ interface FlagEvaluationOptions {
 interface Features {
     /**
      * Performs a flag evaluation that returns a boolean.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {BooleanFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @param {boolean} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<boolean>} Flag evaluation response
      */
-    getBooleanValue(flagKey: string, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<boolean>;
+    getBooleanValue(flagKey: BooleanFlagKey, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<boolean>;
     /**
      * Performs a flag evaluation that a returns an evaluation details object.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {BooleanFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @param {boolean} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<EvaluationDetails<boolean>>} Flag evaluation details response
      */
-    getBooleanDetails(flagKey: string, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<boolean>>;
+    getBooleanDetails(flagKey: BooleanFlagKey, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<boolean>>;
     /**
      * Performs a flag evaluation that returns a string.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {StringFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {string} T A optional generic argument constraining the string
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<T>} Flag evaluation response
      */
-    getStringValue(flagKey: string, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<string>;
-    getStringValue<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
+    getStringValue(flagKey: StringFlagKey, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<string>;
+    getStringValue<T extends string = string>(flagKey: StringFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
     /**
      * Performs a flag evaluation that a returns an evaluation details object.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {StringFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {string} T A optional generic argument constraining the string
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<EvaluationDetails<T>>} Flag evaluation details response
      */
-    getStringDetails(flagKey: string, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<string>>;
-    getStringDetails<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
+    getStringDetails(flagKey: StringFlagKey, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<string>>;
+    getStringDetails<T extends string = string>(flagKey: StringFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
     /**
      * Performs a flag evaluation that returns a number.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {NumberFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {number} T A optional generic argument constraining the number
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<T>} Flag evaluation response
      */
-    getNumberValue(flagKey: string, defaultValue: number, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<number>;
-    getNumberValue<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
+    getNumberValue(flagKey: NumberFlagKey, defaultValue: number, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<number>;
+    getNumberValue<T extends number = number>(flagKey: NumberFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
     /**
      * Performs a flag evaluation that a returns an evaluation details object.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {NumberFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {number} T A optional generic argument constraining the number
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<EvaluationDetails<T>>} Flag evaluation details response
      */
-    getNumberDetails(flagKey: string, defaultValue: number, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<number>>;
-    getNumberDetails<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
+    getNumberDetails(flagKey: NumberFlagKey, defaultValue: number, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<number>>;
+    getNumberDetails<T extends number = number>(flagKey: NumberFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
     /**
      * Performs a flag evaluation that returns an object.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {ObjectFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {JsonValue} T A optional generic argument describing the structure
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<T>} Flag evaluation response
      */
-    getObjectValue(flagKey: string, defaultValue: JsonValue, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<JsonValue>;
-    getObjectValue<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
+    getObjectValue(flagKey: ObjectFlagKey, defaultValue: JsonValue, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<JsonValue>;
+    getObjectValue<T extends JsonValue = JsonValue>(flagKey: ObjectFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<T>;
     /**
      * Performs a flag evaluation that a returns an evaluation details object.
-     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {ObjectFlagKey} flagKey The flag key uniquely identifies a particular flag
      * @template {JsonValue} T A optional generic argument describing the structure
      * @param {T} defaultValue The value returned if an error occurs
      * @param {EvaluationContext} context The evaluation context used on an individual flag evaluation
      * @param {FlagEvaluationOptions} options Additional flag evaluation options
      * @returns {Promise<EvaluationDetails<T>>} Flag evaluation details response
      */
-    getObjectDetails(flagKey: string, defaultValue: JsonValue, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<JsonValue>>;
-    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
+    getObjectDetails(flagKey: ObjectFlagKey, defaultValue: JsonValue, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<JsonValue>>;
+    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: ObjectFlagKey, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): Promise<EvaluationDetails<T>>;
 }
 
 /**
@@ -149,19 +150,23 @@ declare const NOOP_PROVIDER: NoopFeatureProvider;
  * but just for the in-memory provider.
  */
 
-type Variants<T> = Record<string, T>;
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type FlagVariants<T extends string> = Record<T, boolean> | Record<T, string> | Record<T, number> | Record<T, JsonValue>;
 /**
  * A Feature Flag definition, containing it's specification
  */
-type Flag = {
+type Flag<T extends string = string> = {
     /**
      * An object containing all possible flags mappings (variant -> flag value)
      */
-    variants: Variants<boolean> | Variants<string> | Variants<number> | Variants<JsonValue>;
+    variants: FlagVariants<T>;
     /**
      * The variant it will resolve to in STATIC evaluation
      */
-    defaultVariant: string;
+    defaultVariant: NoInfer<T>;
     /**
      * Determines if flag evaluation is enabled or not for this flag.
      * If false, falls back to the default value provided to the client
@@ -173,12 +178,22 @@ type Flag = {
      * If it does not return a valid variant it falls back to the default value provided to the client
      * @param EvaluationContext
      */
-    contextEvaluator?: (ctx: EvaluationContext) => string;
+    contextEvaluator?: (ctx: EvaluationContext) => NoInfer<T>;
+};
+/**
+ * The configuration object for the InMemoryProvider, containing all flags and their specifications.
+ *
+ * The generic ensures that the keys of the `variants` object in each flag specification are consistent with the `defaultVariant` and the return type of `contextEvaluator`.
+ */
+type FlagConfiguration<T extends Record<string, FlagVariants<string>> = Record<string, FlagVariants<string>>> = {
+    [K in keyof T]: Simplify<{
+        variants: T[K];
+    } & Omit<Flag<keyof T[K] & string>, 'variants'>>;
 };
-type FlagConfiguration = Record<string, Flag>;
 
 /**
  * A simple OpenFeature provider intended for demos and as a test stub.
+ * @deprecated Use {@link TypedInMemoryProvider} for type-safe flag configuration.
  */
 declare class InMemoryProvider implements Provider {
     readonly events: OpenFeatureEventEmitter;
@@ -200,114 +215,124 @@ declare class InMemoryProvider implements Provider {
     private resolveFlagWithReason;
     private lookupFlagValue;
 }
-
 /**
- * The OpenFeatureEventEmitter can be used by provider developers to emit
- * events at various parts of the provider lifecycle.
+ * A simple OpenFeature provider intended for demos and as a test stub.
+ * @example
+ * ```
+ * const provider = new TypedInMemoryProvider({
+ *   'my-flag': {
+ *     variants: { on: true, off: false },
+ *     defaultVariant: 'on',
+ *     contextEvaluator: (ctx) => ctx?.user?.id === '123' ? 'on' : 'off',
+ *     disabled: false,
+ *   },
+ * });
  *
- * NOTE: Ready and error events are automatically emitted by the SDK based on
- * the result of the initialize method.
+ * const flags = {
+ *   'my-flag': {
+ *     variants: { on: true, off: false },
+ *     defaultVariant: 'on',
+ *     contextEvaluator: (ctx) => ctx?.user?.id === '123' ? 'on' : 'off',
+ *     disabled: false,
+ *   },
+ * } as const; // 'as const' needed to preserve the `defaultVariant` narrow literal type rather than `string`
+ * const provider = new TypedInMemoryProvider(flags);
+ * ```
  */
-declare class OpenFeatureEventEmitter extends GenericEventEmitter<ServerProviderEvents> {
-    protected readonly eventEmitter: EventEmitter<[never]>;
-    constructor();
-}
-
-type StrategyEvaluationContext = {
-    flagKey: string;
-    flagType: FlagValueType;
-};
-type StrategyProviderContext = {
-    provider: Provider;
-    providerName: string;
-    providerStatus: ServerProviderStatus;
-};
-type StrategyPerProviderContext = StrategyEvaluationContext & StrategyProviderContext;
-type ProviderResolutionResultBase = {
-    provider: Provider;
-    providerName: string;
-};
-type ProviderResolutionSuccessResult<T extends FlagValue> = ProviderResolutionResultBase & {
-    details: ResolutionDetails<T>;
-};
-type ProviderResolutionErrorResult = ProviderResolutionResultBase & {
-    thrownError: unknown;
-};
-type ProviderResolutionResult<T extends FlagValue> = ProviderResolutionSuccessResult<T> | ProviderResolutionErrorResult;
-type FinalResult<T extends FlagValue> = {
-    details?: ResolutionDetails<T>;
-    provider?: Provider;
-    providerName?: string;
-    errors?: {
-        providerName: string;
-        error: unknown;
-    }[];
-};
-/**
- * Base strategy to inherit from. Not directly usable, as strategies must implement the "determineResult" method
- * Contains default implementations for `shouldEvaluateThisProvider` and `shouldEvaluateNextProvider`
- */
-declare abstract class BaseEvaluationStrategy {
-    runMode: 'parallel' | 'sequential';
-    shouldEvaluateThisProvider(strategyContext: StrategyPerProviderContext, _evalContext?: EvaluationContext): boolean;
-    shouldEvaluateNextProvider<T extends FlagValue>(_strategyContext?: StrategyPerProviderContext, _context?: EvaluationContext, _result?: ProviderResolutionResult<T>): boolean;
-    shouldTrackWithThisProvider(strategyContext: StrategyProviderContext, _context?: EvaluationContext, _trackingEventName?: string, _trackingEventDetails?: TrackingEventDetails): boolean;
-    abstract determineFinalResult<T extends FlagValue>(strategyContext: StrategyEvaluationContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
-    protected hasError(resolution: ProviderResolutionResult<FlagValue>): resolution is ProviderResolutionErrorResult | (ProviderResolutionSuccessResult<FlagValue> & {
-        details: ResolutionDetails<FlagValue> & {
-            errorCode: ErrorCode;
-        };
-    });
-    protected hasErrorWithCode(resolution: ProviderResolutionResult<FlagValue>, code: ErrorCode): boolean;
-    protected collectProviderErrors<T extends FlagValue>(resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
-    protected resolutionToFinalResult<T extends FlagValue>(resolution: ProviderResolutionSuccessResult<T>): {
-        details: ResolutionDetails<T>;
-        provider: Provider;
-        providerName: string;
-    };
+declare class TypedInMemoryProvider<T extends Record<string, FlagVariants<string>> = Record<string, FlagVariants<string>>> extends InMemoryProvider {
+    constructor(flagConfiguration?: FlagConfiguration<T>);
+    /**
+     * Overwrites the configured flags.
+     * @param { FlagConfiguration } flagConfiguration new flag configuration
+     * @example
+     * ```
+     * provider.putConfiguration({
+     *   'my-flag': {
+     *     variants: { on: true, off: false },
+     *     defaultVariant: 'on',
+     *     contextEvaluator: (ctx) => ctx?.user?.id === '123' ? 'on' : 'off',
+     *     disabled: false,
+     *   },
+     * });
+     *
+     * const flags = {
+     *   'my-flag': {
+     *     variants: { on: true, off: false },
+     *     defaultVariant: 'on',
+     *     contextEvaluator: (ctx) => ctx?.user?.id === '123' ? 'on' : 'off',
+     *     disabled: false,
+     *   },
+     * } as const; // 'as const' needed to preserve the `defaultVariant` narrow literal type rather than `string`
+     * provider.putConfiguration(flags);
+     * ```
+     */
+    putConfiguration<U extends Record<string, FlagVariants<string>> = Record<string, FlagVariants<string>>>(flagConfiguration: FlagConfiguration<U>): void;
 }
-
 /**
- * Return the first result that did not indicate "flag not found".
- * If any provider in the course of evaluation returns or throws an error, throw that error
+ * The variants object for a flag in the {@link TypedInMemoryProvider}, containing all possible variants and their associated values.
+ *
+ * Can be used in combination with {@link InMemoryFlagConfiguration} to preserve type-safety when extending the provider class.
+ * @example
+ * ```
+ * export class CustomInMemoryProvider<
+ *   T extends Record<string, InMemoryFlagVariants<string>> = Record<string, InMemoryFlagVariants<string>>,
+ * > extends TypedInMemoryProvider<T> {
+ *   constructor(flagConfiguration: InMemoryFlagConfiguration<T>) {
+ *     super(flagConfiguration);
+ *     // custom logic ...
+ *   }
+ *
+ *   override putConfiguration<
+ *     U extends Record<string, InMemoryFlagVariants<string>> = Record<string, InMemoryFlagVariants<string>>,
+ *   >(flagConfiguration: InMemoryFlagConfiguration<U>) {
+ *     super.putConfiguration(flagConfiguration);
+ *     // custom logic ...
+ *   }
+ * }
+ * ```
  */
-declare class FirstMatchStrategy extends BaseEvaluationStrategy {
-    shouldEvaluateNextProvider<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, result: ProviderResolutionResult<T>): boolean;
-    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
-}
-
+type InMemoryFlagVariants<T extends string> = FlagVariants<T>;
 /**
- * Return the first result that did NOT result in an error
- * If any provider in the course of evaluation returns or throws an error, ignore it as long as there is a successful result
- * If there is no successful result, throw all errors
+ * The configuration object for the {@link TypedInMemoryProvider}, containing all flags and their specifications.
+ *
+ * Can be used in combination with {@link InMemoryFlagVariants} to preserve type-safety when extending the provider class.
+ *
+ * The generic ensures that the keys of the `variants` object in each flag specification are consistent with the `defaultVariant` and the return type of `contextEvaluator`.
+ * @example
+ * ```
+ * export class CustomInMemoryProvider<
+ *   T extends Record<string, InMemoryFlagVariants<string>> = Record<string, InMemoryFlagVariants<string>>,
+ * > extends TypedInMemoryProvider<T> {
+ *   constructor(flagConfiguration: InMemoryFlagConfiguration<T>) {
+ *     super(flagConfiguration);
+ *     // custom logic ...
+ *   }
+ *
+ *   override putConfiguration<
+ *     U extends Record<string, InMemoryFlagVariants<string>> = Record<string, InMemoryFlagVariants<string>>,
+ *   >(flagConfiguration: InMemoryFlagConfiguration<U>) {
+ *     super.putConfiguration(flagConfiguration);
+ *     // custom logic ...
+ *   }
+ * }
+ * ```
  */
-declare class FirstSuccessfulStrategy extends BaseEvaluationStrategy {
-    shouldEvaluateNextProvider<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, result: ProviderResolutionResult<T>): boolean;
-    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
-}
+type InMemoryFlagConfiguration<T extends Record<string, FlagVariants<string>> = Record<string, FlagVariants<string>>> = FlagConfiguration<T>;
 
 /**
- * Evaluate all providers in parallel and compare the results.
- * If the values agree, return the value
- * If the values disagree, return the value from the configured "fallback provider" and execute the "onMismatch"
- * callback if defined
+ * The OpenFeatureEventEmitter can be used by provider developers to emit
+ * events at various parts of the provider lifecycle.
+ *
+ * NOTE: Ready and error events are automatically emitted by the SDK based on
+ * the result of the initialize method.
  */
-declare class ComparisonStrategy extends BaseEvaluationStrategy {
-    private fallbackProvider;
-    private onMismatch?;
-    runMode: "parallel";
-    constructor(fallbackProvider: Provider, onMismatch?: ((resolutions: ProviderResolutionResult<FlagValue>[]) => void) | undefined);
-    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+declare class OpenFeatureEventEmitter extends GenericEventEmitter<ServerProviderEvents> {
+    protected readonly eventEmitter: EventEmitter<[never]>;
+    constructor();
 }
 
-type ProviderEntryInput = {
-    provider: Provider;
-    name?: string;
-};
-type RegisteredProvider = Required<ProviderEntryInput>;
-
 declare class MultiProvider implements Provider {
-    readonly constructorProviders: ProviderEntryInput[];
+    readonly constructorProviders: ProviderEntryInput<Provider>[];
     private readonly evaluationStrategy;
     private readonly logger;
     readonly runsOn = "server";
@@ -315,11 +340,11 @@ declare class MultiProvider implements Provider {
     private hookContexts;
     private hookHints;
     metadata: ProviderMetadata;
-    providerEntries: RegisteredProvider[];
+    providerEntries: RegisteredProvider<Provider>[];
     private providerEntriesByName;
     private hookExecutor;
     private statusTracker;
-    constructor(constructorProviders: ProviderEntryInput[], evaluationStrategy?: BaseEvaluationStrategy, logger?: Logger);
+    constructor(constructorProviders: ProviderEntryInput<Provider>[], evaluationStrategy?: BaseEvaluationStrategy<ServerProviderStatus, Provider>, logger?: Logger);
     private registerProviders;
     initialize(context?: EvaluationContext): Promise<void>;
     onClose(): Promise<void>;
@@ -336,25 +361,45 @@ declare class MultiProvider implements Provider {
     private getErrorEvaluationDetails;
 }
 
-declare class ErrorWithCode extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(code: ErrorCode, message: string);
+/**
+ * Pre-configured strategy exports for the server SDK.
+ * These classes extend the base strategies from @openfeature/core with the
+ * server-specific ProviderStatus enum already bound.
+ */
+
+/**
+ * Pre-bound type aliases for server SDK.
+ * These types have the server-specific ProviderStatus and Provider types already applied,
+ * providing backward compatibility for existing consumers.
+ */
+type StrategyProviderContext = BaseStrategyProviderContext<ServerProviderStatus, Provider>;
+type StrategyPerProviderContext = BaseStrategyPerProviderContext<ServerProviderStatus, Provider>;
+type ProviderResolutionResult<T extends FlagValue> = BaseProviderResolutionResult<T, ServerProviderStatus, Provider>;
+type ProviderResolutionSuccessResult<T extends FlagValue> = BaseProviderResolutionSuccessResult<T, ServerProviderStatus, Provider>;
+type ProviderResolutionErrorResult = BaseProviderResolutionErrorResult<ServerProviderStatus, Provider>;
+type FinalResult<T extends FlagValue> = BaseFinalResult<T, ServerProviderStatus, Provider>;
+
+/**
+ * Evaluates providers in order and returns the first successful result.
+ * Providers that return FLAG_NOT_FOUND are skipped. Any other error stops evaluation.
+ */
+declare class FirstMatchStrategy extends BaseFirstMatchStrategy<ServerProviderStatus, Provider> {
+    constructor();
+}
+/**
+ * Evaluates providers in order and returns the first successful result.
+ * Any error causes that provider to be skipped.
+ */
+declare class FirstSuccessfulStrategy extends BaseFirstSuccessfulStrategy<ServerProviderStatus, Provider> {
+    constructor();
 }
-declare class AggregateError extends GeneralError {
-    originalErrors: {
-        source: string;
-        error: unknown;
-    }[];
-    constructor(message: string, originalErrors: {
-        source: string;
-        error: unknown;
-    }[]);
+/**
+ * Evaluates all providers in parallel and compares results.
+ * If all providers agree, returns that result. Otherwise, returns the fallback provider's result.
+ */
+declare class ComparisonStrategy extends BaseComparisonStrategy<ServerProviderStatus, Provider> {
+    constructor(fallbackProvider: Provider, onMismatch?: (resolutions: ProviderResolutionResult<FlagValue>[]) => void);
 }
-declare const constructAggregateError: (providerErrors: {
-    error: unknown;
-    providerName: string;
-}[]) => AggregateError;
-declare const throwAggregateErrorFromPromiseResults: (result: PromiseSettledResult<unknown>[], providerEntries: RegisteredProvider[]) => void;
 
 interface Tracking {
     /**
@@ -560,5 +605,5 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<ServerProviderStatus,
  */
 declare const OpenFeature: OpenFeatureAPI;
 
-export { AggregateError, AsyncLocalStorageTransactionContextPropagator, BaseEvaluationStrategy, ComparisonStrategy, ErrorWithCode, FirstMatchStrategy, FirstSuccessfulStrategy, InMemoryProvider, MultiProvider, NOOP_PROVIDER, NOOP_TRANSACTION_CONTEXT_PROPAGATOR, OpenFeature, OpenFeatureAPI, OpenFeatureEventEmitter, constructAggregateError, throwAggregateErrorFromPromiseResults };
-export type { Client, Features, FinalResult, FlagEvaluationOptions, Hook, ManageTransactionContextPropagator, Provider, ProviderResolutionErrorResult, ProviderResolutionResult, ProviderResolutionSuccessResult, StrategyEvaluationContext, StrategyPerProviderContext, StrategyProviderContext, Tracking, TransactionContext, TransactionContextPropagator };
+export { AsyncLocalStorageTransactionContextPropagator, ComparisonStrategy, FirstMatchStrategy, FirstSuccessfulStrategy, InMemoryProvider, MultiProvider, NOOP_PROVIDER, NOOP_TRANSACTION_CONTEXT_PROPAGATOR, OpenFeature, OpenFeatureAPI, OpenFeatureEventEmitter, TypedInMemoryProvider };
+export type { Client, ConstrainedFlagKey, Features, FinalResult, FlagEvaluationOptions, Hook, InMemoryFlagConfiguration, InMemoryFlagVariants, ManageTransactionContextPropagator, Provider, ProviderResolutionErrorResult, ProviderResolutionResult, ProviderResolutionSuccessResult, StrategyPerProviderContext, StrategyProviderContext, Tracking, TransactionContext, TransactionContextPropagator };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/server-sdk",
-  "version": "1.20.1",
+  "version": "1.21.0",
   "description": "OpenFeature SDK for JavaScript",
   "main": "./dist/cjs/index.js",
   "files": [
@@ -48,9 +48,10 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@openfeature/core": "^1.9.0"
+    "@openfeature/core": "^1.10.0"
   },
   "devDependencies": {
-    "@openfeature/core": "^1.9.0"
-  }
+    "@openfeature/core": "^1.9.2"
+  },
+  "sideEffects": false
 }