@ops-ai/react-router-toggly 1.0.0

package/dist/server.d.cts

@@ -0,0 +1,645 @@
+import { LocalGate } from '@ops-ai/toggly-local-gates';
+import { EvaluatedDefinitions, TogglyEntityContext } from '@ops-ai/toggly-hooks-types';
+export { fromHttpRequest } from '@ops-ai/toggly-eval';
+
+interface MetricsFeatureOptions {
+    /** Optional feature key for experiment-style subcounts. */
+    feature?: string;
+    /** Variant name (default: enabled). */
+    variant?: string;
+}
+
+interface UsageSender {
+    sendStats(request: Record<string, unknown>): Promise<unknown>;
+    close?(): void;
+}
+interface MetricsSender {
+    sendMetrics(request: Record<string, unknown>): Promise<unknown>;
+    close?(): void;
+}
+type TelemetryTransport = 'grpc' | 'https';
+interface TelemetryConfig {
+    appKey: string;
+    environment: string;
+    metricsBaseUrl?: string;
+    enableUsageTracking?: boolean;
+    enableMetrics?: boolean;
+    usageFlushInterval?: number;
+    metricsFlushInterval?: number;
+    instanceName?: string;
+    appVersion?: string;
+    debug?: boolean;
+    /**
+     * Transport used when clients are not injected.
+     * - `grpc`: expect injected usage/metrics clients (server creates them)
+     * - `https`: build soft-fail fetch clients to api/usage/stats + api/metrics
+     */
+    transport?: TelemetryTransport;
+    /**
+     * When true (default for Node/server), attach beforeExit/SIGTERM/SIGINT flush.
+     * Edge runtimes must set false — signal handlers are not available / unsafe.
+     */
+    attachProcessHandlers?: boolean;
+    /** When true, restore batches if HTTPS/send returns soft-fail (default for https). */
+    restoreOnSendFailure?: boolean;
+    fetchImpl?: typeof fetch;
+    /** Injected clients for tests or gRPC transport. */
+    usageClient?: UsageSender | null;
+    metricsClient?: MetricsSender | null;
+}
+
+/**
+ * Feature requirement - whether all or any features must be enabled
+ */
+type FeatureRequirement = 'all' | 'any';
+/**
+ * Where feature evaluation happens for definitions fetches.
+ * - `remote` (default): fetch `evaluated-signed` with context query params
+ * - `local`: fetch `definitions-signed` (rules only) and evaluate with `@ops-ai/toggly-eval`
+ */
+type EvaluationMode = 'local' | 'remote';
+/**
+ * Configuration options for Toggly
+ */
+interface TogglyConfig {
+    /** Toggly application key */
+    appKey?: string;
+    /** Environment name (e.g., 'Production', 'Staging') */
+    environment?: string;
+    /** Base URL for Toggly API */
+    baseUrl?: string;
+    /**
+     * Evaluation rail. Defaults to `remote` for backward compatibility.
+     * Use `local` for definitions-signed + call-site evaluation (server multi-tenant).
+     */
+    evaluationMode?: EvaluationMode;
+    /** Default feature values for offline/fallback mode */
+    featureDefaults?: Record<string, boolean>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /**
+     * When true, verify ES256 signed definition envelopes via JWKS before applying flags.
+     */
+    verifySignatures?: boolean;
+    /**
+     * Optional allow-list of JWKS `kid` values when verifySignatures is enabled.
+     */
+    allowedKeyIds?: string[];
+    /**
+     * Reject envelopes whose `timestamp` is older than this many seconds.
+     * Unset or <= 0 disables freshness checks.
+     */
+    maxSignatureAgeSeconds?: number;
+    /** Device-local gates applied as a read-time AND on worker-evaluated booleans */
+    localGates?: LocalGate[];
+    /** Optional SDK error callback for reporting fetch/evaluation failures. */
+    onError?: (message: string, error?: unknown) => void;
+    /** Initial browser identity; hydrated server identity takes precedence. */
+    identity?: string;
+    /** User groups for targeting */
+    groups?: string[];
+    /** Custom claims for targeting */
+    claims?: Record<string, string>;
+    /**
+     * Base URL for usage/metrics transport (default: https://app.toggly.io/).
+     * Separate from `baseUrl`, which is for definitions/JWKS.
+     */
+    metricsBaseUrl?: string;
+    /**
+     * Enable feature usage tracking (Usage.SendStats / api/usage/stats).
+     * Defaults to false in core; react-router-toggly server enables when appKey is set.
+     */
+    enableUsageTracking?: boolean;
+    /**
+     * Enable business metrics (Metrics.SendMetrics / api/metrics).
+     * Defaults to false in core; react-router-toggly server enables when appKey is set.
+     */
+    enableMetrics?: boolean;
+    /** Usage flush interval in ms (default: 60000). 0 disables the timer. */
+    usageFlushInterval?: number;
+    /** Metrics flush interval in ms (default: 60000). 0 disables the timer. */
+    metricsFlushInterval?: number;
+    /** Hostname/instance name reported with usage/metrics payloads. */
+    instanceName?: string;
+    /** Application version reported with usage payloads. */
+    appVersion?: string;
+    /**
+     * Telemetry transport when clients are not injected.
+     * Server should use `grpc` with injected clients; edge adapters use `https`.
+     */
+    telemetryTransport?: 'grpc' | 'https';
+    /**
+     * Attach Node process signal handlers for best-effort flush (default: true for grpc).
+     * Edge adapters must set false.
+     */
+    telemetryAttachProcessHandlers?: boolean;
+    /**
+     * Injected usage sender (gRPC stub or test double).
+     * @internal
+     */
+    usageClient?: UsageSender | null;
+    /**
+     * Injected metrics sender (gRPC stub or test double).
+     * @internal
+     */
+    metricsClient?: MetricsSender | null;
+    /** Optional fetch override for HTTPS telemetry (edge/tests). */
+    telemetryFetch?: typeof fetch;
+}
+/**
+ * User identity context for feature targeting
+ */
+interface IdentityContext {
+    /** Unique user identifier */
+    identity?: string;
+    /** User groups for targeting */
+    groups?: string[];
+    /** Custom traits for targeting */
+    traits?: Record<string, string | number | boolean>;
+    /** Custom claims for targeting */
+    claims?: Record<string, string>;
+    /** HTTP request segment fields (UA / Accept-Language / country) */
+    request?: {
+        userAgent?: string;
+        acceptLanguage?: string;
+        country?: string;
+    };
+}
+/**
+ * Feature flags state (boolean or entity gate per flag)
+ */
+type FeatureFlags = EvaluatedDefinitions;
+/**
+ * Feature evaluation result
+ */
+interface EvaluationResult {
+    /** Whether the feature(s) are enabled */
+    enabled: boolean;
+    /** The feature keys that were evaluated */
+    featureKeys: string[];
+    /** The requirement type used */
+    requirement: FeatureRequirement;
+    /** Whether the result was negated */
+    negated: boolean;
+}
+/**
+ * Server-side feature context passed to client
+ */
+interface ServerFeatureContext {
+    /** Pre-fetched feature flags */
+    flags: FeatureFlags;
+    /** User identity (if any) */
+    identity?: string;
+    /** App key (for client-side refresh) */
+    appKey?: string;
+    /** Environment */
+    environment?: string;
+    /** Timestamp when flags were fetched */
+    fetchedAt: number;
+}
+/**
+ * Hook metadata
+ */
+interface HookMetadata {
+    name: string;
+    version?: string;
+    description?: string;
+}
+/**
+ * Evaluation series data passed between before/after hooks
+ */
+interface EvaluationSeriesData {
+    [key: string]: unknown;
+}
+/**
+ * Identity series data passed between before/after hooks
+ */
+interface IdentitySeriesData {
+    [key: string]: unknown;
+}
+/**
+ * Hook interface for extending SDK behavior
+ */
+interface TogglyHook {
+    /** Get hook metadata */
+    getMetadata(): HookMetadata;
+    /** Called before feature evaluation */
+    beforeEvaluation?(flagKey: string, defaultValue?: boolean): Promise<EvaluationSeriesData | void> | EvaluationSeriesData | void;
+    /** Called after feature evaluation */
+    afterEvaluation?(flagKey: string, data: EvaluationSeriesData | void, result: boolean): Promise<void> | void;
+    /** Called before user identification */
+    beforeIdentify?(identity: string): Promise<IdentitySeriesData | void> | IdentitySeriesData | void;
+    /** Called after user identification */
+    afterIdentify?(identity: string, data: IdentitySeriesData | void): Promise<void> | void;
+    /** Called after feature flags are refreshed */
+    afterRefresh?(flags: FeatureFlags): Promise<void> | void;
+}
+/**
+ * Error types for Toggly SDK
+ */
+declare class TogglyError extends Error {
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, code: string, cause?: unknown | undefined);
+}
+declare class TogglyNetworkError extends TogglyError {
+    constructor(message: string, cause?: unknown);
+}
+declare class TogglyConfigError extends TogglyError {
+    constructor(message: string);
+}
+declare class TogglyTimeoutError extends TogglyError {
+    constructor(message: string);
+}
+
+/** Cookie/storage key names */
+declare const STORAGE_KEYS: {
+    /** Identity cookie/storage key */
+    readonly IDENTITY: "toggly_identity";
+    /** Feature flags cache key */
+    readonly FLAGS: "toggly_flags";
+    /** Config cache key */
+    readonly CONFIG: "toggly_config";
+    /** Last fetch timestamp key */
+    readonly LAST_FETCH: "toggly_last_fetch";
+};
+/** HTTP header names */
+declare const HEADERS: {
+    /** Identity header */
+    readonly IDENTITY: "x-toggly-identity";
+    /** Feature flags header */
+    readonly FLAGS: "x-toggly-flags";
+    /** Cache control */
+    readonly CACHE_CONTROL: "cache-control";
+};
+/** Meta key for loader data */
+declare const TOGGLY_LOADER_KEY: "__toggly";
+
+/**
+ * Request-scoped ambient EvalContext for React Router loaders and actions.
+ * Never mutates the process-global client identity — bind overrides here only.
+ */
+
+/**
+ * Ambient IdentityContext for the current async scope, if any.
+ * Returns a shallow copy so callers cannot mutate the ALS store.
+ */
+declare function getAmbientEvalOverrides(): IdentityContext | undefined;
+/**
+ * Run `fn` with the given EvalContext bound for the async scope.
+ * Nested calls replace (do not deep-merge) the ambient store for their duration.
+ */
+declare function runWithEvalContext<T>(ctx: IdentityContext, fn: () => T): T;
+/**
+ * Merge ambient defaults with per-call IdentityContext. Explicit per-call
+ * fields win field-by-field via `??`, so a field only overrides ambient when
+ * its value is not `undefined` — a key present with an `undefined` value
+ * (e.g. from `{ claims: user.claims }` where `user.claims` is optional)
+ * falls back to ambient, same as an omitted key. No `IdentityContext` field
+ * is typed nullable, so `??` and an explicit `!== undefined` check are
+ * equivalent here; prefer `??` per lint (S6606).
+ */
+declare function mergeIdentityContext(ambient: IdentityContext | undefined, perCall: IdentityContext | undefined): IdentityContext | undefined;
+
+/**
+ * Build ambient IdentityContext / EvalContext from a Remix Request.
+ */
+
+/**
+ * Providers that build ambient EvalContext for a Remix request.
+ */
+interface EvalContextProviders {
+    /** Extract identity from the request */
+    getIdentity?: (request: Request) => string | undefined | Promise<string | undefined>;
+    /** Extract identity from cookies (fallback when getIdentity is unset) */
+    getIdentityFromCookies?: (cookies: string | null) => string | undefined;
+    /** Extract group memberships for Targeting / Percentage filters */
+    getGroups?: (request: Request) => string[] | undefined | Promise<string[] | undefined>;
+    /** Extract principal / JWT-style claims for UserClaims filters */
+    getClaims?: (request: Request) => Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
+    /**
+     * Full ambient context. When provided, returned fields are used;
+     * missing `request` keys are still filled from headers via `fromHttpRequest`.
+     */
+    getContext?: (request: Request) => IdentityContext | Promise<IdentityContext>;
+}
+/**
+ * Resolve ambient IdentityContext for a Remix Request.
+ * Uses `getContext` when provided; otherwise getIdentity / getGroups / getClaims.
+ * Always fills missing `request` fields from headers via `fromHttpRequest`.
+ * UserClaims must be supplied via `claims` (not `traits`).
+ */
+declare function extractEvalContext(request: Request, providers?: EvalContextProviders): Promise<IdentityContext>;
+
+/**
+ * Server-side Toggly client
+ */
+
+/**
+ * Server-side Toggly client for fetching and evaluating feature flags
+ */
+declare class TogglyServerClient {
+    private readonly config;
+    private readonly logger;
+    /** Compatibility snapshot of locally evaluated booleans (hydration / afterRefresh). */
+    private flags;
+    /** Raw definitions-signed models keyed by featureKey. */
+    private definitions;
+    private hooks;
+    private initialized;
+    /** Dedupes concurrent cold-start definition fetches. */
+    private definitionsLoadPromise;
+    /** Single-flight for definition GET so concurrent joiners are not double-counted. */
+    private definitionsFetchInFlight;
+    private ws;
+    private wsConnected;
+    private wsReconnectTimer;
+    private wsReconnectAttempt;
+    private refreshDebounceTimer;
+    private cachedDefinitionsRevision;
+    private pendingDefinitionsPin;
+    private refreshTimer;
+    private identity?;
+    private localGates;
+    private localGateIndex;
+    private readonly localGatesListeners;
+    private telemetry;
+    constructor(config: TogglyConfig);
+    private startTelemetry;
+    private recordCheckForKey;
+    /** Soft-fail wrapper — definition refresh must not throw from telemetry. */
+    private noteDefinitionCacheHit;
+    private noteDefinitionCacheMiss;
+    private normalizeDefinitionsRevision;
+    private definitionsRevisionsMatch;
+    /**
+     * Add a hook to the client
+     */
+    addHook(hook: TogglyHook): void;
+    /**
+     * Remove a hook by name
+     */
+    removeHook(name: string): boolean;
+    /**
+     * Register device-local post-filter gates
+     */
+    setLocalGates(gates: LocalGate[]): void;
+    /**
+     * Notify subscribers that local gate state changed (no network)
+     */
+    notifyLocalGatesChanged(): void;
+    /**
+     * Subscribe to local gate changes
+     */
+    subscribeLocalGatesChanged(listener: () => void): () => void;
+    private buildEvalContext;
+    /**
+     * Evaluate a boolean snapshot for a specific identity without relying on
+     * shared mutable `this.flags` / `this.identity` (safe under concurrency).
+     */
+    snapshotFlags(identityOverride?: IdentityContext): FeatureFlags;
+    private getEffectiveFlag;
+    private getDefinitionsRevision;
+    private cacheDefinitionsRevision;
+    private scheduleDebouncedRefresh;
+    private handleWsSyncMessage;
+    private handleWsUpdateMessage;
+    private evaluateGateEffective;
+    /**
+     * Whether the WebSocket connection is active
+     */
+    get isWsConnected(): boolean;
+    /**
+     * Initialize the client by fetching feature definitions.
+     * When already initialized, rebinds identity (including clearing it) and
+     * re-snapshots flags without re-fetching (definitions are identity-agnostic).
+     * Concurrent cold starts share one fetch; each caller still receives a
+     * request-local snapshot for its identity.
+     */
+    init(identity?: string): Promise<FeatureFlags>;
+    /**
+     * Fetch feature definitions from the API (definitions-signed; no identity query).
+     * Counts one definition-refresh hit/miss per performed attempt; concurrent
+     * in-flight joiners await the same fetch and are not counted.
+     */
+    fetchFlags(identity?: string): Promise<FeatureFlags>;
+    private performDefinitionsFetch;
+    /**
+     * Get all flags
+     */
+    getFlags(): FeatureFlags;
+    /**
+     * Check if a feature is enabled
+     */
+    isEnabled(featureKey: string, context?: IdentityContext, defaultValue?: boolean, entity?: TogglyEntityContext | Record<string, unknown> | null, kind?: string): Promise<boolean>;
+    registerContext<T>(kind: string, mapper: (entity: T) => TogglyEntityContext): void;
+    /**
+     * Check if a feature is disabled
+     */
+    isDisabled(featureKey: string, context?: IdentityContext, defaultValue?: boolean, entity?: TogglyEntityContext | Record<string, unknown> | null, kind?: string): Promise<boolean>;
+    /**
+     * Evaluate a feature gate (multiple features)
+     */
+    evaluateGate(featureKeys: string[], requirement?: 'all' | 'any', negate?: boolean, defaultValue?: boolean, entity?: TogglyEntityContext | Record<string, unknown> | null, kind?: string, identityOverride?: IdentityContext): Promise<boolean>;
+    /**
+     * Get the server context for client hydration
+     */
+    getServerContext(): {
+        flags: FeatureFlags;
+        appKey?: string;
+        environment?: string;
+        fetchedAt: number;
+    };
+    /**
+     * Start WebSocket connection for live updates
+     */
+    private startWebSocket;
+    /**
+     * Schedule WebSocket reconnection
+     */
+    private scheduleReconnect;
+    /**
+     * Stop WebSocket connection and cleanup
+     */
+    private stopWebSocket;
+    /**
+     * Close the client and cleanup all resources
+     */
+    close(): void;
+    /** Record a feature "used" interaction (usage telemetry). */
+    recordUsage(featureKey: string, identity?: string, variant?: string): void;
+    /** Record a feature "viewed" event (usage telemetry). */
+    recordView(featureKey: string, identity?: string, variant?: string): void;
+    measure(metricKey: string, value: number, options?: MetricsFeatureOptions): void;
+    incrementCounter(metricKey: string, value?: number, options?: MetricsFeatureOptions): void;
+    observe(metricKey: string, value: number, options?: MetricsFeatureOptions): void;
+    flushTelemetry(): Promise<void>;
+    private executeBeforeEvaluation;
+    private executeAfterEvaluation;
+    private executeBeforeIdentify;
+    private executeAfterIdentify;
+    private executeAfterRefresh;
+}
+/**
+ * Create a new server client instance
+ */
+declare function createServerClient(config: TogglyConfig): TogglyServerClient;
+
+/**
+ * React Router loader utilities for Toggly
+ */
+
+/** Structural args for framework-mode loaders (RR7/RR8). */
+interface LoaderFunctionArgs {
+    request: Request;
+    params?: Record<string, string | undefined>;
+    context?: unknown;
+}
+interface TogglyLoaderOptions extends TogglyConfig, EvalContextProviders {
+}
+/**
+ * Create a loader helper for fetching feature flags
+ */
+declare function createTogglyLoader(options: TogglyLoaderOptions): {
+    /**
+     * Get the Toggly client
+     */
+    getClient(): TogglyServerClient;
+    /**
+     * Load feature flags for a loader function.
+     * Builds ambient EvalContext (identity / groups / claims / request) for
+     * the snapshot. Prefer `run` when calling `client.isEnabled('X')` without
+     * an IdentityContext for the full loader duration.
+     */
+    load(args: LoaderFunctionArgs): Promise<ServerFeatureContext>;
+    /**
+     * Bind ambient EvalContext for the full loader duration, then run `fn`.
+     * Prefer this when calling `client.isEnabled('X')` without an IdentityContext.
+     */
+    run<T>(args: LoaderFunctionArgs, fn: (ctx: ServerFeatureContext & {
+        client: TogglyServerClient;
+    }) => T | Promise<T>): Promise<T>;
+    /**
+     * Create loader data with feature context
+     */
+    getLoaderData<T extends Record<string, unknown>>(args: LoaderFunctionArgs, additionalData?: T): Promise<T & {
+        [TOGGLY_LOADER_KEY]: ServerFeatureContext;
+    }>;
+    /**
+     * Check if a feature is enabled.
+     * Ambient EvalContext (from `run` / `load` ALS scope) is merged;
+     * per-call string identity or IdentityContext overrides field-by-field.
+     */
+    isEnabled(featureKey: string, defaultValue?: boolean, identityOrContext?: string | IdentityContext): Promise<boolean>;
+    /**
+     * Check if a feature is disabled
+     */
+    isDisabled(featureKey: string, defaultValue?: boolean, identityOrContext?: string | IdentityContext): Promise<boolean>;
+    /**
+     * Evaluate a feature gate
+     */
+    evaluateGate(featureKeys: string[], requirement?: "all" | "any", negate?: boolean, identityOrContext?: string | IdentityContext): Promise<boolean>;
+    /**
+     * Get all flags
+     */
+    getFlags(): FeatureFlags;
+};
+/**
+ * Standalone function to get feature flags in a loader
+ */
+declare function getFeatureFlags(request: Request, options: TogglyLoaderOptions): Promise<ServerFeatureContext>;
+/**
+ * Check if a single feature is enabled (standalone)
+ */
+declare function isFeatureEnabled(request: Request, featureKey: string, options: TogglyLoaderOptions, defaultValue?: boolean): Promise<boolean>;
+/**
+ * Type helper for loader data with Toggly context
+ */
+type WithTogglyContext<T> = T & {
+    [TOGGLY_LOADER_KEY]: ServerFeatureContext;
+};
+
+/**
+ * React Router action utilities for Toggly
+ */
+
+/** Structural args for framework-mode actions (RR7/RR8). */
+interface ActionFunctionArgs {
+    request: Request;
+    params?: Record<string, string | undefined>;
+    context?: unknown;
+}
+/**
+ * Options for feature-gated actions
+ */
+interface FeatureGatedActionOptions extends TogglyLoaderOptions {
+    /** Feature key(s) required for this action */
+    requiredFeatures?: string | string[];
+    /** Feature requirement type */
+    requirement?: 'all' | 'any';
+    /** Response when feature is disabled */
+    onFeatureDisabled?: (request: Request, featureKeys: string[]) => Response | Promise<Response>;
+    /** Redirect URL when feature is disabled */
+    redirectTo?: string;
+    /** Status code for JSON error response */
+    errorStatus?: number;
+    /** Error message for JSON error response */
+    errorMessage?: string;
+}
+/**
+ * Action context with Toggly client
+ */
+interface TogglyActionContext {
+    /** Toggly server client */
+    client: TogglyServerClient;
+    /** Feature flags */
+    flags: FeatureFlags;
+    /** Ambient EvalContext bound for this action */
+    context: IdentityContext;
+    /** Check if feature is enabled (uses ambient; optional override) */
+    isEnabled: (featureKey: string, defaultValue?: boolean, override?: IdentityContext) => Promise<boolean>;
+    /** Check if feature is disabled */
+    isDisabled: (featureKey: string, defaultValue?: boolean, override?: IdentityContext) => Promise<boolean>;
+    /** Evaluate feature gate */
+    evaluateGate: (featureKeys: string[], requirement?: 'all' | 'any', negate?: boolean, override?: IdentityContext) => Promise<boolean>;
+}
+/**
+ * Create a feature-gated action handler
+ */
+declare function createFeatureGatedAction<T>(options: FeatureGatedActionOptions, handler: (args: ActionFunctionArgs, toggly: TogglyActionContext) => Promise<T> | T): (args: ActionFunctionArgs) => Promise<T | Response>;
+/**
+ * Create a Toggly-aware action helper
+ */
+declare function createTogglyAction(options: TogglyLoaderOptions): {
+    /**
+     * Get the Toggly client
+     */
+    getClient(): TogglyServerClient;
+    /**
+     * Initialize for an action request.
+     * Returned helpers close over ambient EvalContext so `toggly.isEnabled('X')`
+     * needs no IdentityContext. Prefer `run` when using `client.isEnabled('X')`
+     * directly for the full action duration.
+     */
+    init(request: Request): Promise<TogglyActionContext>;
+    /**
+     * Bind ambient EvalContext and run an action handler.
+     */
+    run<T>(args: ActionFunctionArgs, fn: (args: ActionFunctionArgs, toggly: TogglyActionContext) => T | Promise<T>): Promise<T>;
+    /**
+     * Wrap an action with feature checks
+     */
+    requireFeature<T>(featureKey: string, handler: (args: ActionFunctionArgs, toggly: TogglyActionContext) => Promise<T> | T, onDisabled?: () => Response | Promise<Response>): (args: ActionFunctionArgs) => Promise<Response | T>;
+    /**
+     * Wrap an action with feature gate checks
+     */
+    requireFeatures<T>(featureKeys: string[], requirement: "all" | "any", handler: (args: ActionFunctionArgs, toggly: TogglyActionContext) => Promise<T> | T, onDisabled?: () => Response | Promise<Response>): (args: ActionFunctionArgs) => Promise<Response | T>;
+};
+/**
+ * Higher-order function to require a feature for an action
+ */
+declare function requireFeature(featureKey: string, options: TogglyLoaderOptions, onDisabled?: () => Response | Promise<Response>): <T>(handler: (args: ActionFunctionArgs, toggly: TogglyActionContext) => Promise<T> | T) => (args: ActionFunctionArgs) => Promise<Response | T>;
+
+export { type EvalContextProviders, type EvaluationResult, type EvaluationSeriesData, type FeatureFlags, type FeatureGatedActionOptions, type FeatureRequirement, HEADERS, type HookMetadata, type IdentityContext, type IdentitySeriesData, type MetricsFeatureOptions, type MetricsSender, STORAGE_KEYS, type ServerFeatureContext, TOGGLY_LOADER_KEY, type TelemetryConfig, type TelemetryTransport, type TogglyActionContext, type TogglyConfig, TogglyConfigError, TogglyError, type TogglyHook, type TogglyLoaderOptions, TogglyNetworkError, TogglyServerClient, TogglyTimeoutError, type UsageSender, type WithTogglyContext, createFeatureGatedAction, createServerClient, createTogglyAction, createTogglyLoader, extractEvalContext, getAmbientEvalOverrides, getFeatureFlags, isFeatureEnabled, mergeIdentityContext, requireFeature, runWithEvalContext };