@openfeature/web-sdk 0.0.2-experimental

package/dist/types.d.ts

@@ -0,0 +1,627 @@
+type PrimitiveValue = null | boolean | string | number;
+declare enum ProviderEvents {
+    /**
+     * 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 is transitioning to a state of unavailability.
+     */
+    Shutdown = "PROVIDER_SHUTDOWN"
+}
+interface EventData {
+    flagKeysChanged?: string[];
+    changeMetadata?: {
+        [key: string]: boolean | string;
+    };
+}
+declare enum ApiEvents {
+    ProviderChanged = "providerChanged"
+}
+interface Eventing {
+    addHandler(notificationType: string, handler: Handler): void;
+}
+type EventContext = {
+    notificationType: string;
+    [key: string]: unknown;
+};
+type Handler = (eventContext?: EventContext) => void;
+type EventCallbackMessage = (eventContext: EventContext) => void;
+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 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>;
+type FlagValue = boolean | string | number | JsonValue;
+type FlagValueType = 'boolean' | 'string' | 'number' | 'object';
+interface Logger {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}
+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 ResolutionReason = keyof typeof StandardResolutionReasons | (string & Record<never, never>);
+type ResolutionDetails<U> = {
+    value: U;
+    variant?: string;
+    reason?: ResolutionReason;
+    errorCode?: ErrorCode;
+    errorMessage?: string;
+};
+type EvaluationDetails<T extends FlagValue> = {
+    flagKey: string;
+} & ResolutionDetails<T>;
+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;
+}
+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;
+}
+type HookHints = Readonly<Record<string, unknown>>;
+interface Metadata {
+}
+interface ClientMetadata extends Metadata {
+    readonly version?: string;
+    readonly name?: string;
+}
+interface ProviderMetadata extends Metadata {
+    readonly name: string;
+}
+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;
+}
+/**
+ * Transaction context is a mechanism for adding transaction specific context that
+ * is merged with evaluation context prior to flag evaluation. Examples of potential
+ * transaction specific context include: a user id, user agent, or request path.
+ */
+type TransactionContext = EvaluationContext;
+interface ManageTransactionContextPropagator<T> extends TransactionContextPropagator {
+    /**
+     * EXPERIMENTAL: Transaction context propagation is experimental and subject to change.
+     * The OpenFeature Enhancement Proposal regarding transaction context can be found [here](https://github.com/open-feature/ofep/pull/32).
+     *
+     * Sets a transaction context propagator on this receiver. The transaction context
+     * propagator is responsible for persisting context for the duration of a single
+     * transaction.
+     *
+     * @experimental
+     * @template T The type of the receiver
+     * @param {TransactionContextPropagator} transactionContextPropagator The context propagator to be used
+     * @returns {T} The receiver (this object)
+     */
+    setTransactionContextPropagator(transactionContextPropagator: TransactionContextPropagator): T;
+}
+interface TransactionContextPropagator {
+    /**
+     * EXPERIMENTAL: Transaction context propagation is experimental and subject to change.
+     * The OpenFeature Enhancement Proposal regarding transaction context can be found [here](https://github.com/open-feature/ofep/pull/32).
+     *
+     * Returns the currently defined transaction context using the registered transaction
+     * context propagator.
+     *
+     * @experimental
+     * @returns {TransactionContext} The current transaction context
+     */
+    getTransactionContext(): TransactionContext;
+    /**
+     * EXPERIMENTAL: Transaction context propagation is experimental and subject to change.
+     * The OpenFeature Enhancement Proposal regarding transaction context can be found [here](https://github.com/open-feature/ofep/pull/32).
+     *
+     * Sets the transaction context using the registered transaction context propagator.
+     *
+     * @experimental
+     * @template R The return value of the callback
+     * @param {TransactionContext} transactionContext The transaction specific context
+     * @param {(...args: unknown[]) => R} callback Callback function used to set the transaction context on the stack
+     * @param {...unknown[]} args Optional arguments that are passed to the callback function
+     */
+    setTransactionContext<R>(transactionContext: TransactionContext, callback: (...args: unknown[]) => R, ...args: unknown[]): void;
+}
+interface CommonProvider {
+    readonly metadata: ProviderMetadata;
+}
+
+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 DefaultLogger implements Logger {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(): void;
+    debug(): void;
+}
+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;
+}
+
+declare class NoopTransactionContextPropagator implements TransactionContextPropagator {
+    getTransactionContext(): EvaluationContext;
+    setTransactionContext(_: EvaluationContext, callback: () => void): void;
+}
+declare const NOOP_TRANSACTION_CONTEXT_PROPAGATOR: NoopTransactionContextPropagator;
+
+declare abstract class OpenFeatureCommonAPI {
+    protected _transactionContextPropagator: TransactionContextPropagator;
+    protected _context: EvaluationContext;
+    protected _logger: Logger;
+    abstract clearHooks(): this;
+    abstract setLogger(logger: Logger): this;
+    getContext(): EvaluationContext;
+    setTransactionContextPropagator(transactionContextPropagator: TransactionContextPropagator): OpenFeatureCommonAPI;
+    setTransactionContext<R>(transactionContext: TransactionContext, callback: (...args: unknown[]) => R, ...args: unknown[]): void;
+    getTransactionContext(): TransactionContext;
+}
+
+/**
+ * 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[];
+    onContextChange?(oldContext: EvaluationContext, newContext: EvaluationContext): Promise<void>;
+    onClose?(): 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>;
+}
+interface Hook<T extends FlagValue = FlagValue> {
+    /**
+     * 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): EvaluationContext | void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+}
+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 {Hook<FlagValue>[]} hooks A list of hooks that should always run
+     * @returns {T} The receiver (this object)
+     */
+    addHooks(...hooks: Hook[]): T;
+    /**
+     * Access all the hooks that are registered on this receiver.
+     *
+     * @returns {Hook<FlagValue>[]} A list of the client hooks
+     */
+    getHooks(): Hook[];
+    /**
+     * 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;
+}
+interface FlagEvaluationOptions {
+    hooks?: Hook[];
+    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 {EvaluationContext} context The evaluation context used on an individual flag evaluation
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {boolean} Flag evaluation response
+     */
+    getBooleanValue(flagKey: string, defaultValue: boolean, context?: EvaluationContext, 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 {EvaluationContext} context The evaluation context used on an individual flag evaluation
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {EvaluationDetails<boolean>} Flag evaluation details response
+     */
+    getBooleanDetails(flagKey: string, defaultValue: boolean, context?: EvaluationContext, 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 {EvaluationContext} context The evaluation context used on an individual flag evaluation
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {T} Flag evaluation response
+     */
+    getStringValue(flagKey: string, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): string;
+    getStringValue<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, 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 {EvaluationContext} context The evaluation context used on an individual flag evaluation
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {EvaluationDetails<T>} Flag evaluation details response
+     */
+    getStringDetails(flagKey: string, defaultValue: string, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<string>;
+    getStringDetails<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, 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 {EvaluationContext} context The evaluation context used on an individual flag evaluation
+     * @param {FlagEvaluationOptions} options Additional flag evaluation options
+     * @returns {T} Flag evaluation response
+     */
+    getNumberValue(flagKey: string, defaultValue: number, context?: EvaluationContext, options?: FlagEvaluationOptions): number;
+    getNumberValue<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, 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 {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): EvaluationDetails<number>;
+    getNumberDetails<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, 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 {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): JsonValue;
+    getObjectValue<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, 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 {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): EvaluationDetails<JsonValue>;
+    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+}
+interface Client extends EvaluationLifeCycle<Client>, Features, ManageLogger<Client>, Eventing {
+    readonly metadata: ClientMetadata;
+}
+interface GlobalApi extends EvaluationLifeCycle<GlobalApi>, ManageContext<GlobalApi>, ManageLogger<GlobalApi>, ManageTransactionContextPropagator<GlobalApi> {
+    readonly providerMetadata: ProviderMetadata;
+    /**
+     * A factory function for creating new OpenFeature clients. Clients can contain
+     * their own state (e.g. logger, hook, context). Multiple clients can be used
+     * to segment feature flag configuration.
+     *
+     * @param {string} name The name of the client
+     * @param {string} version The version of the client
+     * @param {EvaluationContext} context Evaluation context that should be set on the client to used during flag evaluations
+     * @returns {Client} OpenFeature Client
+     */
+    getClient(name?: string, version?: string, context?: EvaluationContext): Client;
+    /**
+     * Sets the provider that OpenFeature will use for flag evaluations. Setting
+     * a provider supersedes the current provider used in new and existing clients.
+     *
+     * @param {Provider} provider The provider responsible for flag evaluations.
+     * @returns {GlobalApi} OpenFeature API
+     */
+    setProvider(provider: Provider): GlobalApi;
+}
+interface EventProvider {
+    readonly ready: boolean;
+}
+
+type OpenFeatureClientOptions = {
+    name?: string;
+    version?: string;
+};
+declare class OpenFeatureClient implements Client {
+    private readonly providerAccessor;
+    private readonly globalLogger;
+    readonly metadata: ClientMetadata;
+    private _context;
+    private _hooks;
+    private _clientLogger?;
+    private _handlerWrappers;
+    constructor(providerAccessor: () => Provider & Partial<EventProvider>, globalLogger: () => Logger, options: OpenFeatureClientOptions, context?: EvaluationContext);
+    addHandler(eventType: ProviderEvents, handler: Handler): void;
+    setLogger(logger: Logger): OpenFeatureClient;
+    addHooks(...hooks: Hook<FlagValue>[]): OpenFeatureClient;
+    getHooks(): Hook<FlagValue>[];
+    clearHooks(): OpenFeatureClient;
+    getBooleanValue(flagKey: string, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): boolean;
+    getBooleanDetails(flagKey: string, defaultValue: boolean, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<boolean>;
+    getStringValue<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): T;
+    getStringDetails<T extends string = string>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    getNumberValue<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): T;
+    getNumberDetails<T extends number = number>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    getObjectValue<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): T;
+    getObjectDetails<T extends JsonValue = JsonValue>(flagKey: string, defaultValue: T, context?: EvaluationContext, options?: FlagEvaluationOptions): EvaluationDetails<T>;
+    private evaluate;
+    private beforeHooks;
+    private afterHooks;
+    private errorHooks;
+    private finallyHooks;
+    private get _provider();
+    private get _logger();
+    private attachListeners;
+}
+
+/**
+ * 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";
+    };
+    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;
+
+declare class OpenFeatureAPI extends OpenFeatureCommonAPI {
+    protected _hooks: Hook[];
+    protected _provider: Provider;
+    private constructor();
+    /**
+     * Gets a singleton instance of the OpenFeature API.
+     *
+     * @ignore
+     * @returns {OpenFeatureAPI} OpenFeature API
+     */
+    static getInstance(): OpenFeatureAPI;
+    /**
+     * Get metadata about registered provider.
+     *
+     * @returns {ProviderMetadata} Provider Metadata
+     */
+    get providerMetadata(): ProviderMetadata;
+    setLogger(logger: Logger): this;
+    addHooks(...hooks: Hook<FlagValue>[]): this;
+    getHooks(): Hook<FlagValue>[];
+    clearHooks(): this;
+    setContext(context: EvaluationContext): Promise<void>;
+    setProvider(provider: Provider): OpenFeatureCommonAPI;
+    close(): Promise<void>;
+    getClient(name?: string, version?: string, context?: EvaluationContext): Client;
+}
+/**
+ * A singleton instance of the OpenFeature API.
+ *
+ * @returns {OpenFeatureAPI} OpenFeature API
+ */
+declare const OpenFeature: OpenFeatureAPI;
+
+export { ApiEvents, BeforeHookContext, Client, ClientMetadata, CommonProvider, DefaultLogger, ErrorCode, EvaluationContext, EvaluationContextValue, EvaluationDetails, EventCallbackMessage, EventContext, EventData, EventProvider, Eventing, Features, FlagEvaluationOptions, FlagNotFoundError, FlagValue, FlagValueType, GeneralError, GlobalApi, Handler, Hook, HookContext, HookHints, InvalidContextError, JsonArray, JsonObject, JsonValue, Logger, ManageContext, ManageLogger, ManageTransactionContextPropagator, NOOP_PROVIDER, NOOP_TRANSACTION_CONTEXT_PROPAGATOR, OpenFeature, OpenFeatureAPI, OpenFeatureClient, OpenFeatureCommonAPI, OpenFeatureError, ParseError, PrimitiveValue, Provider, ProviderEvents, ProviderMetadata, ResolutionDetails, ResolutionReason, SafeLogger, StandardResolutionReasons, TargetingKeyMissingError, TransactionContext, TransactionContextPropagator, TypeMismatchError };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@openfeature/web-sdk",
+  "version": "0.0.2-experimental",
+  "description": "OpenFeature SDK for Web",
+  "main": "./dist/cjs/index.js",
+  "files": [
+    "dist/"
+  ],
+  "exports": {
+    "types": "./dist/types.d.ts",
+    "import": "./dist/esm/index.js",
+    "require": "./dist/cjs/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "types": "./dist/types.d.ts",
+  "scripts": {
+    "test": "jest --verbose",
+    "lint": "eslint ./",
+    "clean": "shx rm -rf ./dist",
+    "build:web-esm": "esbuild src/index.ts --bundle --sourcemap --target=es2016 --platform=browser --format=esm --outfile=./dist/esm/index.js --analyze",
+    "build:web-cjs": "esbuild src/index.ts --bundle --sourcemap --target=es2016 --platform=browser --format=cjs --outfile=./dist/cjs/index.js --analyze",
+    "build:rollup-types": "rollup -c ../../rollup.config.mjs",
+    "build": "npm run clean && npm run build:web-esm && npm run build:web-cjs && npm run build:rollup-types",
+    "postbuild": "shx cp ./../../package.esm.json ./dist/esm/package.json",
+    "current-version": "echo $npm_package_version",
+    "prepack": "shx cp ./../../LICENSE ./LICENSE",
+    "publish-if-not-exists": "cp $NPM_CONFIG_USERCONFIG .npmrc && if [ \"$(npm show $npm_package_name@$npm_package_version version)\" = \"$(npm run current-version -s)\" ]; then echo 'already published, skipping'; else npm publish --access public --tag experimental; fi",
+    "docs": "typedoc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-feature/js-sdk.git"
+  },
+  "keywords": [
+    "openfeature",
+    "feature",
+    "flags",
+    "toggles",
+    "browser",
+    "web"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/open-feature/js-sdk/issues"
+  },
+  "homepage": "https://github.com/open-feature/js-sdk#readme",
+  "devDependencies": {
+    "@openfeature/shared": "0.0.2"
+  }
+}