@limetech/lime-web-components 6.7.0 → 6.8.0

package/dist/keybindings/registry.d.ts

@@ -6,31 +6,66 @@
  * to individual keys typed by a user. The key combination can be pressing a single
  * key or a sequence of keys one after the other.
  *
- * The service works together with the `CommandBus` to execute the commands and
+ * The service works together with the {@link CommandBus} to execute the commands and
  * a command needs to already be registered on the command bus in order to be
  * bound as a keyboard shortcut.
  *
- * The following example registers the command `MyCommand` to be handled by
- * `MyHandler` and creates a keybinding for it. The `bind` method takes the key
- * combination and command object as input.
+ * Keybindings are scoped to the component that creates them and should be
+ * cleaned up when the component is removed from the DOM to prevent memory leaks
+ * and unintended behavior.
  *
- * Later, if the keybinding no longer is needed it can be removed with the
- * `unbind` method.
+ * ## Key Combination Format
  *
- * @example
+ * Key combinations can be:
+ * - Single keys: `'a'`, `'enter'`, `'escape'`
+ * - Modifier combinations: `'ctrl+s'`, `'alt+shift+n'`, `'meta+k'`
+ * - Sequences: `'g i'` (press 'g' then 'i')
+ *
+ * Supported modifiers: `ctrl`, `alt`, `shift`, `meta` (Command on Mac)
+ *
+ * @example Binding a command to a key combination
+ * ```ts
+ * const saveCommand = new SaveCommand();
+ * commandBus.register(SaveCommand, { handle: (cmd) => handleSave(cmd) });
+ * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+ * registry.bind('ctrl+s', saveCommand);
+ * ```
+ *
+ * @example Checking for conflicts before binding
+ * ```ts
+ * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+ * if (!registry.isBound('j')) {
+ *     registry.bind('j', navigateNextCommand);
+ * }
+ * ```
+ *
+ * @example Vim-style key sequences
+ * ```ts
+ * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+ * registry.bind('g i', goToInboxCommand);
+ * registry.bind('g s', goToSentCommand);
+ * registry.bind('g d', goToDraftsCommand);
  * ```
- * // The command bus needs to have a handler registered for the command
- * // before it can be bound to a key sequence
- * const handler = new MyHandler();
- * commandBus.register(MyCommand, handler);
  *
- * // Bind 'ctrl+s' to trigger the command
- * const command = new MyCommand();
- * keybindingRegistry.bind('ctrl+s', command);
+ * @example Usage in a component
+ * ```ts
+ * class MyComponent {
+ *     private saveCommand = new SaveCommand();
  *
- * // Remove the binding when we no longer need it to trigger the command
- * keybindingRegistry.unbind('ctrl+s')
+ *     connectedCallback() {
+ *         this.keybindingRegistry.bind('ctrl+s', this.saveCommand);
+ *     }
+ *
+ *     disconnectedCallback() {
+ *         this.keybindingRegistry.unbind('ctrl+s', this.saveCommand);
+ *     }
+ *
+ *    private get keybindingRegistry() {
+ *        return this.platform.get(PlatformServiceName.KeybindingRegistry);
+ *    }
+ * }
  * ```
+ *
  * @note This service is work in progress
  * @beta
  * @group Keyboard shortcuts
@@ -39,46 +74,124 @@ export interface KeybindingRegistry {
     /**
      * Bind a command to a specific key combination to add it to the registry
      *
-     * @param keys - the string representation of keys
-     * @param command - the command to trigger when keys are pressed
-     * @throws Will throw an error if the command is invalid or not registered
+     * When a user presses the specified key combination, the command will be
+     * dispatched through the {@link CommandBus}. The command must already have
+     * a handler registered on the command bus before binding.
+     *
+     * If the same key combination is bound to multiple commands, all commands
+     * will be executed in the order they were registered.
+     *
+     * @param keys - the string representation of keys (e.g., 'ctrl+s', 'alt+shift+n', 'g i')
+     * @param command - the command instance to trigger when keys are pressed
+     * @throws Will throw an error if the command is invalid or not registered on the command bus
+     *
+     * @example
+     * ```ts
+     * const command = new SaveCommand();
+     * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+     * registry.bind('ctrl+s', command);
+     * ```
      */
     bind: (keys: string, command: object) => void;
     /**
      * Unbind a keybinding to remove it from the registry
      *
-     * @param keys - the string representation of the key combination
-     * @param command - the command connected to the key combination
+     * Removes the association between a key combination and a command. After
+     * unbinding, pressing the key combination will no longer trigger the command.
+     * This is essential for cleanup when components are removed from the DOM.
+     *
+     * If multiple commands are bound to the same key combination, only the
+     * specified command will be unbound.
+     *
+     * @param keys - the string representation of the key combination (e.g., 'ctrl+s')
+     * @param command - the command instance connected to the key combination
+     *
+     * @example
+     * ```ts
+     * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+     * registry.unbind('ctrl+s', saveCommand);
+     * ```
      */
     unbind: (keys: string, command: object) => void;
     /**
      * Get a list of the key bindings that are currently in the registry
      *
-     * @returns the list of command and its specific key combination
+     * Returns all active keybindings across all components. Useful for debugging,
+     * displaying keyboard shortcuts to users, or detecting conflicts.
+     *
+     * @returns the list of all active keybindings with their commands
+     *
+     * @example
+     * ```ts
+     * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+     * const bindings = registry.getKeybindings();
+     * bindings.forEach(binding => {
+     *     console.log(`${binding.keys} → ${binding.command}`);
+     * });
+     * ```
      */
     getKeybindings: () => Keybinding[];
     /**
      * Checks if a key combination or a specific keybinding is already bound
      *
-     * @param keys - the string representation of a key combination
-     * @param command - the command connected to the key combination
-     * @returns true if key combination already exists, else false
+     * Use this method to detect conflicts before binding new keybindings.
+     * When called with just a key combination, returns true if any command
+     * is bound to those keys. When called with both keys and a command,
+     * returns true only if that specific combination exists.
+     *
+     * @param keys - the string representation of a key combination (e.g., 'ctrl+s')
+     * @param command - optional command instance to check for a specific binding
+     * @returns true if the key combination is bound (to any or the specified command), false otherwise
+     *
+     * @example Check if any command is bound to keys
+     * ```ts
+     * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+     * if (registry.isBound('ctrl+s')) {
+     *     console.warn('ctrl+s is already bound');
+     * }
+     * ```
+     *
+     * @example Check if a specific command is bound to keys
+     * ```ts
+     * const registry = platform.get(PlatformServiceName.KeybindingRegistry);
+     * if (registry.isBound('ctrl+s', saveCommand)) {
+     *     console.log('Save command is bound to ctrl+s');
+     * }
+     * ```
      */
     isBound: (keys: string, command?: object) => boolean;
 }
 /**
  * A key combination and its corresponding command that will be triggered when
  * the key combination is pressed
+ *
+ * Represents an active binding in the {@link KeybindingRegistry}. Each keybinding
+ * associates a specific key combination with a command instance that will be
+ * executed via the {@link CommandBus} when the keys are pressed.
+ *
+ * @example
+ * ```ts
+ * const binding: Keybinding = {
+ *     keys: 'ctrl+s',
+ *     command: new SaveCommand(),
+ * };
+ * ```
+ *
  * @beta
  * @group Keyboard shortcuts
  */
 export interface Keybinding {
     /**
-     * The string representation of key combination
+     * The string representation of a key combination
+     *
+     * Examples: `'ctrl+s'`, `'alt+shift+n'`, `'g i'`, `'escape'`
      */
     keys: string;
     /**
-     * The command to trigger when the key combination is pressed
+     * The command instance to trigger when the key combination is pressed
+     *
+     * This command must be registered on the {@link CommandBus} before the
+     * keybinding is created.
      */
     command: object;
 }

package/dist/keybindings/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/keybindings/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;;;;;OAMG;IACH,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEhD;;;;OAIG;IACH,cAAc,EAAE,MAAM,UAAU,EAAE,CAAC;IAEnC;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CACxD;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACvB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/keybindings/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEhD;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,EAAE,MAAM,UAAU,EAAE,CAAC;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,UAAU;IACvB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;CACnB"}

package/dist/problem/index.d.ts

@@ -0,0 +1,6 @@
+export * from './problem';
+export * from './query';
+export * from './provider';
+export * from './repository';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/problem/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/problem/problem.d.ts

@@ -0,0 +1,394 @@
+/**
+ * Available severity levels for problems.
+ *
+ * Severity indicates the urgency and impact of a problem, helping users
+ * prioritize which issues need attention first. The levels are:
+ * - `Low` - Minor issues that don't significantly impact operations
+ * - `Medium` - Issues that should be addressed but aren't urgent
+ * - `High` - Important issues requiring prompt attention
+ * - `Critical` - Severe issues that need immediate action
+ *
+ * @example
+ * Setting severity when creating a problem
+ * ```typescript
+ * const problem: Problem = {
+ *     id: 'email-123',
+ *     providerId: 'email-integration',
+ *     type: 'delivery-failed',
+ *     description: 'Email could not be delivered to recipient',
+ *     createdAt: new Date().toISOString(),
+ *     severity: ProblemSeverity.High
+ * };
+ * ```
+ *
+ * @example
+ * Filtering problems by severity
+ * ```typescript
+ * const criticalProblems = await provider.getProblems({
+ *     severity: ProblemSeverity.Critical
+ * });
+ *
+ * const urgentProblems = await provider.getProblems({
+ *     severity: [ProblemSeverity.High, ProblemSeverity.Critical]
+ * });
+ * ```
+ *
+ * @alpha
+ * @group Problem
+ */
+export declare const ProblemSeverity: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Critical: "critical";
+};
+/**
+ * Severity level for a problem, indicating urgency and impact.
+ *
+ * @see {@link ProblemSeverity} for available values
+ *
+ * @alpha
+ * @group Problem
+ */
+export type ProblemSeverity = (typeof ProblemSeverity)[keyof typeof ProblemSeverity];
+/**
+ * Links a problem to a specific {@link LimeObject}.
+ *
+ * When a problem is related to a specific business object (e.g., a contact
+ * whose email bounced, or a deal that failed to sync), the context provides
+ * the link to that object. This enables:
+ * - Navigating from the problem to the related object
+ * - Showing problems when viewing a specific object
+ * - Filtering problems by related object type or instance
+ *
+ * @example
+ * Problem linked to a specific contact
+ * ```typescript
+ * const problem: Problem = {
+ *     id: 'email-789',
+ *     providerId: 'email-integration',
+ *     type: 'delivery-failed',
+ *     description: 'Email bounced - invalid address',
+ *     createdAt: new Date().toISOString(),
+ *     context: {
+ *         limetype: 'contact',
+ *         id: 12345
+ *     }
+ * };
+ * ```
+ *
+ * @see {@link Problem.context}
+ * @see {@link ProblemContextFilter} for filtering by context
+ *
+ * @alpha
+ * @group Problem
+ */
+export type ProblemContext = {
+    /**
+     * The limetype of the related object (e.g., 'contact', 'deal', 'company')
+     */
+    limetype: string;
+    /**
+     * The id of the specific object instance
+     */
+    id: number;
+};
+/**
+ * Technical error details for a problem.
+ *
+ * While {@link Problem.description} provides a user-friendly explanation,
+ * ProblemError captures the underlying technical details useful for debugging.
+ * This separation allows the platform to show appropriate information to
+ * different audiences.
+ *
+ * @example
+ * Problem with error details
+ * ```typescript
+ * const problem: Problem = {
+ *     id: 'sync-001',
+ *     providerId: 'external-crm',
+ *     type: 'connection-error',
+ *     description: 'Could not sync deal with external CRM',
+ *     createdAt: new Date().toISOString(),
+ *     error: {
+ *         message: 'Connection refused by remote host',
+ *         code: 'ECONNREFUSED',
+ *         stack: 'Error: Connection refused\n    at TCPConnectWrap...'
+ *     }
+ * };
+ * ```
+ *
+ * @see {@link Problem.error}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemError {
+    /**
+     * Technical error message.
+     *
+     * This is the raw error message from the underlying system, which may
+     * be more technical than the user-facing {@link Problem.description}.
+     */
+    message: string;
+    /**
+     * Error code for programmatic handling.
+     *
+     * Codes allow categorizing errors without parsing message text.
+     * Use standard codes where applicable (e.g., `ETIMEDOUT`, `ECONNREFUSED`)
+     * or provider-specific codes.
+     */
+    code?: string;
+    /**
+     * Stack trace for debugging.
+     *
+     * The full stack trace helps developers diagnose where errors originated.
+     * May be displayed in an expandable "Technical Details" section.
+     */
+    stack?: string;
+}
+/**
+ * Represents a problem reported by a {@link ProblemProvider}.
+ *
+ * Problems are system-level issues that require manual intervention, such as:
+ * - Failed email delivery or validation errors
+ * - Integration sync failures with external systems
+ * - Background task configuration errors
+ * - Data import issues with corrupt records
+ *
+ * Each problem belongs to a provider which owns the problem's lifecycle,
+ * storage, and available actions. Problems can optionally be linked to a
+ * specific {@link LimeObject} via the `context` property.
+ *
+ * The platform aggregates problems from all registered providers, allowing
+ * authorized users to view and manage issues across the system.
+ *
+ * The generic type parameter `T` allows providers to define strongly-typed
+ * metadata for their specific problem types.
+ *
+ * @typeParam T - The type of the metadata object. Defaults to `unknown`.
+ *
+ * @example
+ * Basic problem with required fields only
+ * ```typescript
+ * const problem: Problem = {
+ *     id: 'prob-001',
+ *     providerId: 'email-integration',
+ *     type: 'delivery-failed',
+ *     description: 'Email to john@example.com bounced with error: mailbox full',
+ *     createdAt: '2024-01-15T10:30:00Z'
+ * };
+ * ```
+ *
+ * @example
+ * Problem with typed metadata
+ * ```typescript
+ * interface EmailProblemMetadata {
+ *     recipientEmail: string;
+ *     bounceType: 'permanent' | 'temporary';
+ *     smtpCode: number;
+ * }
+ *
+ * const problem: Problem<EmailProblemMetadata> = {
+ *     id: 'email-123',
+ *     providerId: 'email-integration',
+ *     type: 'delivery-failed',
+ *     description: 'Email bounced',
+ *     createdAt: '2024-01-15T10:30:00Z',
+ *     metadata: {
+ *         recipientEmail: 'john@example.com',
+ *         bounceType: 'permanent',
+ *         smtpCode: 550
+ *     }
+ * };
+ * ```
+ *
+ * @example
+ * Problem with error details
+ * ```typescript
+ * const problem: Problem = {
+ *     id: 'sync-error-042',
+ *     providerId: 'external-crm-sync',
+ *     type: 'connection-error',
+ *     description: 'Failed to sync deal with external CRM',
+ *     createdAt: '2024-01-15T14:22:00Z',
+ *     severity: ProblemSeverity.High,
+ *     status: 'pending-retry',
+ *     context: { limetype: 'deal', id: 98765 },
+ *     error: {
+ *         message: 'ETIMEDOUT: connection timed out after 30000ms',
+ *         code: 'ETIMEDOUT',
+ *         stack: 'Error: ETIMEDOUT\n    at TCPConnectWrap.afterConnect...'
+ *     }
+ * };
+ * ```
+ *
+ * @see {@link ProblemProvider} for the interface that supplies problems
+ * @see {@link ProblemRepository} for registering providers and querying problems
+ * @see {@link ProblemSeverity} for severity levels
+ * @see {@link ProblemError} for technical error details
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface Problem<T = unknown> {
+    /**
+     * Unique identifier for the problem within the provider.
+     *
+     * The id only needs to be unique within a single provider. The combination
+     * of `providerId` and `id` uniquely identifies a problem across the system.
+     */
+    id: string;
+    /**
+     * Identifier of the {@link ProblemProvider} that reported this problem.
+     *
+     * This links the problem back to its owning provider, which controls
+     * the problem's lifecycle and available actions.
+     *
+     * This property is set automatically by the platform when problems are
+     * returned from the {@link ProblemRepository}. Providers should not
+     * include this property when returning problems from their methods.
+     */
+    providerId: string;
+    /**
+     * Type identifier for categorizing the problem.
+     *
+     * Types are provider-specific and allow grouping similar problems together.
+     * Use a consistent naming convention, typically with a prefix indicating
+     * the domain (e.g., 'email.delivery-failed', 'sync.connection-error').
+     *
+     * The provider's {@link ProblemProvider.getType} method returns display
+     * information (title, description, icon) for each type.
+     *
+     * @example
+     * ```typescript
+     * // Email integration provider types
+     * type: 'email.delivery-failed'
+     * type: 'email.validation-error'
+     * type: 'email.attachment-too-large'
+     *
+     * // Sync provider types
+     * type: 'sync.connection-error'
+     * type: 'sync.data-conflict'
+     * type: 'sync.rate-limited'
+     * ```
+     */
+    type: string;
+    /**
+     * Human-readable description of what went wrong.
+     *
+     * The description should be clear enough for users to understand the issue
+     * without needing technical knowledge. Include relevant details like
+     * affected entities, error messages, or suggested actions.
+     *
+     * @example
+     * ```typescript
+     * // Good descriptions
+     * description: 'Email to john@example.com could not be delivered: mailbox is full'
+     * description: 'Failed to sync deal "Big Corp Renewal" with external system: connection timeout'
+     *
+     * // Avoid overly technical descriptions
+     * description: 'SMTP 452 4.2.2 error' // Too technical
+     * ```
+     */
+    description: string;
+    /**
+     * ISO 8601 timestamp when the problem was first detected.
+     *
+     * @example
+     * ```typescript
+     * createdAt: '2024-01-15T10:30:00Z'
+     * createdAt: new Date().toISOString()
+     * ```
+     */
+    createdAt: string;
+    /**
+     * Severity level indicating the problem's urgency and impact.
+     *
+     * Use severity to help users prioritize which problems to address first.
+     *
+     * @see {@link ProblemSeverity}
+     */
+    severity?: ProblemSeverity;
+    /**
+     * Current status in the problem's lifecycle.
+     *
+     * Status is provider-defined. Each provider can define their own status
+     * values that make sense for their workflow (e.g., 'open', 'in-progress',
+     * 'pending-retry', 'resolved').
+     *
+     * Status is optional. Some providers may choose to simply remove problems
+     * when they're resolved rather than tracking status transitions.
+     */
+    status?: string;
+    /**
+     * Tags for additional categorization and filtering.
+     *
+     * Tags provide flexible categorization beyond the `type` field. They can
+     * represent things like affected systems, error categories, or custom
+     * classifications specific to your domain.
+     *
+     * @example
+     * ```typescript
+     * tags: ['email', 'bounce', 'permanent']
+     * tags: ['sync', 'external-system', 'timeout']
+     * tags: ['import', 'validation', 'required-field']
+     * ```
+     */
+    tags?: string[];
+    /**
+     * Identifier of the user associated with this problem.
+     *
+     * This could be the user who triggered the action that failed, or the
+     * user responsible for the affected data. The exact meaning depends on
+     * the provider's context.
+     */
+    userId?: string;
+    /**
+     * Link to a related {@link LimeObject}.
+     *
+     * When a problem is directly related to a specific business object,
+     * the context provides navigation and filtering capabilities.
+     *
+     * @see {@link ProblemContext}
+     */
+    context?: ProblemContext;
+    /**
+     * Technical error details for debugging.
+     *
+     * While `description` provides a user-friendly explanation, `error`
+     * captures the underlying technical details. The platform may display
+     * this in an expandable "Technical Details" section.
+     *
+     * @see {@link ProblemError}
+     */
+    error?: ProblemError;
+    /**
+     * Additional provider-specific data.
+     *
+     * Metadata allows providers to attach arbitrary data to problems that
+     * may be useful for debugging, displaying additional details, or
+     * powering actions. Values should be JSON-serializable.
+     *
+     * Use the generic type parameter to get type safety for your metadata.
+     *
+     * @example
+     * ```typescript
+     * metadata: {
+     *     originalEmailId: 'msg-123',
+     *     recipientEmail: 'john@example.com',
+     *     bounceType: 'permanent',
+     *     smtpCode: 550
+     * }
+     * ```
+     */
+    metadata?: T;
+    /**
+     * ISO 8601 timestamp when the problem was last modified.
+     *
+     * Updated when status changes, metadata is modified, or any other
+     * property is updated after initial creation.
+     */
+    updatedAt?: string;
+}
+//# sourceMappingURL=problem.d.ts.map

package/dist/problem/problem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problem.d.ts","sourceRoot":"","sources":["../../src/problem/problem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GACvB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,YAAY;IACzB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,GAAG,OAAO;IAChC;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;;;OASG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAE3B;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;IAEzB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IAErB;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEb;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB"}