@bernierllc/chat-suite 1.0.0

package/dist/services/MessageOrchestrator.d.ts

@@ -0,0 +1,63 @@
+import type { Provider, ProviderType, ProviderMessage, ProviderMessageResult, OrchestratedMessage, BroadcastConfig, SuiteResult } from '../types';
+import { MessagePriority, MessageStatus } from '../types';
+import { MessageBridge } from '../utils/message-bridge';
+/**
+ * Orchestrates messages across all providers
+ */
+export declare class MessageOrchestrator {
+    private messageBridge?;
+    private messages;
+    /**
+     * Set message bridge for cross-platform sync
+     */
+    setMessageBridge(bridge: MessageBridge): void;
+    /**
+     * Send a message through a specific provider
+     */
+    sendMessage(provider: Provider, message: ProviderMessage): Promise<SuiteResult<ProviderMessageResult>>;
+    /**
+     * Broadcast a message to multiple platforms
+     */
+    broadcastMessage(providers: Map<ProviderType, Provider>, config: BroadcastConfig): Promise<SuiteResult<ProviderMessageResult[]>>;
+    /**
+     * Bridge a message from one provider to another
+     */
+    bridgeMessage(sourceProvider: Provider, targetProvider: Provider, message: ProviderMessage): Promise<SuiteResult<ProviderMessageResult>>;
+    /**
+     * Get an orchestrated message by ID
+     */
+    getMessage(messageId: string): OrchestratedMessage | undefined;
+    /**
+     * Get all messages
+     */
+    getAllMessages(): OrchestratedMessage[];
+    /**
+     * Get messages by status
+     */
+    getMessagesByStatus(status: MessageStatus): OrchestratedMessage[];
+    /**
+     * Update message status
+     */
+    updateMessageStatus(messageId: string, status: MessageStatus): boolean;
+    /**
+     * Clear all messages
+     */
+    clearMessages(): void;
+    /**
+     * Get message count
+     */
+    getMessageCount(): number;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        total: number;
+        byStatus: Record<MessageStatus, number>;
+        byPriority: Record<MessagePriority, number>;
+    };
+    /**
+     * Generate a unique message ID
+     */
+    private generateMessageId;
+}
+//# sourceMappingURL=MessageOrchestrator.d.ts.map

package/dist/services/MessageOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageOrchestrator.d.ts","sourceRoot":"","sources":["../../src/services/MessageOrchestrator.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,QAAQ,EACR,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,WAAW,EACZ,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAA+C;IAE/D;;OAEG;IACI,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAIpD;;OAEG;IACU,WAAW,CACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAwB9C;;OAEG;IACU,gBAAgB,CAC3B,SAAS,EAAE,GAAG,CAAC,YAAY,EAAE,QAAQ,CAAC,EACtC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,WAAW,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAuDhD;;OAEG;IACU,aAAa,CACxB,cAAc,EAAE,QAAQ,EACxB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IA8C9C;;OAEG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIrE;;OAEG;IACI,cAAc,IAAI,mBAAmB,EAAE;IAI9C;;OAEG;IACI,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB,EAAE;IAIxE;;OAEG;IACI,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO;IAW7E;;OAEG;IACI,aAAa,IAAI,IAAI;IAI5B;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,QAAQ,IAAI;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;QACxC,UAAU,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;KAC7C;IA6BD;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAG1B"}

package/dist/services/MessageOrchestrator.js

@@ -0,0 +1,212 @@
+"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.MessageOrchestrator = void 0;
+const types_1 = require("../types");
+const error_handling_1 = require("../utils/error-handling");
+/**
+ * Orchestrates messages across all providers
+ */
+class MessageOrchestrator {
+    constructor() {
+        this.messages = new Map();
+    }
+    /**
+     * Set message bridge for cross-platform sync
+     */
+    setMessageBridge(bridge) {
+        this.messageBridge = bridge;
+    }
+    /**
+     * Send a message through a specific provider
+     */
+    async sendMessage(provider, message) {
+        try {
+            if (!provider.isInitialized()) {
+                return {
+                    success: false,
+                    error: `Provider ${provider.type} is not initialized`
+                };
+            }
+            const result = await (0, error_handling_1.retryOperation)(() => provider.sendMessage(message), 3, 1000);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to send message'
+            };
+        }
+    }
+    /**
+     * Broadcast a message to multiple platforms
+     */
+    async broadcastMessage(providers, config) {
+        try {
+            const results = [];
+            const targetProviders = config.platforms
+                .map(type => providers.get(type))
+                .filter((p) => p !== undefined);
+            if (targetProviders.length === 0) {
+                return {
+                    success: false,
+                    error: 'No valid providers found for broadcast'
+                };
+            }
+            // Create orchestrated message
+            const orchestratedMessage = {
+                id: this.generateMessageId(),
+                content: config.content,
+                priority: config.priority || types_1.MessagePriority.NORMAL,
+                status: types_1.MessageStatus.SENDING,
+                targetProviders: config.platforms,
+                metadata: config.metadata,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            this.messages.set(orchestratedMessage.id, orchestratedMessage);
+            // Send to all providers
+            for (const provider of targetProviders) {
+                const providerMessage = {
+                    content: config.content,
+                    channelId: config.channels?.[0],
+                    metadata: config.metadata
+                };
+                const result = await this.sendMessage(provider, providerMessage);
+                if (result.success && result.data) {
+                    results.push(result.data);
+                }
+            }
+            // Update orchestrated message status
+            orchestratedMessage.status = results.length > 0 ? types_1.MessageStatus.SENT : types_1.MessageStatus.FAILED;
+            orchestratedMessage.updatedAt = new Date();
+            return { success: true, data: results };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to broadcast message'
+            };
+        }
+    }
+    /**
+     * Bridge a message from one provider to another
+     */
+    async bridgeMessage(sourceProvider, targetProvider, message) {
+        try {
+            if (!this.messageBridge) {
+                throw new error_handling_1.ChatSuiteError(error_handling_1.ChatSuiteErrorType.CONFIGURATION_ERROR, 'Message bridge not configured');
+            }
+            if (!this.messageBridge.shouldBridge(sourceProvider.type, targetProvider.type)) {
+                return {
+                    success: false,
+                    error: `Bridging from ${sourceProvider.type} to ${targetProvider.type} is not enabled`
+                };
+            }
+            // Transform message for target provider
+            const transformedMessage = this.messageBridge.transformMessage(message, sourceProvider.type, targetProvider.type);
+            // Send to target provider
+            const result = await this.sendMessage(targetProvider, transformedMessage);
+            if (result.success && result.data) {
+                // Record the bridge
+                this.messageBridge.recordBridgedMessage({
+                    originalMessageId: result.data.messageId || 'unknown',
+                    sourceProvider: sourceProvider.type,
+                    targetProvider: targetProvider.type,
+                    targetMessageId: result.data.messageId,
+                    timestamp: new Date()
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to bridge message'
+            };
+        }
+    }
+    /**
+     * Get an orchestrated message by ID
+     */
+    getMessage(messageId) {
+        return this.messages.get(messageId);
+    }
+    /**
+     * Get all messages
+     */
+    getAllMessages() {
+        return Array.from(this.messages.values());
+    }
+    /**
+     * Get messages by status
+     */
+    getMessagesByStatus(status) {
+        return Array.from(this.messages.values()).filter(m => m.status === status);
+    }
+    /**
+     * Update message status
+     */
+    updateMessageStatus(messageId, status) {
+        const message = this.messages.get(messageId);
+        if (!message) {
+            return false;
+        }
+        message.status = status;
+        message.updatedAt = new Date();
+        return true;
+    }
+    /**
+     * Clear all messages
+     */
+    clearMessages() {
+        this.messages.clear();
+    }
+    /**
+     * Get message count
+     */
+    getMessageCount() {
+        return this.messages.size;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const byStatus = {
+            [types_1.MessageStatus.PENDING]: 0,
+            [types_1.MessageStatus.ROUTING]: 0,
+            [types_1.MessageStatus.SENDING]: 0,
+            [types_1.MessageStatus.SENT]: 0,
+            [types_1.MessageStatus.FAILED]: 0,
+            [types_1.MessageStatus.RETRYING]: 0
+        };
+        const byPriority = {
+            [types_1.MessagePriority.LOW]: 0,
+            [types_1.MessagePriority.NORMAL]: 0,
+            [types_1.MessagePriority.HIGH]: 0,
+            [types_1.MessagePriority.URGENT]: 0
+        };
+        this.messages.forEach(message => {
+            byStatus[message.status]++;
+            byPriority[message.priority]++;
+        });
+        return {
+            total: this.messages.size,
+            byStatus,
+            byPriority
+        };
+    }
+    /**
+     * Generate a unique message ID
+     */
+    generateMessageId() {
+        return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+}
+exports.MessageOrchestrator = MessageOrchestrator;

package/dist/services/ProviderManager.d.ts

@@ -0,0 +1,83 @@
+import type { Provider, ProviderType, SuiteResult } from '../types';
+/**
+ * Provider registration information
+ */
+export interface ProviderRegistration {
+    provider: Provider;
+    priority: number;
+    enabled: boolean;
+}
+/**
+ * Manages all chat providers
+ */
+export declare class ProviderManager {
+    private providers;
+    private initializedProviders;
+    /**
+     * Register a provider
+     */
+    registerProvider(registration: ProviderRegistration): SuiteResult<void>;
+    /**
+     * Initialize a provider
+     */
+    initializeProvider(providerType: ProviderType): Promise<SuiteResult<void>>;
+    /**
+     * Initialize all enabled providers
+     */
+    initializeAll(): Promise<{
+        successful: ProviderType[];
+        failed: Array<{
+            type: ProviderType;
+            error: string;
+        }>;
+    }>;
+    /**
+     * Get a provider by type
+     */
+    getProvider(providerType: ProviderType): Provider | undefined;
+    /**
+     * Check if a provider is initialized
+     */
+    isInitialized(providerType: ProviderType): boolean;
+    /**
+     * Get all enabled providers sorted by priority
+     */
+    getEnabledProviders(): Provider[];
+    /**
+     * Get all initialized providers
+     */
+    getInitializedProviders(): Provider[];
+    /**
+     * Get provider by priority (1 = highest)
+     */
+    getProviderByPriority(priority: number): Provider | undefined;
+    /**
+     * Get highest priority provider
+     */
+    getPrimaryProvider(): Provider | undefined;
+    /**
+     * Shutdown a provider
+     */
+    shutdownProvider(providerType: ProviderType): Promise<SuiteResult<void>>;
+    /**
+     * Shutdown all providers
+     */
+    shutdownAll(): Promise<void>;
+    /**
+     * Unregister a provider
+     */
+    unregisterProvider(providerType: ProviderType): SuiteResult<void>;
+    /**
+     * Get provider count
+     */
+    getProviderCount(): {
+        total: number;
+        enabled: number;
+        initialized: number;
+    };
+    /**
+     * Clear all providers
+     */
+    clear(): void;
+}
+//# sourceMappingURL=ProviderManager.d.ts.map

package/dist/services/ProviderManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderManager.d.ts","sourceRoot":"","sources":["../../src/services/ProviderManager.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGpE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAsD;IACvE,OAAO,CAAC,oBAAoB,CAAgC;IAE5D;;OAEG;IACI,gBAAgB,CAAC,YAAY,EAAE,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAAC;IAmB9E;;OAEG;IACU,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IA4BvF;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC;QACpC,UAAU,EAAE,YAAY,EAAE,CAAC;QAC3B,MAAM,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,YAAY,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACtD,CAAC;IAoBF;;OAEG;IACI,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,QAAQ,GAAG,SAAS;IAIpE;;OAEG;IACI,aAAa,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO;IAIzD;;OAEG;IACI,mBAAmB,IAAI,QAAQ,EAAE;IAQxC;;OAEG;IACI,uBAAuB,IAAI,QAAQ,EAAE;IAM5C;;OAEG;IACI,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAOpE;;OAEG;IACI,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAQjD;;OAEG;IACU,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAyBrF;;OAEG;IACU,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAQzC;;OAEG;IACI,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,WAAW,CAAC,IAAI,CAAC;IAmBxE;;OAEG;IACI,gBAAgB,IAAI;QACzB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;KACrB;IAUD;;OAEG;IACI,KAAK,IAAI,IAAI;CAIrB"}

package/dist/services/ProviderManager.js

@@ -0,0 +1,204 @@
+"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.ProviderManager = void 0;
+const error_handling_1 = require("../utils/error-handling");
+/**
+ * Manages all chat providers
+ */
+class ProviderManager {
+    constructor() {
+        this.providers = new Map();
+        this.initializedProviders = new Set();
+    }
+    /**
+     * Register a provider
+     */
+    registerProvider(registration) {
+        try {
+            if (this.providers.has(registration.provider.type)) {
+                return {
+                    success: false,
+                    error: `Provider ${registration.provider.type} is already registered`
+                };
+            }
+            this.providers.set(registration.provider.type, registration);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to register provider'
+            };
+        }
+    }
+    /**
+     * Initialize a provider
+     */
+    async initializeProvider(providerType) {
+        try {
+            const registration = this.providers.get(providerType);
+            if (!registration) {
+                return {
+                    success: false,
+                    error: `Provider ${providerType} not registered`
+                };
+            }
+            if (!registration.enabled) {
+                return {
+                    success: false,
+                    error: `Provider ${providerType} is not enabled`
+                };
+            }
+            await registration.provider.initialize();
+            this.initializedProviders.add(providerType);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to initialize provider'
+            };
+        }
+    }
+    /**
+     * Initialize all enabled providers
+     */
+    async initializeAll() {
+        const successful = [];
+        const failed = [];
+        for (const [type, registration] of this.providers) {
+            if (!registration.enabled) {
+                continue;
+            }
+            const result = await this.initializeProvider(type);
+            if (result.success) {
+                successful.push(type);
+            }
+            else {
+                failed.push({ type, error: result.error || 'Unknown error' });
+            }
+        }
+        return { successful, failed };
+    }
+    /**
+     * Get a provider by type
+     */
+    getProvider(providerType) {
+        return this.providers.get(providerType)?.provider;
+    }
+    /**
+     * Check if a provider is initialized
+     */
+    isInitialized(providerType) {
+        return this.initializedProviders.has(providerType);
+    }
+    /**
+     * Get all enabled providers sorted by priority
+     */
+    getEnabledProviders() {
+        const enabled = Array.from(this.providers.values())
+            .filter(reg => reg.enabled)
+            .sort((a, b) => a.priority - b.priority);
+        return enabled.map(reg => reg.provider);
+    }
+    /**
+     * Get all initialized providers
+     */
+    getInitializedProviders() {
+        return Array.from(this.initializedProviders)
+            .map(type => this.providers.get(type)?.provider)
+            .filter((p) => p !== undefined);
+    }
+    /**
+     * Get provider by priority (1 = highest)
+     */
+    getProviderByPriority(priority) {
+        const registration = Array.from(this.providers.values())
+            .find(reg => reg.priority === priority && reg.enabled);
+        return registration?.provider;
+    }
+    /**
+     * Get highest priority provider
+     */
+    getPrimaryProvider() {
+        const enabled = Array.from(this.providers.values())
+            .filter(reg => reg.enabled)
+            .sort((a, b) => a.priority - b.priority);
+        return enabled[0]?.provider;
+    }
+    /**
+     * Shutdown a provider
+     */
+    async shutdownProvider(providerType) {
+        try {
+            const provider = this.providers.get(providerType)?.provider;
+            if (!provider) {
+                return {
+                    success: false,
+                    error: `Provider ${providerType} not found`
+                };
+            }
+            if (!this.initializedProviders.has(providerType)) {
+                return { success: true }; // Already shutdown
+            }
+            await provider.shutdown();
+            this.initializedProviders.delete(providerType);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to shutdown provider'
+            };
+        }
+    }
+    /**
+     * Shutdown all providers
+     */
+    async shutdownAll() {
+        const shutdownPromises = Array.from(this.initializedProviders).map(type => this.shutdownProvider(type));
+        await Promise.all(shutdownPromises);
+    }
+    /**
+     * Unregister a provider
+     */
+    unregisterProvider(providerType) {
+        if (this.initializedProviders.has(providerType)) {
+            throw new error_handling_1.ChatSuiteError(error_handling_1.ChatSuiteErrorType.PROVIDER_ERROR, `Cannot unregister initialized provider ${providerType}. Shutdown first.`);
+        }
+        const deleted = this.providers.delete(providerType);
+        if (!deleted) {
+            return {
+                success: false,
+                error: `Provider ${providerType} not registered`
+            };
+        }
+        return { success: true };
+    }
+    /**
+     * Get provider count
+     */
+    getProviderCount() {
+        const enabled = Array.from(this.providers.values()).filter(r => r.enabled).length;
+        return {
+            total: this.providers.size,
+            enabled,
+            initialized: this.initializedProviders.size
+        };
+    }
+    /**
+     * Clear all providers
+     */
+    clear() {
+        this.providers.clear();
+        this.initializedProviders.clear();
+    }
+}
+exports.ProviderManager = ProviderManager;

package/dist/services/UserManager.d.ts

@@ -0,0 +1,61 @@
+import type { ProviderType } from '../types';
+import { UserIdentity } from '../utils/user-mapping';
+import type { SuiteResult } from '../types';
+/**
+ * User registration data
+ */
+export interface UserRegistration {
+    provider: ProviderType;
+    platformUserId: string;
+    displayName?: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Manages users across all chat providers
+ */
+export declare class UserManager {
+    private mapper;
+    constructor();
+    /**
+     * Register a new user or update existing user
+     */
+    registerUser(registration: UserRegistration): SuiteResult<UserIdentity>;
+    /**
+     * Link a platform account to an existing user
+     */
+    linkPlatform(unifiedId: string, provider: ProviderType, platformUserId: string): SuiteResult<UserIdentity>;
+    /**
+     * Get unified user ID from platform-specific ID
+     */
+    getUnifiedId(provider: ProviderType, platformUserId: string): string | undefined;
+    /**
+     * Get platform-specific user ID
+     */
+    getPlatformId(unifiedId: string, provider: ProviderType): string | undefined;
+    /**
+     * Get complete user identity
+     */
+    getUser(unifiedId: string): SuiteResult<UserIdentity>;
+    /**
+     * Get all users
+     */
+    getAllUsers(): UserIdentity[];
+    /**
+     * Remove a user
+     */
+    removeUser(unifiedId: string): SuiteResult<void>;
+    /**
+     * Get user count
+     */
+    getUserCount(): number;
+    /**
+     * Search users by display name or email
+     */
+    searchUsers(query: string): UserIdentity[];
+    /**
+     * Clear all users
+     */
+    clear(): void;
+}
+//# sourceMappingURL=UserManager.d.ts.map

package/dist/services/UserManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserManager.d.ts","sourceRoot":"","sources":["../../src/services/UserManager.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAc,YAAY,EAAmB,MAAM,uBAAuB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,YAAY,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,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,WAAW;IACtB,OAAO,CAAC,MAAM,CAAa;;IAM3B;;OAEG;IACI,YAAY,CAAC,YAAY,EAAE,gBAAgB,GAAG,WAAW,CAAC,YAAY,CAAC;IAgD9E;;OAEG;IACI,YAAY,CACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,YAAY,EACtB,cAAc,EAAE,MAAM,GACrB,WAAW,CAAC,YAAY,CAAC;IAiB5B;;OAEG;IACI,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvF;;OAEG;IACI,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS;IAInF;;OAEG;IACI,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,YAAY,CAAC;IAQ5D;;OAEG;IACI,WAAW,IAAI,YAAY,EAAE;IAIpC;;OAEG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC;IAQvD;;OAEG;IACI,YAAY,IAAI,MAAM;IAI7B;;OAEG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE;IAQjD;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}