@cuby-ui/core 0.0.448 → 0.0.451

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

@@ -0,0 +1,45 @@
+import type { ElementRef, OnInit } from '@angular/core';
+import type { Instruction, StorageObject, TreeStruct } from '@cuby-ui/api';
+import { TreeStructType } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { CuiEditorConfig } from '../../../editor';
+import type { CuiTools } from '../../../editor';
+import type { CuiInstructionFormValues } from '../instruction-info-form';
+import * as i0 from "@angular/core";
+export declare class CuiInstructionInfoComponent implements OnInit {
+    private readonly destroyRef;
+    private readonly translocoService;
+    private readonly cuiIdService;
+    private readonly cuiCategoriesModalService;
+    private readonly treeStructNavigatorApiService;
+    private readonly instructionApiService;
+    protected readonly TYPE = TreeStructType.Instruction;
+    private subscription;
+    private skipCategoryChange;
+    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 instruction: import("@angular/core").ModelSignal<StorageObject<Instruction> | undefined>;
+    readonly tools: import("@angular/core").InputSignal<CuiTools>;
+    readonly editorResourceUrl: import("@angular/core").InputSignal<string>;
+    readonly validationChanged: import("@angular/core").OutputEmitterRef<boolean>;
+    readonly instructionCreated: import("@angular/core").OutputEmitterRef<string>;
+    constructor();
+    ngOnInit(): void;
+    protected onFormChanged(values: Partial<CuiInstructionFormValues>, instructionId: string): void;
+    protected onFormValidationChanged(isValid: boolean): void;
+    private initCategoryEffect;
+    private initConfigEffect;
+    private initCategory;
+    private changeCategory;
+    private createInstruction;
+    private changeTitle;
+    private changeDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiInstructionInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInstructionInfoComponent, "cui-instruction-info", never, { "instruction": { "alias": "instruction"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": true; "isSignal": true; }; "editorResourceUrl": { "alias": "editorResourceUrl"; "required": true; "isSignal": true; }; }, { "instruction": "instructionChange"; "validationChanged": "validationChanged"; "instructionCreated": "instructionCreated"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,2 @@
+export { CuiInstructionInfoFormComponent } from './instruction-info-form.component';
+export { CuiInstructionFormGroup, CuiInstructionFormValues } from './instruction-info-form.options';

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

@@ -0,0 +1,43 @@
+import type { ResourceFragment } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import type { CuiEditorConfig } from '../../../editor';
+import type { CuiInstructionFormGroup, CuiInstructionFormValues } from './instruction-info-form.options';
+import * as i0 from "@angular/core";
+export declare class CuiInstructionInfoFormComponent {
+    private readonly destroy;
+    private readonly formBuilder;
+    private readonly frameApiService;
+    private readonly cuiIdService;
+    protected readonly CONTROL_DELAY = 500;
+    protected readonly titleId: string;
+    protected readonly descriptionId: string;
+    protected readonly form: import("@angular/forms").FormGroup<{
+        readonly title: import("@angular/forms").FormControl<string>;
+        readonly description: 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 description: 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<CuiInstructionFormValues>>;
+    readonly isFormValidChanged: import("@angular/core").OutputEmitterRef<boolean>;
+    protected get controls(): CuiInstructionFormGroup;
+    protected get isTitleError(): boolean;
+    protected get isDescriptionError(): 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<CuiInstructionInfoFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInstructionInfoFormComponent, "cui-instruction-info-form", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "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/instruction-info-form/instruction-info-form.options.d.ts

@@ -0,0 +1,9 @@
+import type { FormControl } from '@angular/forms';
+export interface CuiInstructionFormGroup {
+    readonly title: FormControl<string>;
+    readonly description: FormControl<string>;
+}
+export interface CuiInstructionFormValues {
+    readonly title: string;
+    readonly description: string;
+}

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

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

package/widgets/ui/instruction-readonly-info/instruction-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 CuiInstructionReadonlyInfoComponent {
+    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<CuiInstructionReadonlyInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInstructionReadonlyInfoComponent, "cui-instruction-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/loader/index.d.ts

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

package/widgets/ui/loader/loader.component.d.ts

@@ -0,0 +1,20 @@
+import type { OnDestroy } from '@angular/core';
+import { CuiLoadingState } from '../../../services';
+import * as i0 from "@angular/core";
+export declare class CuiLoaderComponent implements OnDestroy {
+    private readonly loaderService;
+    private readonly translocoService;
+    protected readonly state: {
+        readonly LOADING: "loading";
+        readonly COMPLETED: "completed";
+        readonly INITIAL: "initial";
+    };
+    protected readonly LoaderString: Record<CuiLoadingState, string>;
+    protected readonly LoaderIcon: Record<CuiLoadingState, string>;
+    protected readonly loaderState: import("@angular/core").Signal<CuiLoadingState>;
+    protected readonly loaderString: import("@angular/core").Signal<string>;
+    protected readonly loaderIcon: import("@angular/core").Signal<string>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiLoaderComponent, "cui-loader", never, {}, {}, never, never, true, never>;
+}

package/widgets/ui/modal-criteria-tab/index.d.ts

@@ -0,0 +1 @@
+export { ModalCriteriaTabComponent } from './modal-criteria-tab.component';

package/widgets/ui/modal-criteria-tab/modal-criteria-tab.component.d.ts

@@ -0,0 +1,15 @@
+import type { AfterViewInit } from '@angular/core';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { StorageObjectCriterion } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ModalCriteriaTabComponent implements AfterViewInit {
+    private readonly criterionApiService;
+    protected readonly storageObjectCriteria: import("@angular/core").WritableSignal<CuiNullable<StorageObjectCriterion[]>>;
+    readonly acceptanceCriteriaContainerId: import("@angular/core").InputSignal<string | undefined>;
+    readonly acceptanceCriteriaIds: import("@angular/core").InputSignal<string[] | undefined>;
+    readonly environmentUrlForResources: import("@angular/core").InputSignal<string>;
+    ngAfterViewInit(): void;
+    private initCriteriaSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalCriteriaTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalCriteriaTabComponent, "ng-component", never, { "acceptanceCriteriaContainerId": { "alias": "acceptanceCriteriaContainerId"; "required": false; "isSignal": true; }; "acceptanceCriteriaIds": { "alias": "acceptanceCriteriaIds"; "required": false; "isSignal": true; }; "environmentUrlForResources": { "alias": "environmentUrlForResources"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-divided-section/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalDividedSectionComponent } from './modal-divided-section.component';
+export * from './modal-divided-section.interfaces';

package/widgets/ui/modal-divided-section/modal-divided-section.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { CuiApiContext } from '@cuby-ui/api';
+import { CuiNullable } from '@cuby-ui/cdk';
+import { EmptyStateTitle, GetFramerId, SectionStorageElementTypeName, SectionStorageObject } from './modal-divided-section.interfaces';
+import * as i0 from "@angular/core";
+export declare class ModalDividedSectionComponent implements OnInit {
+    protected readonly EMPTY_STATE_TITLE: EmptyStateTitle;
+    protected readonly GET_FRAMER_ID: GetFramerId;
+    protected readonly selectedStorageObject: import("@angular/core").WritableSignal<CuiNullable<SectionStorageObject>>;
+    protected readonly selectedFramerId: import("@angular/core").Signal<string | undefined>;
+    protected readonly emptyStateSubtitle: import("@angular/core").Signal<string>;
+    readonly storageElementTypeName: import("@angular/core").InputSignal<SectionStorageElementTypeName>;
+    readonly storageObjects: import("@angular/core").InputSignal<SectionStorageObject[]>;
+    readonly environmentUrlForResources: import("@angular/core").InputSignal<string | undefined>;
+    readonly environmentUrlForInstruction: import("@angular/core").InputSignal<string | undefined>;
+    readonly context: import("@angular/core").InputSignal<CuiApiContext | undefined>;
+    ngOnInit(): void;
+    protected onSelect(sectionStorageObject: SectionStorageObject): void;
+    private initSelectedStorageObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalDividedSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalDividedSectionComponent, "cui-modal-divided-section", never, { "storageElementTypeName": { "alias": "storageElementTypeName"; "required": true; "isSignal": true; }; "storageObjects": { "alias": "storageObjects"; "required": true; "isSignal": true; }; "environmentUrlForResources": { "alias": "environmentUrlForResources"; "required": false; "isSignal": true; }; "environmentUrlForInstruction": { "alias": "environmentUrlForInstruction"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-divided-section/modal-divided-section.interfaces.d.ts

@@ -0,0 +1,6 @@
+import { Criterion, Instruction, StorageObject } from '@cuby-ui/api';
+export type SectionStorageElementType = Criterion | Instruction;
+export type SectionStorageElementTypeName = 'CRITERIA' | 'INSTRUCTION';
+export type SectionStorageObject = StorageObject<SectionStorageElementType>;
+export type EmptyStateTitle = Record<SectionStorageElementTypeName, string>;
+export type GetFramerId = Record<SectionStorageElementTypeName, (value: SectionStorageElementType) => string>;

package/widgets/ui/modal-header-inserted-buttons/index.d.ts

@@ -0,0 +1 @@
+export { ModalHeaderInsertedButtonsComponent } from './modal-header-inserted-buttons.component';

package/widgets/ui/modal-header-inserted-buttons/modal-header-inserted-buttons.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class ModalHeaderInsertedButtonsComponent {
+    readonly unbindClicked: import("@angular/core").OutputEmitterRef<void>;
+    protected onUnbind(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderInsertedButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderInsertedButtonsComponent, "cui-modal-header-inserted-buttons", never, {}, { "unbindClicked": "unbindClicked"; }, never, never, true, never>;
+}

package/widgets/ui/modal-header-tabs/index.d.ts

@@ -0,0 +1 @@
+export { ModalHeaderTabsComponent } from './modal-header-tabs.component';

package/widgets/ui/modal-header-tabs/modal-header-tabs.component.d.ts

@@ -0,0 +1,8 @@
+import { ModalHeaderTab } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ModalHeaderTabsComponent {
+    readonly tabs: import("@angular/core").InputSignal<ModalHeaderTab[]>;
+    readonly selectedIndex: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderTabsComponent, "cui-modal-header-tabs", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-info-tab/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalInfoTabComponent } from './modal-info-tab.component';
+export * from './modal-info-tab.options';

package/widgets/ui/modal-info-tab/modal-info-tab.component.d.ts

@@ -0,0 +1,8 @@
+import { Content } from './modal-info-tab.options';
+import * as i0 from "@angular/core";
+export declare class ModalInfoTabComponent {
+    readonly content: import("@angular/core").InputSignal<Content>;
+    protected compareFn(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalInfoTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalInfoTabComponent, "cui-modal-info-tab", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-info-tab/modal-info-tab.options.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateRef } from '@angular/core';
+export interface Content {
+    readonly [key: string]: TemplateRef<unknown>;
+}

package/widgets/ui/modal-instructions-tab/index.d.ts

@@ -0,0 +1 @@
+export { ModalInstructionsTabComponent } from './modal-instructions-tab.component';

package/widgets/ui/modal-instructions-tab/modal-instructions-tab.component.d.ts

@@ -0,0 +1,15 @@
+import type { OnInit } from '@angular/core';
+import { CuiApiContext, StorageObjectInstruction } from '@cuby-ui/api';
+import type { CuiNullable } from '@cuby-ui/cdk';
+import * as i0 from "@angular/core";
+export declare class ModalInstructionsTabComponent implements OnInit {
+    private readonly utilityApiService;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly environmentUrlForInstruction: import("@angular/core").InputSignal<string>;
+    readonly context: import("@angular/core").InputSignal<CuiApiContext>;
+    protected readonly storageObjectInstructions: import("@angular/core").WritableSignal<CuiNullable<StorageObjectInstruction[]>>;
+    ngOnInit(): void;
+    private initInstructions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalInstructionsTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalInstructionsTabComponent, "ng-component", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "environmentUrlForInstruction": { "alias": "environmentUrlForInstruction"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-operation-part/index.d.ts

@@ -0,0 +1 @@
+export { ModalOperationPartComponent } from './modal-operation-part.component';

package/widgets/ui/modal-operation-part/modal-operation-part.component.d.ts

@@ -0,0 +1,24 @@
+import { AfterViewInit, TemplateRef } from '@angular/core';
+import { CuiNullable } from '@cuby-ui/cdk';
+import { ModalHeaderTab, Operation, StorageObject } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ModalOperationPartComponent implements AfterViewInit {
+    private readonly context;
+    private readonly jobApiService;
+    protected readonly tabs: import("@angular/core").WritableSignal<ModalHeaderTab[]>;
+    protected readonly ptFormat: import("@angular/core").Signal<string>;
+    readonly storageObjectOperation: import("@angular/core").InputSignal<StorageObject<Operation>>;
+    readonly isInserted: import("@angular/core").InputSignal<boolean>;
+    readonly containerId: import("@angular/core").InputSignal<CuiNullable<string>>;
+    readonly quantumId: import("@angular/core").InputSignal<CuiNullable<string>>;
+    readonly jobId: import("@angular/core").InputSignal<CuiNullable<string>>;
+    readonly environmentUrlForResources: import("@angular/core").InputSignal<string>;
+    readonly environmentUrlForInstruction: import("@angular/core").InputSignal<string>;
+    protected readonly estimatedTime: import("@angular/core").Signal<unknown>;
+    readonly editor: import("@angular/core").Signal<TemplateRef<unknown>>;
+    ngAfterViewInit(): void;
+    protected onUnbindOperation(): void;
+    private initSectionComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalOperationPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalOperationPartComponent, "cui-modal-operation-part", never, { "storageObjectOperation": { "alias": "storageObjectOperation"; "required": true; "isSignal": true; }; "isInserted": { "alias": "isInserted"; "required": false; "isSignal": true; }; "containerId": { "alias": "containerId"; "required": false; "isSignal": true; }; "quantumId": { "alias": "quantumId"; "required": false; "isSignal": true; }; "jobId": { "alias": "jobId"; "required": false; "isSignal": true; }; "environmentUrlForResources": { "alias": "environmentUrlForResources"; "required": true; "isSignal": true; }; "environmentUrlForInstruction": { "alias": "environmentUrlForInstruction"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/modal-resources-tab/index.d.ts

@@ -0,0 +1 @@
+export { ModalResourcesTabComponent } from './modal-resources-tab.component';

package/widgets/ui/modal-resources-tab/modal-resources-tab.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import { UtilityComponentWithResources } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ModalResourcesTabComponent implements OnInit {
+    private readonly utilityApiService;
+    private readonly utilityService;
+    protected readonly isLoaded: import("@angular/core").WritableSignal<boolean>;
+    protected readonly utilityComponentWithResources: import("@angular/core").Signal<import("@cuby-ui/cdk").CuiNullable<UtilityComponentWithResources>>;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    ngOnInit(): void;
+    private initResources;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalResourcesTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalResourcesTabComponent, "cui-modal-resources-tab", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/render-dynamic-modal/index.d.ts

@@ -0,0 +1,2 @@
+export { RenderDynamicModalComponent } from './render-dynamic-modal.component';
+export * from './render-dynamic-modal.option';

package/widgets/ui/render-dynamic-modal/render-dynamic-modal.component.d.ts

@@ -0,0 +1,11 @@
+import { CuiDialogSize } from '../../../components';
+import * as i0 from "@angular/core";
+export declare class RenderDynamicModalComponent {
+    private readonly cuiDialogContext;
+    private readonly renderDynamicComponentsService;
+    protected get size(): CuiDialogSize;
+    ngOnInit(): void;
+    private initParentParentOfModal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderDynamicModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RenderDynamicModalComponent, "cui-render-dynamic-modal", never, {}, {}, never, never, true, never>;
+}

package/widgets/ui/render-dynamic-modal/render-dynamic-modal.option.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@angular/core';
+export interface CuiRenderDynamicModalDialogData {
+    component: Type<unknown>;
+    inputs: Record<string, unknown>;
+}

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

@@ -0,0 +1,5 @@
+export type { ResourceUtilityMaterial } from './resources-block-consumables';
+export { ResourcesBlockPartComponent } from './resources-block-part';
+export { ResourcesBlockTabsComponent } from './resources-block-tabs';
+export type { ResourceUtilityTool } from './resources-block-toolbox';
+export { ResourcesOptionsComponent } from './resources-options';

package/widgets/ui/resources-block/components/resources-block-consumables/index.d.ts

@@ -0,0 +1,2 @@
+export { ResourcesBlockConsumablesComponent } from './resources-block-consumables.component';
+export type { ResourceUtilityMaterial } from './resources-block-consumables.options';

package/widgets/ui/resources-block/components/resources-block-consumables/resources-block-consumables.component.d.ts

@@ -0,0 +1,17 @@
+import type { ResourceUtilityMaterial } from './resources-block-consumables.options';
+import * as i0 from "@angular/core";
+export declare class ResourcesBlockConsumablesComponent {
+    private readonly factoryApiService;
+    private readonly utilityService;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly containerId: import("@angular/core").InputSignal<string>;
+    readonly elements: import("@angular/core").InputSignal<ResourceUtilityMaterial[]>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    protected onConsumableChanged(consumable: ResourceUtilityMaterial): void;
+    protected onConsumableDeleted(consumableId: string): void;
+    private initConsumablesStructure;
+    private getAddintionalResourceInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesBlockConsumablesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesBlockConsumablesComponent, "cui-resources-block-consumables", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "containerId": { "alias": "containerId"; "required": true; "isSignal": true; }; "elements": { "alias": "elements"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/resources-block/components/resources-block-consumables/resources-block-consumables.options.d.ts

@@ -0,0 +1,7 @@
+import type { Specifications, UtilityMaterialRequestBody } from '@cuby-ui/api';
+export interface ResourceUtilityMaterial extends UtilityMaterialRequestBody {
+    readonly isDelete: boolean;
+    readonly name: string;
+    readonly specifications?: Specifications;
+    readonly parameters?: Specifications;
+}

package/widgets/ui/resources-block/components/resources-block-content/index.d.ts

@@ -0,0 +1 @@
+export { ResourcesBlockContentComponent } from './resources-block-content.component';

package/widgets/ui/resources-block/components/resources-block-content/resources-block-content.component.d.ts

@@ -0,0 +1,19 @@
+import { ResourceContentType } from '@cuby-ui/api';
+import { UtilitySubject } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ResourcesBlockContentComponent {
+    private subjectModalBase;
+    readonly config: {
+        readonly context: import("@angular/common/http").HttpContext;
+    };
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly emptyState: import("@angular/core").Signal<string>;
+    readonly resourcesAdded: import("@angular/core").OutputEmitterRef<UtilitySubject[]>;
+    readonly type: import("@angular/core").InputSignal<ResourceContentType>;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly empty: import("@angular/core").InputSignal<boolean>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    protected onAddResource(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesBlockContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesBlockContentComponent, "cui-resources-block-content", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "resourcesAdded": "resourcesAdded"; }, never, ["*"], true, never>;
+}

package/widgets/ui/resources-block/components/resources-block-part/index.d.ts

@@ -0,0 +1 @@
+export { ResourcesBlockPartComponent } from './resources-block-part.component';

package/widgets/ui/resources-block/components/resources-block-part/resources-block-part.component.d.ts

@@ -0,0 +1,19 @@
+import type { ResourceUtilityPart } from './resources-block-part.options';
+import { ResourceContentType } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ResourcesBlockPartComponent {
+    private readonly factoryApiService;
+    private readonly utilityService;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly containerId: import("@angular/core").InputSignal<string>;
+    readonly elements: import("@angular/core").InputSignal<ResourceUtilityPart[]>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    protected onPartChanged(part: ResourceUtilityPart): void;
+    protected onPartDeleted(partId: string): void;
+    private initPartsStructure;
+    private getAddintionalResourceInfo;
+    protected readonly ResourceContentType: typeof ResourceContentType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesBlockPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesBlockPartComponent, "cui-resources-block-part", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "containerId": { "alias": "containerId"; "required": true; "isSignal": true; }; "elements": { "alias": "elements"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/resources-block/components/resources-block-part/resources-block-part.options.d.ts

@@ -0,0 +1,5 @@
+import { ToolboxType } from '@cuby-ui/api';
+export interface ResourceUtilityPart extends ToolboxType {
+    readonly isDelete: boolean;
+    readonly name: string;
+}

package/widgets/ui/resources-block/components/resources-block-tabs/index.d.ts

@@ -0,0 +1 @@
+export { ResourcesBlockTabsComponent } from './resources-block-tabs.component';

package/widgets/ui/resources-block/components/resources-block-tabs/resources-block-tabs.component.d.ts

@@ -0,0 +1,28 @@
+import type { TemplateRef } from '@angular/core';
+import { CuiTemplateContext } from '@cuby-ui/cdk';
+import type { ResourceDeleteOutput } from './resources-block-tabs.options';
+import { Resource, UtilityComponentWithResources } from '@cuby-ui/api';
+import { UtilitySubject } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+export declare class ResourcesBlockTabsComponent {
+    private readonly utilityApiService;
+    private readonly cuiDialogService;
+    protected readonly UTILITY_TEMPLATE_CONTEXT: CuiTemplateContext<Resource>;
+    protected readonly COMPONENTS_CONTENT: {
+        CONSUMABLES: typeof import("../resources-block-consumables").ResourcesBlockConsumablesComponent;
+        TOOLBOX: typeof import("../resources-block-toolbox").ResourcesBlockToolboxComponent;
+        PART: typeof import("@cuby-ui/core").ResourcesBlockPartComponent;
+    };
+    readonly resourceComponent: import("@angular/core").InputSignal<UtilityComponentWithResources>;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly buttonSlot: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    readonly selectedIndex: import("@angular/core").InputSignal<number>;
+    readonly resourceAdded: import("@angular/core").OutputEmitterRef<ResourceDeleteOutput>;
+    readonly resourceDeleted: import("@angular/core").OutputEmitterRef<Resource>;
+    readonly selectedIndexChange: import("@angular/core").OutputEmitterRef<number>;
+    protected onOpenDeleteResourceModal(resource: Resource): void;
+    protected onResourcesAdded(resources: UtilitySubject[], container: Resource): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesBlockTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesBlockTabsComponent, "cui-resources-block-tabs", never, { "resourceComponent": { "alias": "resourceComponent"; "required": true; "isSignal": true; }; "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "buttonSlot": { "alias": "buttonSlot"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "resourceAdded": "resourceAdded"; "resourceDeleted": "resourceDeleted"; "selectedIndexChange": "selectedIndexChange"; }, never, never, true, never>;
+}

package/widgets/ui/resources-block/components/resources-block-tabs/resources-block-tabs.options.d.ts

@@ -0,0 +1,13 @@
+import { ResourcesBlockConsumablesComponent } from '../resources-block-consumables';
+import { ResourcesBlockPartComponent } from '../resources-block-part';
+import { ResourcesBlockToolboxComponent } from '../resources-block-toolbox';
+import { Resource, UtilitySubject } from '@cuby-ui/api';
+export declare const COMPONENTS_CONTENT: {
+    CONSUMABLES: typeof ResourcesBlockConsumablesComponent;
+    TOOLBOX: typeof ResourcesBlockToolboxComponent;
+    PART: typeof ResourcesBlockPartComponent;
+};
+export interface ResourceDeleteOutput {
+    readonly resources: UtilitySubject[];
+    readonly container: Resource;
+}

package/widgets/ui/resources-block/components/resources-block-toolbox/index.d.ts

@@ -0,0 +1,2 @@
+export { ResourcesBlockToolboxComponent } from './resources-block-toolbox.component';
+export type { ResourceUtilityTool } from './resources-block-toolbox.options';

package/widgets/ui/resources-block/components/resources-block-toolbox/resources-block-toolbox.component.d.ts

@@ -0,0 +1,17 @@
+import { ResourceUtilityTool } from './resources-block-toolbox.options';
+import * as i0 from "@angular/core";
+export declare class ResourcesBlockToolboxComponent {
+    private readonly factoryApiService;
+    private readonly utilityService;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly containerId: import("@angular/core").InputSignal<string>;
+    readonly elements: import("@angular/core").InputSignal<ResourceUtilityTool[]>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    protected onToolChanged(tool: ResourceUtilityTool): void;
+    protected onToolDeleted(toolId: string): void;
+    private initToolsStructure;
+    private getAddintionalResourceInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesBlockToolboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesBlockToolboxComponent, "cui-resources-block-toolbox", never, { "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "containerId": { "alias": "containerId"; "required": true; "isSignal": true; }; "elements": { "alias": "elements"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/widgets/ui/resources-block/components/resources-block-toolbox/resources-block-toolbox.options.d.ts

@@ -0,0 +1,5 @@
+import { ToolboxType } from '@cuby-ui/api';
+export interface ResourceUtilityTool extends ToolboxType {
+    readonly isDelete: boolean;
+    readonly name: string;
+}

package/widgets/ui/resources-block/components/resources-options/index.d.ts

@@ -0,0 +1 @@
+export { ResourcesOptionsComponent } from './resources-options.component';

package/widgets/ui/resources-block/components/resources-options/resources-options.component.d.ts

@@ -0,0 +1,20 @@
+import { Resource, ResourceContentType } from '@cuby-ui/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@cuby-ui/cdk";
+export declare class ResourcesOptionsComponent {
+    private readonly quantumGroupResourcesStructureApiService;
+    protected readonly options: import("@angular/core").Signal<{
+        label: ResourceContentType;
+        command: () => void;
+    }[]>;
+    protected readonly isWithTitle: import("@angular/core").Signal<boolean>;
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly types: import("@angular/core").InputSignal<ResourceContentType[]>;
+    readonly utilityId: import("@angular/core").InputSignal<string>;
+    readonly appearance: import("@angular/core").InputSignal<"flat" | "ghost">;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly resourceAdded: import("@angular/core").OutputEmitterRef<Resource>;
+    protected addResource(type: ResourceContentType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourcesOptionsComponent, "cui-resources-options", never, { "types": { "alias": "types"; "required": true; "isSignal": true; }; "utilityId": { "alias": "utilityId"; "required": true; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "resourceAdded": "resourceAdded"; }, never, never, true, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,2 @@
+export { ResourcesBlockComponent } from './resources-block.component';
+export * from './components';