@teneo-protocol/sdk 1.0.0

package/dist/types/config.d.ts

@@ -0,0 +1,1047 @@
+/**
+ * Configuration schemas for Teneo Protocol SDK using Zod
+ * Provides runtime validation and TypeScript type inference
+ */
+import { z } from "zod";
+import { MessageType } from "./messages";
+import { type RetryStrategy } from "../utils/retry-policy";
+import type { SecurePrivateKey } from "../utils/secure-private-key";
+export interface Logger {
+    debug: (message: string, data?: any) => void;
+    info: (message: string, data?: any) => void;
+    warn: (message: string, data?: any) => void;
+    error: (message: string, data?: any) => void;
+}
+export declare const LoggerSchema: z.ZodType<Logger>;
+export declare const LogLevelSchema: z.ZodEnum<["debug", "info", "warn", "error", "silent"]>;
+export declare const ResponseFormatSchema: z.ZodEnum<["raw", "humanized", "both"]>;
+export declare const WebhookEventTypeSchema: z.ZodEnum<["message", "task", "task_response", "agent_selected", "error", "connection_state", "auth_state"]>;
+export declare const SDKConfigSchema: z.ZodObject<{
+    wsUrl: z.ZodEffects<z.ZodString, string, string>;
+    privateKey: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<SecurePrivateKey, z.ZodTypeDef, SecurePrivateKey>]>>;
+    walletAddress: z.ZodOptional<z.ZodString>;
+    clientType: z.ZodOptional<z.ZodEnum<["user", "agent", "coordinator"]>>;
+    clientName: z.ZodOptional<z.ZodString>;
+    autoJoinRooms: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    webhookHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    webhookRetries: z.ZodOptional<z.ZodNumber>;
+    webhookTimeout: z.ZodOptional<z.ZodNumber>;
+    webhookRetryStrategy: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["exponential", "linear", "constant"]>;
+        baseDelay: z.ZodNumber;
+        maxDelay: z.ZodNumber;
+        maxAttempts: z.ZodNumber;
+        jitter: z.ZodBoolean;
+        backoffMultiplier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }>>;
+    reconnect: z.ZodOptional<z.ZodBoolean>;
+    reconnectDelay: z.ZodOptional<z.ZodNumber>;
+    maxReconnectAttempts: z.ZodOptional<z.ZodNumber>;
+    connectionTimeout: z.ZodOptional<z.ZodNumber>;
+    reconnectStrategy: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["exponential", "linear", "constant"]>;
+        baseDelay: z.ZodNumber;
+        maxDelay: z.ZodNumber;
+        maxAttempts: z.ZodNumber;
+        jitter: z.ZodBoolean;
+        backoffMultiplier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }>>;
+    messageTimeout: z.ZodOptional<z.ZodNumber>;
+    maxMessageSize: z.ZodOptional<z.ZodNumber>;
+    maxMessagesPerSecond: z.ZodOptional<z.ZodNumber>;
+    responseFormat: z.ZodOptional<z.ZodEnum<["raw", "humanized", "both"]>>;
+    includeMetadata: z.ZodOptional<z.ZodBoolean>;
+    logLevel: z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>;
+    logger: z.ZodOptional<z.ZodType<Logger, z.ZodTypeDef, Logger>>;
+    enableCache: z.ZodOptional<z.ZodBoolean>;
+    cacheTimeout: z.ZodOptional<z.ZodNumber>;
+    maxCacheSize: z.ZodOptional<z.ZodNumber>;
+    validateSignatures: z.ZodOptional<z.ZodBoolean>;
+    trustedAgentAddresses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    requireSignaturesFor: z.ZodOptional<z.ZodArray<z.ZodEnum<["request_challenge", "challenge", "check_cached_auth", "auth", "auth_required", "auth_success", "auth_error", "register", "registration_success", "message", "task", "task_response", "agent_selected", "agents", "error", "ping", "pong", "capabilities", "subscribe", "unsubscribe", "list_rooms"]>, "many">>;
+    strictSignatureValidation: z.ZodOptional<z.ZodBoolean>;
+    allowInsecureWebhooks: z.ZodOptional<z.ZodBoolean>;
+    enableMessageDeduplication: z.ZodOptional<z.ZodBoolean>;
+    messageDedupeTtl: z.ZodOptional<z.ZodNumber>;
+    messageDedupMaxSize: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    wsUrl: string;
+    webhookUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}, {
+    wsUrl: string;
+    webhookUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}>;
+export declare const PartialSDKConfigSchema: z.ZodEffects<z.ZodObject<{
+    wsUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    privateKey: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<SecurePrivateKey, z.ZodTypeDef, SecurePrivateKey>]>>>;
+    walletAddress: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    clientType: z.ZodOptional<z.ZodOptional<z.ZodEnum<["user", "agent", "coordinator"]>>>;
+    clientName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    autoJoinRooms: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    webhookUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    webhookHeaders: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    webhookRetries: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    webhookTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    webhookRetryStrategy: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["exponential", "linear", "constant"]>;
+        baseDelay: z.ZodNumber;
+        maxDelay: z.ZodNumber;
+        maxAttempts: z.ZodNumber;
+        jitter: z.ZodBoolean;
+        backoffMultiplier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }>>>;
+    reconnect: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    reconnectDelay: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxReconnectAttempts: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    connectionTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    reconnectStrategy: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["exponential", "linear", "constant"]>;
+        baseDelay: z.ZodNumber;
+        maxDelay: z.ZodNumber;
+        maxAttempts: z.ZodNumber;
+        jitter: z.ZodBoolean;
+        backoffMultiplier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }, {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    }>>>;
+    messageTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxMessageSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxMessagesPerSecond: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    responseFormat: z.ZodOptional<z.ZodOptional<z.ZodEnum<["raw", "humanized", "both"]>>>;
+    includeMetadata: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    logLevel: z.ZodOptional<z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>>;
+    logger: z.ZodOptional<z.ZodOptional<z.ZodType<Logger, z.ZodTypeDef, Logger>>>;
+    enableCache: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    cacheTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxCacheSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    validateSignatures: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    trustedAgentAddresses: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    requireSignaturesFor: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<["request_challenge", "challenge", "check_cached_auth", "auth", "auth_required", "auth_success", "auth_error", "register", "registration_success", "message", "task", "task_response", "agent_selected", "agents", "error", "ping", "pong", "capabilities", "subscribe", "unsubscribe", "list_rooms"]>, "many">>>;
+    strictSignatureValidation: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    allowInsecureWebhooks: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    enableMessageDeduplication: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    messageDedupeTtl: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    messageDedupMaxSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    webhookUrl?: string | undefined;
+    wsUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}, {
+    webhookUrl?: string | undefined;
+    wsUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}>, {
+    webhookUrl?: string | undefined;
+    wsUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}, {
+    webhookUrl?: string | undefined;
+    wsUrl?: string | undefined;
+    privateKey?: string | SecurePrivateKey | undefined;
+    walletAddress?: string | undefined;
+    clientType?: "user" | "agent" | "coordinator" | undefined;
+    clientName?: string | undefined;
+    autoJoinRooms?: string[] | undefined;
+    webhookHeaders?: Record<string, string> | undefined;
+    webhookRetries?: number | undefined;
+    webhookTimeout?: number | undefined;
+    webhookRetryStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    reconnect?: boolean | undefined;
+    reconnectDelay?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectStrategy?: {
+        type: "exponential" | "linear" | "constant";
+        baseDelay: number;
+        maxDelay: number;
+        maxAttempts: number;
+        jitter: boolean;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+    messageTimeout?: number | undefined;
+    maxMessageSize?: number | undefined;
+    maxMessagesPerSecond?: number | undefined;
+    responseFormat?: "raw" | "humanized" | "both" | undefined;
+    includeMetadata?: boolean | undefined;
+    logLevel?: "error" | "debug" | "info" | "warn" | "silent" | undefined;
+    logger?: Logger | undefined;
+    enableCache?: boolean | undefined;
+    cacheTimeout?: number | undefined;
+    maxCacheSize?: number | undefined;
+    validateSignatures?: boolean | undefined;
+    trustedAgentAddresses?: string[] | undefined;
+    requireSignaturesFor?: ("message" | "request_challenge" | "challenge" | "check_cached_auth" | "auth" | "auth_required" | "auth_success" | "auth_error" | "register" | "registration_success" | "task" | "task_response" | "agent_selected" | "agents" | "error" | "ping" | "pong" | "capabilities" | "subscribe" | "unsubscribe" | "list_rooms")[] | undefined;
+    strictSignatureValidation?: boolean | undefined;
+    allowInsecureWebhooks?: boolean | undefined;
+    enableMessageDeduplication?: boolean | undefined;
+    messageDedupeTtl?: number | undefined;
+    messageDedupMaxSize?: number | undefined;
+}>;
+export declare const ConnectionStateSchema: z.ZodObject<{
+    connected: z.ZodBoolean;
+    authenticated: z.ZodBoolean;
+    reconnecting: z.ZodBoolean;
+    reconnectAttempts: z.ZodNumber;
+    lastError: z.ZodOptional<z.ZodType<Error, z.ZodTypeDef, Error>>;
+    lastConnectedAt: z.ZodOptional<z.ZodDate>;
+    lastDisconnectedAt: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    connected: boolean;
+    authenticated: boolean;
+    reconnecting: boolean;
+    reconnectAttempts: number;
+    lastError?: Error | undefined;
+    lastConnectedAt?: Date | undefined;
+    lastDisconnectedAt?: Date | undefined;
+}, {
+    connected: boolean;
+    authenticated: boolean;
+    reconnecting: boolean;
+    reconnectAttempts: number;
+    lastError?: Error | undefined;
+    lastConnectedAt?: Date | undefined;
+    lastDisconnectedAt?: Date | undefined;
+}>;
+export declare const AuthenticationStateSchema: z.ZodObject<{
+    authenticated: z.ZodBoolean;
+    clientId: z.ZodOptional<z.ZodString>;
+    walletAddress: z.ZodOptional<z.ZodString>;
+    isWhitelisted: z.ZodOptional<z.ZodBoolean>;
+    isAdmin: z.ZodOptional<z.ZodBoolean>;
+    nftVerified: z.ZodOptional<z.ZodBoolean>;
+    rooms: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    roomObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        is_public: z.ZodPipeline<z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodString, boolean, string>]>, z.ZodBoolean>;
+        is_active: z.ZodPipeline<z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodString, boolean, string>]>, z.ZodBoolean>;
+        created_by: z.ZodString;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        is_public: boolean;
+        is_active: boolean;
+        created_by: string;
+        created_at: string;
+        updated_at: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        id: string;
+        is_public: string | boolean;
+        is_active: string | boolean;
+        created_by: string;
+        created_at: string;
+        updated_at: string;
+        description?: string | undefined;
+    }>, "many">>;
+    privateRoomId: z.ZodOptional<z.ZodString>;
+    challenge: z.ZodOptional<z.ZodString>;
+    challengeTimestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    authenticated: boolean;
+    challenge?: string | undefined;
+    rooms?: string[] | undefined;
+    walletAddress?: string | undefined;
+    clientId?: string | undefined;
+    isWhitelisted?: boolean | undefined;
+    isAdmin?: boolean | undefined;
+    nftVerified?: boolean | undefined;
+    roomObjects?: {
+        name: string;
+        id: string;
+        is_public: boolean;
+        is_active: boolean;
+        created_by: string;
+        created_at: string;
+        updated_at: string;
+        description?: string | undefined;
+    }[] | undefined;
+    privateRoomId?: string | undefined;
+    challengeTimestamp?: number | undefined;
+}, {
+    authenticated: boolean;
+    challenge?: string | undefined;
+    rooms?: string[] | undefined;
+    walletAddress?: string | undefined;
+    clientId?: string | undefined;
+    isWhitelisted?: boolean | undefined;
+    isAdmin?: boolean | undefined;
+    nftVerified?: boolean | undefined;
+    roomObjects?: {
+        name: string;
+        id: string;
+        is_public: string | boolean;
+        is_active: string | boolean;
+        created_by: string;
+        created_at: string;
+        updated_at: string;
+        description?: string | undefined;
+    }[] | undefined;
+    privateRoomId?: string | undefined;
+    challengeTimestamp?: number | undefined;
+}>;
+export declare const WebhookConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<["message", "task", "task_response", "agent_selected", "error", "connection_state", "auth_state"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    headers?: Record<string, string> | undefined;
+    retries?: number | undefined;
+    timeout?: number | undefined;
+    events?: ("message" | "task" | "task_response" | "agent_selected" | "error" | "connection_state" | "auth_state")[] | undefined;
+}, {
+    url: string;
+    headers?: Record<string, string> | undefined;
+    retries?: number | undefined;
+    timeout?: number | undefined;
+    events?: ("message" | "task" | "task_response" | "agent_selected" | "error" | "connection_state" | "auth_state")[] | undefined;
+}>;
+export declare const WebhookPayloadSchema: z.ZodObject<{
+    event: z.ZodEnum<["message", "task", "task_response", "agent_selected", "error", "connection_state", "auth_state"]>;
+    timestamp: z.ZodString;
+    data: z.ZodAny;
+    metadata: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        roomId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        clientId?: string | undefined;
+        roomId?: string | undefined;
+        agentId?: string | undefined;
+        taskId?: string | undefined;
+    }, {
+        clientId?: string | undefined;
+        roomId?: string | undefined;
+        agentId?: string | undefined;
+        taskId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    event: "message" | "task" | "task_response" | "agent_selected" | "error" | "connection_state" | "auth_state";
+    data?: any;
+    metadata?: {
+        clientId?: string | undefined;
+        roomId?: string | undefined;
+        agentId?: string | undefined;
+        taskId?: string | undefined;
+    } | undefined;
+}, {
+    timestamp: string;
+    event: "message" | "task" | "task_response" | "agent_selected" | "error" | "connection_state" | "auth_state";
+    data?: any;
+    metadata?: {
+        clientId?: string | undefined;
+        roomId?: string | undefined;
+        agentId?: string | undefined;
+        taskId?: string | undefined;
+    } | undefined;
+}>;
+export type LogLevel = z.infer<typeof LogLevelSchema>;
+export type ResponseFormat = z.infer<typeof ResponseFormatSchema>;
+export type WebhookEventType = z.infer<typeof WebhookEventTypeSchema>;
+export type SDKConfig = z.infer<typeof SDKConfigSchema>;
+export type PartialSDKConfig = z.infer<typeof PartialSDKConfigSchema>;
+export type ConnectionState = z.infer<typeof ConnectionStateSchema>;
+export type AuthenticationState = z.infer<typeof AuthenticationStateSchema>;
+export type WebhookConfig = z.infer<typeof WebhookConfigSchema>;
+export type WebhookPayload = z.infer<typeof WebhookPayloadSchema>;
+export type { RetryStrategy };
+export declare const DEFAULT_CONFIG: PartialSDKConfig;
+export declare function validateConfig(config: unknown): SDKConfig;
+export declare function safeParseConfig(config: unknown): {
+    success: boolean;
+    data?: SDKConfig;
+    error?: z.ZodError | Error;
+};
+/**
+ * Fluent API builder for creating Teneo SDK configurations with validation.
+ * Provides a chainable interface for configuring the SDK with runtime validation
+ * at each step. Call `.build()` to create the final validated configuration.
+ *
+ * This is the recommended way to configure the SDK for complex setups, as it provides
+ * better IDE intellisense, method chaining, and validates each configuration option
+ * as you set it.
+ *
+ * @example
+ * ```typescript
+ * // Basic configuration
+ * const config = new SDKConfigBuilder()
+ *   .withWebSocketUrl('wss://teneo.example.com')
+ *   .withAuthentication('0x...')
+ *   .build();
+ *
+ * const sdk = new TeneoSDK(config);
+ *
+ * // Full configuration with all options
+ * const config = new SDKConfigBuilder()
+ *   .withWebSocketUrl('wss://teneo.example.com')
+ *   .withAuthentication('0x...', '0xYourWalletAddress')
+ *   .withAutoJoinRooms(['general', 'announcements'])
+ *   .withWebhook('https://api.example.com/webhooks', {
+ *     'Authorization': 'Bearer token'
+ *   })
+ *   .withReconnection(true, 5000, 10)
+ *   .withResponseFormat({ format: 'both', includeMetadata: true })
+ *   .withLogging('debug')
+ *   .withCache(true, 300000, 100)
+ *   .build();
+ *
+ * const sdk = new TeneoSDK(config);
+ *
+ * // Using via TeneoSDK.builder() (recommended)
+ * const sdk = TeneoSDK.builder()
+ *   .withWebSocketUrl('wss://teneo.example.com')
+ *   .withAuthentication('0x...')
+ *   .withAutoJoinRooms(['general'])
+ *   .build();
+ * ```
+ *
+ * @see {@link TeneoSDK} for the main SDK class
+ * @see {@link TeneoSDK.builder} for creating a builder instance
+ */
+export declare class SDKConfigBuilder {
+    private config;
+    /**
+     * Sets the WebSocket URL for connecting to the Teneo network.
+     * URL must start with 'ws://' or 'wss://'. HTTPS (wss://) is recommended for production.
+     *
+     * @param url - WebSocket URL (e.g., 'wss://teneo.example.com')
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If URL is invalid or doesn't start with ws:// or wss://
+     *
+     * @example
+     * ```typescript
+     * builder.withWebSocketUrl('wss://teneo.example.com')
+     * ```
+     */
+    withWebSocketUrl(url: string): this;
+    /**
+     * Configures Ethereum wallet-based authentication credentials.
+     * Private key is used to sign authentication challenges from the server.
+     * Wallet address is optional and will be derived from the private key if not provided.
+     *
+     * For enhanced security (SEC-3), you can pass a SecurePrivateKey instance to keep
+     * the private key encrypted in memory from the start.
+     *
+     * @param privateKey - Ethereum private key (hex string starting with 0x) or SecurePrivateKey instance
+     * @param walletAddress - Optional wallet address (will be derived if not provided)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If privateKey or walletAddress is invalid
+     *
+     * @example
+     * ```typescript
+     * // With private key string only (address derived automatically)
+     * builder.withAuthentication('0x...')
+     *
+     * // With explicit wallet address
+     * builder.withAuthentication('0x...privatekey', '0x...address')
+     *
+     * // With SecurePrivateKey for enhanced security (SEC-3)
+     * const secureKey = new SecurePrivateKey('0x...');
+     * builder.withAuthentication(secureKey, '0x...address')
+     * ```
+     */
+    withAuthentication(privateKey: string | SecurePrivateKey, walletAddress?: string): this;
+    /**
+     * Configures webhook URL and optional HTTP headers for receiving real-time event notifications.
+     * Webhook URL must use HTTPS for non-localhost endpoints (security requirement).
+     * Events are sent via HTTP POST requests with JSON payloads.
+     *
+     * @param url - Webhook endpoint URL (must be HTTPS unless localhost)
+     * @param headers - Optional HTTP headers to include with webhook requests (e.g., Authorization)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If URL is invalid
+     *
+     * @example
+     * ```typescript
+     * // Basic webhook
+     * builder.withWebhook('https://api.example.com/webhooks/teneo')
+     *
+     * // With authentication headers
+     * builder.withWebhook('https://api.example.com/webhooks', {
+     *   'Authorization': 'Bearer your-token',
+     *   'X-Custom-Header': 'value'
+     * })
+     * ```
+     */
+    withWebhook(url: string, headers?: Record<string, string>): this;
+    /**
+     * Configures rooms to automatically subscribe to after authentication.
+     * These rooms will be subscribed to automatically when connection is established.
+     *
+     * @param rooms - Array of room IDs to auto-subscribe to on connection
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If room IDs are invalid
+     *
+     * @example
+     * ```typescript
+     * builder.withAutoJoinRooms(['general', 'announcements', 'support'])
+     * ```
+     */
+    withAutoJoinRooms(rooms: string[]): this;
+    /**
+     * Configures automatic reconnection behavior for WebSocket connections.
+     * When enabled, SDK will automatically attempt to reconnect on disconnection.
+     * Uses exponential backoff strategy for reconnection attempts.
+     *
+     * @param optionsOrEnabled - Reconnection configuration options object, or boolean for backwards compatibility
+     * @param delay - (Deprecated positional arg) Delay between reconnection attempts in ms
+     * @param maxAttempts - (Deprecated positional arg) Maximum reconnection attempts
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If options are out of valid range
+     *
+     * @example
+     * ```typescript
+     * // New API with object (recommended)
+     * builder.withReconnection({ enabled: true })
+     * builder.withReconnection({
+     *   enabled: true,
+     *   delay: 3000,
+     *   maxAttempts: 5
+     * })
+     *
+     * // Old API with positional args (backwards compatible)
+     * builder.withReconnection(true, 3000, 5)
+     * ```
+     */
+    withReconnection(optionsOrEnabled: {
+        enabled?: boolean;
+        delay?: number;
+        maxAttempts?: number;
+    } | boolean, delay?: number, maxAttempts?: number): this;
+    /**
+     * Configures how agent responses are formatted when received.
+     * Choose between raw JSON, human-readable text, or both formats.
+     * Metadata includes timestamps, agent info, and other contextual data.
+     *
+     * @param optionsOrFormat - Response format configuration object, or format string for backwards compatibility
+     * @param includeMetadata - (Deprecated positional arg) Include metadata in responses
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If format is invalid
+     *
+     * @example
+     * ```typescript
+     * // New API with object (recommended)
+     * builder.withResponseFormat({ format: 'humanized' })
+     * builder.withResponseFormat({
+     *   format: 'both',
+     *   includeMetadata: true
+     * })
+     *
+     * // Old API with positional args (backwards compatible)
+     * builder.withResponseFormat('humanized', true)
+     * ```
+     */
+    withResponseFormat(optionsOrFormat: {
+        format?: ResponseFormat;
+        includeMetadata?: boolean;
+    } | ResponseFormat, includeMetadata?: boolean): this;
+    /**
+     * Configures logging level and optionally provides a custom logger implementation.
+     * Default logger uses pino with pretty printing in development and JSON in production.
+     * Custom logger must implement the Logger interface (debug, info, warn, error methods).
+     *
+     * @param level - Log level: 'debug', 'info', 'warn', 'error', or 'silent' (default: 'info')
+     * @param logger - Optional custom logger implementation
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If level is invalid or logger doesn't implement required interface
+     *
+     * @example
+     * ```typescript
+     * // Set log level only (uses default pino logger)
+     * builder.withLogging('debug')
+     *
+     * // With custom logger
+     * const customLogger = {
+     *   debug: (msg, data) => console.debug(msg, data),
+     *   info: (msg, data) => console.info(msg, data),
+     *   warn: (msg, data) => console.warn(msg, data),
+     *   error: (msg, data) => console.error(msg, data)
+     * };
+     * builder.withLogging('info', customLogger)
+     *
+     * // Silent mode (no logs)
+     * builder.withLogging('silent')
+     * ```
+     */
+    withLogging(level: LogLevel, logger?: Logger): this;
+    /**
+     * Configures agent caching for improved performance.
+     * Cache stores agent information to reduce lookup overhead.
+     * Automatically invalidates stale entries based on timeout.
+     *
+     * @param enabled - Enable/disable agent caching (default: true)
+     * @param timeout - Cache entry timeout in ms (default: 300000 / 5 minutes, range: 1000-3600000)
+     * @param maxSize - Maximum cache size (default: 100, range: 1-10000)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If timeout or maxSize are out of valid range
+     *
+     * @example
+     * ```typescript
+     * // Enable with defaults
+     * builder.withCache(true)
+     *
+     * // Custom cache settings
+     * builder.withCache(true, 600000, 500)  // 10 minutes, 500 entries
+     *
+     * // Disable caching
+     * builder.withCache(false)
+     * ```
+     */
+    withCache(enabled: boolean, timeout?: number, maxSize?: number): this;
+    /**
+     * Configures message signature verification for security (SEC-2).
+     * Verifies Ethereum ECDSA signatures on incoming messages to prevent spoofing attacks.
+     * Disabled by default for backwards compatibility.
+     *
+     * @param options - Signature verification configuration
+     * @param options.enabled - Enable/disable signature verification (default: false)
+     * @param options.trustedAddresses - Whitelist of trusted agent addresses (empty = allow all)
+     * @param options.requireFor - Message types that require signatures (default: ['task_response', 'agent_selected'])
+     * @param options.strictMode - Reject all unsigned messages vs just critical ones (default: false)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If options are invalid
+     *
+     * @example
+     * ```typescript
+     * // Enable with defaults (verify but allow unsigned non-critical messages)
+     * builder.withSignatureVerification({ enabled: true })
+     *
+     * // Enable with trusted address whitelist
+     * builder.withSignatureVerification({
+     *   enabled: true,
+     *   trustedAddresses: ['0xAgent1...', '0xAgent2...']
+     * })
+     *
+     * // Strict mode (reject all unsigned messages)
+     * builder.withSignatureVerification({
+     *   enabled: true,
+     *   strictMode: true,
+     *   requireFor: ['task_response', 'agent_selected', 'message']
+     * })
+     * ```
+     */
+    withSignatureVerification(options: {
+        enabled?: boolean;
+        trustedAddresses?: string[];
+        requireFor?: MessageType[];
+        strictMode?: boolean;
+    }): this;
+    /**
+     * Configures WebSocket reconnection retry strategy (REL-3).
+     * Allows full control over retry behavior: exponential, linear, or constant backoff.
+     * If not specified, uses exponential backoff with default parameters for backward compatibility.
+     *
+     * @param strategy - Partial retry strategy configuration (unspecified fields use defaults)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If strategy parameters are invalid
+     *
+     * @example
+     * ```typescript
+     * // Exponential backoff with aggressive multiplier
+     * builder.withReconnectionStrategy({
+     *   type: 'exponential',
+     *   baseDelay: 3000,
+     *   maxDelay: 120000,
+     *   maxAttempts: 20,
+     *   jitter: true,
+     *   backoffMultiplier: 3
+     * })
+     *
+     * // Linear backoff for predictable delays
+     * builder.withReconnectionStrategy({
+     *   type: 'linear',
+     *   baseDelay: 5000,
+     *   maxDelay: 60000,
+     *   maxAttempts: 10,
+     *   jitter: false
+     * })
+     *
+     * // Constant delay (useful for testing)
+     * builder.withReconnectionStrategy({
+     *   type: 'constant',
+     *   baseDelay: 10000,
+     *   maxDelay: 10000,
+     *   maxAttempts: 5,
+     *   jitter: false
+     * })
+     * ```
+     */
+    withReconnectionStrategy(strategy: Partial<RetryStrategy>): this;
+    /**
+     * Configures webhook delivery retry strategy (REL-3).
+     * Allows full control over retry behavior: exponential, linear, or constant backoff.
+     * If not specified, uses exponential backoff with default parameters for backward compatibility.
+     *
+     * @param strategy - Partial retry strategy configuration (unspecified fields use defaults)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If strategy parameters are invalid
+     *
+     * @example
+     * ```typescript
+     * // Exponential backoff without jitter
+     * builder.withWebhookRetryStrategy({
+     *   type: 'exponential',
+     *   baseDelay: 1000,
+     *   maxDelay: 30000,
+     *   maxAttempts: 5,
+     *   jitter: false,
+     *   backoffMultiplier: 2
+     * })
+     *
+     * // Linear backoff with jitter to spread load
+     * builder.withWebhookRetryStrategy({
+     *   type: 'linear',
+     *   baseDelay: 2000,
+     *   maxDelay: 20000,
+     *   maxAttempts: 3,
+     *   jitter: true
+     * })
+     * ```
+     */
+    withWebhookRetryStrategy(strategy: Partial<RetryStrategy>): this;
+    /**
+     * Configures message deduplication to prevent duplicate processing (CB-4).
+     * Uses TTL-based cache to track recently processed message IDs.
+     * Automatically expires entries to prevent unbounded memory growth.
+     * Enabled by default with sensible limits for most use cases.
+     *
+     * @param enabled - Enable/disable message deduplication (default: true)
+     * @param ttl - How long to remember message IDs in milliseconds (default: 60000 / 1 minute, range: 1000-3600000)
+     * @param maxSize - Maximum cache size (default: 10000, range: 1-100000)
+     * @returns this builder for method chaining
+     * @throws {z.ZodError} If ttl or maxSize are out of valid range
+     *
+     * @example
+     * ```typescript
+     * // Enable with defaults (60s TTL, 10k cache)
+     * builder.withMessageDeduplication(true)
+     *
+     * // Custom settings for high-volume scenarios
+     * builder.withMessageDeduplication(true, 120000, 50000)  // 2 minutes, 50k entries
+     *
+     * // Disable deduplication (not recommended for production)
+     * builder.withMessageDeduplication(false)
+     * ```
+     */
+    withMessageDeduplication(enabled: boolean, ttl?: number, maxSize?: number): this;
+    /**
+     * Builds and validates the final SDK configuration.
+     * Performs comprehensive validation including custom refinements (e.g., webhook security).
+     * Must be called after setting all desired configuration options.
+     *
+     * @returns Validated SDK configuration ready to pass to TeneoSDK constructor
+     * @throws {Error} If configuration is invalid or fails validation
+     * @throws {z.ZodError} If required fields are missing or values are out of range
+     *
+     * @example
+     * ```typescript
+     * const config = new SDKConfigBuilder()
+     *   .withWebSocketUrl('wss://teneo.example.com')
+     *   .withAuthentication('0x...')
+     *   .withAutoJoinRooms(['general'])
+     *   .build();  // Validates and returns final config
+     *
+     * const sdk = new TeneoSDK(config);
+     * ```
+     */
+    build(): SDKConfig;
+}
+//# sourceMappingURL=config.d.ts.map