@openfeature/web-sdk 0.4.11 → 0.4.13

package/dist/types.d.ts

@@ -1,641 +1,8 @@
+import { BaseHook, HookHints, EvaluationDetails, JsonValue, EvaluationLifeCycle, ManageLogger, Eventing, ClientMetadata, ProviderStatus, ClientProviderEvents, GenericEventEmitter, CommonEventDetails, FlagValue, CommonProvider, EvaluationContext, Logger, ResolutionDetails, EventHandler, OpenFeatureCommonAPI, ManageContext } from '@openfeature/core';
+export * from '@openfeature/core';
+export { ClientProviderEvents as ProviderEvents } from '@openfeature/core';
 import EventEmitter from 'events';
 
-type FlagValueType = 'boolean' | 'string' | 'number' | 'object';
-type PrimitiveValue = null | boolean | string | number;
-type JsonObject = {
-    [key: string]: JsonValue;
-};
-type JsonArray = JsonValue[];
-/**
- * Represents a JSON node value.
- */
-type JsonValue = PrimitiveValue | JsonObject | JsonArray;
-/**
- * Represents a JSON node value, or Date.
- */
-type FlagValue = boolean | string | number | JsonValue;
-type ResolutionReason = keyof typeof StandardResolutionReasons | (string & Record<never, never>);
-/**
- * A structure which supports definition of arbitrary properties, with keys of type string, and values of type boolean, string, or number.
- *
- * This structure is populated by a provider for use by an Application Author (via the Evaluation API) or an Application Integrator (via hooks).
- */
-type FlagMetadata = Record<string, string | number | boolean>;
-type ResolutionDetails<U> = {
-    value: U;
-    variant?: string;
-    flagMetadata?: FlagMetadata;
-    reason?: ResolutionReason;
-    errorCode?: ErrorCode;
-    errorMessage?: string;
-};
-type EvaluationDetails<T extends FlagValue> = {
-    flagKey: string;
-    flagMetadata: Readonly<FlagMetadata>;
-} & ResolutionDetails<T>;
-declare const StandardResolutionReasons: {
-    /**
-     * The resolved value was the result of a dynamic evaluation, such as a rule or specific user-targeting.
-     */
-    readonly TARGETING_MATCH: "TARGETING_MATCH";
-    /**
-     * The resolved value was the result of pseudorandom assignment.
-     */
-    readonly SPLIT: "SPLIT";
-    /**
-     * The resolved value was the result of the flag being disabled in the management system.
-     */
-    readonly DISABLED: "DISABLED";
-    /**
-     *  The resolved value was configured statically, or otherwise fell back to a pre-configured value.
-     */
-    readonly DEFAULT: "DEFAULT";
-    /**
-     * The reason for the resolved value could not be determined.
-     */
-    readonly UNKNOWN: "UNKNOWN";
-    /**
-     * The resolved value is static (no dynamic evaluation).
-     */
-    readonly STATIC: "STATIC";
-    /**
-     * The resolved value was retrieved from cache.
-     */
-    readonly CACHED: "CACHED";
-    /**
-     * The resolved value was the result of an error.
-     *
-     * Note: The `errorCode` and `errorMessage` fields may contain additional details of this error.
-     */
-    readonly ERROR: "ERROR";
-};
-declare enum ErrorCode {
-    /**
-     * The value was resolved before the provider was ready.
-     */
-    PROVIDER_NOT_READY = "PROVIDER_NOT_READY",
-    /**
-     * The flag could not be found.
-     */
-    FLAG_NOT_FOUND = "FLAG_NOT_FOUND",
-    /**
-     * An error was encountered parsing data, such as a flag configuration.
-     */
-    PARSE_ERROR = "PARSE_ERROR",
-    /**
-     * The type of the flag value does not match the expected type.
-     */
-    TYPE_MISMATCH = "TYPE_MISMATCH",
-    /**
-     * The provider requires a targeting key and one was not provided in the evaluation context.
-     */
-    TARGETING_KEY_MISSING = "TARGETING_KEY_MISSING",
-    /**
-     * The evaluation context does not meet provider requirements.
-     */
-    INVALID_CONTEXT = "INVALID_CONTEXT",
-    /**
-     * An error with an unspecified code.
-     */
-    GENERAL = "GENERAL"
-}
-
-type EvaluationContextValue = PrimitiveValue | Date | {
-    [key: string]: EvaluationContextValue;
-} | EvaluationContextValue[];
-/**
- * A container for arbitrary contextual data that can be used as a basis for dynamic evaluation
- */
-type EvaluationContext = {
-    /**
-     * A string uniquely identifying the subject (end-user, or client service) of a flag evaluation.
-     * Providers may require this field for fractional flag evaluation, rules, or overrides targeting specific users.
-     * Such providers may behave unpredictably if a targeting key is not specified at flag resolution.
-     */
-    targetingKey?: string;
-} & Record<string, EvaluationContextValue>;
-interface ManageContext<T> {
-    /**
-     * Access the evaluation context set on the receiver.
-     * @returns {EvaluationContext} Evaluation context
-     */
-    getContext(): EvaluationContext;
-    /**
-     * Sets evaluation context that will be used during flag evaluations
-     * on this receiver.
-     * @template T The type of the receiver
-     * @param {EvaluationContext} context Evaluation context
-     * @returns {T} The receiver (this object)
-     */
-    setContext(context: EvaluationContext): T;
-}
-
-/**
- * An enumeration of possible events for server-sdk providers.
- */
-declare enum ServerProviderEvents {
-    /**
-     * The provider is ready to evaluate flags.
-     */
-    Ready = "PROVIDER_READY",
-    /**
-     * The provider is in an error state.
-     */
-    Error = "PROVIDER_ERROR",
-    /**
-     * The flag configuration in the source-of-truth has changed.
-     */
-    ConfigurationChanged = "PROVIDER_CONFIGURATION_CHANGED",
-    /**
-     * The provider's cached state is no longer valid and may not be up-to-date with the source of truth.
-     */
-    Stale = "PROVIDER_STALE"
-}
-/**
- * An enumeration of possible events for web-sdk providers.
- */
-declare enum ClientProviderEvents {
-    /**
-     * The provider is ready to evaluate flags.
-     */
-    Ready = "PROVIDER_READY",
-    /**
-     * The provider is in an error state.
-     */
-    Error = "PROVIDER_ERROR",
-    /**
-     * The flag configuration in the source-of-truth has changed.
-     */
-    ConfigurationChanged = "PROVIDER_CONFIGURATION_CHANGED",
-    /**
-     * The context associated with the provider has changed, and the provider has reconciled it's associated state.
-     */
-    ContextChanged = "PROVIDER_CONTEXT_CHANGED",
-    /**
-     * The provider's cached state is no longer valid and may not be up-to-date with the source of truth.
-     */
-    Stale = "PROVIDER_STALE"
-}
-
-/**
- * A type representing any possible ProviderEvent (server or client side).
- * If you are implementing a hook or provider, you probably want to import `ProviderEvents` from the respective SDK.
- */
-type AnyProviderEvent = ServerProviderEvents | ClientProviderEvents;
-
-/**
- * Returns true if the provider's status corresponds to the event.
- * If the provider's status is not defined, it matches READY.
- * @param {AnyProviderEvent} event event to match
- * @param {ProviderStatus} status  status of provider
- * @returns {boolean} boolean indicating if the provider status corresponds to the event.
- */
-declare const statusMatchesEvent: <T extends AnyProviderEvent>(event: T, status?: ProviderStatus) => boolean;
-
-type EventMetadata = {
-    [key: string]: string | boolean | number;
-};
-type CommonEventDetails = {
-    providerName: string;
-    clientName?: string;
-};
-type CommonEventProps = {
-    message?: string;
-    metadata?: EventMetadata;
-};
-type ReadyEvent = CommonEventProps;
-type ErrorEvent = CommonEventProps;
-type StaleEvent = CommonEventProps;
-type ConfigChangeEvent = CommonEventProps & {
-    flagsChanged?: string[];
-};
-type EventMap = {
-    [ClientProviderEvents.Ready]: ReadyEvent;
-    [ClientProviderEvents.Error]: ErrorEvent;
-    [ClientProviderEvents.Stale]: StaleEvent;
-    [ClientProviderEvents.ContextChanged]: CommonEventProps;
-    [ClientProviderEvents.ConfigurationChanged]: ConfigChangeEvent;
-};
-type EventContext<U extends Record<string, unknown> = Record<string, unknown>> = EventMap[ClientProviderEvents] & U;
-type EventDetails = EventContext & CommonEventDetails;
-type EventHandler = (eventDetails?: EventDetails) => Promise<unknown> | unknown;
-interface Eventing {
-    /**
-     * Adds a handler for the given provider event type.
-     * The handlers are called in the order they have been added.
-     * @param {AnyProviderEvent} eventType The provider event type to listen to
-     * @param {EventHandler} handler The handler to run on occurrence of the event type
-     */
-    addHandler(eventType: AnyProviderEvent, handler: EventHandler): void;
-    /**
-     * Removes a handler for the given provider event type.
-     * @param {AnyProviderEvent} eventType The provider event type to remove the listener for
-     * @param {EventHandler} handler The handler to remove for the provider event type
-     */
-    removeHandler(eventType: AnyProviderEvent, handler: EventHandler): void;
-    /**
-     * Gets the current handlers for the given provider event type.
-     * @param {AnyProviderEvent} eventType The provider event type to get the current handlers for
-     * @returns {EventHandler[]} The handlers currently attached to the given provider event type
-     */
-    getHandlers(eventType: AnyProviderEvent): EventHandler[];
-}
-
-interface Logger {
-    error(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-}
-interface ManageLogger<T> {
-    /**
-     * Sets a logger on this receiver. This logger supersedes to the global logger
-     * and is passed to various components in the SDK.
-     * The logger configured on the global API object will be used for all evaluations,
-     * unless overridden in a particular client.
-     * @template T The type of the receiver
-     * @param {Logger} logger The logger to be used
-     * @returns {T} The receiver (this object)
-     */
-    setLogger(logger: Logger): T;
-}
-
-declare class DefaultLogger implements Logger {
-    error(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    info(): void;
-    debug(): void;
-}
-
-declare const LOG_LEVELS: Array<keyof Logger>;
-declare class SafeLogger implements Logger {
-    private readonly logger;
-    private readonly fallbackLogger;
-    constructor(logger: Logger);
-    error(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-    private log;
-}
-
-/**
- * The GenericEventEmitter should only be used within the SDK. It supports additional properties that can be included
- * in the event details.
- */
-declare abstract class GenericEventEmitter<E extends AnyProviderEvent, AdditionalContext extends Record<string, unknown> = Record<string, unknown>> implements ManageLogger<GenericEventEmitter<E, AdditionalContext>> {
-    private readonly globalLogger?;
-    protected abstract readonly eventEmitter: PlatformEventEmitter;
-    private readonly _handlers;
-    private _eventLogger?;
-    constructor(globalLogger?: (() => Logger) | undefined);
-    emit(eventType: E, context?: EventContext): void;
-    addHandler(eventType: AnyProviderEvent, handler: EventHandler): void;
-    removeHandler(eventType: AnyProviderEvent, handler: EventHandler): void;
-    removeAllHandlers(eventType?: AnyProviderEvent): void;
-    getHandlers(eventType: AnyProviderEvent): EventHandler[];
-    setLogger(logger: Logger): this;
-    protected get _logger(): Logger | undefined;
-}
-/**
- * This is an un-exported type that corresponds to NodeJS.EventEmitter.
- * We can't use that type here, because this module is used in both the browser, and the server.
- * In the server, node (or whatever server runtime) provides an implementation for this.
- * In the browser, we bundle in the popular 'events' package, which is a polyfill of NodeJS.EventEmitter.
- */
-interface PlatformEventEmitter {
-    addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    removeAllListeners(event?: string | symbol): this;
-    setMaxListeners(n: number): this;
-    getMaxListeners(): number;
-    listeners(eventName: string | symbol): Function[];
-    rawListeners(eventName: string | symbol): Function[];
-    emit(eventName: string | symbol, ...args: any[]): boolean;
-    listenerCount(eventName: string | symbol, listener?: Function): number;
-    prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    eventNames(): Array<string | symbol>;
-}
-
-interface Metadata {
-}
-
-/**
- * Defines where the library is intended to be run.
- */
-type Paradigm = 'server' | 'client';
-
-/**
- * The state of the provider.
- */
-declare enum ProviderStatus {
-    /**
-     * The provider has not been initialized and cannot yet evaluate flags.
-     */
-    NOT_READY = "NOT_READY",
-    /**
-     * The provider is ready to resolve flags.
-     */
-    READY = "READY",
-    /**
-     * The provider is in an error state and unable to evaluate flags.
-     */
-    ERROR = "ERROR",
-    /**
-     * The provider's cached state is no longer valid and may not be up-to-date with the source of truth.
-     */
-    STALE = "STALE"
-}
-/**
- * Static data about the provider.
- */
-interface ProviderMetadata extends Metadata {
-    readonly name: string;
-}
-interface CommonProvider {
-    readonly metadata: ProviderMetadata;
-    /**
-     * Represents where the provider is intended to be run. If defined,
-     * the SDK will enforce that the defined paradigm at runtime.
-     */
-    readonly runsOn?: Paradigm;
-    /**
-     * Returns a representation of the current readiness of the provider.
-     * If the provider needs to be initialized, it should return {@link ProviderStatus.READY}.
-     * If the provider is in an error state, it should return {@link ProviderStatus.ERROR}.
-     * If the provider is functioning normally, it should return {@link ProviderStatus.NOT_READY}.
-     *
-     * _Providers which do not implement this method are assumed to be ready immediately._
-     */
-    readonly status?: ProviderStatus;
-    /**
-     * An event emitter for ProviderEvents.
-     * @see ProviderEvents
-     */
-    events?: GenericEventEmitter<AnyProviderEvent>;
-    /**
-     * A function used to shut down the provider.
-     * Called when this provider is replaced with a new one, or when the OpenFeature is shut down.
-     */
-    onClose?(): Promise<void>;
-    /**
-     * A function used to setup the provider.
-     * Called by the SDK after the provider is set if the provider's status is {@link ProviderStatus.NOT_READY}.
-     * When the returned promise resolves, the SDK fires the ProviderEvents.Ready event.
-     * If the returned promise rejects, the SDK fires the ProviderEvents.Error event.
-     * Use this function to perform any context-dependent setup within the provider.
-     * @param context
-     */
-    initialize?(context?: EvaluationContext): Promise<void>;
-}
-
-interface ClientMetadata extends Metadata {
-    readonly version?: string;
-    readonly name?: string;
-    readonly providerMetadata: ProviderMetadata;
-}
-
-type HookHints = Readonly<Record<string, unknown>>;
-interface HookContext<T extends FlagValue = FlagValue> {
-    readonly flagKey: string;
-    readonly defaultValue: T;
-    readonly flagValueType: FlagValueType;
-    readonly context: Readonly<EvaluationContext>;
-    readonly clientMetadata: ClientMetadata;
-    readonly providerMetadata: ProviderMetadata;
-    readonly logger: Logger;
-}
-interface BeforeHookContext extends HookContext {
-    context: EvaluationContext;
-}
-
-interface BaseHook<T extends FlagValue = FlagValue, BeforeHookReturn = unknown, HooksReturn = unknown> {
-    /**
-     * Runs before flag values are resolved from the provider.
-     * If an EvaluationContext is returned, it will be merged with the pre-existing EvaluationContext.
-     * @param hookContext
-     * @param hookHints
-     */
-    before?(hookContext: BeforeHookContext, hookHints?: HookHints): BeforeHookReturn;
-    /**
-     * Runs after flag values are successfully resolved from the provider.
-     * @param hookContext
-     * @param evaluationDetails
-     * @param hookHints
-     */
-    after?(hookContext: Readonly<HookContext<T>>, evaluationDetails: EvaluationDetails<T>, hookHints?: HookHints): HooksReturn;
-    /**
-     * Runs in the event of an unhandled error or promise rejection during flag resolution, or any attached hooks.
-     * @param hookContext
-     * @param error
-     * @param hookHints
-     */
-    error?(hookContext: Readonly<HookContext<T>>, error: unknown, hookHints?: HookHints): HooksReturn;
-    /**
-     * Runs after all other hook stages, regardless of success or error.
-     * Errors thrown here are unhandled by the client and will surface in application code.
-     * @param hookContext
-     * @param hookHints
-     */
-    finally?(hookContext: Readonly<HookContext<T>>, hookHints?: HookHints): HooksReturn;
-}
-
-interface EvaluationLifeCycle<T> {
-    /**
-     * Adds hooks that will run during flag evaluations on this receiver.
-     * Hooks are executed in the order they were registered. Adding additional hooks
-     * will not remove existing hooks.
-     * Hooks registered on the global API object run with all evaluations.
-     * Hooks registered on the client run with all evaluations on that client.
-     * @template T The type of the receiver
-     * @param {BaseHook[]} hooks A list of hooks that should always run
-     * @returns {T} The receiver (this object)
-     */
-    addHooks(...hooks: BaseHook[]): T;
-    /**
-     * Access all the hooks that are registered on this receiver.
-     * @returns {BaseHook<FlagValue>[]} A list of the client hooks
-     */
-    getHooks(): BaseHook[];
-    /**
-     * Clears all the hooks that are registered on this receiver.
-     * @template T The type of the receiver
-     * @returns {T} The receiver (this object)
-     */
-    clearHooks(): T;
-}
-
-declare abstract class OpenFeatureError extends Error {
-    abstract code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class GeneralError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class FlagNotFoundError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class ParseError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class TypeMismatchError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class TargetingKeyMissingError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class InvalidContextError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-declare class ProviderNotReadyError extends OpenFeatureError {
-    code: ErrorCode;
-    constructor(message?: string, options?: ErrorOptions);
-}
-
-/**
- * Checks whether the parameter is a string.
- * @param {unknown} value The value to check
- * @returns {value is string} True if the value is a string
- */
-declare function isString(value: unknown): value is string;
-/**
- * Returns the parameter if it is a string, otherwise returns undefined.
- * @param {unknown} value The value to check
- * @returns {string|undefined} The parameter if it is a string, otherwise undefined
- */
-declare function stringOrUndefined(value: unknown): string | undefined;
-/**
- * Checks whether the parameter is an object.
- * @param {unknown} value The value to check
- * @returns {value is string} True if the value is an object
- */
-declare function isObject<T extends object>(value: unknown): value is T;
-/**
- * Returns the parameter if it is an object, otherwise returns undefined.
- * @param {unknown} value The value to check
- * @returns {object|undefined} The parameter if it is an object, otherwise undefined
- */
-declare function objectOrUndefined<T extends object>(value: unknown): T | undefined;
-
-declare abstract class OpenFeatureCommonAPI<P extends CommonProvider = CommonProvider, H extends BaseHook = BaseHook> implements Eventing, EvaluationLifeCycle<OpenFeatureCommonAPI<P>>, ManageLogger<OpenFeatureCommonAPI<P>> {
-    protected abstract _createEventEmitter(): GenericEventEmitter<AnyProviderEvent>;
-    protected abstract _defaultProvider: P;
-    protected abstract readonly _events: GenericEventEmitter<AnyProviderEvent>;
-    protected _hooks: H[];
-    protected _context: EvaluationContext;
-    protected _logger: Logger;
-    private readonly _clientEventHandlers;
-    protected _clientProviders: Map<string, P>;
-    protected _clientEvents: Map<string | undefined, GenericEventEmitter<AnyProviderEvent>>;
-    protected _runsOn: Paradigm;
-    constructor(category: Paradigm);
-    addHooks(...hooks: H[]): this;
-    getHooks(): H[];
-    clearHooks(): this;
-    setLogger(logger: Logger): this;
-    /**
-     * Get metadata about the default provider.
-     * @returns {ProviderMetadata} Provider Metadata
-     */
-    get providerMetadata(): ProviderMetadata;
-    /**
-     * Get metadata about a registered provider using the client name.
-     * An unbound or empty client name will return metadata from the default provider.
-     * @param {string} [clientName] The name to identify the client
-     * @returns {ProviderMetadata} Provider Metadata
-     */
-    getProviderMetadata(clientName?: string): ProviderMetadata;
-    /**
-     * Adds a handler for the given provider event type.
-     * The handlers are called in the order they have been added.
-     * API (global) events run for all providers.
-     * @param {AnyProviderEvent} eventType The provider event type to listen to
-     * @param {EventHandler} handler The handler to run on occurrence of the event type
-     */
-    addHandler<T extends AnyProviderEvent>(eventType: T, handler: EventHandler): void;
-    /**
-     * Removes a handler for the given provider event type.
-     * @param {AnyProviderEvent} eventType The provider event type to remove the listener for
-     * @param {EventHandler} handler The handler to remove for the provider event type
-     */
-    removeHandler<T extends AnyProviderEvent>(eventType: T, handler: EventHandler): void;
-    /**
-     * Removes all event handlers.
-     */
-    clearHandlers(): void;
-    /**
-     * Gets the current handlers for the given provider event type.
-     * @param {AnyProviderEvent} eventType The provider event type to get the current handlers for
-     * @returns {EventHandler[]} The handlers currently attached to the given provider event type
-     */
-    getHandlers<T extends AnyProviderEvent>(eventType: T): EventHandler[];
-    /**
-     * Sets the default provider for flag evaluations and returns a promise that resolves when the provider is ready.
-     * This provider will be used by unnamed clients and named clients to which no provider is bound.
-     * Setting a provider supersedes the current provider used in new and existing clients without a name.
-     * @template P
-     * @param {P} provider The provider responsible for flag evaluations.
-     * @returns {Promise<void>}
-     * @throws Uncaught exceptions thrown by the provider during initialization.
-     */
-    setProviderAndWait(provider: P): Promise<void>;
-    /**
-     * Sets the provider that OpenFeature will use for flag evaluations of providers with the given name.
-     * A promise is returned that resolves when the provider is ready.
-     * Setting a provider supersedes the current provider used in new and existing clients with that name.
-     * @template P
-     * @param {string} clientName The name to identify the client
-     * @param {P} provider The provider responsible for flag evaluations.
-     * @returns {Promise<void>}
-     * @throws Uncaught exceptions thrown by the provider during initialization.
-     */
-    setProviderAndWait(clientName: string, provider: P): Promise<void>;
-    /**
-     * Sets the default provider for flag evaluations.
-     * This provider will be used by unnamed clients and named clients to which no provider is bound.
-     * Setting a provider supersedes the current provider used in new and existing clients without a name.
-     * @template P
-     * @param {P} provider The provider responsible for flag evaluations.
-     * @returns {this} OpenFeature API
-     */
-    setProvider(provider: P): this;
-    /**
-     * Sets the provider that OpenFeature will use for flag evaluations of providers with the given name.
-     * Setting a provider supersedes the current provider used in new and existing clients with that name.
-     * @template P
-     * @param {string} clientName The name to identify the client
-     * @param {P} provider The provider responsible for flag evaluations.
-     * @returns {this} OpenFeature API
-     */
-    setProvider(clientName: string, provider: P): this;
-    private setAwaitableProvider;
-    protected getProviderForClient(name?: string): P;
-    protected buildAndCacheEventEmitterForClient(name?: string): GenericEventEmitter<AnyProviderEvent>;
-    private getUnboundEmitters;
-    protected getAssociatedEventEmitters(clientName: string | undefined): GenericEventEmitter<AnyProviderEvent, Record<string, unknown>>[];
-    private transferListeners;
-    close(): Promise<void>;
-    protected clearProvidersAndSetDefault(defaultProvider: P): Promise<void>;
-    private handleShutdownError;
-}
-
 interface FlagEvaluationOptions {
     hooks?: BaseHook[];
     hookHints?: HookHints;
@@ -872,7 +239,11 @@ declare class InMemoryProvider implements Provider {
 }
 
 type OpenFeatureClientOptions = {
+    /**
+     * @deprecated Use `domain` instead.
+     */
     name?: string;
+    domain?: string;
     version?: string;
 };
 declare class OpenFeatureClient implements Client {
@@ -913,7 +284,6 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
     protected _events: GenericEventEmitter<ClientProviderEvents>;
     protected _defaultProvider: Provider;
     protected _createEventEmitter: () => OpenFeatureEventEmitter;
-    protected _namedProviderContext: Map<string, EvaluationContext>;
     private constructor();
     /**
      * Gets a singleton instance of the OpenFeature API.
@@ -923,7 +293,7 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
     static getInstance(): OpenFeatureAPI;
     /**
      * Sets the evaluation context globally.
-     * This will be used by all providers that have not been overridden with a named client.
+     * This will be used by all providers that have not bound to a domain.
      * @param {EvaluationContext} context Evaluation context
      * @example
      * await OpenFeature.setContext({ region: "us" });
@@ -931,15 +301,15 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
     setContext(context: EvaluationContext): Promise<void>;
     /**
      * Sets the evaluation context for a specific provider.
-     * This will only affect providers with a matching client name.
-     * @param {string} clientName The name to identify the client
+     * This will only affect providers bound to a domain.
+     * @param {string} domain An identifier which logically binds clients with providers
      * @param {EvaluationContext} context Evaluation context
      * @example
      * await OpenFeature.setContext("test", { scope: "provider" });
      * OpenFeature.setProvider(new MyProvider()) // Uses the default context
      * OpenFeature.setProvider("test", new MyProvider()) // Uses context: { scope: "provider" }
      */
-    setContext(clientName: string, context: EvaluationContext): Promise<void>;
+    setContext(domain: string, context: EvaluationContext): Promise<void>;
     /**
      * Access the global evaluation context.
      * @returns {EvaluationContext} Evaluation context
@@ -948,22 +318,22 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
     /**
      * Access the evaluation context for a specific named client.
      * The global evaluation context is returned if a matching named client is not found.
-     * @param {string} clientName The name to identify the client
+     * @param {string} domain An identifier which logically binds clients with providers
      * @returns {EvaluationContext} Evaluation context
      */
-    getContext(clientName?: string): EvaluationContext;
+    getContext(domain?: string): EvaluationContext;
     /**
      * Resets the global evaluation context to an empty object.
      */
     clearContext(): Promise<void>;
     /**
      * Removes the evaluation context for a specific named client.
-     * @param {string} clientName The name to identify the client
+     * @param {string} domain An identifier which logically binds clients with providers
      */
-    clearContext(clientName: string): Promise<void>;
+    clearContext(domain: string): Promise<void>;
     /**
      * Resets the global evaluation context and removes the evaluation context for
-     * all named clients.
+     * all domains.
      */
     clearContexts(): Promise<void>;
     /**
@@ -973,11 +343,11 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
      *
      * If there is already a provider bound to this name via {@link this.setProvider setProvider}, this provider will be used.
      * Otherwise, the default provider is used until a provider is assigned to that name.
-     * @param {string} name The name of the client
+     * @param {string} domain An identifier which logically binds clients with providers
      * @param {string} version The version of the client (only used for metadata)
      * @returns {Client} OpenFeature Client
      */
-    getClient(name?: string, version?: string): Client;
+    getClient(domain?: string, version?: string): Client;
     /**
      * Clears all registered providers and resets the default provider.
      * @returns {Promise<void>}
@@ -991,4 +361,4 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implem
  */
 declare const OpenFeature: OpenFeatureAPI;
 
-export { ClientProviderEvents as AllProviderEvents, AnyProviderEvent, BaseHook, BeforeHookContext, Client, ClientMetadata, ClientProviderEvents, CommonEventDetails, CommonProvider, ConfigChangeEvent, DefaultLogger, ErrorCode, ErrorEvent, EvaluationContext, EvaluationContextValue, EvaluationDetails, EvaluationLifeCycle, EventContext, EventDetails, EventHandler, EventMetadata, Eventing, Features, FlagEvaluationOptions, FlagMetadata, FlagNotFoundError, FlagValue, FlagValueType, GeneralError, GenericEventEmitter, Hook, HookContext, HookHints, InMemoryProvider, InvalidContextError, JsonArray, JsonObject, JsonValue, LOG_LEVELS, Logger, ManageContext, ManageLogger, Metadata, NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, OpenFeatureClient, OpenFeatureCommonAPI, OpenFeatureError, OpenFeatureEventEmitter, Paradigm, ParseError, PrimitiveValue, Provider, ProviderEmittableEvents, ClientProviderEvents as ProviderEvents, ProviderMetadata, ProviderNotReadyError, ProviderStatus, ReadyEvent, ResolutionDetails, ResolutionReason, SafeLogger, ServerProviderEvents, StaleEvent, StandardResolutionReasons, TargetingKeyMissingError, TypeMismatchError, isObject, isString, objectOrUndefined, statusMatchesEvent, stringOrUndefined };
+export { Client, Features, FlagEvaluationOptions, Hook, InMemoryProvider, NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, OpenFeatureClient, OpenFeatureEventEmitter, Provider, ProviderEmittableEvents };