@quonfig/node 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,755 @@
+type ValueType = "bool" | "int" | "double" | "string" | "json" | "string_list" | "log_level" | "weighted_values" | "schema" | "provided" | "duration";
+type ConfigTypeString = "feature_flag" | "config" | "segment" | "log_level" | "schema";
+interface ProvidedData {
+    source: string;
+    lookup: string;
+}
+interface WeightedValue {
+    weight: number;
+    value: Value;
+}
+interface WeightedValuesData {
+    weightedValues: WeightedValue[];
+    hashByPropertyName?: string;
+}
+interface SchemaData {
+    schemaType: string;
+    schema: string;
+}
+interface Value {
+    type: ValueType;
+    value: any;
+    confidential?: boolean;
+    decryptWith?: string;
+}
+interface Criterion {
+    propertyName?: string;
+    operator: string;
+    valueToMatch?: Value;
+}
+interface Rule {
+    criteria: Criterion[];
+    value: Value;
+}
+interface RuleSet {
+    rules: Rule[];
+}
+interface Environment {
+    id: string;
+    rules: Rule[];
+}
+interface ConfigResponse {
+    id: string;
+    key: string;
+    type: ConfigTypeString;
+    valueType: ValueType;
+    sendToClientSdk: boolean;
+    default: RuleSet;
+    environment?: Environment;
+}
+interface Meta {
+    version: string;
+    environment: string;
+    workspaceId?: string;
+}
+interface ConfigEnvelope {
+    configs: ConfigResponse[];
+    meta: Meta;
+}
+type ContextValue = string | number | boolean | string[] | null | undefined;
+type Contexts = {
+    [contextName: string]: {
+        [key: string]: ContextValue;
+    };
+};
+type GetValue = string | number | boolean | string[] | undefined;
+type OnNoDefault = "error" | "warn" | "ignore";
+type ContextUploadMode = "none" | "shapes_only" | "periodic_example";
+interface QuonfigOptions {
+    sdkKey: string;
+    apiUrl?: string;
+    /** Base URL for the dedicated telemetry service. Defaults to https://telemetry.quonfig.com. Overridden by QUONFIG_TELEMETRY_URL env var. */
+    telemetryUrl?: string;
+    enableSSE?: boolean;
+    enablePolling?: boolean;
+    pollInterval?: number;
+    namespace?: string;
+    globalContext?: Contexts;
+    onNoDefault?: OnNoDefault;
+    collectEvaluationSummaries?: boolean;
+    collectLoggerCounts?: boolean;
+    contextUploadMode?: ContextUploadMode;
+    initTimeout?: number;
+    datafile?: string | object;
+}
+interface EvalMatch {
+    isMatch: boolean;
+    value?: Value;
+    ruleIndex: number;
+    weightedValueIndex: number;
+}
+type LogLevelName = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+type LogLevelNumber = 1 | 2 | 3 | 5 | 6 | 9;
+interface EvaluationCounter {
+    configId: string;
+    conditionalValueIndex: number;
+    configRowIndex: number;
+    selectedValue: any;
+    count: number;
+    weightedValueIndex?: number;
+}
+interface EvaluationSummary {
+    key: string;
+    type: string;
+    counters: EvaluationCounter[];
+}
+interface ContextShape {
+    name: string;
+    fieldTypes: {
+        [key: string]: number;
+    };
+}
+interface ExampleContextEntry {
+    timestamp: number;
+    contextSet: {
+        contexts: Array<{
+            type: string;
+            values: {
+                [key: string]: any;
+            };
+        }>;
+    };
+}
+interface TelemetryEvent {
+    summaries?: {
+        start: number;
+        end: number;
+        summaries: EvaluationSummary[];
+    };
+    contextShapes?: {
+        shapes: ContextShape[];
+    };
+    exampleContexts?: {
+        examples: ExampleContextEntry[];
+    };
+}
+interface Evaluation {
+    configId: string;
+    configKey: string;
+    configType: ConfigTypeString;
+    unwrappedValue: GetValue;
+    reportableValue?: GetValue;
+    ruleIndex: number;
+    weightedValueIndex?: number;
+}
+declare const ConfigType: {
+    readonly FeatureFlag: ConfigTypeString;
+    readonly Config: ConfigTypeString;
+    readonly Segment: ConfigTypeString;
+    readonly LogLevel: ConfigTypeString;
+    readonly Schema: ConfigTypeString;
+};
+declare const ProvidedSource: {
+    readonly EnvVar: "ENV_VAR";
+};
+interface NodeServerConfigurationRaw {
+}
+interface NodeServerConfigurationAccessor {
+}
+type TypedNodeServerConfigurationRaw = NodeServerConfigurationRaw;
+type TypedNodeServerConfigurationAccessor = NodeServerConfigurationAccessor;
+
+/**
+ * BoundQuonfig is a Quonfig client bound to a specific context.
+ * All get* calls automatically include the bound context.
+ */
+declare class BoundQuonfig {
+    private client;
+    private boundContexts;
+    constructor(client: Quonfig, contexts: Contexts);
+    get(key: string, contexts?: Contexts, defaultValue?: any): any;
+    getString(key: string, contexts?: Contexts): string | undefined;
+    getNumber(key: string, contexts?: Contexts): number | undefined;
+    getBool(key: string, contexts?: Contexts): boolean | undefined;
+    getStringList(key: string, contexts?: Contexts): string[] | undefined;
+    getDuration(key: string, contexts?: Contexts): number | undefined;
+    getJSON(key: string, contexts?: Contexts): any;
+    isFeatureEnabled(key: string, contexts?: Contexts): boolean;
+    shouldLog(args: {
+        loggerName: string;
+        desiredLevel: string;
+        defaultLevel?: string;
+        contexts?: Contexts;
+    }): boolean;
+    keys(): string[];
+    inContext(contexts: Contexts): BoundQuonfig;
+}
+/**
+ * Quonfig is the main SDK client.
+ *
+ * Usage:
+ * ```typescript
+ * const quonfig = new Quonfig({ sdkKey: "your-key" });
+ * await quonfig.init();
+ * const value = quonfig.get("my-config");
+ * ```
+ */
+declare class Quonfig {
+    private readonly sdkKey;
+    private readonly apiUrl;
+    private readonly telemetryUrl?;
+    private readonly enableSSE;
+    private readonly enablePolling;
+    private readonly pollInterval;
+    private readonly namespace?;
+    private readonly onNoDefault;
+    private readonly globalContext?;
+    private readonly initTimeout;
+    private readonly datafile?;
+    private store;
+    private evaluator;
+    private resolver;
+    private transport;
+    private sseConnection?;
+    private pollTimer?;
+    private telemetryReporter?;
+    private instanceHash;
+    private environmentId;
+    private initialized;
+    private evaluationSummaries;
+    private contextShapes;
+    private exampleContexts;
+    constructor(options: QuonfigOptions);
+    /**
+     * Initialize the SDK. Downloads configs from the API (or loads from datafile)
+     * and starts background update mechanisms (SSE/polling).
+     *
+     * Must be called before using any get* methods.
+     */
+    init(): Promise<void>;
+    /**
+     * Get a config value by key. Evaluates rules against the provided context.
+     */
+    get(key: string, contexts?: Contexts, defaultValue?: any): any;
+    /**
+     * Get a string config value.
+     */
+    getString(key: string, contexts?: Contexts): string | undefined;
+    /**
+     * Get a number config value.
+     */
+    getNumber(key: string, contexts?: Contexts): number | undefined;
+    /**
+     * Get a boolean config value.
+     */
+    getBool(key: string, contexts?: Contexts): boolean | undefined;
+    /**
+     * Get a string list config value.
+     */
+    getStringList(key: string, contexts?: Contexts): string[] | undefined;
+    /**
+     * Get a duration config value in milliseconds.
+     */
+    getDuration(key: string, contexts?: Contexts): number | undefined;
+    /**
+     * Get a JSON config value (parsed).
+     */
+    getJSON(key: string, contexts?: Contexts): any;
+    /**
+     * Check if a feature flag is enabled.
+     * Returns false if the key is not found or the value is not a boolean.
+     */
+    isFeatureEnabled(key: string, contexts?: Contexts): boolean;
+    /**
+     * Check if a log message should be logged at the given level.
+     */
+    shouldLog(args: {
+        loggerName: string;
+        desiredLevel: string;
+        defaultLevel?: string;
+        contexts?: Contexts;
+    }): boolean;
+    /**
+     * Get all config keys currently in the store.
+     */
+    keys(): string[];
+    /**
+     * Get the raw ConfigResponse for a key (for advanced usage / CLI tooling).
+     */
+    rawConfig(key: string): ConfigResponse | undefined;
+    /**
+     * Create a BoundQuonfig with the given context baked in.
+     */
+    inContext(contexts: Contexts): BoundQuonfig;
+    /**
+     * Close the SDK. Stops SSE, polling, and telemetry.
+     */
+    close(): void;
+    private requireInitialized;
+    private handleNoDefault;
+    private loadDatafile;
+    private fetchAndInstall;
+    private startSSE;
+    private startPolling;
+    private startTelemetry;
+}
+
+/**
+ * Look up a property value from contexts using dotted notation.
+ * "user.email" -> contexts["user"]["email"]
+ * If there is no dot, look up in the unnamed ("") context: "domain" -> contexts[""]["domain"]
+ */
+declare function contextLookup(contexts: Contexts, propertyName: string | undefined): ContextValue | undefined;
+/**
+ * Merge multiple context sets. Later sets override earlier ones at the key level
+ * within each named context.
+ */
+declare function mergeContexts(...sets: (Contexts | undefined)[]): Contexts;
+/**
+ * Get context value with support for magic properties.
+ * "prefab.current-time" and "quonfig.current-time" return current UTC millis.
+ */
+declare function getContextValue(contexts: Contexts, propertyName: string): {
+    value: any;
+    exists: boolean;
+};
+
+/**
+ * Generate a new random hex-encoded 32-byte key for AES-256-GCM encryption.
+ */
+declare function generateNewHexKey(): string;
+/**
+ * Encrypt a string using AES-256-GCM.
+ *
+ * Returns a string in format: "DATA--IV--AUTH_TAG" where each part is hex-encoded.
+ */
+declare function encrypt(clearText: string, keyStringHex: string): string;
+/**
+ * Decrypt an AES-256-GCM encrypted value.
+ *
+ * The encrypted string must be in format: "DATA--IV--AUTH_TAG" where each part is hex-encoded.
+ */
+declare function decrypt(encryptedString: string, keyStringHex: string): string;
+
+/**
+ * Parse an ISO 8601 duration string and return the number of milliseconds.
+ *
+ * Supports formats like: PT0.2S, PT90S, PT1.5M, PT0.5H, P1DT6H2M1.5S
+ */
+declare function durationToMilliseconds(duration: string): number;
+
+interface SemanticVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string;
+    buildMetadata: string;
+}
+/**
+ * Parse a semantic version string. Returns undefined if invalid.
+ */
+declare function parseSemver(version: string): SemanticVersion | undefined;
+/**
+ * Compare two semantic versions.
+ * Returns -1 if a < b, 0 if a == b, 1 if a > b.
+ */
+declare function compareSemver(a: SemanticVersion, b: SemanticVersion): number;
+
+/**
+ * Hash a string to a float64 in [0, 1) using Murmur3.
+ * This matches the Go SDK's HashZeroToOne implementation.
+ */
+declare function hashZeroToOne(value: string): number;
+
+declare const LOG_LEVEL_PREFIX = "log-level.";
+/**
+ * Convert a log level name to its numeric value.
+ */
+declare function wordLevelToNumber(level: LogLevelName): LogLevelNumber | undefined;
+/**
+ * Parse a log level (string name or number) to a numeric value.
+ */
+declare function parseLevel(level: string | number | undefined): LogLevelNumber | undefined;
+/**
+ * Check if a log message at desiredLevel should be logged, given the logger hierarchy.
+ *
+ * Walks up the logger name hierarchy (e.g., "log-level.a.b.c" -> "log-level.a.b" -> "log-level.a")
+ * looking for a matching config. If no config is found, uses defaultLevel.
+ */
+declare function shouldLog(args: {
+    loggerName: string;
+    desiredLevel: LogLevelNumber;
+    defaultLevel: LogLevelNumber;
+    getConfig: (key: string) => GetValue;
+}): boolean;
+
+/**
+ * In-memory config store.
+ *
+ * Stores parsed ConfigResponse objects keyed by config key.
+ * The store replaces all configs atomically on each update.
+ */
+declare class ConfigStore {
+    private configs;
+    private version;
+    private environmentId;
+    get(key: string): ConfigResponse | undefined;
+    keys(): string[];
+    getEnvironmentId(): string;
+    getVersion(): string;
+    /**
+     * Replace all configs with those from the given envelope.
+     * Also normalizes values that need special deserialization (weighted_values, provided).
+     */
+    update(envelope: ConfigEnvelope): void;
+    /**
+     * Load from a raw datafile (JSON object).
+     */
+    loadFromDatafile(data: ConfigEnvelope): void;
+}
+
+/**
+ * Evaluator is the main evaluation engine. It evaluates configs against contexts,
+ * resolving rules, operators, segments, and weighted values.
+ *
+ * This is a faithful port of the Go SDK's evalcore.Evaluator.
+ */
+declare class Evaluator {
+    private configStore;
+    private weighted;
+    constructor(configStore: ConfigStore);
+    /**
+     * Evaluate a config for the given environment and context.
+     *
+     * Evaluation flow:
+     *  1. Find the environment block matching envID (if any)
+     *  2. Iterate its rules top-to-bottom; first match wins
+     *  3. If no env-specific match, fall back to default.rules
+     *  4. For each rule, all criteria must match (AND logic)
+     *  5. If matched value is weighted_values, resolve through WeightedValueResolver
+     */
+    evaluateConfig(cfg: ConfigResponse, envID: string, contexts: Contexts): EvalMatch;
+    private evaluateRules;
+    private evaluateAllCriteria;
+    private evaluateSingleCriterion;
+}
+
+/**
+ * Resolver handles post-evaluation value resolution:
+ * - ENV_VAR provided values
+ * - Decryption of confidential values
+ * - Type coercion
+ * - Duration parsing
+ * - JSON parsing
+ */
+declare class Resolver {
+    private store;
+    private evaluator;
+    constructor(store: ConfigStore, evaluator: Evaluator);
+    /**
+     * Resolve a matched value. Handles:
+     * - provided values (ENV_VAR lookup)
+     * - decryption of confidential values
+     */
+    resolveValue(val: Value, configKey: string, valueType: ValueType, envID: string, contexts: Contexts): {
+        resolved: Value;
+        reportableValue?: GetValue;
+    };
+    /**
+     * Unwrap a resolved value to a plain JS value.
+     */
+    unwrapValue(val: Value): GetValue;
+}
+
+interface FetchResult {
+    envelope?: ConfigEnvelope;
+    notChanged: boolean;
+}
+declare class Transport {
+    private baseUrl;
+    private telemetryBaseUrl;
+    private sdkKey;
+    private etag;
+    constructor(baseUrl: string, sdkKey: string, telemetryBaseUrl?: string);
+    /**
+     * Build the Basic auth header value.
+     * Uses username "1" like the Go SDK: base64("1:{sdkKey}")
+     */
+    private getAuthHeader;
+    /**
+     * Common headers for all requests.
+     */
+    private getHeaders;
+    /**
+     * Fetch configs from GET /api/v2/configs with ETag caching.
+     *
+     * Returns `{ notChanged: true }` if the server responds with 304.
+     */
+    fetchConfigs(): Promise<FetchResult>;
+    /**
+     * Post telemetry data to the telemetry endpoint.
+     */
+    postTelemetry(data: any): Promise<void>;
+    /**
+     * Get the SSE URL for config streaming.
+     */
+    getSSEUrl(): string;
+    /**
+     * Get auth headers for SSE connection.
+     */
+    getSSEHeaders(): Record<string, string>;
+}
+
+/**
+ * WeightedValueResolver resolves weighted value distributions to a single value.
+ *
+ * This is a faithful port of the Go SDK's WeightedValueResolver.
+ */
+declare class WeightedValueResolver {
+    /**
+     * Resolve picks a value from the weighted distribution.
+     *
+     * If hashByPropertyName is set and the context has a value for that property,
+     * the selection is deterministic via Murmur3 hash. Otherwise, it falls back
+     * to Math.random().
+     *
+     * Returns the selected value and its index, or [undefined, -1] if no values.
+     */
+    resolve(wv: WeightedValuesData, configKey: string, contexts: Contexts): {
+        value: Value | undefined;
+        index: number;
+    };
+    private getUserFraction;
+}
+
+declare const OP_NOT_SET = "NOT_SET";
+declare const OP_ALWAYS_TRUE = "ALWAYS_TRUE";
+declare const OP_PROP_IS_ONE_OF = "PROP_IS_ONE_OF";
+declare const OP_PROP_IS_NOT_ONE_OF = "PROP_IS_NOT_ONE_OF";
+declare const OP_PROP_STARTS_WITH_ONE_OF = "PROP_STARTS_WITH_ONE_OF";
+declare const OP_PROP_DOES_NOT_START_WITH_ONE_OF = "PROP_DOES_NOT_START_WITH_ONE_OF";
+declare const OP_PROP_ENDS_WITH_ONE_OF = "PROP_ENDS_WITH_ONE_OF";
+declare const OP_PROP_DOES_NOT_END_WITH_ONE_OF = "PROP_DOES_NOT_END_WITH_ONE_OF";
+declare const OP_PROP_CONTAINS_ONE_OF = "PROP_CONTAINS_ONE_OF";
+declare const OP_PROP_DOES_NOT_CONTAIN_ONE_OF = "PROP_DOES_NOT_CONTAIN_ONE_OF";
+declare const OP_PROP_MATCHES = "PROP_MATCHES";
+declare const OP_PROP_DOES_NOT_MATCH = "PROP_DOES_NOT_MATCH";
+declare const OP_HIERARCHICAL_MATCH = "HIERARCHICAL_MATCH";
+declare const OP_IN_INT_RANGE = "IN_INT_RANGE";
+declare const OP_PROP_GREATER_THAN = "PROP_GREATER_THAN";
+declare const OP_PROP_GREATER_THAN_OR_EQUAL = "PROP_GREATER_THAN_OR_EQUAL";
+declare const OP_PROP_LESS_THAN = "PROP_LESS_THAN";
+declare const OP_PROP_LESS_THAN_OR_EQUAL = "PROP_LESS_THAN_OR_EQUAL";
+declare const OP_PROP_BEFORE = "PROP_BEFORE";
+declare const OP_PROP_AFTER = "PROP_AFTER";
+declare const OP_PROP_SEMVER_LESS_THAN = "PROP_SEMVER_LESS_THAN";
+declare const OP_PROP_SEMVER_EQUAL = "PROP_SEMVER_EQUAL";
+declare const OP_PROP_SEMVER_GREATER_THAN = "PROP_SEMVER_GREATER_THAN";
+declare const OP_IN_SEG = "IN_SEG";
+declare const OP_NOT_IN_SEG = "NOT_IN_SEG";
+type SegmentResolver = (segmentKey: string) => {
+    result: boolean;
+    found: boolean;
+};
+/**
+ * Evaluate a single criterion against a context value.
+ *
+ * This is a faithful port of the Go SDK's EvaluateCriterion function.
+ */
+declare function evaluateCriterion(contextValue: any, contextExists: boolean, criterion: Criterion, segmentResolver?: SegmentResolver): boolean;
+
+/**
+ * Collects evaluation summaries for telemetry reporting.
+ *
+ * Each evaluation is aggregated by (configKey, configType) and
+ * counted by (configId, ruleIndex, value, weightedValueIndex).
+ */
+declare class EvaluationSummaryCollector {
+    private enabled;
+    private data;
+    private startAt;
+    private maxDataSize;
+    constructor(enabled: boolean, maxDataSize?: number);
+    isEnabled(): boolean;
+    push(evaluation: Evaluation): void;
+    /**
+     * Drain collected summaries into a TelemetryEvent, or return undefined if empty.
+     */
+    drain(): TelemetryEvent | undefined;
+}
+
+/**
+ * Collects context shapes (field names + types) for telemetry reporting.
+ */
+declare class ContextShapeCollector {
+    private enabled;
+    private data;
+    private maxDataSize;
+    constructor(contextUploadMode: ContextUploadMode, maxDataSize?: number);
+    isEnabled(): boolean;
+    push(contexts: Contexts): void;
+    /**
+     * Drain collected shapes into a TelemetryEvent, or return undefined if empty.
+     */
+    drain(): TelemetryEvent | undefined;
+}
+
+/**
+ * Collects example contexts for telemetry reporting.
+ * Only collects when contextUploadMode is "periodic_example".
+ */
+declare class ExampleContextCollector {
+    private enabled;
+    private data;
+    private seen;
+    private maxDataSize;
+    private rateLimitMs;
+    constructor(contextUploadMode: ContextUploadMode, maxDataSize?: number, rateLimitMs?: number);
+    isEnabled(): boolean;
+    push(contexts: Contexts): void;
+    /**
+     * Drain collected examples into a TelemetryEvent, or return undefined if empty.
+     */
+    drain(): TelemetryEvent | undefined;
+    private groupedKey;
+    private pruneCache;
+}
+
+/**
+ * TelemetryReporter periodically drains collected telemetry data and sends it
+ * to the Quonfig telemetry endpoint.
+ */
+declare class TelemetryReporter {
+    private transport;
+    private instanceHash;
+    private evaluationSummaries;
+    private contextShapes;
+    private exampleContexts;
+    private timer;
+    private initialDelay;
+    private maxDelay;
+    private currentDelay;
+    private stopped;
+    constructor(args: {
+        transport: Transport;
+        instanceHash: string;
+        evaluationSummaries: EvaluationSummaryCollector;
+        contextShapes: ContextShapeCollector;
+        exampleContexts: ExampleContextCollector;
+        initialDelay?: number;
+        maxDelay?: number;
+    });
+    /**
+     * Start the periodic telemetry reporting loop.
+     */
+    start(): void;
+    /**
+     * Stop telemetry reporting.
+     */
+    stop(): void;
+    private scheduleNext;
+    private sync;
+}
+
+/**
+ * CLI-compatibility types and utilities.
+ *
+ * These are needed by @quonfig/cli but are NOT part of the core SDK.
+ * They provide the HTTP API client, SDK-key parsing, and legacy
+ * config-value types that the CLI's CRUD commands depend on.
+ */
+
+interface ClientOptions {
+    jwt?: string;
+    sdkKey?: string;
+    apiUrl: string;
+    clientIdentifier: string;
+    log?: (category: string | unknown, message?: unknown) => void;
+}
+/**
+ * Minimal HTTP client for the Quonfig REST API.
+ * Used by the CLI for CRUD operations (create, set-default, download, etc.).
+ */
+declare class Client {
+    private jwt?;
+    private sdkKey?;
+    private apiUrl;
+    private clientIdentifier;
+    private log;
+    constructor(options: ClientOptions);
+    private headers;
+    get(path: string): Promise<Response>;
+    post(path: string, payload: unknown): Promise<Response>;
+    put(path: string, payload: unknown): Promise<Response>;
+}
+interface ProjectEnvId {
+    id: string;
+    projectId: number;
+}
+/**
+ * Parse a Prefab/Quonfig SDK key to extract the project-environment ID.
+ * SDK keys are typically in the format: `<projectId>-<envId>-<secret>`
+ */
+declare function getProjectEnvFromSdkKey(sdkKey: string): ProjectEnvId;
+/**
+ * ConfigValueType enum, matching the legacy quonfig-common types.
+ * Used by the CLI's coerce and config-value-dto utilities.
+ */
+declare enum ConfigValueType {
+    NotSetValue = 0,
+    Int = 1,
+    String = 2,
+    Bytes = 3,
+    Double = 4,
+    Bool = 5,
+    LimitDefinition = 7,
+    LogLevel = 8,
+    StringList = 9,
+    IntRange = 10,
+    Duration = 11,
+    Json = 12
+}
+/**
+ * ConfigValue represents a typed value in the legacy format.
+ * Used by the CLI for constructing API request payloads.
+ */
+interface ConfigValue {
+    int?: bigint | number;
+    string?: string;
+    bytes?: Uint8Array;
+    double?: number;
+    bool?: boolean;
+    logLevel?: string;
+    stringList?: {
+        values: string[];
+    };
+    intRange?: {
+        start?: number;
+        end?: number;
+    };
+    duration?: {
+        definition?: string;
+        millis?: number;
+    };
+    json?: {
+        json: string;
+    };
+    provided?: {
+        source: string;
+        lookup: string;
+    };
+    confidential?: boolean;
+    decryptWith?: string;
+}
+/**
+ * Extract the value-type string for a ConfigResponse (e.g., "bool", "string", "int").
+ * Used by the CLI's `serve` command to format evaluation responses.
+ */
+declare function valueTypeStringForConfig(config: ConfigResponse): ValueType | undefined;
+
+declare const encryption: {
+    encrypt: typeof encrypt;
+    generateNewHexKey: typeof generateNewHexKey;
+};
+
+export { BoundQuonfig, Client, type ClientOptions, type ConfigEnvelope, type ConfigResponse, ConfigStore, ConfigType, type ConfigTypeString, type ConfigValue, ConfigValueType, ContextShapeCollector, type ContextUploadMode, type ContextValue, type Contexts, type Criterion, type Environment, type EvalMatch, type Evaluation, EvaluationSummaryCollector, Evaluator, ExampleContextCollector, type GetValue, LOG_LEVEL_PREFIX, type LogLevelName, type LogLevelNumber, type Meta, type NodeServerConfigurationAccessor, type NodeServerConfigurationRaw, OP_ALWAYS_TRUE, OP_HIERARCHICAL_MATCH, OP_IN_INT_RANGE, OP_IN_SEG, OP_NOT_IN_SEG, OP_NOT_SET, OP_PROP_AFTER, OP_PROP_BEFORE, OP_PROP_CONTAINS_ONE_OF, OP_PROP_DOES_NOT_CONTAIN_ONE_OF, OP_PROP_DOES_NOT_END_WITH_ONE_OF, OP_PROP_DOES_NOT_MATCH, OP_PROP_DOES_NOT_START_WITH_ONE_OF, OP_PROP_ENDS_WITH_ONE_OF, OP_PROP_GREATER_THAN, OP_PROP_GREATER_THAN_OR_EQUAL, OP_PROP_IS_NOT_ONE_OF, OP_PROP_IS_ONE_OF, OP_PROP_LESS_THAN, OP_PROP_LESS_THAN_OR_EQUAL, OP_PROP_MATCHES, OP_PROP_SEMVER_EQUAL, OP_PROP_SEMVER_GREATER_THAN, OP_PROP_SEMVER_LESS_THAN, OP_PROP_STARTS_WITH_ONE_OF, type OnNoDefault, type ProjectEnvId, type ProvidedData, ProvidedSource, Quonfig, type QuonfigOptions, Resolver, type Rule, type RuleSet, type SchemaData, type SegmentResolver, type SemanticVersion, TelemetryReporter, Transport, type TypedNodeServerConfigurationAccessor, type TypedNodeServerConfigurationRaw, type Value, type ValueType, type WeightedValue, WeightedValueResolver, type WeightedValuesData, compareSemver, contextLookup, decrypt, durationToMilliseconds, encrypt, encryption, evaluateCriterion, generateNewHexKey, getContextValue, getProjectEnvFromSdkKey, hashZeroToOne, mergeContexts, parseLevel, parseSemver, shouldLog, valueTypeStringForConfig, wordLevelToNumber };