@cloudflare/flagship 0.0.0 → 0.0.1

package/dist/server.cjs

@@ -0,0 +1,298 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src = require("./src-De-abNIr.cjs");
+let _openfeature_server_sdk = require("@openfeature/server-sdk");
+//#region src/server-provider.ts
+const _noop = () => {};
+/**
+* OpenFeature provider for Flagship (server-side / dynamic context).
+*
+* Use this provider with `@openfeature/server-sdk` for Node.js,
+* Cloudflare Workers, and other server-side JavaScript environments.
+*
+* @example
+* ```typescript
+* import { OpenFeature } from '@openfeature/server-sdk';
+* import { FlagshipServerProvider } from '@cloudflare/flagship/server';
+*
+* await OpenFeature.setProviderAndWait(
+*   new FlagshipServerProvider({
+*     appId: 'app-abc123',
+*     accountId: 'your-account-id',
+*     authToken: 'your-token',
+*   })
+* );
+*
+* const client = OpenFeature.getClient();
+* const value = await client.getBooleanValue('my-flag', false, {
+*   targetingKey: 'user-123',
+*   email: 'user@example.com',
+* });
+* ```
+*/
+var FlagshipServerProvider = class {
+	constructor(options) {
+		this.runsOn = "server";
+		this.events = new _openfeature_server_sdk.OpenFeatureEventEmitter();
+		this.currentStatus = _openfeature_server_sdk.ProviderStatus.NOT_READY;
+		this.metadata = { name: "Flagship Server Provider" };
+		this.client = new require_src.FlagshipClient(options);
+		this.logging = options.logging ?? false;
+	}
+	/**
+	* Returns the provided logger when logging is enabled, or a no-op logger
+	* when `logging` is `false`. Using this in every resolve method ensures
+	* the SDK produces no console output unless the caller opts in.
+	*/
+	logger(logger) {
+		if (this.logging) return logger;
+		return {
+			debug: _noop,
+			info: _noop,
+			warn: _noop,
+			error: _noop
+		};
+	}
+	/**
+	* Probes the evaluation endpoint with a health-check request. A 404 response
+	* is treated as success — it means the endpoint is reachable but the
+	* health-check flag simply doesn't exist, which is expected. Any network
+	* failure or timeout sets the status to ERROR.
+	*/
+	async initialize(_context) {
+		try {
+			await this.client.evaluate("_flagship_health_check", {});
+			this.currentStatus = _openfeature_server_sdk.ProviderStatus.READY;
+			this.events.emit(_openfeature_server_sdk.ProviderEvents.Ready);
+		} catch (error) {
+			if (error instanceof require_src.FlagshipError && error.cause instanceof Response && error.cause.status === 404) {
+				this.currentStatus = _openfeature_server_sdk.ProviderStatus.READY;
+				this.events.emit(_openfeature_server_sdk.ProviderEvents.Ready);
+				return;
+			}
+			this.currentStatus = _openfeature_server_sdk.ProviderStatus.ERROR;
+			this.events.emit(_openfeature_server_sdk.ProviderEvents.Error, { message: error instanceof Error ? error.message : String(error) });
+		}
+	}
+	async onClose() {
+		this.currentStatus = _openfeature_server_sdk.ProviderStatus.NOT_READY;
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	async resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
+		return this.resolve(flagKey, defaultValue, context, "boolean", logger);
+	}
+	async resolveStringEvaluation(flagKey, defaultValue, context, logger) {
+		return this.resolve(flagKey, defaultValue, context, "string", logger);
+	}
+	async resolveNumberEvaluation(flagKey, defaultValue, context, logger) {
+		return this.resolve(flagKey, defaultValue, context, "number", logger);
+	}
+	async resolveObjectEvaluation(flagKey, defaultValue, context, logger) {
+		return this.resolve(flagKey, defaultValue, context, "object", logger);
+	}
+	async resolve(flagKey, defaultValue, context, expectedType, logger) {
+		const log = this.logger(logger);
+		try {
+			log.debug(`[Flagship] Evaluating flag "${flagKey}" (expected: ${expectedType})`);
+			const result = await this.client.evaluate(flagKey, context);
+			const actualType = this.getValueType(result.value);
+			if (actualType !== expectedType) {
+				const msg = `Flag "${flagKey}" type mismatch: expected ${expectedType}, got ${actualType}`;
+				log.warn(`[Flagship] ${msg}`);
+				return {
+					value: defaultValue,
+					errorCode: _openfeature_server_sdk.ErrorCode.TYPE_MISMATCH,
+					errorMessage: msg,
+					reason: "ERROR"
+				};
+			}
+			log.debug(`[Flagship] Flag "${flagKey}" resolved: value=${String(result.value)} reason=${result.reason} variant=${result.variant}`);
+			return {
+				value: result.value,
+				variant: result.variant,
+				reason: result.reason,
+				flagMetadata: {}
+			};
+		} catch (error) {
+			return this.handleError(flagKey, defaultValue, error, log);
+		}
+	}
+	/**
+	* Maps a runtime value to one of the four OpenFeature flag types.
+	* `null` maps to `'object'` (typeof null === 'object'), treating it as a
+	* JSON null which belongs to the object/structure category.
+	*/
+	getValueType(value) {
+		if (typeof value === "boolean") return "boolean";
+		if (typeof value === "string") return "string";
+		if (typeof value === "number") return "number";
+		return "object";
+	}
+	handleError(flagKey, defaultValue, error, logger) {
+		if (error instanceof require_src.FlagshipError) {
+			let errorCode;
+			switch (error.code) {
+				case require_src.FlagshipErrorCode.NETWORK_ERROR:
+					errorCode = error.cause instanceof Response && error.cause.status === 404 ? _openfeature_server_sdk.ErrorCode.FLAG_NOT_FOUND : _openfeature_server_sdk.ErrorCode.GENERAL;
+					break;
+				case require_src.FlagshipErrorCode.TIMEOUT_ERROR:
+					errorCode = _openfeature_server_sdk.ErrorCode.GENERAL;
+					break;
+				case require_src.FlagshipErrorCode.PARSE_ERROR:
+					errorCode = _openfeature_server_sdk.ErrorCode.PARSE_ERROR;
+					break;
+				case require_src.FlagshipErrorCode.INVALID_CONTEXT:
+					errorCode = _openfeature_server_sdk.ErrorCode.INVALID_CONTEXT;
+					break;
+				default: errorCode = _openfeature_server_sdk.ErrorCode.GENERAL;
+			}
+			logger.error(`[Flagship] Flag "${flagKey}" evaluation failed (${errorCode}): ${error.message}`);
+			return {
+				value: defaultValue,
+				errorCode,
+				errorMessage: error.message,
+				reason: "ERROR"
+			};
+		}
+		const errorMessage = String(error);
+		logger.error(`[Flagship] Flag "${flagKey}" evaluation failed (GENERAL): ${errorMessage}`);
+		return {
+			value: defaultValue,
+			errorCode: _openfeature_server_sdk.ErrorCode.GENERAL,
+			errorMessage,
+			reason: "ERROR"
+		};
+	}
+};
+//#endregion
+//#region src/hooks/logging-hook.ts
+/**
+* Logging hook for debugging flag evaluations
+*
+* @example
+* ```typescript
+* import { OpenFeature } from '@openfeature/server-sdk';
+* import { FlagshipServerProvider, LoggingHook } from '@cloudflare/flagship/server';
+*
+* const provider = new FlagshipServerProvider({ appId: 'your-app-id', accountId: 'your-account-id' });
+* await OpenFeature.setProviderAndWait(provider);
+*
+* // Add logging hook
+* OpenFeature.addHooks(new LoggingHook());
+* ```
+*/
+var LoggingHook = class {
+	constructor(logger = console.log) {
+		this.logger = logger;
+	}
+	before(hookContext, _hookHints) {
+		this.logger(`[Flagship] Evaluating flag: ${hookContext.flagKey}`, {
+			defaultValue: hookContext.defaultValue,
+			context: hookContext.context
+		});
+	}
+	after(hookContext, evaluationDetails, _hookHints) {
+		this.logger(`[Flagship] Flag ${hookContext.flagKey} evaluated`, {
+			value: evaluationDetails.value,
+			reason: evaluationDetails.reason,
+			variant: evaluationDetails.variant,
+			errorCode: evaluationDetails.errorCode
+		});
+	}
+	error(hookContext, error, _hookHints) {
+		const message = error instanceof Error ? error.message : String(error);
+		this.logger(`[Flagship] Error evaluating flag ${hookContext.flagKey}:`, message);
+	}
+	finally(_hookContext, _evaluationDetails, _hookHints) {}
+};
+//#endregion
+//#region src/hooks/telemetry-hook.ts
+/**
+* Telemetry hook for tracking flag evaluations
+*
+* @example
+* ```typescript
+* import { OpenFeature } from '@openfeature/server-sdk';
+* import { FlagshipServerProvider, TelemetryHook } from '@cloudflare/flagship/server';
+*
+* const telemetryHook = new TelemetryHook((event) => {
+*   // Send to your analytics service
+*   analytics.track('flag_evaluated', event);
+* });
+*
+* OpenFeature.addHooks(telemetryHook);
+* ```
+*/
+var TelemetryHook = class {
+	constructor(onEvent) {
+		this.startTimes = /* @__PURE__ */ new Map();
+		this.contextKeys = /* @__PURE__ */ new WeakMap();
+		this.hints = /* @__PURE__ */ new WeakMap();
+		this.onEvent = onEvent;
+	}
+	before(hookContext, hookHints) {
+		const now = Date.now();
+		const key = `${hookContext.flagKey}-${now}-${Math.random()}`;
+		this.startTimes.set(key, now);
+		this.contextKeys.set(hookContext, key);
+		if (hookHints !== void 0) this.hints.set(hookContext, hookHints);
+	}
+	after(hookContext, evaluationDetails, _hookHints) {
+		const telemetryKey = this.contextKeys.get(hookContext);
+		const startTime = telemetryKey ? this.startTimes.get(telemetryKey) : void 0;
+		const duration = startTime !== void 0 ? Date.now() - startTime : void 0;
+		if (telemetryKey !== void 0) {
+			this.startTimes.delete(telemetryKey);
+			this.contextKeys.delete(hookContext);
+		}
+		this.onEvent({
+			type: "evaluation",
+			flagKey: hookContext.flagKey,
+			timestamp: Date.now(),
+			duration,
+			value: evaluationDetails.value,
+			reason: evaluationDetails.reason,
+			variant: evaluationDetails.variant,
+			errorCode: evaluationDetails.errorCode,
+			context: hookContext.context,
+			hints: this.hints.get(hookContext)
+		});
+	}
+	error(hookContext, error, _hookHints) {
+		const telemetryKey = this.contextKeys.get(hookContext);
+		const startTime = telemetryKey ? this.startTimes.get(telemetryKey) : void 0;
+		const duration = startTime !== void 0 ? Date.now() - startTime : void 0;
+		if (telemetryKey !== void 0) {
+			this.startTimes.delete(telemetryKey);
+			this.contextKeys.delete(hookContext);
+		}
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		this.onEvent({
+			type: "error",
+			flagKey: hookContext.flagKey,
+			timestamp: Date.now(),
+			duration,
+			errorMessage,
+			context: hookContext.context,
+			hints: this.hints.get(hookContext)
+		});
+	}
+	finally(hookContext, _evaluationDetails, _hookHints) {
+		const telemetryKey = this.contextKeys.get(hookContext);
+		if (telemetryKey !== void 0) {
+			this.startTimes.delete(telemetryKey);
+			this.contextKeys.delete(hookContext);
+		}
+		this.hints.delete(hookContext);
+	}
+};
+//#endregion
+exports.ContextTransformer = require_src.ContextTransformer;
+exports.FLAGSHIP_DEFAULT_BASE_URL = require_src.FLAGSHIP_DEFAULT_BASE_URL;
+exports.FlagshipClient = require_src.FlagshipClient;
+exports.FlagshipError = require_src.FlagshipError;
+exports.FlagshipErrorCode = require_src.FlagshipErrorCode;
+exports.FlagshipServerProvider = FlagshipServerProvider;
+exports.LoggingHook = LoggingHook;
+exports.TelemetryHook = TelemetryHook;

package/dist/server.d.cts

@@ -0,0 +1,144 @@
+import { c as FlagshipEvaluationResponse, i as FLAGSHIP_DEFAULT_BASE_URL, l as FlagshipProviderOptions, n as ContextTransformer, o as FlagshipError, s as FlagshipErrorCode, t as FlagshipClient } from "./index-D8YLMfBG.cjs";
+import { BeforeHookContext, ErrorCode, EvaluationContext, EvaluationDetails, FlagValue, Hook, HookContext, HookHints, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/server-sdk";
+
+//#region src/server-provider.d.ts
+/**
+ * OpenFeature provider for Flagship (server-side / dynamic context).
+ *
+ * Use this provider with `@openfeature/server-sdk` for Node.js,
+ * Cloudflare Workers, and other server-side JavaScript environments.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider } from '@cloudflare/flagship/server';
+ *
+ * await OpenFeature.setProviderAndWait(
+ *   new FlagshipServerProvider({
+ *     appId: 'app-abc123',
+ *     accountId: 'your-account-id',
+ *     authToken: 'your-token',
+ *   })
+ * );
+ *
+ * const client = OpenFeature.getClient();
+ * const value = await client.getBooleanValue('my-flag', false, {
+ *   targetingKey: 'user-123',
+ *   email: 'user@example.com',
+ * });
+ * ```
+ */
+declare class FlagshipServerProvider implements Provider {
+  readonly metadata: ProviderMetadata;
+  readonly runsOn: "server";
+  readonly events: OpenFeatureEventEmitter;
+  private readonly client;
+  private readonly logging;
+  private currentStatus;
+  constructor(options: FlagshipProviderOptions);
+  /**
+   * Returns the provided logger when logging is enabled, or a no-op logger
+   * when `logging` is `false`. Using this in every resolve method ensures
+   * the SDK produces no console output unless the caller opts in.
+   */
+  private logger;
+  /**
+   * Probes the evaluation endpoint with a health-check request. A 404 response
+   * is treated as success — it means the endpoint is reachable but the
+   * health-check flag simply doesn't exist, which is expected. Any network
+   * failure or timeout sets the status to ERROR.
+   */
+  initialize(_context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  get status(): ProviderStatus;
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<boolean>>;
+  resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<string>>;
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<number>>;
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<T>>;
+  private resolve;
+  /**
+   * Maps a runtime value to one of the four OpenFeature flag types.
+   * `null` maps to `'object'` (typeof null === 'object'), treating it as a
+   * JSON null which belongs to the object/structure category.
+   */
+  private getValueType;
+  private handleError;
+}
+//#endregion
+//#region src/hooks/logging-hook.d.ts
+/**
+ * Logging hook for debugging flag evaluations
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider, LoggingHook } from '@cloudflare/flagship/server';
+ *
+ * const provider = new FlagshipServerProvider({ appId: 'your-app-id', accountId: 'your-account-id' });
+ * await OpenFeature.setProviderAndWait(provider);
+ *
+ * // Add logging hook
+ * OpenFeature.addHooks(new LoggingHook());
+ * ```
+ */
+declare class LoggingHook implements Hook {
+  private readonly logger;
+  constructor(logger?: (message: string, ...args: unknown[]) => void);
+  before(hookContext: BeforeHookContext, _hookHints?: HookHints): void;
+  after(hookContext: Readonly<HookContext>, evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+  error(hookContext: Readonly<HookContext>, error: unknown, _hookHints?: HookHints): void;
+  finally(_hookContext: Readonly<HookContext>, _evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+}
+//#endregion
+//#region src/hooks/telemetry-hook.d.ts
+/**
+ * Telemetry event data
+ */
+interface TelemetryEvent {
+  type: 'evaluation' | 'error';
+  flagKey: string;
+  timestamp: number;
+  duration?: number;
+  value?: unknown;
+  reason?: string;
+  variant?: string;
+  /** The OpenFeature ErrorCode, if evaluation produced an error. */
+  errorCode?: ErrorCode;
+  errorMessage?: string;
+  context?: Record<string, unknown>;
+  /**
+   * Caller-supplied hints forwarded from `EvaluationOptions.hookHints`.
+   * Use this to attach trace IDs, request IDs, or any other metadata
+   * that the application author wants to associate with the evaluation.
+   */
+  hints?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Telemetry hook for tracking flag evaluations
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider, TelemetryHook } from '@cloudflare/flagship/server';
+ *
+ * const telemetryHook = new TelemetryHook((event) => {
+ *   // Send to your analytics service
+ *   analytics.track('flag_evaluated', event);
+ * });
+ *
+ * OpenFeature.addHooks(telemetryHook);
+ * ```
+ */
+declare class TelemetryHook implements Hook {
+  private startTimes;
+  private contextKeys;
+  private hints;
+  private readonly onEvent;
+  constructor(onEvent: (event: TelemetryEvent) => void);
+  before(hookContext: BeforeHookContext, hookHints?: HookHints): void;
+  after(hookContext: Readonly<HookContext>, evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+  error(hookContext: Readonly<HookContext>, error: unknown, _hookHints?: HookHints): void;
+  finally(hookContext: Readonly<HookContext>, _evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+}
+//#endregion
+export { ContextTransformer, FLAGSHIP_DEFAULT_BASE_URL, FlagshipClient, FlagshipError, FlagshipErrorCode, type FlagshipEvaluationResponse, type FlagshipProviderOptions, FlagshipServerProvider, LoggingHook, type TelemetryEvent, TelemetryHook };

package/dist/server.d.mts

@@ -0,0 +1,144 @@
+import { c as FlagshipEvaluationResponse, i as FLAGSHIP_DEFAULT_BASE_URL, l as FlagshipProviderOptions, n as ContextTransformer, o as FlagshipError, s as FlagshipErrorCode, t as FlagshipClient } from "./index-C_sW3e_7.mjs";
+import { BeforeHookContext, ErrorCode, EvaluationContext, EvaluationDetails, FlagValue, Hook, HookContext, HookHints, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/server-sdk";
+
+//#region src/server-provider.d.ts
+/**
+ * OpenFeature provider for Flagship (server-side / dynamic context).
+ *
+ * Use this provider with `@openfeature/server-sdk` for Node.js,
+ * Cloudflare Workers, and other server-side JavaScript environments.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider } from '@cloudflare/flagship/server';
+ *
+ * await OpenFeature.setProviderAndWait(
+ *   new FlagshipServerProvider({
+ *     appId: 'app-abc123',
+ *     accountId: 'your-account-id',
+ *     authToken: 'your-token',
+ *   })
+ * );
+ *
+ * const client = OpenFeature.getClient();
+ * const value = await client.getBooleanValue('my-flag', false, {
+ *   targetingKey: 'user-123',
+ *   email: 'user@example.com',
+ * });
+ * ```
+ */
+declare class FlagshipServerProvider implements Provider {
+  readonly metadata: ProviderMetadata;
+  readonly runsOn: "server";
+  readonly events: OpenFeatureEventEmitter;
+  private readonly client;
+  private readonly logging;
+  private currentStatus;
+  constructor(options: FlagshipProviderOptions);
+  /**
+   * Returns the provided logger when logging is enabled, or a no-op logger
+   * when `logging` is `false`. Using this in every resolve method ensures
+   * the SDK produces no console output unless the caller opts in.
+   */
+  private logger;
+  /**
+   * Probes the evaluation endpoint with a health-check request. A 404 response
+   * is treated as success — it means the endpoint is reachable but the
+   * health-check flag simply doesn't exist, which is expected. Any network
+   * failure or timeout sets the status to ERROR.
+   */
+  initialize(_context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  get status(): ProviderStatus;
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<boolean>>;
+  resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<string>>;
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<number>>;
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<T>>;
+  private resolve;
+  /**
+   * Maps a runtime value to one of the four OpenFeature flag types.
+   * `null` maps to `'object'` (typeof null === 'object'), treating it as a
+   * JSON null which belongs to the object/structure category.
+   */
+  private getValueType;
+  private handleError;
+}
+//#endregion
+//#region src/hooks/logging-hook.d.ts
+/**
+ * Logging hook for debugging flag evaluations
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider, LoggingHook } from '@cloudflare/flagship/server';
+ *
+ * const provider = new FlagshipServerProvider({ appId: 'your-app-id', accountId: 'your-account-id' });
+ * await OpenFeature.setProviderAndWait(provider);
+ *
+ * // Add logging hook
+ * OpenFeature.addHooks(new LoggingHook());
+ * ```
+ */
+declare class LoggingHook implements Hook {
+  private readonly logger;
+  constructor(logger?: (message: string, ...args: unknown[]) => void);
+  before(hookContext: BeforeHookContext, _hookHints?: HookHints): void;
+  after(hookContext: Readonly<HookContext>, evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+  error(hookContext: Readonly<HookContext>, error: unknown, _hookHints?: HookHints): void;
+  finally(_hookContext: Readonly<HookContext>, _evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+}
+//#endregion
+//#region src/hooks/telemetry-hook.d.ts
+/**
+ * Telemetry event data
+ */
+interface TelemetryEvent {
+  type: 'evaluation' | 'error';
+  flagKey: string;
+  timestamp: number;
+  duration?: number;
+  value?: unknown;
+  reason?: string;
+  variant?: string;
+  /** The OpenFeature ErrorCode, if evaluation produced an error. */
+  errorCode?: ErrorCode;
+  errorMessage?: string;
+  context?: Record<string, unknown>;
+  /**
+   * Caller-supplied hints forwarded from `EvaluationOptions.hookHints`.
+   * Use this to attach trace IDs, request IDs, or any other metadata
+   * that the application author wants to associate with the evaluation.
+   */
+  hints?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Telemetry hook for tracking flag evaluations
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/server-sdk';
+ * import { FlagshipServerProvider, TelemetryHook } from '@cloudflare/flagship/server';
+ *
+ * const telemetryHook = new TelemetryHook((event) => {
+ *   // Send to your analytics service
+ *   analytics.track('flag_evaluated', event);
+ * });
+ *
+ * OpenFeature.addHooks(telemetryHook);
+ * ```
+ */
+declare class TelemetryHook implements Hook {
+  private startTimes;
+  private contextKeys;
+  private hints;
+  private readonly onEvent;
+  constructor(onEvent: (event: TelemetryEvent) => void);
+  before(hookContext: BeforeHookContext, hookHints?: HookHints): void;
+  after(hookContext: Readonly<HookContext>, evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+  error(hookContext: Readonly<HookContext>, error: unknown, _hookHints?: HookHints): void;
+  finally(hookContext: Readonly<HookContext>, _evaluationDetails: EvaluationDetails<FlagValue>, _hookHints?: HookHints): void;
+}
+//#endregion
+export { ContextTransformer, FLAGSHIP_DEFAULT_BASE_URL, FlagshipClient, FlagshipError, FlagshipErrorCode, type FlagshipEvaluationResponse, type FlagshipProviderOptions, FlagshipServerProvider, LoggingHook, type TelemetryEvent, TelemetryHook };