@limetech/lime-web-components 6.4.1 → 6.5.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [6.5.0](https://github.com/Lundalogik/lime-web-components/compare/v6.4.1...v6.5.0) (2025-11-25)
+
+
+### Features
+
+
+* **limeobject/file:** add id to LimeFile interface ([dda4484](https://github.com/Lundalogik/lime-web-components/commit/dda448437193f72d3591eae9b20212d23f5e361e))
+
 ## [6.4.1](https://github.com/Lundalogik/lime-web-components/compare/v6.4.0...v6.4.1) (2025-10-20)
 
 

package/dist/action/action.d.ts

@@ -2,52 +2,344 @@ import { AnyCommand, LimeObjectBulkCommand, LimeObjectCommand } from '../command
 import { Condition } from '../conditionregistry';
 import { Icon } from '../core';
 /**
- * Represents an action that is displayed in the UI
+ * Represents a user-triggerable action that can be displayed in various UI contexts.
+ *
+ * Actions are the primary way to expose functionality to users through the UI.
+ * They can appear as:
+ * - Toolbar buttons
+ * - Dropdown menu options
+ * - Quick action buttons
+ *
+ * Each action wraps a command that executes when the action is triggered.
+ * Actions can be conditionally shown or hidden using {@link Condition}s, and they
+ * support rich metadata like icons, labels, and descriptions for better UX.
+ *
+ * The generic type parameter `T` allows you to specify the exact command type,
+ * enabling type-safe action definitions for specific contexts like single objects
+ * or bulk operations.
+ *
+ * @example
+ * Basic action with icon and label
+ * ```typescript
+ * const actions = [
+ *     {
+ *         label: 'Save',
+ *         icon: 'save',
+ *         command: new SaveRecordCommand()
+ *     },
+ *     {
+ *         label: 'Delete',
+ *         icon: 'trash',
+ *         command: new DeleteRecordCommand()
+ *     }
+ * ];
+ * ```
+ *
+ * @example
+ * Conditional action with icon-only display
+ * ```typescript
+ * const canSendEmail = {
+ *     id: 'contact.can-send-email',
+ *     type: 'limeobject',
+ *     evaluate: (contact) => contact.email && contact.email.length > 0
+ * };
+ *
+ * const sendEmailAction = {
+ *     label: 'Send Email',
+ *     icon: 'envelope',
+ *     hideLabel: true,
+ *     command: new SendEmailCommand(),
+ *     condition: canSendEmail
+ * };
+ * ```
+ *
+ * @example
+ * Action with description and disabled state
+ * ```typescript
+ * const exportAction = {
+ *     label: 'Export to Excel',
+ *     description: 'Download this record as an Excel spreadsheet',
+ *     icon: 'file-excel',
+ *     command: new ExportExcelCommand(),
+ *     disabled: !object || !object.id
+ * };
+ * ```
+ *
+ * @see {@link LimeObjectAction} for single-object actions
+ * @see {@link LimeObjectBulkAction} for bulk actions
+ * @see {@link AnyCommand} for command types
+ * @see {@link Condition} for conditional visibility
+ *
  * @beta
  * @group Actions
  */
 export interface Action<T extends AnyCommand = AnyCommand> {
     /**
-     * The command to execute when the action is activated
+     * The command to execute when the action is activated.
+     *
+     * This command will be dispatched to the {@link CommandBus} when the user
+     * triggers the action. The command type determines what operation will be
+     * performed (e.g., save, delete, export, send email).
+     *
+     * @see {@link AnyCommand}
+     * @see {@link LimeObjectCommand}
+     * @see {@link LimeObjectBulkCommand}
      */
     command: T;
     /**
-     * Condition to determine if the action is available
+     * Optional condition that determines whether the action is available.
+     *
+     * If provided, the condition's evaluate function will be called to determine
+     * if the action should be shown or enabled. If the condition evaluates to
+     * `false`, the action is typically hidden from the UI.
+     *
+     * This is particularly useful for:
+     * - Showing actions only for objects in specific states
+     * - Permission-based action visibility
+     * - Context-dependent action availability
+     *
+     * @example
+     * ```typescript
+     * const canDelete: LimeObjectCondition = {
+     *     id: 'record.can-delete',
+     *     type: 'limeobject',
+     *     evaluate: (obj) => !obj.locked
+     * };
+     *
+     * const deleteAction: LimeObjectAction = {
+     *     label: 'Delete',
+     *     command: new DeleteObjectCommand(),
+     *     condition: canDelete
+     * };
+     * ```
+     *
+     * @see {@link Condition}
      */
     condition?: Condition;
     /**
-     * Icon of the action
+     * Icon to display with the action.
+     *
+     * 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.
+     *
+     * Icons help users quickly identify actions and improve visual scannability
+     * of action menus and toolbars.
+     *
+     * @see {@link Icon}
      */
     icon?: string | Icon;
     /**
-     * True if the icon should be displayed without a label.
-     * A `label` should still be provided for accessibility and for scenarios
-     * where the action is displayed differently, such as in a tooltip or menu.
+     * Controls whether the action's label should be hidden in the UI.
+     *
+     * When `true`, only the icon is displayed, creating a more compact interface.
+     * However, the label should still be provided for:
+     * - Accessibility (screen readers)
+     * - Tooltips on hover
+     * - Alternative display contexts (e.g., dropdown menus)
+     *
+     * Icon-only actions work best in toolbars where space is limited and icons
+     * are easily recognizable.
      */
     hideLabel?: boolean;
     /**
-     * Label to display on or next to the action.
-     * The label will be translated by the {@link Translator}
+     * Display label for the action.
+     *
+     * This text is shown to the user in menus, buttons, or tooltips. The label
+     * is automatically translated using the platform's {@link Translator} service,
+     * so you should provide translation keys rather than hardcoded strings.
+     *
+     * Even if `hideLabel` is true, you should still provide a label for
+     * accessibility and alternative display contexts.
+     *
+     * @see {@link Translator}
      */
     label?: string;
     /**
-     * Additional description about the action
+     * Additional descriptive text explaining what the action does.
+     *
+     * Descriptions provide more context than labels alone and are typically
+     * displayed in:
+     * - Tooltips on hover
+     * - Help text in configuration dialogs
+     * - Extended menu descriptions
+     *
+     * Use descriptions to clarify the action's purpose or any side effects.
+     *
+     * @example
+     * ```typescript
+     * {
+     *     label: 'Export to Excel',
+     *     description: 'Download all selected records as an Excel spreadsheet',
+     *     command: { name: 'export-excel' }
+     * }
+     * ```
      */
     description?: string;
     /**
-     * True if the action is disabled
+     * Controls whether the action is disabled (grayed out but visible).
+     *
+     * When `true`, the action is shown in the UI but cannot be triggered.
+     * This is different from hiding the action entirely (using `condition`).
+     *
+     * Use disabled state to:
+     * - Indicate that an action exists but is temporarily unavailable
+     * - Show what actions would be available in different contexts
+     * - Provide better user feedback than simply hiding the action
+     *
+     * @example
+     * ```typescript
+     * {
+     *     label: 'Save',
+     *     icon: 'save',
+     *     command: new SaveCommand(),
+     *     disabled: !this.hasUnsavedChanges
+     * }
+     * ```
      */
     disabled?: boolean;
 }
 /**
- * An action for a single {@link LimeObject}
+ * Specialized action type for operations on a single {@link LimeObject}.
+ *
+ * LimeObject actions are used in contexts where the user interacts with a single
+ * business object instance (deal, contact, company, etc.).
+ *
+ * The command associated with this action type is {@link LimeObjectCommand},
+ * which provides type-safe access to object-specific payload properties.
+ *
+ * @example
+ * Actions for a contact detail view
+ * ```typescript
+ * const sendEmailCommand = new SendEmailCommand();
+ * sendEmailCommand.context = { limetype: 'contact', id: contact.id };
+ *
+ * const scheduleMeetingCommand = new ScheduleMeetingCommand();
+ * scheduleMeetingCommand.context = { limetype: 'contact', id: contact.id };
+ *
+ * const addToCampaignCommand = new AddToCampaignCommand();
+ * addToCampaignCommand.context = { limetype: 'contact', id: contact.id };
+ *
+ * const actions = [
+ *     {
+ *         label: 'Send Email',
+ *         icon: 'envelope',
+ *         command: sendEmailCommand
+ *     },
+ *     {
+ *         label: 'Schedule Meeting',
+ *         icon: 'calendar',
+ *         command: scheduleMeetingCommand
+ *     },
+ *     {
+ *         label: 'Add to Campaign',
+ *         icon: 'bullhorn',
+ *         command: addToCampaignCommand
+ *     }
+ * ];
+ * ```
+ *
+ * @example
+ * Conditional action based on object state
+ * ```typescript
+ * const isDealOpen = {
+ *     id: 'deal.is-open',
+ *     type: 'limeobject',
+ *     evaluate: (deal) => deal.dealstatus !== 'won' && deal.dealstatus !== 'lost'
+ * };
+ *
+ * const closeDealCommand = new CloseDealCommand();
+ * closeDealCommand.context = { limetype: 'deal', id: dealId };
+ *
+ * const closeDealAction = {
+ *     label: 'Close Deal',
+ *     icon: 'check-circle',
+ *     description: 'Mark this deal as won or lost',
+ *     command: closeDealCommand,
+ *     condition: isDealOpen
+ * };
+ * ```
+ *
+ * @see {@link Action} for the base action type
+ * @see {@link LimeObjectCommand} for the command type
+ * @see {@link LimeObject} for the object structure
  *
  * @beta
  * @group Actions
  */
 export type LimeObjectAction = Action<LimeObjectCommand>;
 /**
- * An action for multiple {@link LimeObject}s
+ * Specialized action type for bulk operations on multiple {@link LimeObject}s.
+ *
+ * Bulk actions are used when the user selects multiple objects and wants to
+ * perform the same operation on all of them. These actions typically appear in:
+ * - List view toolbars (when items are selected)
+ * - Bulk action menus
+ * - Selection context menus
+ *
+ * The command associated with this action type is {@link LimeObjectBulkCommand},
+ * which uses a filter expression to specify which objects to operate on.
+ *
+ * Common use cases include:
+ * - Mass updates (change status, assign owner)
+ * - Bulk exports (download selected records)
+ * - Batch operations (send emails, delete records)
+ *
+ * @example
+ * Bulk actions for a list view
+ * ```typescript
+ * const exportCommand = new BulkExportCommand();
+ * exportCommand.context = { limetype: 'contact' };
+ * exportCommand.filter = selectedObjectsFilter;
+ *
+ * const deleteCommand = new BulkDeleteCommand();
+ * deleteCommand.context = { limetype: 'contact' };
+ * deleteCommand.filter = selectedObjectsFilter;
+ *
+ * const sendEmailCommand = new BulkSendEmailCommand();
+ * sendEmailCommand.context = { limetype: 'contact' };
+ * sendEmailCommand.filter = selectedObjectsFilter;
+ *
+ * const bulkActions = [
+ *     {
+ *         label: 'Export to Excel',
+ *         icon: 'file-excel',
+ *         description: 'Download selected records as Excel spreadsheet',
+ *         command: exportCommand
+ *     },
+ *     {
+ *         label: 'Delete Selected',
+ *         icon: 'trash',
+ *         description: 'Permanently delete all selected records',
+ *         command: deleteCommand
+ *     },
+ *     {
+ *         label: 'Send Email',
+ *         icon: 'envelope',
+ *         description: 'Send email to all selected contacts',
+ *         command: sendEmailCommand
+ *     }
+ * ];
+ * ```
+ *
+ * @example
+ * Conditional bulk action with minimum selection
+ * ```typescript
+ * const updateStatusCommand = new BulkUpdateStatusCommand();
+ * updateStatusCommand.context = { limetype: 'deal' };
+ * updateStatusCommand.filter = selectedObjectsFilter;
+ *
+ * const bulkUpdateAction = {
+ *     label: 'Update Status',
+ *     icon: 'edit',
+ *     description: 'Change status for all selected records',
+ *     command: updateStatusCommand,
+ *     disabled: !selectedObjectsFilter
+ * };
+ * ```
+ *
+ * @see {@link Action} for the base action type
+ * @see {@link LimeObjectBulkCommand} for the command type
+ * @see {@link LimeObject} for the object structure
  *
  * @beta
  * @group Actions

package/dist/action/action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/action/action.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,qBAAqB,EACrB,iBAAiB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAM/B;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IACrD;;OAEG;IACH,OAAO,EAAE,CAAC,CAAC;IAEX;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/action/action.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,qBAAqB,EACrB,iBAAiB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAM/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IACrD;;;;;;;;;;OAUG;IACH,OAAO,EAAE,CAAC,CAAC;IAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/application/decorators/application.d.ts

@@ -1,9 +1,63 @@
 import { StateOptions } from '../../core';
 /**
- * Get the name of the application
+ * Decorator that subscribes to the application name from the {@link ApplicationRepository}.
+ *
+ * This decorator automatically updates the decorated property whenever the application
+ * name changes in the platform. It's the recommended approach over manual subscriptions
+ * as it handles subscription lifecycle automatically.
+ *
+ * @param options - Configuration for state transformation and filtering via {@link StateOptions}
+ * @returns A PropertyDecorator that sets up automatic subscription to application name
+ *
+ * @remarks
+ * Subscribes to: {@link ApplicationRepository}
+ *
+ * Updates: The decorated property with the application name (`string`)
+ *
+ * Lifecycle: Automatically subscribes in `connectedCallback` and
+ * unsubscribes in `disconnectedCallback` of the component.
+ *
+ * @example
+ * ```typescript
+ * @State()
+ * @SelectApplicationName()
+ * private appName: string;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Transform the application name
+ * @State()
+ * @SelectApplicationName({
+ *     map: [(name) => name?.toUpperCase()]
+ * })
+ * private appNameUppercase: string;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Only update when name is defined
+ * @State()
+ * @SelectApplicationName({
+ *     filter: [(name) => name !== null && name !== undefined]
+ * })
+ * private validAppName: string;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Combine map and filter for complex transformations
+ * @State()
+ * @SelectApplicationName({
+ *     map: [
+ *         (name) => name?.toLowerCase(),
+ *         (name) => `${name} CRM`
+ *     ],
+ *     filter: [(formattedName) => formattedName?.length > 4]
+ * })
+ * private brandedName: string;
+ * ```
  *
- * @param options - options for the state selector
- * @returns state decorator
  * @public
  * @group Application
  */

package/dist/application/decorators/application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/application.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAGpB;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,OAAO,GAAE,YAAiB,GAC3B,iBAAiB,CAOnB"}
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/application.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,wBAAgB,qBAAqB,CACjC,OAAO,GAAE,YAAiB,GAC3B,iBAAiB,CAOnB"}

package/dist/application/decorators/session.d.ts

@@ -1,9 +1,50 @@
 import { StateOptions } from '../../core';
 /**
- * Get the application session
+ * Decorator that subscribes to the application session from the {@link ApplicationRepository}.
+ *
+ * This decorator automatically updates the decorated property whenever the session
+ * changes in the platform. The session contains authentication and authorization
+ * information. It's the recommended approach over manual subscriptions as it handles
+ * subscription lifecycle automatically.
+ *
+ * @param options - Configuration for state transformation and filtering via {@link StateOptions}
+ * @returns A PropertyDecorator that sets up automatic subscription to the session
+ *
+ * @remarks
+ * Subscribes to: {@link ApplicationRepository}
+ *
+ * Updates: The decorated property with the {@link Session} object
+ *
+ * Lifecycle: Automatically subscribes in `connectedCallback` and
+ * unsubscribes in `disconnectedCallback` of the component.
+ *
+ * @example
+ * ```typescript
+ * @State()
+ * @SelectSession()
+ * private session: Session;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Extract specific session property
+ * @State()
+ * @SelectSession({
+ *     map: [(session) => session?.admin]
+ * })
+ * private isAdmin: boolean;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filter for valid sessions only
+ * @State()
+ * @SelectSession({
+ *     filter: [(session) => session !== null && session?.active === true]
+ * })
+ * private activeSession: Session;
+ * ```
  *
- * @param options - state decorator options
- * @returns state decorator
  * @public
  * @group Application
  */

package/dist/application/decorators/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAIpB;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,YAAiB,GAAG,iBAAiB,CAO3E"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,YAAiB,GAAG,iBAAiB,CAO3E"}

package/dist/application/decorators/user.d.ts

@@ -1,9 +1,53 @@
 import { StateOptions } from '../../core';
 /**
- * Get the currently logged in user
+ * Decorator that subscribes to the currently logged in user from the {@link ApplicationRepository}.
+ *
+ * This decorator automatically updates the decorated property whenever the current user
+ * changes in the platform. It's the recommended approach over manual subscriptions as it
+ * handles subscription lifecycle automatically.
+ *
+ * @param options - Configuration for state transformation and filtering via {@link StateOptions}
+ * @returns A PropertyDecorator that sets up automatic subscription to the current user
+ *
+ * @remarks
+ * Subscribes to: {@link ApplicationRepository}
+ *
+ * Updates: The decorated property with the {@link User} object
+ *
+ * Lifecycle: Automatically subscribes in `connectedCallback` and
+ * unsubscribes in `disconnectedCallback` of the component.
+ *
+ * @example
+ * ```typescript
+ * @State()
+ * @SelectCurrentUser()
+ * private user: User;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Extract user's full name
+ * @State()
+ * @SelectCurrentUser({
+ *     map: [(user) => user?.fullname]
+ * })
+ * private userName: string;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create initials with map transformations
+ * @State()
+ * @SelectCurrentUser({
+ *     map: [
+ *         (user) => user?.fullname,
+ *         (name) => name?.split(' ').map(n => n[0]).join('').toUpperCase()
+ *     ],
+ *     filter: [(initials) => initials !== undefined]
+ * })
+ * private userInitials: string;
+ * ```
  *
- * @param options - state decorator options
- * @returns state decorator
  * @public
  * @group Application
  */

package/dist/application/decorators/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAIpB;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,GAAE,YAAiB,GAC3B,iBAAiB,CAOnB"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/application/decorators/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAEf,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,GAAE,YAAiB,GAC3B,iBAAiB,CAOnB"}