@sessionvision/core 0.2.0

package/dist/vue/core/init.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SDK initialization module
+ * Orchestrates the initialization of all SDK components
+ */
+import { SessionVisionConfig, ResolvedConfig, UserTraits, EventProperties } from '../types';
+/**
+ * Initialize the SDK
+ */
+export declare function init(projectToken: string, config?: SessionVisionConfig): Promise<void>;
+/**
+ * Capture a custom event
+ */
+export declare function capture(eventName: string, properties?: EventProperties): void;
+/**
+ * Identify a user
+ */
+export declare function identify(userId: string, traits?: UserTraits): void;
+/**
+ * Reset user identity (for logout)
+ */
+export declare function reset(): void;
+/**
+ * Get the current distinct ID
+ */
+export declare function getDistinctIdValue(): string;
+/**
+ * Register properties to send with every event
+ */
+export declare function register(properties: EventProperties): void;
+/**
+ * Register properties only if they don't exist
+ */
+export declare function registerOnce(properties: EventProperties): void;
+/**
+ * Manually flush the event buffer
+ */
+export declare function flushEvents(): Promise<void>;
+/**
+ * Shutdown the SDK
+ */
+export declare function shutdown(): void;
+/**
+ * Check if the SDK is initialized
+ */
+export declare function isSDKInitialized(): boolean;
+/**
+ * Get the current configuration
+ */
+export declare function getConfig(): ResolvedConfig | null;
+/**
+ * Reset for testing
+ */
+export declare function _reset(): void;

package/dist/vue/core/queue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Queue replay module
+ * Handles replaying method calls that were queued before SDK loaded
+ */
+import { QueuedCall, SessionVisionAPI } from '../types';
+/**
+ * Replay queued method calls
+ * The stub queues calls like ['capture', 'event_name', {...}] before SDK loads
+ */
+export declare function replayQueue(queue: QueuedCall[] | undefined, api: SessionVisionAPI): void;
+/**
+ * Parse the legacy array-style queue format
+ * PostHog-style: sessionvision._q = [['capture', 'event', {}], ...]
+ */
+export declare function parseLegacyQueue(legacyQueue: unknown[][] | undefined): QueuedCall[];
+/**
+ * Get init calls from _i array
+ */
+export declare function getInitCalls(initArray: Array<[string, unknown?]> | undefined): Array<{
+    projectToken: string;
+    config?: unknown;
+}>;

package/dist/vue/identity/anonymous.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Anonymous ID management
+ * Generates and persists anonymous user identifiers using UUID v4
+ */
+/**
+ * Get the current anonymous ID, creating one if it doesn't exist
+ */
+export declare function getAnonymousId(): string;
+/**
+ * Set a specific anonymous ID (used when migrating from another analytics tool)
+ */
+export declare function setAnonymousId(id: string): void;
+/**
+ * Reset the anonymous ID (generates a new one)
+ * Called during reset() when user logs out
+ */
+export declare function resetAnonymousId(): string;
+/**
+ * Clear the anonymous ID from storage and cache
+ * Used internally during full reset
+ */
+export declare function clearAnonymousId(): void;
+/**
+ * Check if an anonymous ID exists
+ */
+export declare function hasAnonymousId(): boolean;
+/**
+ * Clear the in-memory cache (for testing)
+ */
+export declare function _clearCache(): void;

package/dist/vue/identity/identify.d.ts

@@ -0,0 +1,46 @@
+/**
+ * User identification management
+ * Handles identify() calls and user ID persistence
+ */
+import { UserTraits } from '../types';
+/**
+ * Set the callback to be called when identify() is invoked
+ * Used by the SDK to capture an $identify event
+ */
+export declare function setIdentifyCallback(callback: (userId: string, traits?: UserTraits) => void): void;
+/**
+ * Get the current user ID, or null if not identified
+ */
+export declare function getUserId(): string | null;
+/**
+ * Identify a user with an ID and optional traits
+ * - Sets the user ID in localStorage
+ * - Triggers an $identify event with traits
+ * - Forward-only: does not retroactively link past anonymous events
+ */
+export declare function identify(userId: string, traits?: UserTraits): void;
+/**
+ * Check if a user is currently identified
+ */
+export declare function isIdentified(): boolean;
+/**
+ * Get the distinct ID (user ID if identified, anonymous ID otherwise)
+ */
+export declare function getDistinctId(): string;
+/**
+ * Reset user identity
+ * - Clears user ID
+ * - Generates new anonymous ID
+ * - Starts new session
+ * Used on logout
+ */
+export declare function reset(): void;
+/**
+ * Clear the user ID only (without resetting anonymous ID or session)
+ * Used internally
+ */
+export declare function clearUserId(): void;
+/**
+ * Clear the in-memory cache (for testing)
+ */
+export declare function _clearCache(): void;

package/dist/vue/identity/session.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Session ID management
+ * Manages session lifecycle with configurable inactivity timeout
+ */
+/**
+ * Set the session timeout duration (for server-side configuration)
+ */
+export declare function setSessionTimeout(timeoutMinutes: number): void;
+/**
+ * Get the current session timeout in milliseconds
+ */
+export declare function getSessionTimeout(): number;
+/**
+ * Get or create a session ID
+ * Creates a new session if:
+ * - No existing session
+ * - Session has timed out (30 minutes of inactivity by default)
+ */
+export declare function getSessionId(): string;
+/**
+ * Force start a new session
+ */
+export declare function startNewSession(): string;
+/**
+ * Reset the session (clear storage and cache)
+ */
+export declare function resetSession(): string;
+/**
+ * Check if the current session has expired
+ */
+export declare function isSessionExpired(): boolean;
+/**
+ * Get the time remaining in the current session (in milliseconds)
+ * Returns 0 if session has expired
+ */
+export declare function getSessionTimeRemaining(): number;
+/**
+ * Touch the session to keep it alive
+ * Called on user activity
+ */
+export declare function touchSession(): void;
+/**
+ * Clear the in-memory cache (for testing)
+ */
+export declare function _clearCache(): void;
+/**
+ * Reset timeout to default (for testing)
+ */
+export declare function _resetTimeout(): void;

package/dist/vue/index.cjs.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var sessionvision = require('@sessionvision/core');
+var vue = require('vue');
+
+const sessionVisionKey = Symbol('SessionVision');
+function createSessionVision(apiKey, options) {
+    return {
+        install(app) {
+            if (typeof window !== 'undefined' && !sessionvision.__SV) {
+                sessionvision.init(apiKey, options);
+            }
+            app.provide(sessionVisionKey, sessionvision);
+        },
+    };
+}
+
+function useSessionVision() {
+    const instance = vue.inject(sessionVisionKey);
+    if (!instance) {
+        throw new Error('useSessionVision must be used after installing the Session Vision plugin. ' +
+            'Call app.use(createSessionVision(...)) before this composable.');
+    }
+    return instance;
+}
+function useCapture() {
+    const sessionvision = useSessionVision();
+    return (eventName, properties) => {
+        sessionvision.capture(eventName, properties);
+    };
+}
+function useIdentify() {
+    const sessionvision = useSessionVision();
+    return (userId, traits) => {
+        sessionvision.identify(userId, traits);
+    };
+}
+
+exports.createSessionVision = createSessionVision;
+exports.useCapture = useCapture;
+exports.useIdentify = useIdentify;
+exports.useSessionVision = useSessionVision;
+//# sourceMappingURL=index.cjs.js.map

package/dist/vue/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":["../../src/vue/plugin.ts","../../src/vue/composables.ts"],"sourcesContent":[null,null],"names":["inject"],"mappings":";;;;;AAIO,MAAM,gBAAgB,GAAmC,MAAM,CAAC,eAAe,CAAC;AAEjF,SAAU,mBAAmB,CACjC,MAAc,EACd,OAA8C,EAAA;IAE9C,OAAO;AACL,QAAA,OAAO,CAAC,GAAQ,EAAA;YACd,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;AACxD,gBAAA,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;YACrC;AAEA,YAAA,GAAG,CAAC,OAAO,CAAC,gBAAgB,EAAE,aAAa,CAAC;QAC9C,CAAC;KACF;AACH;;SCfgB,gBAAgB,GAAA;AAC9B,IAAA,MAAM,QAAQ,GAAGA,UAAM,CAAC,gBAAgB,CAAC;IAEzC,IAAI,CAAC,QAAQ,EAAE;QACb,MAAM,IAAI,KAAK,CACb,4EAA4E;AAC1E,YAAA,gEAAgE,CACnE;IACH;AAEA,IAAA,OAAO,QAAQ;AACjB;SAEgB,UAAU,GAAA;AACxB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,CAAC,SAAiB,EAAE,UAA4B,KAAI;AACzD,QAAA,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;AAC9C,IAAA,CAAC;AACH;SAEgB,WAAW,GAAA;AACzB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,CAAC,MAAc,EAAE,MAAmB,KAAI;AAC7C,QAAA,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;AACxC,IAAA,CAAC;AACH;;;;;;;"}

package/dist/vue/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Vision JavaScript Snippet
+ * Main SDK entry point
+ *
+ * @version __SESSIONVISION_VERSION__
+ */
+import { SessionVisionConfig, EventProperties, UserTraits, SessionVisionAPI } from './types';
+/**
+ * Session Vision SDK instance
+ */
+declare const sessionvision: SessionVisionAPI;
+export default sessionvision;
+export type { SessionVisionConfig, EventProperties, UserTraits };

package/dist/vue/index.esm.js

@@ -0,0 +1,38 @@
+import sessionvision from '@sessionvision/core';
+import { inject } from 'vue';
+
+const sessionVisionKey = Symbol('SessionVision');
+function createSessionVision(apiKey, options) {
+    return {
+        install(app) {
+            if (typeof window !== 'undefined' && !sessionvision.__SV) {
+                sessionvision.init(apiKey, options);
+            }
+            app.provide(sessionVisionKey, sessionvision);
+        },
+    };
+}
+
+function useSessionVision() {
+    const instance = inject(sessionVisionKey);
+    if (!instance) {
+        throw new Error('useSessionVision must be used after installing the Session Vision plugin. ' +
+            'Call app.use(createSessionVision(...)) before this composable.');
+    }
+    return instance;
+}
+function useCapture() {
+    const sessionvision = useSessionVision();
+    return (eventName, properties) => {
+        sessionvision.capture(eventName, properties);
+    };
+}
+function useIdentify() {
+    const sessionvision = useSessionVision();
+    return (userId, traits) => {
+        sessionvision.identify(userId, traits);
+    };
+}
+
+export { createSessionVision, useCapture, useIdentify, useSessionVision };
+//# sourceMappingURL=index.esm.js.map

package/dist/vue/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../src/vue/plugin.ts","../../src/vue/composables.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAIO,MAAM,gBAAgB,GAAmC,MAAM,CAAC,eAAe,CAAC;AAEjF,SAAU,mBAAmB,CACjC,MAAc,EACd,OAA8C,EAAA;IAE9C,OAAO;AACL,QAAA,OAAO,CAAC,GAAQ,EAAA;YACd,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;AACxD,gBAAA,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;YACrC;AAEA,YAAA,GAAG,CAAC,OAAO,CAAC,gBAAgB,EAAE,aAAa,CAAC;QAC9C,CAAC;KACF;AACH;;SCfgB,gBAAgB,GAAA;AAC9B,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,CAAC;IAEzC,IAAI,CAAC,QAAQ,EAAE;QACb,MAAM,IAAI,KAAK,CACb,4EAA4E;AAC1E,YAAA,gEAAgE,CACnE;IACH;AAEA,IAAA,OAAO,QAAQ;AACjB;SAEgB,UAAU,GAAA;AACxB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,CAAC,SAAiB,EAAE,UAA4B,KAAI;AACzD,QAAA,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;AAC9C,IAAA,CAAC;AACH;SAEgB,WAAW,GAAA;AACzB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,CAAC,MAAc,EAAE,MAAmB,KAAI;AAC7C,QAAA,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;AACxC,IAAA,CAAC;AACH;;;;"}

package/dist/vue/react/SessionVisionProvider.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { SessionVisionConfig } from '../types';
+export interface SessionVisionProviderProps {
+    apiKey: string;
+    options?: Omit<SessionVisionConfig, 'apiHost'>;
+    children: ReactNode;
+}
+export declare function SessionVisionProvider({ apiKey, options, children }: SessionVisionProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/vue/react/context.d.ts

@@ -0,0 +1,3 @@
+import type { SessionVisionAPI } from '../types';
+export declare const SessionVisionContext: import("react").Context<SessionVisionAPI | null>;
+export declare function useSessionVision(): SessionVisionAPI;

package/dist/vue/react/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { EventProperties, UserTraits } from '../types';
+export declare function useCapture(): (eventName: string, properties?: EventProperties) => void;
+export declare function useIdentify(): (userId: string, traits?: UserTraits) => void;

package/dist/vue/react/index.d.ts

@@ -0,0 +1,4 @@
+export { SessionVisionProvider } from './SessionVisionProvider';
+export type { SessionVisionProviderProps } from './SessionVisionProvider';
+export { SessionVisionContext, useSessionVision } from './context';
+export { useCapture, useIdentify } from './hooks';

package/dist/vue/stub.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Session Vision Inline Stub
+ *
+ * This is the minimal script that customers paste in their <head> tag.
+ * It creates the sessionvision global, queues method calls, and loads the main SDK.
+ *
+ * Target size: < 1KB minified
+ */
+export {};

package/dist/vue/transport/buffer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Event buffer module
+ * Buffers events and flushes them periodically or when buffer is full
+ */
+import { CapturedEvent, ResolvedConfig } from '../types';
+/**
+ * Set the configuration
+ */
+export declare function setBufferConfig(cfg: ResolvedConfig): void;
+/**
+ * Add an event to the buffer
+ */
+export declare function addToBuffer(event: CapturedEvent): void;
+/**
+ * Flush the event buffer
+ * Sends all buffered events to the server
+ */
+export declare function flush(): Promise<void>;
+/**
+ * Start the flush timer
+ */
+export declare function startFlushTimer(): void;
+/**
+ * Stop the flush timer
+ */
+export declare function stopFlushTimer(): void;
+/**
+ * Initialize visibility change handler for flushing on tab hide
+ */
+export declare function initVisibilityHandler(): void;
+/**
+ * Get the current buffer size
+ */
+export declare function getBufferSize(): number;
+/**
+ * Check if the buffer is full
+ */
+export declare function isBufferFull(): boolean;
+/**
+ * Clear the buffer (for testing or shutdown)
+ */
+export declare function clearBuffer(): void;
+/**
+ * Get buffer contents (for testing)
+ */
+export declare function _getBuffer(): CapturedEvent[];
+/**
+ * Reset buffer state (for testing)
+ */
+export declare function _reset(): void;

package/dist/vue/transport/compress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Payload compression module
+ * Uses CompressionStream API when available
+ */
+/**
+ * Check if compression is supported
+ */
+export declare function isCompressionSupported(): boolean;
+/**
+ * Compress a string using gzip
+ * Returns the compressed data as a Blob, or null if compression is not supported
+ */
+export declare function compressPayload(data: string): Promise<Blob | null>;
+/**
+ * Get the size of data in bytes
+ */
+export declare function getByteSize(data: string): number;
+/**
+ * Check if payload should be compressed (based on size threshold)
+ * Only compress if payload is larger than 1KB
+ */
+export declare function shouldCompress(data: string): boolean;

package/dist/vue/transport/send.d.ts

@@ -0,0 +1,30 @@
+/**
+ * HTTP transport module
+ * Handles sending events to the ingest API
+ */
+import { EventBatchPayload, ResolvedConfig } from '../types';
+/**
+ * Set the configuration
+ */
+export declare function setTransportConfig(cfg: ResolvedConfig): void;
+/**
+ * Send events to the ingest API
+ * Handles compression and retry logic
+ */
+export declare function sendEvents(payload: EventBatchPayload): Promise<boolean>;
+/**
+ * Get the number of consecutive failures
+ */
+export declare function getConsecutiveFailures(): number;
+/**
+ * Check if we should stop retrying (3+ consecutive failures)
+ */
+export declare function shouldStopRetrying(): boolean;
+/**
+ * Reset failure counter (for testing)
+ */
+export declare function _resetFailures(): void;
+/**
+ * Reset config (for testing)
+ */
+export declare function _resetConfig(): void;

package/dist/vue/types.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Session Vision Snippet Type Definitions
+ */
+/**
+ * Autocapture configuration options
+ */
+export interface AutocaptureConfig {
+    /** Capture $pageview events (default: true) */
+    pageview?: boolean;
+    /** Capture $click events (default: true) */
+    clicks?: boolean;
+    /** Capture $form_submit events (default: true) */
+    formSubmit?: boolean;
+}
+/**
+ * SDK configuration options passed to init()
+ */
+export interface SessionVisionConfig {
+    /** CDN endpoint for SDK loading (default: 'https://cdn.sessionvision.com') */
+    apiHost?: string;
+    /** API endpoint for event ingestion and config (default: 'https://app.sessionvision.com') */
+    ingestHost?: string;
+    /** SDK version to load (default: 'latest') */
+    version?: string;
+    /** Enable console logging of all events (default: false) */
+    debug?: boolean;
+    /** Disable all tracking for consent management (default: false) */
+    optOut?: boolean;
+    /** Mask all input values in recordings (default: true) */
+    maskAllInputs?: boolean;
+    /** Enable/disable auto-capture (default: true) */
+    autocapture?: boolean | AutocaptureConfig;
+}
+/**
+ * Internal resolved configuration
+ */
+export interface ResolvedConfig {
+    projectToken: string;
+    apiHost: string;
+    ingestHost: string;
+    version: string;
+    debug: boolean;
+    optOut: boolean;
+    maskAllInputs: boolean;
+    autocapture: {
+        pageview: boolean;
+        clicks: boolean;
+        formSubmit: boolean;
+    };
+}
+/**
+ * Remote configuration fetched from server
+ */
+export interface RemoteConfig {
+    recording?: {
+        enabled: boolean;
+        sampleRate: number;
+    };
+    session?: {
+        timeoutMinutes: number;
+    };
+    version?: string;
+}
+/**
+ * User traits for identify()
+ */
+export interface UserTraits {
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+/**
+ * Event properties
+ */
+export interface EventProperties {
+    [key: string]: unknown;
+}
+/**
+ * Automatic properties attached to every event
+ */
+export interface AutomaticProperties {
+    $current_url: string;
+    $referrer: string;
+    $browser: string;
+    $browser_version: string;
+    $os: string;
+    $device_type: string;
+    $screen_width: number;
+    $screen_height: number;
+    $viewport_width: number;
+    $viewport_height: number;
+    $timezone: string;
+    $locale: string;
+    $connection_type: string | null;
+    $lib_version: string;
+}
+/**
+ * Internal event structure
+ */
+export interface CapturedEvent {
+    event: string;
+    timestamp: number;
+    properties: EventProperties & Partial<AutomaticProperties>;
+    anonymousId: string;
+    userId: string | null;
+    sessionId: string;
+}
+/**
+ * Event batch payload sent to server
+ */
+export interface EventBatchPayload {
+    projectToken: string;
+    events: CapturedEvent[];
+}
+/**
+ * Click event properties
+ */
+export interface ClickEventProperties extends EventProperties {
+    $element_tag: string;
+    $element_text: string;
+    $element_classes: string;
+    $element_id: string | null;
+    $element_selector: string;
+    $element_href: string | null;
+}
+/**
+ * Form submit event properties
+ */
+export interface FormSubmitEventProperties extends EventProperties {
+    $form_id: string | null;
+    $form_action: string;
+    $form_method: string;
+    $form_name: string | null;
+}
+/**
+ * Pageview event properties
+ */
+export interface PageviewEventProperties extends EventProperties {
+    $current_url: string;
+    $referrer: string;
+    $title: string;
+}
+/**
+ * Session data stored in sessionStorage
+ */
+export interface SessionData {
+    id: string;
+    lastActivity: number;
+}
+/**
+ * Identity data stored in localStorage
+ */
+export interface IdentityData {
+    anonymousId: string;
+    userId: string | null;
+}
+/**
+ * Registered properties stored in localStorage
+ */
+export interface RegisteredProperties {
+    [key: string]: unknown;
+}
+/**
+ * Queued method call before SDK loads
+ */
+export interface QueuedCall {
+    method: string;
+    args: unknown[];
+}
+/**
+ * Public API interface
+ */
+export interface SessionVisionAPI {
+    /** Initialize the SDK with project token and config */
+    init(projectToken: string, config?: SessionVisionConfig): void;
+    /** Capture a custom event */
+    capture(eventName: string, properties?: EventProperties): void;
+    /** Identify a user */
+    identify(userId: string, traits?: UserTraits): void;
+    /** Reset identity (for logout) */
+    reset(): void;
+    /** Get the current distinct ID (userId if identified, anonymousId otherwise) */
+    getDistinctId(): string;
+    /** Register properties to be sent with every event */
+    register(properties: EventProperties): void;
+    /** Register properties only if they don't already exist */
+    registerOnce(properties: EventProperties): void;
+    /** SDK version */
+    version: string;
+    /** Internal: queued method calls before SDK loads */
+    _q?: QueuedCall[];
+    /** Internal: init calls */
+    _i?: Array<[string, SessionVisionConfig?]>;
+    /** Internal: SDK version marker */
+    __SV?: number;
+}
+/**
+ * Storage key constants
+ */
+export declare const STORAGE_KEYS: {
+    readonly ANONYMOUS_ID: "sessionvision_anonymous_id";
+    readonly USER_ID: "sessionvision_user_id";
+    readonly SESSION: "sessionvision_session";
+    readonly REGISTERED_PROPS: "sessionvision_registered";
+    readonly REGISTERED_ONCE_PROPS: "sessionvision_registered_once";
+    readonly CONFIG_CACHE: "sessionvision_config";
+};
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: Omit<ResolvedConfig, 'projectToken'>;
+/**
+ * Session timeout in milliseconds (30 minutes)
+ */
+export declare const SESSION_TIMEOUT_MS: number;
+/**
+ * Event buffer configuration
+ */
+export declare const BUFFER_CONFIG: {
+    readonly MAX_EVENTS: 10;
+    readonly FLUSH_INTERVAL_MS: 5000;
+    readonly MAX_RETRIES: 3;
+    readonly RETRY_DELAYS_MS: readonly [1000, 2000, 4000];
+};
+/**
+ * Config cache TTL in milliseconds (1 hour)
+ */
+export declare const CONFIG_CACHE_TTL_MS: number;