@openfeature/react-sdk 0.0.5-experimental → 0.0.6-experimental

package/dist/types.d.ts

@@ -1,14 +1,1054 @@
-import { FlagValue, EvaluationDetails, Client } from '@openfeature/web-sdk';
-export * from '@openfeature/web-sdk';
 import * as React from 'react';
+import EventEmitter from 'events';
 
-declare function useFeatureFlag<T extends FlagValue>(flagKey: string, defaultValue: T): EvaluationDetails<T>;
+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);
+}
+
+declare class GeneralError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
 
+declare class FlagNotFoundError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+declare class ParseError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+declare class TypeMismatchError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+declare class TargetingKeyMissingError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+declare class InvalidContextError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+declare class ProviderNotReadyError extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(message?: string);
+}
+
+/**
+ * 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;
+}
+interface Features {
+    /**
+     * Performs a flag evaluation that returns a boolean.
+     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {boolean} defaultValue The value returned if an error occurs
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {boolean} Flag evaluation response
+     */
+    getBooleanValue(flagKey: string, defaultValue: boolean, options?: FlagEvaluationOptions): boolean;
+    /**
+     * Performs a flag evaluation that a returns an evaluation details object.
+     * @param {string} flagKey The flag key uniquely identifies a particular flag
+     * @param {boolean} defaultValue The value returned if an error occurs
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {EvaluationDetails<boolean>} Flag evaluation details response
+     */
+    getBooleanDetails(flagKey: string, defaultValue: boolean, options?: FlagEvaluationOptions): EvaluationDetails<boolean>;
+    /**
+     * Performs a flag evaluation that returns a string.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {T} Flag evaluation response
+     */
+    getStringValue(flagKey: string, defaultValue: string, options?: FlagEvaluationOptions): string;
+    getStringValue<T extends string = string>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    /**
+     * Performs a flag evaluation that a returns an evaluation details object.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {EvaluationDetails<T>} Flag evaluation details response
+     */
+    getStringDetails(flagKey: string, defaultValue: string, options?: FlagEvaluationOptions): EvaluationDetails<string>;
+    getStringDetails<T extends string = string>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    /**
+     * Performs a flag evaluation that returns a number.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {T} Flag evaluation response
+     */
+    getNumberValue(flagKey: string, defaultValue: number, options?: FlagEvaluationOptions): number;
+    getNumberValue<T extends number = number>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    /**
+     * Performs a flag evaluation that a returns an evaluation details object.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {Promise<EvaluationDetails<T>>} Flag evaluation details response
+     */
+    getNumberDetails(flagKey: string, defaultValue: number, options?: FlagEvaluationOptions): EvaluationDetails<number>;
+    getNumberDetails<T extends number = number>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    /**
+     * Performs a flag evaluation that returns an object.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {Promise<T>} Flag evaluation response
+     */
+    getObjectValue(flagKey: string, defaultValue: JsonValue, options?: FlagEvaluationOptions): JsonValue;
+    getObjectValue<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    /**
+     * Performs a flag evaluation that a returns an evaluation details object.
+     * @param {string} 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 {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {Promise<EvaluationDetails<T>>} Flag evaluation details response
+     */
+    getObjectDetails(flagKey: string, defaultValue: JsonValue, options?: FlagEvaluationOptions): EvaluationDetails<JsonValue>;
+    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+}
+
+interface Client extends EvaluationLifeCycle<Client>, Features, ManageLogger<Client>, Eventing {
+    readonly metadata: ClientMetadata;
+    /**
+     * Returns the status of the associated provider.
+     */
+    readonly providerStatus: ProviderStatus;
+}
+
+/**
+ * A subset of events that can be directly emitted by providers.
+ */
+type ProviderEmittableEvents = Exclude<ClientProviderEvents, ClientProviderEvents.ContextChanged>;
+
+/**
+ * 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 OpenFeatureEventEmitter extends GenericEventEmitter<ProviderEmittableEvents> {
+    protected readonly eventEmitter: EventEmitter;
+    constructor();
+}
+
+/**
+ * The InternalEventEmitter is not exported publicly and should only be used within the SDK. It extends the
+ * OpenFeatureEventEmitter to include additional properties that can be included
+ * in the event details.
+ */
+declare abstract class InternalEventEmitter extends GenericEventEmitter<ClientProviderEvents, CommonEventDetails> {
+}
+
+type Hook = BaseHook<FlagValue, void, void>;
+
+/**
+ * Interface that providers must implement to resolve flag values for their particular
+ * backend or vendor.
+ *
+ * Implementation for resolving all the required flag types must be defined.
+ */
+interface Provider extends CommonProvider {
+    /**
+     * A provider hook exposes a mechanism for provider authors to register hooks
+     * to tap into various stages of the flag evaluation lifecycle. These hooks can
+     * be used to perform side effects and mutate the context for purposes of the
+     * provider. Provider hooks are not configured or controlled by the application author.
+     */
+    readonly hooks?: Hook[];
+    /**
+     * A handler function to reconcile changes when the static context.
+     * Called by the SDK when the context is changed.
+     * @param oldContext
+     * @param newContext
+     */
+    onContextChange?(oldContext: EvaluationContext, newContext: EvaluationContext): Promise<void>;
+    /**
+     * Resolve a boolean flag and its evaluation details.
+     */
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): ResolutionDetails<boolean>;
+    /**
+     * Resolve a string flag and its evaluation details.
+     */
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): ResolutionDetails<string>;
+    /**
+     * Resolve a numeric flag and its evaluation details.
+     */
+    resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): ResolutionDetails<number>;
+    /**
+     * Resolve and parse an object flag and its evaluation details.
+     */
+    resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): ResolutionDetails<T>;
+}
+
+/**
+ * The No-op provider is set by default, and simply always returns the default value.
+ */
+declare class NoopFeatureProvider implements Provider {
+    readonly metadata: {
+        readonly name: "No-op Provider";
+    };
+    get status(): ProviderStatus;
+    resolveBooleanEvaluation(_: string, defaultValue: boolean): ResolutionDetails<boolean>;
+    resolveStringEvaluation(_: string, defaultValue: string): ResolutionDetails<string>;
+    resolveNumberEvaluation(_: string, defaultValue: number): ResolutionDetails<number>;
+    resolveObjectEvaluation<T extends JsonValue>(_: string, defaultValue: T): ResolutionDetails<T>;
+    private noOp;
+}
+declare const NOOP_PROVIDER: NoopFeatureProvider;
+
+/**
+ * Don't export types from this file publicly.
+ * It might cause confusion since these types are not a part of the general API,
+ * but just for the in-memory provider.
+ */
+
+type Variants<T> = Record<string, T>;
+/**
+ * A Feature Flag definition, containing it's specification
+ */
+type Flag = {
+    /**
+     * An object containing all possible flags mappings (variant -> flag value)
+     */
+    variants: Variants<boolean> | Variants<string> | Variants<number> | Variants<JsonValue>;
+    /**
+     * The variant it will resolve to in STATIC evaluation
+     */
+    defaultVariant: string;
+    /**
+     * Determines if flag evaluation is enabled or not for this flag.
+     * If false, falls back to the default value provided to the client
+     */
+    disabled: boolean;
+    /**
+     * Function used in order to evaluate a flag to a specific value given the provided context.
+     * It should return a variant key.
+     * 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;
+};
+type FlagConfiguration = Record<string, Flag>;
+
+/**
+ * A simple OpenFeature provider intended for demos and as a test stub.
+ */
+declare class InMemoryProvider implements Provider {
+    readonly events: OpenFeatureEventEmitter;
+    readonly runsOn = "client";
+    status: ProviderStatus;
+    readonly metadata: {
+        readonly name: "in-memory";
+    };
+    private _flagConfiguration;
+    private _context;
+    constructor(flagConfiguration?: FlagConfiguration);
+    initialize(context?: EvaluationContext | undefined): Promise<void>;
+    /**
+     * Overwrites the configured flags.
+     * @param { FlagConfiguration } flagConfiguration new flag configuration
+     */
+    putConfiguration(flagConfiguration: FlagConfiguration): Promise<void>;
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context?: EvaluationContext, logger?: Logger): ResolutionDetails<boolean>;
+    resolveNumberEvaluation(flagKey: string, defaultValue: number, context?: EvaluationContext, logger?: Logger): ResolutionDetails<number>;
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context?: EvaluationContext, logger?: Logger): ResolutionDetails<string>;
+    resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, logger?: Logger): ResolutionDetails<T>;
+    private resolveAndCheckFlag;
+    private resolveFlagWithReason;
+    private lookupFlagValue;
+}
+
+type OpenFeatureClientOptions = {
+    name?: string;
+    version?: string;
+};
+declare class OpenFeatureClient implements Client {
+    private readonly providerAccessor;
+    private readonly emitterAccessor;
+    private readonly globalLogger;
+    private readonly options;
+    private _hooks;
+    private _clientLogger?;
+    constructor(providerAccessor: () => Provider, emitterAccessor: () => InternalEventEmitter, globalLogger: () => Logger, options: OpenFeatureClientOptions);
+    get metadata(): ClientMetadata;
+    get providerStatus(): ProviderStatus;
+    addHandler(eventType: ClientProviderEvents, handler: EventHandler): void;
+    removeHandler(notificationType: ClientProviderEvents, handler: EventHandler): void;
+    getHandlers(eventType: ClientProviderEvents): EventHandler[];
+    setLogger(logger: Logger): this;
+    addHooks(...hooks: Hook[]): this;
+    getHooks(): Hook[];
+    clearHooks(): this;
+    getBooleanValue(flagKey: string, defaultValue: boolean, options?: FlagEvaluationOptions): boolean;
+    getBooleanDetails(flagKey: string, defaultValue: boolean, options?: FlagEvaluationOptions): EvaluationDetails<boolean>;
+    getStringValue<T extends string = string>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    getStringDetails<T extends string = string>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    getNumberValue<T extends number = number>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    getNumberDetails<T extends number = number>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    getObjectValue<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): T;
+    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    private evaluate;
+    private beforeHooks;
+    private afterHooks;
+    private errorHooks;
+    private finallyHooks;
+    private get _provider();
+    private get _logger();
+}
+
+declare class OpenFeatureAPI extends OpenFeatureCommonAPI<Provider, Hook> implements ManageContext<Promise<void>> {
+    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.
+     * @ignore
+     * @returns {OpenFeatureAPI} OpenFeature API
+     */
+    static getInstance(): OpenFeatureAPI;
+    /**
+     * Sets the evaluation context globally.
+     * This will be used by all providers that have not been overridden with a named client.
+     * @param {EvaluationContext} context Evaluation context
+     * @example
+     * await OpenFeature.setContext({ region: "us" });
+     */
+    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
+     * @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>;
+    /**
+     * Access the global evaluation context.
+     * @returns {EvaluationContext} Evaluation context
+     */
+    getContext(): EvaluationContext;
+    /**
+     * 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
+     * @returns {EvaluationContext} Evaluation context
+     */
+    getContext(clientName?: 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
+     */
+    clearContext(clientName: string): Promise<void>;
+    /**
+     * Resets the global evaluation context and removes the evaluation context for
+     * all named clients.
+     */
+    clearContexts(): Promise<void>;
+    /**
+     * A factory function for creating new named OpenFeature clients. Clients can contain
+     * their own state (e.g. logger, hook, context). Multiple clients can be used
+     * to segment feature flag configuration.
+     *
+     * 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} version The version of the client (only used for metadata)
+     * @returns {Client} OpenFeature Client
+     */
+    getClient(name?: string, version?: string): Client;
+    /**
+     * Clears all registered providers and resets the default provider.
+     * @returns {Promise<void>}
+     */
+    clearProviders(): Promise<void>;
+    private runProviderContextChangeHandler;
+}
+/**
+ * A singleton instance of the OpenFeature API.
+ * @returns {OpenFeatureAPI} OpenFeature API
+ */
+declare const OpenFeature: OpenFeatureAPI;
+
+type ReactFlagEvaluationOptions = {
+    /**
+     * Suspend flag evaluations while the provider is not ready.
+     * Set to false if you don't want to use React Suspense API.
+     * Defaults to true.
+     */
+    suspend?: boolean;
+    /**
+     * Update the component if the provider emits a ConfigurationChanged event.
+     * Set to false to prevent components from re-rendering when flag value changes
+     * are received by the associated provider.
+     * Defaults to true.
+     */
+    updateOnConfigurationChanged?: boolean;
+    /**
+     * Update the component when the OpenFeature context changes.
+     * Set to false to prevent components from re-rendering when attributes which
+     * may be factors in flag evaluation change.
+     * Defaults to true.
+     */
+    updateOnContextChanged?: boolean;
+} & FlagEvaluationOptions;
+/**
+ * Evaluates a feature flag, returning evaluation details.
+ * @param {string}flagKey the flag identifier
+ * @param {T} defaultValue the default value
+ * @param {ReactFlagEvaluationOptions} options options for this evaluation
+ * @template T flag type
+ * @returns { EvaluationDetails<T>} a EvaluationDetails object for this evaluation
+ */
+declare function useFeatureFlag<T extends FlagValue>(flagKey: string, defaultValue: T, options?: ReactFlagEvaluationOptions): EvaluationDetails<T>;
+
+type ClientOrClientName = {
+    /**
+     * The name of the client.
+     * @see OpenFeature.setProvider() and overloads.
+     */
+    clientName: string;
+    /**
+     * OpenFeature client to use.
+     */
+    client?: never;
+} | {
+    /**
+     * OpenFeature client to use.
+     */
+    client: Client;
+    /**
+     * The name of the client.
+     * @see OpenFeature.setProvider() and overloads.
+     */
+    clientName?: never;
+};
 type ProviderProps = {
-    client?: Client;
     children?: React.ReactNode;
-};
-declare const OpenFeatureProvider: ({ client, children }: ProviderProps) => React.JSX.Element;
+} & ClientOrClientName;
+declare const OpenFeatureProvider: ({ client, clientName, children }: ProviderProps) => React.JSX.Element;
 declare const useOpenFeatureClient: () => Client;
 
-export { OpenFeatureProvider, useFeatureFlag, useOpenFeatureClient };
+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, OpenFeatureProvider, 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, useFeatureFlag, useOpenFeatureClient };