@seniorsistemas/data-seniorx-core 2.3.0 → 3.0.0

package/features/inline-edit/components/inline-edit-item/inline-edit-item.component.d.ts

@@ -0,0 +1,37 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { InlineEditField } from '../../fields/inline-edit-field';
+import { InlineEditTextField } from '../../fields/inline-edit-text-field';
+import { InlineEditNumberField } from '../../fields/inline-edit-number-field';
+import { InlineEditTextAreaField } from '../../fields/inline-edit-textarea-field';
+import * as i0 from "@angular/core";
+export declare class InlineEditItemComponent implements OnInit {
+    private readonly cdr;
+    field: InlineEditField;
+    formGroup: FormGroup;
+    errorMessages?: Record<string, string>;
+    private readonly textEditor?;
+    private readonly numberEditor?;
+    private readonly textareaEditor?;
+    protected isEditing: boolean;
+    private originalValue;
+    protected readonly addInfoKey = "platform.datacore.inline_edit.add_information";
+    protected readonly editKey = "platform.datacore.inline_edit.edit";
+    protected readonly saveKey = "platform.datacore.inline_edit.save";
+    protected readonly cancelKey = "platform.datacore.inline_edit.cancel";
+    ngOnInit(): void;
+    protected get hasValue(): boolean;
+    protected get showValue(): boolean;
+    protected get showEmptyButton(): boolean;
+    protected get showEditButton(): boolean;
+    protected get fieldType(): string;
+    protected get resolvedErrorMessages(): Record<string, string>;
+    protected asTextField(): InlineEditTextField;
+    protected asNumberField(): InlineEditNumberField;
+    protected asTextareaField(): InlineEditTextAreaField;
+    protected onEdit(): void;
+    protected onSave(): void;
+    protected onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineEditItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineEditItemComponent, "sdc-inline-edit-item", never, { "field": { "alias": "field"; "required": true; }; "formGroup": { "alias": "formGroup"; "required": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/inline-edit/fields/inline-edit-field.d.ts

@@ -0,0 +1,12 @@
+import type { InlineEditFieldOptions } from '../../../core/types/inline-edit.type';
+/**
+ * Classe base abstrata para todos os campos do InlineEdit.
+ * Estenda esta classe para criar novos tipos de campo.
+ */
+export declare abstract class InlineEditField {
+    readonly label: string;
+    readonly name: string;
+    readonly tooltip?: string;
+    readonly errorMessages?: Record<string, string> | (() => Record<string, string>);
+    constructor(opts: InlineEditFieldOptions);
+}

package/features/inline-edit/fields/inline-edit-number-field.d.ts

@@ -0,0 +1,9 @@
+import type { InlineEditNumberFieldOptions } from '../../../core/types/inline-edit.type';
+import { InlineEditField } from './inline-edit-field';
+export declare class InlineEditNumberField extends InlineEditField {
+    readonly placeholder?: string;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    constructor(opts: InlineEditNumberFieldOptions);
+}

package/features/inline-edit/fields/inline-edit-text-field.d.ts

@@ -0,0 +1,7 @@
+import type { InlineEditTextFieldOptions } from '../../../core/types/inline-edit.type';
+import { InlineEditField } from './inline-edit-field';
+export declare class InlineEditTextField extends InlineEditField {
+    readonly placeholder?: string;
+    readonly maxlength?: number;
+    constructor(opts: InlineEditTextFieldOptions);
+}

package/features/inline-edit/fields/inline-edit-textarea-field.d.ts

@@ -0,0 +1,9 @@
+import type { InlineEditTextAreaFieldOptions } from '../../../core/types/inline-edit.type';
+import { InlineEditField } from './inline-edit-field';
+export declare class InlineEditTextAreaField extends InlineEditField {
+    readonly rows?: number;
+    readonly cols?: number;
+    readonly placeholder?: string;
+    readonly maxlength?: number;
+    constructor(opts: InlineEditTextAreaFieldOptions);
+}

package/features/inline-edit/inline-edit.component.d.ts

@@ -0,0 +1,13 @@
+import { FormGroup } from '@angular/forms';
+import { InlineEditField } from './fields/inline-edit-field';
+import * as i0 from "@angular/core";
+export declare class InlineEditComponent {
+    /** FormGroup que contém os controles para cada campo. */
+    formGroup: FormGroup;
+    /** Lista de campos a renderizar. Cada item gera um sdc-inline-edit-item. */
+    fields: InlineEditField[];
+    /** Mensagens de erro globais, aplicadas a todos os campos (podem ser sobrescritas por campo). */
+    errorMessages?: Record<string, string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineEditComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineEditComponent, "sdc-inline-edit", never, { "formGroup": { "alias": "formGroup"; "required": true; }; "fields": { "alias": "fields"; "required": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/interactive-content/interactive-content.directive.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter, OnChanges, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export type SdcInteractiveContentRole = 'button' | 'link' | 'option' | null;
+export declare class InteractiveContentDirective implements OnInit, OnChanges {
+    private readonly hostRef;
+    private readonly renderer;
+    private initialTabIndex;
+    private initialRole;
+    private initialAriaDisabled;
+    private capturedInitialAttributes;
+    focusable: boolean;
+    disabled: boolean;
+    stopPropagation: boolean;
+    role: SdcInteractiveContentRole;
+    activated: EventEmitter<Event>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    protected onClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private canActivate;
+    private captureInitialAttributes;
+    private syncAccessibilityAttributes;
+    private syncTabIndex;
+    private syncRole;
+    private syncAriaDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InteractiveContentDirective, "[sdcInteractiveContent]", never, { "focusable": { "alias": "focusable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "stopPropagation": { "alias": "stopPropagation"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, { "activated": "sdcInteractiveContent"; }, never, never, true, never>;
+    static ngAcceptInputType_focusable: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_stopPropagation: unknown;
+}

package/features/kanban/components/kanban-column/kanban-column.component.d.ts

@@ -0,0 +1,22 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import type { KanbanColumn, KanbanItem } from '../../../../core/types/kanban.type';
+import * as i0 from "@angular/core";
+export declare class KanbanColumnComponent implements OnInit, OnDestroy {
+    data: KanbanColumn;
+    showCheckbox: boolean;
+    headerTemplate: TemplateRef<unknown> | null;
+    emptyMessageTemplate: TemplateRef<unknown> | null;
+    allSelected: boolean;
+    showColumnMenu: boolean;
+    private readonly eventService;
+    private readonly destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSelectAll(event: Event): void;
+    toggleMenu(event: Event): void;
+    onOptionClick(event: Event, optionCommand: (column: KanbanColumn) => void): void;
+    getSelectableItems(): KanbanItem[];
+    private _updateAllSelectedState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KanbanColumnComponent, "sdc-kanban-column", never, { "data": { "alias": "data"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "emptyMessageTemplate": { "alias": "emptyMessageTemplate"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/features/kanban/components/kanban-item/kanban-item.component.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import type { KanbanItem } from '../../../../core/types/kanban.type';
+import * as i0 from "@angular/core";
+export declare class KanbanItemComponent implements OnInit, OnDestroy {
+    private static nextCheckboxId;
+    private static allocateCheckboxId;
+    item: KanbanItem;
+    selected: boolean;
+    showCheckbox: boolean;
+    headerTemplate: TemplateRef<unknown> | null;
+    bodyTemplate: TemplateRef<unknown> | null;
+    footerTemplate: TemplateRef<unknown> | null;
+    readonly checkboxId: string;
+    showItemMenu: boolean;
+    private readonly eventService;
+    private readonly destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onMenuToggle(event: Event): void;
+    onOptionClick(event: Event, optionCommand: (item: KanbanItem) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KanbanItemComponent, "sdc-kanban-item", never, { "item": { "alias": "item"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/kanban/components/kanban-item-dragging/kanban-item-dragging.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class KanbanItemDraggingComponent {
+    quantityItems: number;
+    readonly draggingKey = "platform.datacore.kanban.dragging";
+    readonly itemsSelectedKey = "platform.datacore.kanban.items_selected";
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanItemDraggingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KanbanItemDraggingComponent, "sdc-kanban-item-dragging", never, { "quantityItems": { "alias": "quantityItems"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/kanban/directives/kanban-template.directive.d.ts

@@ -0,0 +1,10 @@
+import { TemplateRef } from '@angular/core';
+import type { KanbanTemplateType } from '../../../core/types/kanban.type';
+import * as i0 from "@angular/core";
+export declare class KanbanTemplateDirective {
+    readonly template: TemplateRef<unknown>;
+    type: KanbanTemplateType;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KanbanTemplateDirective, "ng-template[sdcKanbanTemplate]", never, { "type": { "alias": "sdcKanbanTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/kanban/kanban.component.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import type { KanbanColumn, KanbanData, KanbanItem, KanbanItemMovedData, KanbanTemplateType } from '../../core/types/kanban.type';
+import { KanbanTemplateDirective } from './directives/kanban-template.directive';
+import * as i0 from "@angular/core";
+export declare class KanbanComponent implements OnInit, OnDestroy {
+    data: KanbanData;
+    showItemCheckboxes: boolean;
+    showColumnCheckboxes: boolean;
+    itemsMoved: EventEmitter<KanbanItemMovedData>;
+    dataUpdated: EventEmitter<KanbanData>;
+    itemsSelected: EventEmitter<KanbanItem[]>;
+    templates: QueryList<KanbanTemplateDirective>;
+    selectedItems: Set<KanbanItem>;
+    selectedColumn: KanbanColumn | null;
+    draggingItems: Set<KanbanItem>;
+    private readonly eventService;
+    private readonly cdr;
+    private readonly destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onDrop(event: CdkDragDrop<KanbanItem[]>, targetColumn: KanbanColumn): void;
+    onItemClick(event: Event, item: KanbanItem, column: KanbanColumn): void;
+    onDragStarted(item: KanbanItem): void;
+    getTemplate(type: KanbanTemplateType): TemplateRef<unknown> | null;
+    getColumnId(index: number): string;
+    getConnectedDropLists(currentIndex: number): string[];
+    private _normalizeData;
+    private _subscribeEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KanbanComponent, "sdc-kanban", never, { "data": { "alias": "data"; "required": false; }; "showItemCheckboxes": { "alias": "showItemCheckboxes"; "required": false; }; "showColumnCheckboxes": { "alias": "showColumnCheckboxes"; "required": false; }; }, { "itemsMoved": "itemsMoved"; "dataUpdated": "dataUpdated"; "itemsSelected": "itemsSelected"; }, ["templates"], never, true, never>;
+}

package/features/kanban/services/kanban-event.service.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from 'rxjs';
+import type { KanbanColumn, KanbanItem } from '../../../core/types/kanban.type';
+import * as i0 from "@angular/core";
+export declare class KanbanEventService {
+    readonly selectAllColumnItems$: Subject<KanbanColumn>;
+    readonly unselectAllColumnItems$: Subject<KanbanColumn>;
+    readonly selectItem$: Subject<KanbanItem>;
+    readonly unselectItem$: Subject<KanbanItem>;
+    emitSelectAllColumnItems(col: KanbanColumn): void;
+    emitUnselectAllColumnItems(col: KanbanColumn): void;
+    emitSelectItem(item: KanbanItem): void;
+    emitUnselectItem(item: KanbanItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KanbanEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KanbanEventService>;
+}

package/features/loading-state/loading-state.component.d.ts

@@ -2,7 +2,6 @@ import { OnDestroy, TemplateRef } from '@angular/core';
 import type { LoadingStateIndicator } from '../../core/types/loading-state.type';
 import * as i0 from "@angular/core";
 export declare class LoadingStateComponent implements OnDestroy {
-    private static readonly LOGO_SVG;
     contents: TemplateRef<unknown> | null;
     indicator: LoadingStateIndicator;
     id: string;
@@ -13,7 +12,6 @@ export declare class LoadingStateComponent implements OnDestroy {
     get loading(): boolean;
     get blocking(): boolean;
     readonly fullscreenZIndex = 1005;
-    readonly logoSvg: string;
     private readonly _loading;
     private readonly _blocking;
     private blockTimeoutId?;

package/features/mouse-events/directives/double-click.directive.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DoubleClickDirective {
+    private lastClickAt;
+    delay: number;
+    doubleClicked: EventEmitter<MouseEvent>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DoubleClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DoubleClickDirective, "[sdcDoubleClick]", never, { "delay": { "alias": "doubleClickDelay"; "required": false; }; }, { "doubleClicked": "doubleClicked"; }, never, never, true, never>;
+    static ngAcceptInputType_delay: unknown;
+}

package/features/mouse-events/directives/long-press.directive.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class LongPressDirective implements OnDestroy {
+    private pressHandle;
+    delay: number;
+    longPressed: EventEmitter<Event>;
+    ngOnDestroy(): void;
+    protected startPress(event: Event): void;
+    protected cancelPress(): void;
+    private clearPressHandle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LongPressDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LongPressDirective, "[sdcLongPress]", never, { "delay": { "alias": "sdcLongPressDelay"; "required": false; }; }, { "longPressed": "sdcLongPress"; }, never, never, true, never>;
+    static ngAcceptInputType_delay: unknown;
+}

package/features/panel/panel.component.d.ts

@@ -1,20 +1,29 @@
 import { EventEmitter } from '@angular/core';
-import { BorderButtonOptions, EnumSeverity } from '@seniorsistemas/angular-components/shared';
+import { BorderButtonOptions, type Severities } from '../../core/types/panel.type';
 import * as i0 from "@angular/core";
 export declare class PanelComponent {
+    readonly contentId: string;
     header: string;
     toggleable: boolean;
     set collapsed(value: boolean);
     get collapsed(): boolean;
     collapsedChange: EventEmitter<boolean>;
-    private $collapsed;
-    severity: EnumSeverity;
+    severity: Severities;
     borderButtonOptions?: BorderButtonOptions;
     panelClass: string;
     ariaLabel?: string;
     ariaLabelledBy?: string;
+    private $collapsed;
     onCollapsedChanged(v: boolean): void;
+    toggleCollapsed(): void;
+    onBorderButtonClick(event: Event): void;
     get panelClasses(): string;
+    get severityClass(): string;
+    get showBorderButton(): boolean;
+    get borderButtonLabel(): string;
+    get borderButtonTooltip(): string | null;
+    get borderButtonIcon(): string | null;
+    get borderButtonDisabled(): boolean;
     getToggleAriaLabel(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<PanelComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PanelComponent, "sdc-panel", never, { "header": { "alias": "header"; "required": false; }; "toggleable": { "alias": "toggleable"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; "borderButtonOptions": { "alias": "borderButtonOptions"; "required": false; }; "panelClass": { "alias": "class"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*", "[sdcFooter]"], true, never>;

package/features/pin-code-field/pin-code-field.component.d.ts

@@ -0,0 +1,44 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnChanges, QueryList, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class PinCodeFieldComponent implements ControlValueAccessor, OnChanges {
+    private readonly cdr;
+    id: string;
+    length: number;
+    alphanumeric: boolean;
+    helpText: string;
+    invalid: boolean;
+    disabled: boolean;
+    codeFilled: EventEmitter<string>;
+    pinInputs: QueryList<ElementRef<HTMLInputElement>>;
+    protected readonly groupAriaLabelKey = "platform.datacore.pin_code_field.group_label";
+    protected readonly digitAriaLabelKey = "platform.datacore.pin_code_field.digit_n_of_total";
+    protected readonly characterAriaLabelKey = "platform.datacore.pin_code_field.character_n_of_total";
+    protected inputs: string[];
+    protected touched: boolean;
+    private _onChange?;
+    private _onTouched?;
+    constructor(cdr: ChangeDetectorRef);
+    get currentValue(): string;
+    get isComplete(): boolean;
+    get hasError(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(event: FocusEvent): void;
+    onInput(event: Event, index: number): void;
+    onKeydown(event: KeyboardEvent, index: number): void;
+    onPaste(event: ClipboardEvent, startIndex: number): void;
+    onBlur(index: number): void;
+    private extractValidChar;
+    private extractValidCharsFromString;
+    private isValidChar;
+    private advanceFocus;
+    private moveFocus;
+    private getInputEl;
+    private notifyChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinCodeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinCodeFieldComponent, "sdc-pin-code-field", never, { "id": { "alias": "id"; "required": false; }; "length": { "alias": "length"; "required": false; }; "alphanumeric": { "alias": "alphanumeric"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "codeFilled": "codeFilled"; }, never, never, true, never>;
+}

package/features/profile-picture-picker/profile-picture-picker.component.d.ts

@@ -0,0 +1,77 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import type { FileValidationErrors, ProfilePicturePickerData } from '../../core/types/profile-picture-picker.type';
+import type { ModalButton } from '../../core/types/modal.type';
+import * as i0 from "@angular/core";
+type ProfilePictureValue = string | ProfilePicturePickerData | null;
+export declare class ProfilePicturePickerComponent implements ControlValueAccessor {
+    private static nextId;
+    private static allocateComponentId;
+    fileInput?: ElementRef<HTMLInputElement>;
+    protected readonly componentId: string;
+    subtitle?: string;
+    simpleTitle?: string;
+    actionTitle?: string;
+    removeButtonLabel?: string;
+    changeButtonLabel?: string;
+    aspectRatio: number;
+    maxFileSize?: number;
+    accept?: string;
+    supportedExtensions: string[];
+    confirmBeforeApply: boolean;
+    confirmTitle: string;
+    confirmMessage: string;
+    confirmAcceptLabel: string;
+    confirmRejectLabel: string;
+    set image(value: ProfilePictureValue);
+    get image(): ProfilePictureValue;
+    imageChange: EventEmitter<string | ProfilePicturePickerData>;
+    removedImage: EventEmitter<void>;
+    invalidFile: EventEmitter<FileValidationErrors>;
+    protected confirmVisible: boolean;
+    protected dragActive: boolean;
+    private _image;
+    private pendingImageData;
+    private readonly cdr;
+    private readonly imageCropperService;
+    private onChange;
+    private onTouched;
+    get imageBase64(): string | null;
+    get hasImage(): boolean;
+    get confirmPreview(): string | null;
+    get resolvedRemoveLabel(): string;
+    get resolvedChangeLabel(): string;
+    get resolvedSimpleTitle(): string;
+    get resolvedActionTitle(): string;
+    get usesRoundedCrop(): boolean;
+    get confirmPreviewAspectRatio(): string;
+    get confirmFooterButtons(): ModalButton[];
+    onAvatarClick(): void;
+    onActionClick(): void;
+    onChangeClick(): void;
+    onRemoveClick(): void;
+    onFileSelected(event: Event): void;
+    onDragEnter(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onConfirmVisibleChange(visible: boolean): void;
+    writeValue(value: ProfilePictureValue): void;
+    registerOnChange(fn: (value: ProfilePictureValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(_isDisabled: boolean): void;
+    private openFileSelector;
+    private processFile;
+    private validateFile;
+    private getExtension;
+    private normalizeExtension;
+    private openCropperWithFile;
+    private handleCroppedImageData;
+    private applyImageData;
+    private acceptPendingImage;
+    private rejectPendingImage;
+    private hasDraggedFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfilePicturePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProfilePicturePickerComponent, "sdc-profile-picture-picker", never, { "subtitle": { "alias": "subtitle"; "required": false; }; "simpleTitle": { "alias": "simpleTitle"; "required": false; }; "actionTitle": { "alias": "actionTitle"; "required": false; }; "removeButtonLabel": { "alias": "removeButtonLabel"; "required": false; }; "changeButtonLabel": { "alias": "changeButtonLabel"; "required": false; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "supportedExtensions": { "alias": "supportedExtensions"; "required": false; }; "confirmBeforeApply": { "alias": "confirmBeforeApply"; "required": false; }; "confirmTitle": { "alias": "confirmTitle"; "required": false; }; "confirmMessage": { "alias": "confirmMessage"; "required": false; }; "confirmAcceptLabel": { "alias": "confirmAcceptLabel"; "required": false; }; "confirmRejectLabel": { "alias": "confirmRejectLabel"; "required": false; }; "image": { "alias": "image"; "required": false; }; }, { "imageChange": "imageChange"; "removedImage": "removedImage"; "invalidFile": "invalidFile"; }, never, never, true, never>;
+}
+export {};

package/features/rating-scale/rating-scale.component.d.ts

@@ -0,0 +1,24 @@
+import { ControlValueAccessor } from '@angular/forms';
+import type { RatingScaleNode } from '../../core/types/rating-scale.type';
+import * as i0 from "@angular/core";
+export declare class RatingScaleComponent implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly translate;
+    nodes: RatingScaleNode[];
+    startLabel?: string;
+    endLabel?: string;
+    disabled: boolean;
+    value: RatingScaleNode | null;
+    private onChangeFn;
+    private onTouchedFn;
+    get groupAriaLabel(): string;
+    isSelected(node: RatingScaleNode): boolean;
+    getNodeAriaLabel(node: RatingScaleNode): string;
+    selectNode(node: RatingScaleNode): void;
+    writeValue(value: RatingScaleNode | null): void;
+    registerOnChange(fn: (value: RatingScaleNode | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RatingScaleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RatingScaleComponent, "sdc-rating-scale", never, { "nodes": { "alias": "nodes"; "required": false; }; "startLabel": { "alias": "startLabel"; "required": false; }; "endLabel": { "alias": "endLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/select-button/select-button.component.d.ts

@@ -6,6 +6,7 @@ export declare class SelectButtonComponent implements ControlValueAccessor {
     private readonly cdr;
     items: SelectButtonItem[];
     multiple: boolean;
+    appearance: 'default' | 'pills' | 'soft';
     compareWith: (a: SelectButtonItem, b: SelectButtonItem) => boolean;
     itemSelected: EventEmitter<SelectButtonItem<unknown>[]>;
     itemClicked: EventEmitter<SelectButtonItem<unknown>>;
@@ -33,5 +34,5 @@ export declare class SelectButtonComponent implements ControlValueAccessor {
     private _isArrayTypeEqual;
     private _areKeysDeepEqual;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectButtonComponent, "sdc-select-button", never, { "items": { "alias": "items"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, { "itemSelected": "itemSelected"; "itemClicked": "itemClicked"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectButtonComponent, "sdc-select-button", never, { "items": { "alias": "items"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, { "itemSelected": "itemSelected"; "itemClicked": "itemClicked"; }, never, never, true, never>;
 }

package/features/speech-recognition/services/speech-recognition.service.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export type SpeechRecognitionStartOptions = {
+    lang: string;
+    silenceTimeoutMs: number;
+};
+export declare class SpeechRecognitionService {
+    private recognition;
+    private silenceHandle;
+    private readonly transcriptSubject;
+    private readonly errorSubject;
+    private readonly permissionDeniedSubject;
+    private readonly listeningSubject;
+    readonly transcript$: import("rxjs").Observable<string>;
+    readonly error$: import("rxjs").Observable<string>;
+    readonly permissionDenied$: import("rxjs").Observable<void>;
+    readonly listening$: import("rxjs").Observable<boolean>;
+    get supported(): boolean;
+    start(options: SpeechRecognitionStartOptions): boolean;
+    stop(): void;
+    abort(): void;
+    private disposeActiveRecognition;
+    private extractTranscript;
+    private resetSilenceTimer;
+    private clearSilenceTimer;
+    private clearRecognitionHandlers;
+    private getSpeechRecognitionConstructor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeechRecognitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpeechRecognitionService>;
+}

package/features/speech-recognition/services/text-to-speech.service.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+export type TextToSpeechSpeakOptions = {
+    lang: string;
+    rate: number;
+};
+export declare class TextToSpeechService {
+    private utterance;
+    private lastText;
+    private lastOptions;
+    private readonly speakingSubject;
+    private readonly pausedSubject;
+    readonly speaking$: import("rxjs").Observable<boolean>;
+    readonly paused$: import("rxjs").Observable<boolean>;
+    get supported(): boolean;
+    get hasSpokenText(): boolean;
+    speak(text: string, options: TextToSpeechSpeakOptions): boolean;
+    pause(): void;
+    resume(): void;
+    restart(text?: string, options?: TextToSpeechSpeakOptions): boolean;
+    cancel(): void;
+    private resetState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextToSpeechService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TextToSpeechService>;
+}

package/features/speech-recognition/speech-recognition.component.d.ts

@@ -0,0 +1,50 @@
+import { ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+type TextAreaLike = HTMLTextAreaElement | ElementRef<HTMLTextAreaElement> | null | undefined;
+export declare class SpeechRecognitionComponent implements OnDestroy {
+    private readonly cdr;
+    private readonly translate;
+    private readonly speechRecognitionService;
+    private readonly textToSpeechService;
+    private baseText;
+    private transcript;
+    textAreaElement: TextAreaLike;
+    keepContext: boolean;
+    speechRecognitionPlaceholder: string;
+    silenceTimeoutMs: number;
+    enableTextToSpeech: boolean;
+    recognizedText: EventEmitter<string>;
+    permissionDenied: EventEmitter<void>;
+    listeningChange: EventEmitter<boolean>;
+    protected previewText: string;
+    protected listening: boolean;
+    protected permissionDeniedState: boolean;
+    protected speaking: boolean;
+    protected paused: boolean;
+    protected voiceRate: number;
+    protected readonly voiceRates: number[];
+    constructor();
+    ngOnDestroy(): void;
+    protected get canListen(): boolean;
+    protected get canApply(): boolean;
+    protected get canSpeak(): boolean;
+    protected get recognitionSupported(): boolean;
+    protected get pauseActionLabel(): string;
+    protected get previewPlaceholder(): string;
+    protected get previewValue(): string;
+    protected get statusMessage(): string;
+    protected toggleListening(): void;
+    protected discardRecognition(): void;
+    protected applyRecognizedText(): void;
+    protected playSpeech(): void;
+    protected togglePause(): void;
+    protected restartSpeech(): void;
+    protected updateVoiceRate(value: string | number): void;
+    private combineRecognizedText;
+    private readCurrentText;
+    private resolveSpeechSourceText;
+    private getTextArea;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeechRecognitionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpeechRecognitionComponent, "sdc-speech-recognition", never, { "textAreaElement": { "alias": "textAreaElement"; "required": true; }; "keepContext": { "alias": "keepContext"; "required": false; }; "speechRecognitionPlaceholder": { "alias": "speechRecognitionPlaceholder"; "required": false; }; "silenceTimeoutMs": { "alias": "silenceTimeoutMs"; "required": false; }; "enableTextToSpeech": { "alias": "enableTextToSpeech"; "required": false; }; }, { "recognizedText": "recognizedText"; "permissionDenied": "permissionDenied"; "listeningChange": "listeningChange"; }, never, never, true, never>;
+}
+export {};