@cuby-ui/core 0.0.487 → 0.0.488

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

@@ -0,0 +1,2 @@
+export { CuiCategoriesComponent } from './categories.component';
+export { CuiSelectedCategoryService } from './services';

package/widgets/ui/categories/services/index.d.ts

@@ -0,0 +1 @@
+export { CuiSelectedCategoryService } from './selected-category.service';

package/widgets/ui/categories/services/selected-category.service.d.ts

@@ -0,0 +1,18 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { TreeStruct } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class CuiSelectedCategoryService {
+    private readonly editingIdSignal;
+    private readonly creatingIdSignal;
+    private readonly categorySignal;
+    readonly editingId: import("@angular/core").Signal<CuiNullable<string>>;
+    readonly creatingId: import("@angular/core").Signal<CuiNullable<string>>;
+    readonly category: import("@angular/core").Signal<CuiNullable<TreeStruct<import("@cuby-ui/api").Job<import("@cuby-ui/api").JobContentStructureType>>>>;
+    setCurrentCategory(category: CuiNullable<TreeStruct>): void;
+    setEditingId(id: string): void;
+    setCreatingId(id: string): void;
+    clearEditingId(): void;
+    clearCreatingId(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiSelectedCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiSelectedCategoryService>;
+}

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

@@ -0,0 +1,21 @@
+import { NodeCheckListItem, NodeCheckListItemContentType } from '@cuby-ui/api';
+import { CuiContextMenuItem } from '../../../interfaces';
+import { CuiEditorConfig } from '../../../editor/interfaces';
+import * as i0 from "@angular/core";
+export declare class CuiChecklistBlockComponent {
+    private readonly destroyRef;
+    private readonly treeStructApiService;
+    private readonly translocoService;
+    private readonly nodeCheckListApiService;
+    private readonly checkListBlockService;
+    protected readonly CHECKLIST_BLOCK_SELECT_OPTIONS: CuiContextMenuItem[];
+    protected readonly checkListItems: import("@angular/core").Signal<import("@cuby-ui/cdk").CuiNullable<NodeCheckListItem<NodeCheckListItemContentType>[]>>;
+    protected readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly componentId: import("@angular/core").InputSignal<string>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    constructor();
+    private initNodeCheckListBlock;
+    private addCheckListItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiChecklistBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiChecklistBlockComponent, "cui-checklist-block, [cuiCheckListBlock]", never, { "componentId": { "alias": "componentId"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,12 @@
+import type { Type } from '@angular/core';
+import { NodeCheckListItem, NodeCheckListItemContentType } from '@cuby-ui/api';
+export declare const enum CuiCheckListBlockItemType {
+    WITH_VERIFICATION = "NODE_CHECKLIST_ACTION_WITH_VERIFICATION",
+    WITHOUT_VERIFICATION = "NODE_CHECKLIST_ACTION_WITHOUT_VERIFICATION",
+    EVALUATION = "NODE_CHECKLIST_EVALUATION"
+}
+export interface CuiCheckListBlockItem {
+    readonly id: string;
+    readonly content: NodeCheckListItem<NodeCheckListItemContentType>;
+    readonly component: Type<unknown>;
+}

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

@@ -0,0 +1,27 @@
+import { NodeCheckListItem, NodeCheckListItemContentType } from '@cuby-ui/api';
+import { CuiDragDropData } from '@cuby-ui/cdk';
+import { CuiEditorConfig } from '../../../../../editor';
+import type { CuiCheckListBlockItem } from '../../checklist-block.options';
+import { CuiCheckListBlockListItemActionWithVerificationComponent } from '../checklist-block-list-item-action-with-verification';
+import { CuiCheckListBlockListItemActionWithoutVerificationComponent } from '../checklist-block-list-item-action-without-verification';
+import { CuiCheckListBlockListItemEvaluationComponent } from '../checklist-block-list-item-evaluation';
+import * as i0 from "@angular/core";
+export declare class CuiChecklistBlockListComponent {
+    private readonly treeStructApiService;
+    private readonly treeStructNavigatorApiService;
+    private readonly checkListBlockService;
+    protected readonly checkListItems: import("@angular/core").Signal<import("@cuby-ui/cdk").CuiNullable<NodeCheckListItem<NodeCheckListItemContentType>[]>>;
+    protected readonly isDragAvailable: import("@angular/core").Signal<boolean>;
+    protected readonly checkListItemActionWithVerification: typeof CuiCheckListBlockListItemActionWithVerificationComponent;
+    protected readonly checkListItemActionWithoutVerification: typeof CuiCheckListBlockListItemActionWithoutVerificationComponent;
+    protected readonly checkListItemEvaluation: typeof CuiCheckListBlockListItemEvaluationComponent;
+    protected readonly componentId: import("@angular/core").Signal<import("@cuby-ui/cdk").CuiNullable<string>>;
+    protected readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isDragEnabled: import("@angular/core").Signal<boolean>;
+    protected readonly checkListItemsWithComponents: import("@angular/core").Signal<CuiCheckListBlockItem[]>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    protected moveTreeStruct(data: CuiDragDropData, element: CuiCheckListBlockItem): void;
+    private getNodeCheckListItemComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiChecklistBlockListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiChecklistBlockListComponent, "cui-checklist-block-list", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

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

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

@@ -0,0 +1,30 @@
+import type { OnInit } from '@angular/core';
+import type { FormGroup } from '@angular/forms';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { NodeCheckListActionItemContent, NodeCheckListItemContentAction } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockListItemActionCardComponent implements OnInit {
+    private readonly destroyRef;
+    private readonly nonNullableFormBuilder;
+    actionForm: FormGroup;
+    readonly purposeType: import("@angular/core").InputSignal<string | undefined>;
+    readonly isConsiderationNeeded: import("@angular/core").InputSignal<boolean>;
+    readonly actionInfo: import("@angular/core").InputSignal<NodeCheckListActionItemContent>;
+    readonly consideredCorrectChanged: import("@angular/core").OutputEmitterRef<string>;
+    readonly checkListActionChanged: import("@angular/core").OutputEmitterRef<NodeCheckListItemContentAction>;
+    protected readonly _actionInfo: import("@angular/core").WritableSignal<CuiNullable<NodeCheckListActionItemContent>>;
+    protected readonly attachmentPhotoAction: import("@angular/core").Signal<NodeCheckListItemContentAction>;
+    protected readonly textAreaAction: import("@angular/core").Signal<NodeCheckListItemContentAction>;
+    protected readonly isConsideredCorrectControl: import("@angular/forms").FormControl<boolean>;
+    protected get photoGroup(): FormGroup;
+    protected get commentGroup(): FormGroup;
+    constructor();
+    ngOnInit(): void;
+    private initActionForm;
+    private initActionFormSegmentsSubscriptions;
+    private isConsideredCorrectControlSubscription;
+    private initPhotoGroupSubscription;
+    private initCommentGroupSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockListItemActionCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckListBlockListItemActionCardComponent, "cui-checklist-block-list-item-action-card", never, { "purposeType": { "alias": "purposeType"; "required": false; "isSignal": true; }; "isConsiderationNeeded": { "alias": "isConsiderationNeeded"; "required": false; "isSignal": true; }; "actionInfo": { "alias": "actionInfo"; "required": true; "isSignal": true; }; }, { "consideredCorrectChanged": "consideredCorrectChanged"; "checkListActionChanged": "checkListActionChanged"; }, never, never, true, never>;
+}

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

@@ -0,0 +1 @@
+export { CuiCheckListBlockListItemActionCardComponent } from './checklist-block-list-item-action-card.component';

package/widgets/ui/checklist-block/components/checklist-block-list-item-action-with-verification/checklist-block-list-item-action-with-verification.component.d.ts

@@ -0,0 +1,11 @@
+import { NodeCheckListActionItemContent, NodeCheckListItem, NodeCheckListItemContentAction } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockListItemActionWithVerificationComponent {
+    private readonly nodeCheckListApiService;
+    private checkListBlockService;
+    readonly checkListItem: import("@angular/core").InputSignal<NodeCheckListItem<NodeCheckListActionItemContent>>;
+    protected onConsiderCorrectChanged(actionId: string, purposeType: string): void;
+    protected onCheckListActionChanged(actionContent: NodeCheckListItemContentAction, actionId: string, purposeType: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockListItemActionWithVerificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckListBlockListItemActionWithVerificationComponent, "cui-checklist-block-list-item-action-with-verification", never, { "checkListItem": { "alias": "checkListItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-action-with-verification/index.d.ts

@@ -0,0 +1 @@
+export { CuiCheckListBlockListItemActionWithVerificationComponent } from './checklist-block-list-item-action-with-verification.component';

package/widgets/ui/checklist-block/components/checklist-block-list-item-action-without-verification/checklist-block-list-item-action-without-verification.component.d.ts

@@ -0,0 +1,10 @@
+import { NodeCheckListActionItemContent, NodeCheckListItem, NodeCheckListItemContentAction } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class CuiCheckListBlockListItemActionWithoutVerificationComponent {
+    private readonly nodeCheckListApiService;
+    private checkListBlockService;
+    readonly checkListItem: import("@angular/core").InputSignal<NodeCheckListItem<NodeCheckListActionItemContent>>;
+    protected onCheckListActionChanged(actionContent: NodeCheckListItemContentAction, actionId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckListBlockListItemActionWithoutVerificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckListBlockListItemActionWithoutVerificationComponent, "cui-checklist-block-list-item-action-without-verification", never, { "checkListItem": { "alias": "checkListItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/checklist-block/components/checklist-block-list-item-action-without-verification/index.d.ts

@@ -0,0 +1 @@
+export { CuiCheckListBlockListItemActionWithoutVerificationComponent } from './checklist-block-list-item-action-without-verification.component';

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/circle-loader/circle-loader.component.d.ts

@@ -0,0 +1,8 @@
+import { CuiCircleLoaderSize } from '../../model';
+import * as i0 from "@angular/core";
+export declare class CuiCircleLoaderComponent {
+    readonly position: import("@angular/core").InputSignal<"auto" | "center">;
+    readonly size: import("@angular/core").InputSignal<CuiCircleLoaderSize>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCircleLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCircleLoaderComponent, "cui-circle-loader", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/circle-loader/index.d.ts

@@ -0,0 +1 @@
+export { CuiCircleLoaderComponent } from './circle-loader.component';

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';