@bernierllc/chat-suite 1.0.0

package/dist/utils/config-inheritance.js

@@ -0,0 +1,167 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SUITE_CONFIG = void 0;
+exports.mergeConfigs = mergeConfigs;
+exports.validateConfig = validateConfig;
+exports.getActiveProviders = getActiveProviders;
+/**
+ * Default provider configuration
+ */
+const DEFAULT_PROVIDER_CONFIG = {
+    enabled: false,
+    priority: 999,
+    config: {}
+};
+/**
+ * Default chat suite configuration
+ */
+exports.DEFAULT_SUITE_CONFIG = {
+    enabled: true,
+    providers: {
+        chatkit: {
+            enabled: true,
+            priority: 1,
+            config: {
+                serviceName: 'chatkit-adapter',
+                features: ['streaming', 'attachments', 'threads']
+            }
+        }
+    },
+    aiRouting: {
+        enabled: true,
+        serviceName: 'chat-ai-router',
+        fallbackToHuman: true,
+        intentThreshold: 0.8
+    },
+    analytics: {
+        enabled: true,
+        serviceName: 'chat-analytics',
+        metricsInterval: 60000
+    },
+    neverhub: {
+        enabled: true,
+        serviceName: 'chat-suite',
+        capabilities: [
+            { type: 'chat', name: 'multi-provider-chat', version: '1.0.0' },
+            { type: 'orchestration', name: 'chat-orchestration', version: '1.0.0' },
+            { type: 'ai', name: 'intelligent-routing', version: '1.0.0' }
+        ],
+        dependencies: ['chat-provider-*', 'chat-ai-router', 'chat-analytics']
+    }
+};
+/**
+ * Merge configurations with inheritance
+ */
+function mergeConfigs(baseConfig, overrideConfig) {
+    return {
+        enabled: overrideConfig.enabled ?? baseConfig.enabled,
+        providers: mergeProviderConfigs(baseConfig.providers, overrideConfig.providers),
+        aiRouting: overrideConfig.aiRouting ? {
+            ...baseConfig.aiRouting,
+            ...overrideConfig.aiRouting
+        } : baseConfig.aiRouting,
+        analytics: overrideConfig.analytics ? {
+            ...baseConfig.analytics,
+            ...overrideConfig.analytics
+        } : baseConfig.analytics,
+        neverhub: overrideConfig.neverhub ? {
+            ...baseConfig.neverhub,
+            ...overrideConfig.neverhub
+        } : baseConfig.neverhub,
+        messageBridge: overrideConfig.messageBridge ?? baseConfig.messageBridge
+    };
+}
+/**
+ * Merge provider configurations
+ */
+function mergeProviderConfigs(baseProviders, overrideProviders) {
+    if (!overrideProviders) {
+        return baseProviders;
+    }
+    return {
+        chatkit: mergeProviderConfig(baseProviders.chatkit, overrideProviders.chatkit),
+        slack: mergeProviderConfig(baseProviders.slack, overrideProviders.slack),
+        discord: mergeProviderConfig(baseProviders.discord, overrideProviders.discord),
+        teams: mergeProviderConfig(baseProviders.teams, overrideProviders.teams)
+    };
+}
+/**
+ * Merge individual provider configuration
+ */
+function mergeProviderConfig(base, override) {
+    if (!override && !base) {
+        return undefined;
+    }
+    const baseConfig = base || DEFAULT_PROVIDER_CONFIG;
+    if (!override) {
+        return baseConfig;
+    }
+    return {
+        enabled: override.enabled ?? baseConfig.enabled,
+        priority: override.priority ?? baseConfig.priority,
+        config: {
+            ...baseConfig.config,
+            ...override.config
+        }
+    };
+}
+/**
+ * Validate configuration
+ */
+function validateConfig(config) {
+    const errors = [];
+    // Check that at least one provider is enabled
+    const enabledProviders = Object.values(config.providers).filter(p => p?.enabled);
+    if (enabledProviders.length === 0) {
+        errors.push('At least one provider must be enabled');
+    }
+    // Validate AI routing config
+    if (config.aiRouting?.enabled) {
+        if (!config.aiRouting.serviceName) {
+            errors.push('AI routing service name is required when AI routing is enabled');
+        }
+        if (config.aiRouting.intentThreshold !== undefined &&
+            (config.aiRouting.intentThreshold < 0 || config.aiRouting.intentThreshold > 1)) {
+            errors.push('AI routing intent threshold must be between 0 and 1');
+        }
+    }
+    // Validate analytics config
+    if (config.analytics?.enabled && !config.analytics.serviceName) {
+        errors.push('Analytics service name is required when analytics is enabled');
+    }
+    // Validate NeverHub config
+    if (config.neverhub?.enabled) {
+        if (!config.neverhub.serviceName) {
+            errors.push('NeverHub service name is required when NeverHub is enabled');
+        }
+        if (!config.neverhub.capabilities || config.neverhub.capabilities.length === 0) {
+            errors.push('NeverHub capabilities are required when NeverHub is enabled');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Get active providers from configuration
+ */
+function getActiveProviders(config) {
+    const providers = [];
+    Object.entries(config.providers).forEach(([name, providerConfig]) => {
+        if (providerConfig?.enabled) {
+            providers.push({
+                name,
+                priority: providerConfig.priority
+            });
+        }
+    });
+    return providers.sort((a, b) => a.priority - b.priority);
+}

package/dist/utils/error-handling.d.ts

@@ -0,0 +1,37 @@
+import type { SuiteResult } from '../types';
+/**
+ * Chat suite error types
+ */
+export declare enum ChatSuiteErrorType {
+    PROVIDER_ERROR = "PROVIDER_ERROR",
+    ROUTING_ERROR = "ROUTING_ERROR",
+    CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
+    INITIALIZATION_ERROR = "INITIALIZATION_ERROR",
+    MESSAGE_ERROR = "MESSAGE_ERROR",
+    NEVERHUB_ERROR = "NEVERHUB_ERROR"
+}
+/**
+ * Custom error class for chat suite errors
+ */
+export declare class ChatSuiteError extends Error {
+    type: ChatSuiteErrorType;
+    originalError?: Error | undefined;
+    constructor(type: ChatSuiteErrorType, message: string, originalError?: Error | undefined);
+}
+/**
+ * Safely execute an async operation and return a SuiteResult
+ */
+export declare function safeExecute<T>(operation: () => Promise<T>, errorType?: ChatSuiteErrorType): Promise<SuiteResult<T>>;
+/**
+ * Retry an operation with exponential backoff
+ */
+export declare function retryOperation<T>(operation: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;
+/**
+ * Create a standardized error message
+ */
+export declare function formatError(context: string, error: unknown): string;
+/**
+ * Check if an error is retryable
+ */
+export declare function isRetryableError(error: unknown): boolean;
+//# sourceMappingURL=error-handling.d.ts.map

package/dist/utils/error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["../../src/utils/error-handling.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;IAC/B,mBAAmB,wBAAwB;IAC3C,oBAAoB,yBAAyB;IAC7C,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;CAClC;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAE9B,IAAI,EAAE,kBAAkB;IAExB,aAAa,CAAC,EAAE,KAAK;gBAFrB,IAAI,EAAE,kBAAkB,EAC/B,OAAO,EAAE,MAAM,EACR,aAAa,CAAC,EAAE,KAAK,YAAA;CAM/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,SAAS,GAAE,kBAAqD,GAC/D,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAWzB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAa,GACvB,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,GACb,MAAM,CAQR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYxD"}

package/dist/utils/error-handling.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSuiteError = exports.ChatSuiteErrorType = void 0;
+exports.safeExecute = safeExecute;
+exports.retryOperation = retryOperation;
+exports.formatError = formatError;
+exports.isRetryableError = isRetryableError;
+/**
+ * Chat suite error types
+ */
+var ChatSuiteErrorType;
+(function (ChatSuiteErrorType) {
+    ChatSuiteErrorType["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+    ChatSuiteErrorType["ROUTING_ERROR"] = "ROUTING_ERROR";
+    ChatSuiteErrorType["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+    ChatSuiteErrorType["INITIALIZATION_ERROR"] = "INITIALIZATION_ERROR";
+    ChatSuiteErrorType["MESSAGE_ERROR"] = "MESSAGE_ERROR";
+    ChatSuiteErrorType["NEVERHUB_ERROR"] = "NEVERHUB_ERROR";
+})(ChatSuiteErrorType || (exports.ChatSuiteErrorType = ChatSuiteErrorType = {}));
+/**
+ * Custom error class for chat suite errors
+ */
+class ChatSuiteError extends Error {
+    constructor(type, message, originalError) {
+        super(message);
+        this.type = type;
+        this.originalError = originalError;
+        this.name = 'ChatSuiteError';
+        Object.setPrototypeOf(this, ChatSuiteError.prototype);
+    }
+}
+exports.ChatSuiteError = ChatSuiteError;
+/**
+ * Safely execute an async operation and return a SuiteResult
+ */
+async function safeExecute(operation, errorType = ChatSuiteErrorType.MESSAGE_ERROR) {
+    try {
+        const data = await operation();
+        return { success: true, data };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        return {
+            success: false,
+            error: `${errorType}: ${errorMessage}`
+        };
+    }
+}
+/**
+ * Retry an operation with exponential backoff
+ */
+async function retryOperation(operation, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error('Unknown error');
+            if (attempt < maxRetries) {
+                const delay = baseDelay * Math.pow(2, attempt);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError || new Error('Operation failed after retries');
+}
+/**
+ * Create a standardized error message
+ */
+function formatError(context, error) {
+    if (error instanceof ChatSuiteError) {
+        return `[${context}] ${error.type}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `[${context}] ${error.message}`;
+    }
+    return `[${context}] Unknown error: ${String(error)}`;
+}
+/**
+ * Check if an error is retryable
+ */
+function isRetryableError(error) {
+    if (error instanceof ChatSuiteError) {
+        return error.type === ChatSuiteErrorType.PROVIDER_ERROR ||
+            error.type === ChatSuiteErrorType.MESSAGE_ERROR;
+    }
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        return message.includes('timeout') ||
+            message.includes('network') ||
+            message.includes('unavailable');
+    }
+    return false;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './error-handling';
+export * from './config-inheritance';
+export * from './user-mapping';
+export * from './message-bridge';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAQA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error-handling"), exports);
+__exportStar(require("./config-inheritance"), exports);
+__exportStar(require("./user-mapping"), exports);
+__exportStar(require("./message-bridge"), exports);

package/dist/utils/message-bridge.d.ts

@@ -0,0 +1,68 @@
+import type { ProviderType, ProviderMessage, MessageBridgeConfig } from '../types';
+/**
+ * Bridged message information
+ */
+export interface BridgedMessage {
+    originalMessageId: string;
+    sourceProvider: ProviderType;
+    targetProvider: ProviderType;
+    targetMessageId?: string;
+    timestamp: Date;
+}
+/**
+ * Message bridge for cross-platform synchronization
+ */
+export declare class MessageBridge {
+    private config;
+    private bridgedMessages;
+    private channelMappings;
+    constructor(config: MessageBridgeConfig);
+    /**
+     * Check if message should be bridged
+     */
+    shouldBridge(sourceProvider: ProviderType, targetProvider: ProviderType): boolean;
+    /**
+     * Transform message for target provider
+     */
+    transformMessage(message: ProviderMessage, sourceProvider: ProviderType, targetProvider: ProviderType): ProviderMessage;
+    /**
+     * Record a bridged message
+     */
+    recordBridgedMessage(bridgedMessage: BridgedMessage): void;
+    /**
+     * Get all bridges for a message
+     */
+    getBridges(originalMessageId: string): BridgedMessage[];
+    /**
+     * Add channel mapping
+     */
+    addChannelMapping(sourceChannel: string, targetChannel: string): void;
+    /**
+     * Get mapped channel
+     */
+    getMappedChannel(sourceChannel: string, _sourceProvider: ProviderType, _targetProvider: ProviderType): string | undefined;
+    /**
+     * Check if reactions should be synced
+     */
+    shouldSyncReactions(): boolean;
+    /**
+     * Check if edits should be synced
+     */
+    shouldSyncEdits(): boolean;
+    /**
+     * Check if deletions should be synced
+     */
+    shouldSyncDeletions(): boolean;
+    /**
+     * Clear all bridged message records
+     */
+    clear(): void;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalBridged: number;
+        bridgesByProvider: Map<ProviderType, number>;
+    };
+}
+//# sourceMappingURL=message-bridge.d.ts.map

package/dist/utils/message-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-bridge.d.ts","sourceRoot":"","sources":["../../src/utils/message-bridge.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,YAAY,CAAC;IAC7B,cAAc,EAAE,YAAY,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,aAAa;IAIZ,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAAkC;gBAErC,MAAM,EAAE,mBAAmB;IAM/C;;OAEG;IACI,YAAY,CAAC,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,GAAG,OAAO;IASxF;;OAEG;IACI,gBAAgB,CACrB,OAAO,EAAE,eAAe,EACxB,cAAc,EAAE,YAAY,EAC5B,cAAc,EAAE,YAAY,GAC3B,eAAe;IAyBlB;;OAEG;IACI,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAMjE;;OAEG;IACI,UAAU,CAAC,iBAAiB,EAAE,MAAM,GAAG,cAAc,EAAE;IAI9D;;OAEG;IACI,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAI5E;;OAEG;IACI,gBAAgB,CACrB,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,YAAY,GAC5B,MAAM,GAAG,SAAS;IAIrB;;OAEG;IACI,mBAAmB,IAAI,OAAO;IAIrC;;OAEG;IACI,eAAe,IAAI,OAAO;IAIjC;;OAEG;IACI,mBAAmB,IAAI,OAAO;IAIrC;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;OAEG;IACI,QAAQ,IAAI;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;KAC9C;CAiBF"}

package/dist/utils/message-bridge.js

@@ -0,0 +1,126 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBridge = void 0;
+/**
+ * Message bridge for cross-platform synchronization
+ */
+class MessageBridge {
+    constructor(config) {
+        this.config = config;
+        this.bridgedMessages = new Map();
+        this.channelMappings = new Map();
+        if (config.channelMappings) {
+            this.channelMappings = config.channelMappings;
+        }
+    }
+    /**
+     * Check if message should be bridged
+     */
+    shouldBridge(sourceProvider, targetProvider) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        return this.config.sourceProviders.includes(sourceProvider) &&
+            this.config.targetProviders.includes(targetProvider);
+    }
+    /**
+     * Transform message for target provider
+     */
+    transformMessage(message, sourceProvider, targetProvider) {
+        const transformed = {
+            ...message,
+            metadata: {
+                ...message.metadata,
+                bridged: true,
+                sourceProvider,
+                originalContent: message.content
+            }
+        };
+        // Map channel if mapping exists
+        if (message.channelId) {
+            const mappedChannel = this.getMappedChannel(message.channelId, sourceProvider, targetProvider);
+            if (mappedChannel) {
+                transformed.channelId = mappedChannel;
+            }
+        }
+        // Add source provider prefix to content
+        transformed.content = `[From ${sourceProvider}] ${message.content}`;
+        return transformed;
+    }
+    /**
+     * Record a bridged message
+     */
+    recordBridgedMessage(bridgedMessage) {
+        const existing = this.bridgedMessages.get(bridgedMessage.originalMessageId) || [];
+        existing.push(bridgedMessage);
+        this.bridgedMessages.set(bridgedMessage.originalMessageId, existing);
+    }
+    /**
+     * Get all bridges for a message
+     */
+    getBridges(originalMessageId) {
+        return this.bridgedMessages.get(originalMessageId) || [];
+    }
+    /**
+     * Add channel mapping
+     */
+    addChannelMapping(sourceChannel, targetChannel) {
+        this.channelMappings.set(sourceChannel, targetChannel);
+    }
+    /**
+     * Get mapped channel
+     */
+    getMappedChannel(sourceChannel, _sourceProvider, _targetProvider) {
+        return this.channelMappings.get(sourceChannel);
+    }
+    /**
+     * Check if reactions should be synced
+     */
+    shouldSyncReactions() {
+        return this.config.syncReactions ?? false;
+    }
+    /**
+     * Check if edits should be synced
+     */
+    shouldSyncEdits() {
+        return this.config.syncEdits ?? false;
+    }
+    /**
+     * Check if deletions should be synced
+     */
+    shouldSyncDeletions() {
+        return this.config.syncDeletions ?? false;
+    }
+    /**
+     * Clear all bridged message records
+     */
+    clear() {
+        this.bridgedMessages.clear();
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const bridgesByProvider = new Map();
+        let total = 0;
+        this.bridgedMessages.forEach(bridges => {
+            bridges.forEach(bridge => {
+                const count = bridgesByProvider.get(bridge.targetProvider) || 0;
+                bridgesByProvider.set(bridge.targetProvider, count + 1);
+                total++;
+            });
+        });
+        return {
+            totalBridged: total,
+            bridgesByProvider
+        };
+    }
+}
+exports.MessageBridge = MessageBridge;

package/dist/utils/user-mapping.d.ts

@@ -0,0 +1,63 @@
+import type { ProviderType } from '../types';
+/**
+ * User identity across platforms
+ */
+export interface UserIdentity {
+    unifiedId: string;
+    platformIds: Map<ProviderType, string>;
+    displayName?: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * User mapping storage
+ */
+export declare class UserMapper {
+    private identities;
+    private providerIndex;
+    /**
+     * Create or update a user identity
+     */
+    mapUser(identity: UserIdentity): void;
+    /**
+     * Get unified user ID from platform-specific ID
+     */
+    getUnifiedId(provider: ProviderType, platformUserId: string): string | undefined;
+    /**
+     * Get platform-specific user ID from unified ID
+     */
+    getPlatformId(unifiedId: string, provider: ProviderType): string | undefined;
+    /**
+     * Get full user identity
+     */
+    getIdentity(unifiedId: string): UserIdentity | undefined;
+    /**
+     * Add platform ID to existing user
+     */
+    addPlatformId(unifiedId: string, provider: ProviderType, platformUserId: string): boolean;
+    /**
+     * Remove user identity
+     */
+    removeUser(unifiedId: string): boolean;
+    /**
+     * Get all users
+     */
+    getAllUsers(): UserIdentity[];
+    /**
+     * Clear all mappings
+     */
+    clear(): void;
+    /**
+     * Get number of mapped users
+     */
+    size(): number;
+    /**
+     * Create provider key for indexing
+     */
+    private getProviderKey;
+}
+/**
+ * Create a new unified user ID
+ */
+export declare function createUnifiedId(): string;
+//# sourceMappingURL=user-mapping.d.ts.map

package/dist/utils/user-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-mapping.d.ts","sourceRoot":"","sources":["../../src/utils/user-mapping.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAwC;IAC1D,OAAO,CAAC,aAAa,CAAkC;IAEvD;;OAEG;IACI,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAU5C;;OAEG;IACI,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKvF;;OAEG;IACI,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS;IAKnF;;OAEG;IACI,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI/D;;OAEG;IACI,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO;IAWhG;;OAEG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAe7C;;OAEG;IACI,WAAW,IAAI,YAAY,EAAE;IAIpC;;OAEG;IACI,KAAK,IAAI,IAAI;IAKpB;;OAEG;IACI,IAAI,IAAI,MAAM;IAIrB;;OAEG;IACH,OAAO,CAAC,cAAc;CAGvB;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC"}