@limetech/lime-web-components 6.6.0 → 6.8.0

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"}

package/dist/problem/provider.d.ts

@@ -0,0 +1,192 @@
+import { Action } from '../action';
+import { Icon } from '../core';
+import { Problem } from './problem';
+import { ProblemQueryOptions, ProblemStatus, ProblemType } from './query';
+/**
+ * Interface that packages implement to provide problems to the platform.
+ *
+ * Providers are responsible for:
+ * - Storing and managing their own problems
+ * - Defining problem types with display information
+ * - Supplying actions users can take on problems
+ * - Responding to queries from the platform
+ *
+ * The platform aggregates problems from all registered providers.
+ *
+ * @example
+ * Provider implementation
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     id = 'email-integration';
+ *     title = 'Email Integration';
+ *     description = 'Problems related to email sending and delivery';
+ *     icon = 'envelope';
+ *
+ *     private types: ProblemType[] = [
+ *         { id: 'delivery-failed', title: 'Delivery Failed' }
+ *     ];
+ *
+ *     private statuses: ProblemStatus[] = [
+ *         { id: 'open', title: 'Open' },
+ *         { id: 'resolved', title: 'Resolved' }
+ *     ];
+ *
+ *     getTypes(): ProblemType[] { return this.types; }
+ *     getType(type: string): ProblemType | undefined {
+ *         return this.types.find(t => t.id === type);
+ *     }
+ *     getStatuses(): ProblemStatus[] { return this.statuses; }
+ *     getStatus(status: string): ProblemStatus | undefined {
+ *         return this.statuses.find(s => s.id === status);
+ *     }
+ *     // ... implement remaining methods
+ * }
+ * ```
+ *
+ * @example
+ * Registering a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * repository.registerProvider(new EmailProblemProvider());
+ * ```
+ *
+ * @see {@link ProblemRepository} for registering providers and querying problems
+ * @see {@link Problem} for the problem structure
+ * @see {@link ProblemQueryOptions} for query filtering
+ * @see {@link ProblemType} for problem type display information
+ * @see {@link Action} for problem actions
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemProvider {
+    /**
+     * Unique identifier for this provider.
+     *
+     * Used to identify the provider in the repository and to link problems back
+     * to their source. Should be a stable, lowercase identifier using hyphens
+     * for word separation (e.g., 'email-integration', 'external-crm-sync').
+     *
+     * The platform uses this id to set {@link Problem.providerId} when
+     * returning problems to consumers.
+     */
+    id: string;
+    /**
+     * Human-readable title for the provider.
+     *
+     * Should clearly identify the source of problems
+     * (e.g., 'Email Integration', 'External CRM Sync').
+     */
+    title: string;
+    /**
+     * Description of what problems this provider handles.
+     */
+    description: string;
+    /**
+     * Icon representing this provider.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon: string | Icon;
+    /**
+     * Retrieves problems from this provider.
+     *
+     * Implement filtering based on the provided options where supported.
+     * Unsupported filters should be silently ignored.
+     *
+     * @param options - Query options for filtering and pagination. All properties
+     * are optional. Providers should handle what they support and ignore the rest.
+     * @returns A promise resolving to an array of problems matching the query.
+     *
+     * @see {@link ProblemQueryOptions}
+     */
+    getProblems(options?: ProblemQueryOptions): Promise<Omit<Problem, 'providerId'>[]>;
+    /**
+     * Returns the count of problems matching the query options.
+     *
+     * Should return the total count of matching problems, not affected by
+     * pagination (limit/offset).
+     *
+     * @param options - Query options for filtering. Pagination options (limit/offset)
+     * should be ignored when counting.
+     * @returns A promise resolving to the number of matching problems.
+     */
+    getCount(options?: ProblemQueryOptions): Promise<number>;
+    /**
+     * Retrieves a specific problem by its id.
+     *
+     * @param id - The unique identifier of the problem within this provider.
+     * @returns A promise resolving to the problem if found, or undefined if
+     * no problem with that id exists.
+     */
+    get(id: string): Promise<Omit<Problem, 'providerId'> | undefined>;
+    /**
+     * Returns available actions for a specific problem.
+     *
+     * Actions allow users to take action on problems (e.g., retry, dismiss,
+     * navigate to configuration). Each action wraps a command that executes
+     * when triggered.
+     *
+     * @param problem - The problem to get actions for.
+     * @returns An array of actions available for this problem. Return an empty
+     * array `[]` if no actions are available.
+     *
+     * @see {@link Action}
+     */
+    getActions(problem: Problem): Action[];
+    /**
+     * Returns all problem types supported by this provider.
+     *
+     * Used by the platform to render type filters and understand
+     * the provider's problem categories.
+     *
+     * @returns An array of all problem types this provider can produce.
+     *
+     * @see {@link ProblemType}
+     * @see {@link Problem."type"}
+     */
+    getTypes(): ProblemType[];
+    /**
+     * Returns display information for a problem type.
+     *
+     * Problem types are provider-specific identifiers (e.g., 'delivery-failed',
+     * 'connection-error'). This method provides the human-readable title,
+     * description, and icon for each type.
+     *
+     * @param type - The problem type identifier (from {@link Problem."type"}).
+     * @returns Display information for the type, or undefined if the type
+     * is not recognized by this provider.
+     *
+     * @see {@link ProblemType}
+     * @see {@link Problem."type"}
+     */
+    getType(type: string): ProblemType | undefined;
+    /**
+     * Returns all statuses supported by this provider.
+     *
+     * Used by the platform to render status filters and understand
+     * the provider's workflow.
+     *
+     * @returns An array of all statuses this provider uses. Return an empty
+     * array `[]` if this provider doesn't track status.
+     *
+     * @see {@link ProblemStatus}
+     * @see {@link Problem.status}
+     */
+    getStatuses(): ProblemStatus[];
+    /**
+     * Returns display information for a problem status.
+     *
+     * @param status - The status identifier (from {@link Problem.status}).
+     * @returns Display information for the status, or undefined if the status
+     * is not recognized by this provider.
+     *
+     * @see {@link ProblemStatus}
+     * @see {@link Problem.status}
+     */
+    getStatus(status: string): ProblemStatus | undefined;
+}
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/problem/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,WAAW,eAAe;IAC5B;;;;;;;;;OASG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB;;;;;;;;;;;OAWG;IACH,WAAW,CACP,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAE1C;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzD;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,SAAS,CAAC,CAAC;IAElE;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAEvC;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,WAAW,EAAE,CAAC;IAE1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IAE/C;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,aAAa,EAAE,CAAC;IAE/B;;;;;;;;;OASG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;CACxD"}