@cuby-ui/core 0.0.448 → 0.0.451

package/widgets/ui/checklist-block/components/checklist-block-list-item-container/checklist-block-list-item-container.component.d.ts

@@ -0,0 +1,41 @@
+import type { OnInit, Type } from '@angular/core';
+import { NodeCheckListItem, NodeCheckListItemContentType } from '@cuby-ui/api';
+import type { CuiCheckListBlockItem } from '../../checklist-block.options';
+import { CuiNodeCheckListItemWithOption } from './checklist-block-list-item-container.options';
+import { CuiEditorConfig } from '../../../../../editor';
+import * as i0 from "@angular/core";
+export declare class CuiChecklistBlockListItemContainerComponent implements OnInit {
+    private readonly destroyRef;
+    private readonly nonNullableFormBuilder;
+    private readonly translocoService;
+    private readonly cuiDialogService;
+    private readonly treeStructApiService;
+    private readonly checkListBlockService;
+    private readonly nodeCheckListApiService;
+    protected readonly DEFAULT_CONTROL_DELAY = 700;
+    protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly checkListBlockItem: import("@angular/core").InputSignal<CuiCheckListBlockItem>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    readonly index: import("@angular/core").InputSignal<number>;
+    protected readonly componentId: import("@angular/core").Signal<import("@cuby-ui/cdk").CuiNullable<string>>;
+    protected readonly rotate: import("@angular/core").Signal<string>;
+    protected readonly headerText: import("@angular/core").Signal<string>;
+    protected readonly checkListItem: import("@angular/core").Signal<NodeCheckListItem<NodeCheckListItemContentType>>;
+    protected readonly checkListItemComponent: import("@angular/core").Signal<Type<unknown>>;
+    protected readonly checkListItemWithOptions: import("@angular/core").Signal<CuiNodeCheckListItemWithOption<NodeCheckListItemContentType>>;
+    protected readonly headerBorderColor: import("@angular/core").Signal<"var(--cui-violet-bg)" | "var(--cui-cyan-bg)" | null>;
+    protected readonly iconChecklistType: import("@angular/core").Signal<"cuiIconUsersSm" | "cuiIconChecklist" | "cuiIconUserSm">;
+    protected readonly titleControl: import("@angular/forms").FormControl<string>;
+    protected get isTitleEmpty(): boolean;
+    protected get isTitleError(): boolean;
+    ngOnInit(): void;
+    protected onRowToggle(): void;
+    protected onAllowDrag(): void;
+    protected onProhibitDrag(): void;
+    private initControls;
+    private initTitleControlValue;
+    private initTitleControlSubscription;
+    private openDeleteChecklistNodeModal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiChecklistBlockListItemContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiChecklistBlockListItemContainerComponent, "cui-checklist-block-list-item-container", never, { "checkListBlockItem": { "alias": "checkListBlockItem"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-container/checklist-block-list-item-container.options.d.ts

@@ -0,0 +1,5 @@
+import { NodeCheckListItem } from '@cuby-ui/api';
+import { CuiContextMenuItem } from '../../../../../interfaces';
+export interface CuiNodeCheckListItemWithOption<T> extends NodeCheckListItem<T> {
+    readonly options: CuiContextMenuItem[];
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-container/index.d.ts

@@ -0,0 +1 @@
+export { CuiChecklistBlockListItemContainerComponent } from './checklist-block-list-item-container.component';

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation/checklist-block-list-item-evaluation.component.d.ts

@@ -0,0 +1,51 @@
+import type { OnInit } from '@angular/core';
+import type { FormGroup } from '@angular/forms';
+import { CuiDragDropData } from '@cuby-ui/cdk';
+import { NodeCheckListEvaluationCriteria, NodeCheckListEvaluationItemContent, NodeCheckListItem, NodeCheckListItemContentAction, NodeCheckListItemSwitchContentPointer } from '@cuby-ui/api';
+import type { CuiEvaluationCriteriaGroup } from './checklist-block-list-item-evaluation.options';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockListItemEvaluationComponent implements OnInit {
+    private readonly nonNullableFormBuilder;
+    private readonly nodeCheckListApiService;
+    private readonly checkListBlockService;
+    private readonly cdRef;
+    private readonly cuiDialogService;
+    private readonly isAvailableObserver;
+    protected readonly photoFormGroup: FormGroup<{
+        isEnable: import("@angular/forms").FormControl<boolean>;
+        isRequired: import("@angular/forms").FormControl<boolean>;
+    }>;
+    protected readonly commentFormGroup: FormGroup<{
+        isEnable: import("@angular/forms").FormControl<boolean>;
+        isRequired: import("@angular/forms").FormControl<boolean>;
+    }>;
+    protected readonly evaluationCriteriaFormArray: import("@angular/forms").FormArray<FormGroup<any>>;
+    protected readonly loadingIds: import("@angular/core").WritableSignal<Record<string, boolean>>;
+    protected readonly isAddButtonDisabled: import("@angular/core").WritableSignal<boolean>;
+    private readonly assignee;
+    protected readonly attachmentPhotoAction: import("@angular/core").Signal<NodeCheckListItemContentAction>;
+    protected readonly textAreaAction: import("@angular/core").Signal<NodeCheckListItemContentAction>;
+    readonly checkListItem: import("@angular/core").InputSignal<NodeCheckListItem<NodeCheckListEvaluationItemContent>>;
+    protected getPointer(currentIndex: number): NodeCheckListItemSwitchContentPointer;
+    protected getTargetIndex(currentIndex: number): number;
+    protected onDrop(event: CuiDragDropData): void;
+    protected onAddEvaluationCriteriaItem(): void;
+    protected onSaveEvaluationCriteria(group: CuiEvaluationCriteriaGroup): void;
+    protected onCancelNewEvaluationCriteria(): void;
+    protected openModalDeleteEvaluationCriteria(id: string): void;
+    protected completeEvaluationCriteriaDeletion(criteria: NodeCheckListEvaluationCriteria): void;
+    private onCheckListActionChanged;
+    ngOnInit(): void;
+    private initEvaluationFormValues;
+    private initActionFormSegmentsSubscriptions;
+    private initPhotoGroupSubscription;
+    private initCommentGroupSubscription;
+    private updateEvaluationCriteria;
+    private addEvaluationCriteria;
+    private updateCreatedEvaluationCriteria;
+    private createEvaluationFormGroup;
+    private findExistingEvaluationCriteria;
+    private moveItemInArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockListItemEvaluationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckListBlockListItemEvaluationComponent, "cui-checklist-block-list-item-evaluation", never, { "checkListItem": { "alias": "checkListItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation/checklist-block-list-item-evaluation.options.d.ts

@@ -0,0 +1,14 @@
+import type { FormControl } from '@angular/forms';
+import type { CuiNullable } from '@cuby-ui/cdk';
+export interface CuiEvaluationCriteriaGroup {
+    id: FormControl<string>;
+    criteria: FormControl<string>;
+    evaluation: FormControl<number>;
+    isNew: FormControl<boolean>;
+}
+export interface CuiEvaluationCriteriaElementData {
+    id?: string;
+    criteria?: string;
+    evaluation?: CuiNullable<number>;
+    isNew?: boolean;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation/index.d.ts

@@ -0,0 +1,2 @@
+export { CuiCheckListBlockListItemEvaluationComponent } from './checklist-block-list-item-evaluation.component';
+export type { CuiEvaluationCriteriaGroup } from './checklist-block-list-item-evaluation.options';

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation-criteria/checklist-block-list-item-evaluation-criteria.component.d.ts

@@ -0,0 +1,33 @@
+import type { FormArray, FormGroup } from '@angular/forms';
+import type { CuiEvaluationCriteriaGroup } from '../checklist-block-list-item-evaluation';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockListItemEvaluationCriteriaComponent {
+    private readonly cuiAlertService;
+    private readonly translocoService;
+    private readonly EVALUATION_ALREADY_EXIST;
+    private previousData;
+    protected readonly isEditMode: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isNew: import("@angular/core").Signal<boolean>;
+    protected readonly gap: import("@angular/core").Signal<0 | 8>;
+    protected readonly isLoading: import("@angular/core").Signal<boolean>;
+    protected readonly isDragEnabled: import("@angular/core").Signal<boolean>;
+    protected get isEvaluationInvalid(): boolean;
+    protected get isCriteriaInvalid(): boolean;
+    readonly loadingIds: import("@angular/core").InputSignal<Record<string, boolean>>;
+    readonly index: import("@angular/core").InputSignal<number>;
+    readonly criteriaGroup: import("@angular/core").InputSignal<FormGroup<CuiEvaluationCriteriaGroup>>;
+    readonly evaluationCriteriaFormArray: import("@angular/core").InputSignal<FormArray<FormGroup<any>>>;
+    readonly saveClicked: import("@angular/core").OutputEmitterRef<CuiEvaluationCriteriaGroup>;
+    readonly deleteClicked: import("@angular/core").OutputEmitterRef<string>;
+    readonly cancelClicked: import("@angular/core").OutputEmitterRef<void>;
+    constructor();
+    protected onSave(): void;
+    protected onDelete(): void;
+    protected onCancel(): void;
+    protected onToggleEditMode(): void;
+    private initEditModeEffect;
+    private initNewEvaluationCriteriaEffect;
+    private checkIsEvaluationCriteriaExist;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockListItemEvaluationCriteriaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckListBlockListItemEvaluationCriteriaComponent, "li[cuiChecklistBlockListItemEvaluationCriteria]", never, { "loadingIds": { "alias": "loadingIds"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "criteriaGroup": { "alias": "criteriaGroup"; "required": true; "isSignal": true; }; "evaluationCriteriaFormArray": { "alias": "evaluationCriteriaFormArray"; "required": true; "isSignal": true; }; }, { "saveClicked": "saveClicked"; "deleteClicked": "deleteClicked"; "cancelClicked": "cancelClicked"; }, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation-criteria/checklist-block-list-item-evaluation-criteria.options.d.ts

@@ -0,0 +1,4 @@
+export interface CuiEvaluationCriteriaData {
+    readonly criteria: string;
+    readonly evaluation: number;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-evaluation-criteria/index.d.ts

@@ -0,0 +1 @@
+export { CuiCheckListBlockListItemEvaluationCriteriaComponent } from './checklist-block-list-item-evaluation-criteria.component';

package/widgets/ui/checklist-block/components/checklist-block-title-control/checklist-block-title-control.component.d.ts

@@ -0,0 +1,8 @@
+import type { FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class CuiChecklistBlockTitleControlComponent {
+    readonly control: import("@angular/core").InputSignal<FormControl<any>>;
+    protected get isTitleError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiChecklistBlockTitleControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiChecklistBlockTitleControlComponent, "cui-checklist-block-title-control", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-title-control/index.d.ts

@@ -0,0 +1 @@
+export { CuiChecklistBlockTitleControlComponent } from './checklist-block-title-control.component';

package/widgets/ui/checklist-block/components/index.d.ts

@@ -0,0 +1 @@
+export { CuiChecklistBlockListComponent } from './checklist-block-list';

package/widgets/ui/checklist-block/index.d.ts

@@ -0,0 +1 @@
+export { CuiChecklistBlockComponent } from './checklist-block.component';

package/widgets/ui/checklist-block/services/checklist-block.service.d.ts

@@ -0,0 +1,19 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { NodeCheckListItem, NodeCheckListItemContentType } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockService {
+    private readonly checkListItemsSignal;
+    private readonly componentIdSignal;
+    private readonly isDragAvailableSignal;
+    readonly checkListItems: import("@angular/core").Signal<CuiNullable<NodeCheckListItem<NodeCheckListItemContentType>[]>>;
+    readonly componentId: import("@angular/core").Signal<CuiNullable<string>>;
+    readonly isDragAvailable: import("@angular/core").Signal<boolean>;
+    setCheckListItems(checkListItems: NodeCheckListItem<NodeCheckListItemContentType>[]): void;
+    addCheckListItem(checkListItem: NodeCheckListItem<NodeCheckListItemContentType>): void;
+    updateCheckListItem(updatedCheckListItem: NodeCheckListItem<NodeCheckListItemContentType>): void;
+    deleteCheckListItem(id: string): void;
+    setComponentId(id: string): void;
+    toggleDragPermission(isDragButtonVisible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiCheckListBlockService>;
+}

package/widgets/ui/checklist-block/services/index.d.ts

@@ -0,0 +1 @@
+export { CuiCheckListBlockService } from './checklist-block.service';

package/widgets/ui/consumable-form/components/consumable-form-item/consumable-form-item.component.d.ts

@@ -0,0 +1,31 @@
+import type { FormGroup } from '@angular/forms';
+import type { ConsumableFormGroup, ConsumableFormValues } from '../../consumable-form.options';
+import { CuiOption } from '../../../../../interfaces';
+import * as i0 from "@angular/core";
+export declare class ConsumableFormItemComponent {
+    private readonly destroyRef;
+    private readonly cuiIdService;
+    private readonly cuiConsumptionUnitsService;
+    protected readonly quantityId: string;
+    protected readonly consumptionId: string;
+    protected readonly consumable: import("@angular/core").Signal<{
+        readonly quantity: number;
+        readonly unit: string;
+        readonly measure: {
+            readonly measure: string;
+            readonly unit: string;
+            readonly value: number;
+        };
+    }>;
+    protected readonly piecesOptions: import("@angular/core").Signal<CuiOption[]>;
+    readonly title: import("@angular/core").InputSignal<string>;
+    readonly consumptionOptions: import("@angular/core").InputSignal<CuiOption[]>;
+    readonly form: import("@angular/core").InputSignal<FormGroup<ConsumableFormGroup>>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    readonly consumableChanged: import("@angular/core").OutputEmitterRef<Partial<ConsumableFormValues>>;
+    constructor();
+    protected hasFormError(): boolean;
+    private initFormChangesEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsumableFormItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConsumableFormItemComponent, "cc-consumable-form-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "consumptionOptions": { "alias": "consumptionOptions"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "consumableChanged": "consumableChanged"; }, never, never, true, never>;
+}

package/widgets/ui/consumable-form/components/consumable-form-item/default-control-delay.d.ts

@@ -0,0 +1 @@
+export declare const CUI_DEFAULT_CONTROL_DELAY = 700;

package/widgets/ui/consumable-form/components/consumable-form-item/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsumableFormItemComponent } from './consumable-form-item.component';
+export * from './default-control-delay';

package/widgets/ui/consumable-form/components/consumable-form-item-readonly/consumable-form-item-readonly.component.d.ts

@@ -0,0 +1,8 @@
+import type { ConsumableFormValues } from '../../consumable-form.options';
+import * as i0 from "@angular/core";
+export declare class ConsumableFormItemReadonlyComponent {
+    readonly title: import("@angular/core").InputSignal<string>;
+    readonly consumable: import("@angular/core").InputSignal<ConsumableFormValues>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsumableFormItemReadonlyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConsumableFormItemReadonlyComponent, "cui-consumable-form-item-readonly", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "consumable": { "alias": "consumable"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/consumable-form/components/consumable-form-item-readonly/index.d.ts

@@ -0,0 +1 @@
+export { ConsumableFormItemReadonlyComponent } from './consumable-form-item-readonly.component';

package/widgets/ui/consumable-form/components/index.d.ts

@@ -0,0 +1,3 @@
+export { ConsumableFormItemComponent } from './consumable-form-item';
+export * from './consumable-form-item';
+export * from './consumable-form-item-readonly';

package/widgets/ui/consumable-form/consumable-form.component.d.ts

@@ -0,0 +1,46 @@
+import type { FormGroup } from '@angular/forms';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import type { ResourceUtilityMaterial } from '../resources-block/components';
+import type { SeasonForm } from './consumable-form.options';
+import { SeasonType } from '@cuby-ui/api';
+import { CuiContextMenuItem } from '../../../interfaces';
+import * as i0 from "@angular/core";
+export declare class ConsumableFormComponent {
+    private readonly destroyRef;
+    private readonly translocoService;
+    private readonly formBuilder;
+    private readonly cuiAlertService;
+    private readonly cuiConsumptionUnitsService;
+    private readonly quantumGroupResourcesStructureApiService;
+    private static readonly CONSUMABLE_WAS_DELETED;
+    protected readonly CONSUMABLE_OPTIONS: CuiContextMenuItem[];
+    protected readonly seasons: ("SUMMER" | "AUTUMN" | "WINTER" | "SPRING")[];
+    protected readonly allSeasonForm: import("@angular/core").WritableSignal<CuiNullable<FormGroup<any>>>;
+    protected readonly seasonForms: import("@angular/core").WritableSignal<SeasonForm[]>;
+    protected readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly availableSeasons: import("@angular/core").Signal<("SUMMER" | "AUTUMN" | "WINTER" | "SPRING")[]>;
+    protected readonly consumptionOptions: import("@angular/core").Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly SEASON_OPTIONS: import("@angular/core").Signal<{
+        label: "SUMMER" | "AUTUMN" | "WINTER" | "SPRING";
+        command: () => void;
+    }[]>;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly consumable: import("@angular/core").InputSignal<ResourceUtilityMaterial>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    readonly consumableChanged: import("@angular/core").OutputEmitterRef<ResourceUtilityMaterial>;
+    readonly consumableDeleted: import("@angular/core").OutputEmitterRef<string>;
+    constructor();
+    protected onConsumableChanged(): void;
+    protected onRemoveSeason(type: SeasonType): void;
+    protected onDeleteConsumable(): void;
+    private initFormValuesEffect;
+    private addSeason;
+    private updateConsumable;
+    private createForm;
+    private formatMeasureUnits;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsumableFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConsumableFormComponent, "cui-consumable-form", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "consumable": { "alias": "consumable"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "consumableChanged": "consumableChanged"; "consumableDeleted": "consumableDeleted"; }, never, never, true, never>;
+}

package/widgets/ui/consumable-form/consumable-form.options.d.ts

@@ -0,0 +1,22 @@
+import type { FormControl, FormGroup } from '@angular/forms';
+import type { Measurement } from '@cuby-ui/api';
+import { SeasonType } from '@cuby-ui/api';
+export interface SeasonForm {
+    readonly type: SeasonType;
+    readonly form: FormGroup<ConsumableFormGroup>;
+}
+export interface ConsumableFormGroup {
+    readonly quantity: FormControl<number>;
+    readonly unit: FormControl<string>;
+    readonly measure: FormGroup<ConsumableMeasureFormGroup>;
+}
+export interface ConsumableMeasureFormGroup {
+    readonly measure: FormControl<string>;
+    readonly unit: FormControl<string>;
+    readonly value: FormControl<number>;
+}
+export interface ConsumableFormValues {
+    readonly quantity: number;
+    readonly unit: string;
+    readonly measure: Measurement;
+}

package/widgets/ui/consumable-form/index.d.ts

@@ -0,0 +1 @@
+export { ConsumableFormComponent } from './consumable-form.component';

package/widgets/ui/criterion-info/criterion-info.component.d.ts

@@ -0,0 +1,43 @@
+import type { ElementRef, OnInit } from '@angular/core';
+import { Criterion, StorageObject, TreeStruct } from '@cuby-ui/api';
+import { TreeStructType } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { CuiCriterionFormValues } from '../criterion-info-form';
+import type { CuiTools, CuiEditorConfig } from '../../../editor';
+import * as i0 from "@angular/core";
+export declare class CuiCriterionInfoComponent implements OnInit {
+    private readonly destroyRef;
+    private readonly translocoService;
+    private readonly cuiIdService;
+    private readonly cuiCategoriesModalService;
+    private readonly treeStructNavigatorApiService;
+    private readonly criterionApiService;
+    private subscription;
+    private skipCategoryChange;
+    protected readonly TYPE = TreeStructType.Criteria;
+    protected readonly categoryId: string;
+    protected readonly category: import("@angular/core").Signal<CuiNullable<TreeStruct<import("@cuby-ui/api").Job<import("@cuby-ui/api").JobContentStructureType>>>>;
+    protected readonly isFormValid: import("@angular/core").WritableSignal<boolean>;
+    protected readonly prevCategoryId: import("@angular/core").WritableSignal<CuiNullable<string>>;
+    protected readonly editorConfig: import("@angular/core").WritableSignal<CuiNullable<CuiEditorConfig>>;
+    protected readonly labelColor: import("@angular/core").Signal<"var(--cui-base-900)" | "var(--cui-base-400)">;
+    protected readonly selectTitle: import("@angular/core").Signal<string>;
+    protected readonly element: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    readonly criterion: import("@angular/core").ModelSignal<StorageObject<Criterion> | undefined>;
+    readonly tools: import("@angular/core").InputSignal<CuiTools>;
+    readonly editorResourceUrl: import("@angular/core").InputSignal<string>;
+    readonly validationChanged: import("@angular/core").OutputEmitterRef<boolean>;
+    readonly criterionCreated: import("@angular/core").OutputEmitterRef<string>;
+    constructor();
+    ngOnInit(): void;
+    protected onFormChanged(values: Partial<CuiCriterionFormValues>, criterionId: string): void;
+    protected onFormValidationChanged(isValid: boolean): void;
+    private initCategoryEffect;
+    private initConfigEffect;
+    private initCategory;
+    private changeCategory;
+    private createCriterion;
+    private changeTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCriterionInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCriterionInfoComponent, "cui-criterion-info", never, { "criterion": { "alias": "criterion"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": true; "isSignal": true; }; "editorResourceUrl": { "alias": "editorResourceUrl"; "required": true; "isSignal": true; }; }, { "criterion": "criterionChange"; "validationChanged": "validationChanged"; "criterionCreated": "criterionCreated"; }, never, never, true, never>;
+}

package/widgets/ui/criterion-info/index.d.ts

@@ -0,0 +1 @@
+export { CuiCriterionInfoComponent } from './criterion-info.component';

package/widgets/ui/criterion-info-form/criterion-info-form.component.d.ts

@@ -0,0 +1,39 @@
+import type { ResourceFragment } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import type { CuiEditorConfig } from '../../../editor';
+import type { CuiCriterionFormGroup, CuiCriterionFormValues } from './criterion-info-form.options';
+import * as i0 from "@angular/core";
+export declare class CuiCriterionInfoFormComponent {
+    private readonly destroy;
+    private readonly formBuilder;
+    private readonly frameApiService;
+    private readonly cuiIdService;
+    protected readonly CONTROL_DELAY = 500;
+    protected readonly titleId: string;
+    protected readonly form: import("@angular/forms").FormGroup<{
+        readonly title: import("@angular/forms").FormControl<string>;
+    }>;
+    protected heading: CuiNullable<string>;
+    protected readonly isDescriptionEmpty: import("@angular/core").WritableSignal<boolean>;
+    protected readonly editorId: import("@angular/core").WritableSignal<CuiNullable<string>>;
+    protected readonly thumbnail: import("@angular/core").WritableSignal<CuiNullable<ResourceFragment>>;
+    readonly title: import("@angular/core").InputSignal<string>;
+    readonly framerId: import("@angular/core").InputSignal<string>;
+    readonly baseResourceUrl: import("@angular/core").InputSignal<string>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    readonly formChanged: import("@angular/core").OutputEmitterRef<Partial<CuiCriterionFormValues>>;
+    readonly isFormValidChanged: import("@angular/core").OutputEmitterRef<boolean>;
+    protected get controls(): CuiCriterionFormGroup;
+    protected get isTitleError(): boolean;
+    constructor();
+    protected onEditorEmpty(isEmpty: boolean): void;
+    private initUtilityEffect;
+    private initFormSubscriptions;
+    private initFrameFragments;
+    private compareFormValues;
+    private setResourceFile;
+    private getCaptureFromVideo;
+    private checkFormValidation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCriterionInfoFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCriterionInfoFormComponent, "cui-criterion-info-form", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "framerId": { "alias": "framerId"; "required": true; "isSignal": true; }; "baseResourceUrl": { "alias": "baseResourceUrl"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "formChanged": "formChanged"; "isFormValidChanged": "isFormValidChanged"; }, never, never, true, never>;
+}

package/widgets/ui/criterion-info-form/criterion-info-form.options.d.ts

@@ -0,0 +1,7 @@
+import type { FormControl } from '@angular/forms';
+export interface CuiCriterionFormGroup {
+    readonly title: FormControl<string>;
+}
+export interface CuiCriterionFormValues {
+    readonly title: string;
+}

package/widgets/ui/criterion-info-form/index.d.ts

@@ -0,0 +1,2 @@
+export { CuiCriterionInfoFormComponent } from './criterion-info-form.component';
+export { CuiCriterionFormGroup, CuiCriterionFormValues } from './criterion-info-form.options';

package/widgets/ui/criterion-readonly-info/criterion-readonly-info.component.d.ts

@@ -0,0 +1,26 @@
+import type { JTextFragment } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import type { CuiImgUrl } from '../../../interfaces';
+import type { CuiTools, CuiEditorConfig } from '../../../editor';
+import * as i0 from "@angular/core";
+export declare class CuiCriterionReadonlyInfoComponent {
+    private readonly hostElement;
+    private readonly frameApiService;
+    private subscription;
+    protected isVideo: boolean;
+    protected editorConfig: CuiEditorConfig;
+    protected readonly jText: import("@angular/core").WritableSignal<CuiNullable<JTextFragment>>;
+    protected readonly thumbnailUrl: import("@angular/core").WritableSignal<CuiNullable<CuiImgUrl>>;
+    protected readonly isDescriptionEmpty: import("@angular/core").Signal<boolean>;
+    readonly framerId: import("@angular/core").InputSignal<string>;
+    readonly element: import("@angular/core").InputSignal<HTMLElement>;
+    readonly tools: import("@angular/core").InputSignal<CuiTools>;
+    readonly editorResourceUrl: import("@angular/core").InputSignal<string>;
+    constructor();
+    private initConfigEffect;
+    private initFramerIdEffect;
+    private initFrameFragments;
+    private setResourceFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCriterionReadonlyInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCriterionReadonlyInfoComponent, "cui-criterion-readonly-info", never, { "framerId": { "alias": "framerId"; "required": true; "isSignal": true; }; "element": { "alias": "element"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": true; "isSignal": true; }; "editorResourceUrl": { "alias": "editorResourceUrl"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/criterion-readonly-info/index.d.ts

@@ -0,0 +1 @@
+export * from './criterion-readonly-info.component';

package/widgets/ui/delete-modal/delete-modal.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class CuiDeleteModalComponent {
+    private readonly context;
+    private readonly data;
+    protected readonly title: string;
+    protected readonly content: string[];
+    protected readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isDisabled: boolean;
+    protected onDelete(): void;
+    protected onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDeleteModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiDeleteModalComponent, "cui-delete-modal", never, {}, {}, never, never, true, never>;
+}

package/widgets/ui/delete-modal/delete-modal.options.d.ts

@@ -0,0 +1,7 @@
+import type { Observable } from 'rxjs';
+export interface CuiDialogDeleteData {
+    readonly title: string;
+    readonly content: string[];
+    readonly isDisabled?: boolean;
+    readonly delete: () => Observable<void>;
+}

package/widgets/ui/delete-modal/index.d.ts

@@ -0,0 +1,2 @@
+export { CuiDeleteModalComponent } from './delete-modal.component';
+export { CuiDialogDeleteData } from './delete-modal.options';

package/widgets/ui/framer-preview/framer-preview.component.d.ts

@@ -0,0 +1,26 @@
+import { JTextFragment } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import type { CuiEditorConfig } from '../../../editor';
+import { CuiImageUrl } from './framer-preview.options';
+import * as i0 from "@angular/core";
+export declare class CuiFramerPreviewComponent {
+    private readonly hostElement;
+    private readonly frameApiService;
+    private subscription;
+    protected isVideo: boolean;
+    protected editorConfig: CuiEditorConfig;
+    protected readonly jText: import("@angular/core").WritableSignal<CuiNullable<JTextFragment>>;
+    protected readonly thumbnailUrl: import("@angular/core").WritableSignal<CuiNullable<CuiImageUrl>>;
+    protected readonly isDescriptionEmpty: import("@angular/core").Signal<boolean>;
+    readonly framerId: import("@angular/core").InputSignal<string>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    readonly editorResourceUrl: import("@angular/core").InputSignal<string>;
+    readonly title: import("@angular/core").InputSignal<string | undefined>;
+    constructor();
+    private initConfigEffect;
+    private initFramerIdEffect;
+    private initFrameFragments;
+    private setResourceFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiFramerPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiFramerPreviewComponent, "cui-framer-preview", never, { "framerId": { "alias": "framerId"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "editorResourceUrl": { "alias": "editorResourceUrl"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/framer-preview/framer-preview.options.d.ts

@@ -0,0 +1,5 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+export interface CuiImageUrl {
+    readonly src: CuiNullable<string>;
+    readonly name: string;
+}

package/widgets/ui/framer-preview/index.d.ts

@@ -0,0 +1,2 @@
+export { CuiFramerPreviewComponent } from './framer-preview.component';
+export { CuiImageUrl } from './framer-preview.options';

package/widgets/ui/general-control-error-hint/general-control-error-hint.component.d.ts

@@ -0,0 +1,9 @@
+import type { AbstractControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class CuiGeneralControlErrorHintComponent {
+    readonly control: import("@angular/core").InputSignal<AbstractControl<any, any>>;
+    readonly isVisible: import("@angular/core").InputSignal<boolean | undefined>;
+    protected get isInvalid(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiGeneralControlErrorHintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiGeneralControlErrorHintComponent, "cui-general-control-error-hint", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/general-control-error-hint/index.d.ts

@@ -0,0 +1 @@
+export { CuiGeneralControlErrorHintComponent } from './general-control-error-hint.component';

package/widgets/ui/index.d.ts

@@ -0,0 +1,24 @@
+export { CuiLoaderComponent } from './loader';
+export { CuiDeleteModalComponent } from './delete-modal';
+export { CuiCategoriesComponent, CuiSelectedCategoryService } from './categories';
+export { CuiChecklistBlockComponent } from './checklist-block';
+export { CuiInstructionReadonlyInfoComponent } from './instruction-readonly-info';
+export { CuiCriterionInfoComponent } from './criterion-info';
+export { CuiInstructionInfoComponent } from './instruction-info';
+export { CuiGeneralControlErrorHintComponent } from './general-control-error-hint';
+export * from './select-modal';
+export * from './storage-list';
+export * from './utility-modal';
+export * from './user-action-context-menu';
+export { CuiFramerPreviewComponent, CuiImageUrl } from './framer-preview';
+export * from './assignee-role-item';
+export * from './assignee-roles-tabs';
+export * from './modal-divided-section';
+export * from './modal-header-inserted-buttons';
+export * from './modal-info-tab';
+export * from './modal-operation-part';
+export * from './modal-resources-tab';
+export * from './render-dynamic-modal';
+export * from './resources-block';
+export * from './utility-info-readonly';
+export * from './inserted';

package/widgets/ui/inserted/index.d.ts

@@ -1 +1 @@
-export { InsertedComponent } from './inserted.component';
+export * from './inserted.component';

package/widgets/ui/instruction-info/index.d.ts

@@ -0,0 +1 @@
+export { CuiInstructionInfoComponent } from './instruction-info.component';