@cuby-ui/api 0.0.228

package/project/models/design-job-main-group-api.options.d.ts

@@ -0,0 +1,71 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+export interface Group extends SimpleGroup {
+    readonly jtext: string;
+    readonly structure: GroupBox[];
+}
+export interface GroupPart extends SimpleGroup {
+    readonly sizeStructure?: number;
+}
+export interface SimpleGroup {
+    readonly id: string;
+    readonly name: string;
+    readonly attributes: Record<string, string>;
+    readonly componentType: string;
+}
+export interface GroupBox extends GroupBoxPart {
+    readonly id: string;
+    readonly contentType: string;
+    readonly quantumFormalizations: GroupBoxFormalization[];
+}
+export interface GroupBoxPart {
+    readonly subjectElement: GroupBoxSubject;
+    readonly contentQuantumId: string;
+}
+export type GroupSubjectType = 'MATERIAL' | 'PART';
+export interface GroupBoxSubject {
+    readonly itemId: string;
+    readonly contentType: GroupSubjectType;
+}
+export interface GroupBoxFormalization {
+    readonly id?: string;
+    readonly quantumId: string;
+    readonly specification?: GroupBoxSpecification;
+}
+export interface GroupBoxSpecification {
+    readonly parameter: GroupBoxSpecificationParameter;
+}
+export interface GroupBoxSpecificationParameter {
+    readonly fileDXF: CuiNullable<File>;
+    readonly size: CuiNullable<number>;
+    readonly quantity: CuiNullable<number>;
+}
+export interface AddGroupBoxFormalizationRequestParams extends FormalizationRequestIds {
+    readonly quantumId: string;
+    readonly body: GroupBoxRequestSpecification;
+}
+export interface UpdateGroupBoxFormalizationRequestParams extends FormalizationRequestIds {
+    readonly formalizationId: string;
+    readonly body: GroupBoxRequestSpecification;
+}
+export interface DeleteGroupBoxFormalizationRequestParams extends FormalizationRequestIds {
+    readonly formalizationId: string;
+}
+export interface FormalizationRequestIds {
+    readonly phaseId: string;
+    readonly jobId: string;
+    readonly groupId: string;
+    readonly boxId: string;
+}
+export interface GroupBoxRequestSpecification {
+    readonly parameter: GroupBoxRequestSpecificationParameter;
+    readonly fileDXF: CuiNullable<File>;
+}
+export interface GroupBoxRequestSpecificationParameter {
+    readonly size: CuiNullable<number>;
+    readonly quantity: number;
+    readonly type_operations: FormalizationTypeOperations;
+}
+export declare const enum FormalizationTypeOperations {
+    PART = "PART_QUANTUM_FORMALIZATION",
+    MATERIAL = "MATERIAL_QUANTUM_FORMALIZATION"
+}

package/project/models/index.d.ts

@@ -0,0 +1,9 @@
+export * from './design-job-main-api.options';
+export * from './design-job-main-group-api.options';
+export * from './project-api.options';
+export * from './project-details-phase-init-api.options';
+export * from './project-init-phase-api.options';
+export * from './project-phase-design-technology-api.options';
+export * from './project-resource-phase-init-api.options';
+export * from './project-schedule-phase-init-api.options';
+export * from './technology-phase-init-api.options';

package/project/models/project-api.options.d.ts

@@ -0,0 +1,75 @@
+import type { ProjectDetailsPhase, ProjectInitPhases } from './project-init-phase-api.options';
+import type { TechnologyPhaseRules } from './technology-phase-init-api.options';
+export declare const enum ProjectTypeOperations {
+    create = "CREATE_PROJECT"
+}
+export declare const enum ProjectPhases {
+    Init = "INIT",
+    Design = "DESIGN",
+    Preparation = "PREPARATION_FOR_CONSTRUCTION",
+    Construction = "CONSTRUCTION"
+}
+export interface CreateProjectRequestBody {
+    readonly title: string;
+    readonly storageNodeId: string;
+}
+export interface Project {
+    readonly id: string;
+    readonly title: string;
+    readonly currentPhase: SimpleProjectPhase;
+}
+export interface SimpleProjectPhase<T = ProjectPhases> {
+    readonly id: string;
+    readonly type: T;
+}
+export interface ProjectPhase<T = ProjectPhaseContent> {
+    readonly id: string;
+    readonly projectId: string;
+    readonly type: ProjectPhases;
+    readonly content: T;
+}
+export interface ProjectPhaseContent {
+    readonly timeCreated: string;
+    readonly isCompleted: boolean;
+}
+export interface ProjectInitPhase {
+    readonly id: string;
+    readonly projectId: string;
+    readonly type: ProjectPhases.Init;
+    readonly content: ProjectInitPhaseContent;
+}
+export interface ProjectDesignPhase {
+    readonly id: string;
+    readonly projectId: string;
+    readonly type: ProjectPhases.Design;
+    readonly content: ProjectDesignPhaseContent;
+}
+export interface ProjectInitPhaseContent extends ProjectPhaseContent {
+    readonly components: ProjectInitComponents[];
+}
+export interface ProjectDesignPhaseContent extends ProjectPhaseContent {
+    readonly phaseInitializationId: string;
+}
+export type ProjectInitComponents = ProjectDetailsPhase | ProjectLinkTechnologyPhase | ProjectHomeProduserPhase | ProjectResourceManagmentPhase;
+export interface ProjectLinkTechnologyPhase {
+    readonly id: string;
+    readonly type: ProjectInitPhases.LinkTechnology;
+    readonly constructionTechnologyId: string;
+    readonly stageRules: TechnologyRule[];
+}
+export interface TechnologyRule {
+    readonly id: string;
+    readonly key: string;
+    readonly rulesType: TechnologyPhaseRules;
+    readonly stageId: string;
+    readonly taskId: string;
+}
+export interface ProjectHomeProduserPhase {
+    readonly id: string;
+    readonly type: ProjectInitPhases.HomeProducer;
+    readonly homeProviderId: string;
+}
+export interface ProjectResourceManagmentPhase {
+    readonly id: string;
+    readonly type: ProjectInitPhases.ConstructionResourseManagment;
+}

package/project/models/project-details-phase-init-api.options.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectCoordinates } from './project-init-phase-api.options';
+export interface ProjectAddressDetailsRequestBody {
+    readonly address: string;
+    readonly mapsLink: string;
+    readonly addressGps: ProjectCoordinates;
+    readonly polygonGPSCoordinate: ProjectCoordinates[];
+}

package/project/models/project-init-phase-api.options.d.ts

@@ -0,0 +1,29 @@
+export declare const enum ProjectInitPhases {
+    Details = "PROJECT_DETAILS",
+    LinkTechnology = "LINK_TECHNOLOGY",
+    HomeProducer = "HOME_PRODUCER",
+    ConstructionResourseManagment = "CONSTRUCTION_RESOURCE_MANAGEMENT",
+    Schedule = "SCHEDULE"
+}
+export declare const enum ProjectInitPhaseIndex {
+    Details = 0,
+    LinkTechnology = 1,
+    HomeProducer = 2,
+    ConstructionResourseManagment = 3
+}
+export interface ProjectDetailsPhase {
+    readonly id: string;
+    readonly type: ProjectInitPhases.Details;
+    readonly address: ProjectDetailsAddress;
+    readonly jdescription: string;
+}
+export interface ProjectDetailsAddress {
+    readonly address: string;
+    readonly mapsLink: string;
+    readonly addressGps: ProjectCoordinates;
+    readonly polygonGPSCoordinate: ProjectCoordinates[];
+}
+export interface ProjectCoordinates {
+    readonly x: number;
+    readonly y: number;
+}

package/project/models/project-phase-design-technology-api.options.d.ts

@@ -0,0 +1,33 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { FrameActivity, Job, JobContent, JobContentStructureType, SimpleMainJob, TreeStruct } from '../../shared';
+export type ProjectStageStruct = TreeStruct<SimpleMainJob<ProjectStageActivity>>;
+export interface ProjectStageExtendedActivity extends FrameActivity<ProjectStageExtendedActivityWorks> {
+    readonly constructionTechnologyId: string;
+    readonly phaseDesignId: string;
+    readonly projectId: string;
+}
+export interface ProjectStageExtendedActivityWorks {
+    readonly MAIN_WORKS: Job<ProjectStageMainJobContent>[];
+}
+export interface ProjectStageActivity {
+    readonly stageDesignContext: ProjectDesignContent;
+    readonly contentStage: ProjectStageContent;
+}
+export interface ProjectDesignContent {
+    readonly stageDesignContextType: DesignContextType;
+    readonly isDesignComplete: boolean;
+}
+export interface ProjectStageContent extends FrameActivity {
+    readonly utilityId: CuiNullable<string>;
+}
+export interface ProjectStageMainJobContent extends JobContentStructureType {
+    readonly stageDesignContext: ProjectDesignContent;
+    readonly contentJob: ProjectStageMainJobContentJob;
+}
+export interface ProjectStageMainJobContentJob extends JobContent {
+    readonly correctionTasks: string[];
+}
+export declare const enum DesignContextType {
+    Complete = "DESIGN_COMPLETE",
+    Exclude = "DESIGN_EXCLUDE"
+}

package/project/models/project-resource-phase-init-api.options.d.ts

@@ -0,0 +1,31 @@
+export interface ProjectResourceRequestBody {
+    readonly phaseInitId: string;
+    readonly crewTemplate: ProjectResourceTemplateRequestBody;
+}
+export type ProjectResourceTemplateRequestBody = Omit<ProjectResourceTemplatePart, 'id'>;
+export interface ProjectResourceTemplatePart {
+    readonly id: string;
+    readonly crewId: string;
+    readonly crewRoleParticipants: ProjectCrewRoleParticipant[];
+    readonly schedule?: ProjectResourceSchedule;
+}
+export interface ProjectResourceSchedule {
+    readonly builderCrewId: string;
+    readonly scheduleId: string;
+    readonly scheduleType: string;
+}
+export interface ProjectResourceTemplate extends ProjectResourceTemplatePart {
+    readonly projectId: string;
+    readonly phaseInitId: string;
+}
+export interface CreateProjectResourceResponse {
+    readonly builderCrews: [string];
+}
+export interface ProjectCrewRoleParticipant {
+    readonly roleCrewId: string;
+    readonly workerUserId: string;
+}
+export declare const enum ProjectResourceTypeOperations {
+    Create = "CONSTRUCTION_RESOURCE_CREW_OPERATION_CREATE",
+    Update = "CONSTRUCTION_RESOURCE_CREW_OPERATION_TEMPLATE"
+}

package/project/models/project-schedule-phase-init-api.options.d.ts

@@ -0,0 +1,10 @@
+export interface ApplyCrewScheduleRequestBody {
+    readonly builderCrewId: string;
+    readonly scheduleId: string;
+    readonly startingFromData: string;
+    readonly type_operations: CrewScheduleTypeOperations;
+}
+export declare const enum CrewScheduleTypeOperations {
+    Weekly = "WEEKLY_SCHEDULE",
+    Rotating = "ROTATING_SCHEDULE"
+}

package/project/models/technology-phase-init-api.options.d.ts

@@ -0,0 +1,4 @@
+export declare const enum TechnologyPhaseRules {
+    Stage = "STAGE_EXCLUDE",
+    Task = "STAGE_TASK_EXCLUDE"
+}

package/project/services/crew-template-api.service.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { ProjectResourceTemplate, ProjectResourceTemplateRequestBody } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiCrewTemplateApiService {
+    private readonly httpClient;
+    private readonly CREW_TEMPLATE_URL;
+    getCrewTemplates(crewId: string): Observable<ProjectResourceTemplate>;
+    createTemplate(body: ProjectResourceTemplateRequestBody): Observable<ProjectResourceTemplate[]>;
+    getTemplateById(templateId: string): Observable<ProjectResourceTemplate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCrewTemplateApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiCrewTemplateApiService>;
+}

package/project/services/design-job-main-api.service.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import type { ProjectMainJobContent } from '../models';
+import type { Job } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class CuiDesignJobMainApiService {
+    private readonly httpClient;
+    private readonly PROJECT_STAGE_URL;
+    getTask(phaseId: string, activityId: string, taskId: string): Observable<Job<ProjectMainJobContent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDesignJobMainApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiDesignJobMainApiService>;
+}

package/project/services/design-job-main-group-api.service.d.ts

@@ -0,0 +1,20 @@
+import type { Observable } from 'rxjs';
+import type { AddGroupBoxFormalizationRequestParams, DeleteGroupBoxFormalizationRequestParams, Group, GroupBox, GroupBoxFormalization, GroupBoxPart, UpdateGroupBoxFormalizationRequestParams } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiDesignJobMainGroupApiService {
+    private readonly httpClient;
+    private readonly DESIGN_URL;
+    private readonly JOB_GROUP_URL;
+    changeName(jobId: string, groupId: string, name: string): Observable<void>;
+    getGroup(phaseId: string, jobId: string, groupId: string): Observable<Group>;
+    createGroup(phaseId: string, jobId: string): Observable<Group>;
+    deleteGroup(phaseId: string, jobId: string, groupId: string): Observable<void>;
+    addGroupBox(phaseId: string, jobId: string, groupId: string, body: GroupBoxPart): Observable<GroupBox>;
+    addFormalization(params: AddGroupBoxFormalizationRequestParams): Observable<GroupBoxFormalization>;
+    updateFormalization(params: UpdateGroupBoxFormalizationRequestParams): Observable<GroupBoxFormalization>;
+    deleteFormalization(params: DeleteGroupBoxFormalizationRequestParams): Observable<void>;
+    deleteGroupBox(phaseId: string, jobId: string, groupId: string, boxId: string): Observable<void>;
+    private getFormalizationFormData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDesignJobMainGroupApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiDesignJobMainGroupApiService>;
+}

package/project/services/index.d.ts

@@ -0,0 +1,10 @@
+export { CuiCrewTemplateApiService } from './crew-template-api.service';
+export { CuiDesignJobMainApiService } from './design-job-main-api.service';
+export { CuiDesignJobMainGroupApiService } from './design-job-main-group-api.service';
+export { CuiProjectApiService } from './project-api.service';
+export { CuiProjectDetailsPhaseInitApiService } from './project-details-phase-init-api.service';
+export { CuiProjectInitPhaseApiService } from './project-init-phase-api.service';
+export { CuiProjectPhaseDesignTechnologyService } from './project-phase-design-technology-api.service';
+export { CuiProjectResoursePhaseInitApiService } from './project-resource-phase-init-api.service';
+export { CuiProjectSchedulePhaseInitApiService } from './project-schedule-phase-init-api.service';
+export { CuiTechnologyPhaseInitApiService } from './technology-phase-init-api.service';

package/project/services/project-api.service.d.ts

@@ -0,0 +1,15 @@
+import { type Observable } from 'rxjs';
+import { CreateProjectRequestBody, Project, ProjectPhase, ProjectPhaseContent, ProjectPhases } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiProjectApiService {
+    private readonly httpClient;
+    private readonly PROJECT_URL;
+    getProject(id: string): Observable<Project>;
+    getProjects(): Observable<Project[]>;
+    changePhase(projectId: string, type: ProjectPhases): Observable<ProjectPhase>;
+    getProjectPhase<T = ProjectPhaseContent>(phaseId: string): Observable<ProjectPhase<T>>;
+    updateTitle(id: string, title: string): Observable<void>;
+    createProject(body: CreateProjectRequestBody): Observable<Project>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectApiService>;
+}

package/project/services/project-details-phase-init-api.service.d.ts

@@ -0,0 +1,10 @@
+import type { Observable } from 'rxjs';
+import type { ProjectAddressDetailsRequestBody } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiProjectDetailsPhaseInitApiService {
+    private readonly httpClient;
+    private readonly PROJECT_INIT_PHASE_URL;
+    setAddress(phaseId: string, body: ProjectAddressDetailsRequestBody): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectDetailsPhaseInitApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectDetailsPhaseInitApiService>;
+}

package/project/services/project-init-phase-api.service.d.ts

@@ -0,0 +1,10 @@
+import type { Observable } from 'rxjs';
+import type { ProjectInitComponents, ProjectInitPhases } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiProjectInitPhaseApiService {
+    private readonly httpClient;
+    private readonly PROJECT_INIT_PHASE_URL;
+    changePhase(initPhaseId: string, type: ProjectInitPhases): Observable<ProjectInitComponents>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectInitPhaseApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectInitPhaseApiService>;
+}

package/project/services/project-phase-design-technology-api.service.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { ProjectStageExtendedActivity, ProjectStageStruct } from '../models';
+import { SimpleMainJob } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class CuiProjectPhaseDesignTechnologyService {
+    private readonly httpClient;
+    private readonly DESIGN_PAHASE_URL;
+    getTechnologyStages(phaseId: string): Observable<ProjectStageStruct>;
+    getStage(phaseId: string, stageActivityId: string): Observable<SimpleMainJob<ProjectStageExtendedActivity>>;
+    getStageChildren(phaseId: string, stageId: string): Observable<ProjectStageStruct>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectPhaseDesignTechnologyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectPhaseDesignTechnologyService>;
+}

package/project/services/project-resource-phase-init-api.service.d.ts

@@ -0,0 +1,14 @@
+import { type Observable } from 'rxjs';
+import { ProjectCrewRoleParticipant, ProjectResourceRequestBody, ProjectResourceTemplate } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiProjectResoursePhaseInitApiService {
+    private readonly httpClient;
+    private readonly PROJECT_RESOURCE_URL;
+    createCrewTemplate(body: ProjectResourceRequestBody): Observable<string>;
+    replaceCrewTemplate(phaseInitId: string, crewTemplateId: string): Observable<string>;
+    updateCrewTemplate(phaseId: string, builderId: string, body: ProjectCrewRoleParticipant): Observable<void>;
+    getCrewTemplates(phaseId: string): Observable<ProjectResourceTemplate[]>;
+    deleteCrewTemplate(phaseId: string, builderCrewId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectResoursePhaseInitApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectResoursePhaseInitApiService>;
+}

package/project/services/project-schedule-phase-init-api.service.d.ts

@@ -0,0 +1,10 @@
+import type { Observable } from 'rxjs';
+import type { ProjectResourceTemplate, ApplyCrewScheduleRequestBody } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiProjectSchedulePhaseInitApiService {
+    private readonly httpClient;
+    private readonly PROJECT_INIT_URL;
+    applySchedule(phaseId: string, body: ApplyCrewScheduleRequestBody): Observable<ProjectResourceTemplate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiProjectSchedulePhaseInitApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiProjectSchedulePhaseInitApiService>;
+}

package/project/services/technology-phase-init-api.service.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import { TechnologyRule } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiTechnologyPhaseInitApiService {
+    private readonly httpClient;
+    private readonly PROJECT_INIT_PHASE_URL;
+    setTechnology(id: string, technologyId: string): Observable<void>;
+    addStageRule(phaseId: string, stageId: string): Observable<TechnologyRule>;
+    addTaskRule(phaseId: string, stageId: string, taskId: string): Observable<TechnologyRule>;
+    deleteRule(phaseId: string, technologyId: string, stageRulesId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTechnologyPhaseInitApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiTechnologyPhaseInitApiService>;
+}

package/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './services';

package/shared/models/frame-api.options.d.ts

@@ -0,0 +1,22 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+export interface Frame {
+    id: string;
+    fragments: Fragment[];
+}
+export type Fragment = JTextFragment | ResourceFragment;
+export declare const enum FragmentType {
+    jText = "J_TEXT",
+    resourceFile = "RESOURCE_FILE"
+}
+export interface JTextFragment {
+    readonly id: string;
+    readonly type: FragmentType.jText;
+    readonly notEmpty: boolean;
+}
+export interface ResourceFragment {
+    readonly id: string;
+    readonly type: FragmentType.resourceFile;
+    readonly name: CuiNullable<string>;
+    readonly fileId: CuiNullable<string>;
+    readonly resource: CuiNullable<string>;
+}

package/shared/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from './job.options';
+export * from './frame-api.options';
+export * from './tree-struct.options';
+export * from './tree-struct-type.options';
+export * from './tree-struct-navigator-api.options';

package/shared/models/job.options.d.ts

@@ -0,0 +1,62 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+export declare const enum JobStructureType {
+    Simple = "SIMPLE",
+    Parallel = "PARALLEL"
+}
+export declare const enum JobType {
+    JobAction = "JOB_ACTION",
+    JobMain = "JOB_MAIN",
+    JobApproval = "JOB_APPROVAL",
+    JobEvaluation = "JOB_EVALUATION",
+    JobCorrective = "JOB_CORRECTIVE_MAIN_TASK"
+}
+export interface Job<T extends JobContentStructureType = JobContentStructureType> {
+    readonly id: string;
+    readonly title: string;
+    readonly type: JobType;
+    readonly textContainerId: string;
+    readonly content: T;
+}
+export interface SimpleMainJob<T = FrameActivity> {
+    readonly frameActivity: T;
+    readonly id: string;
+    readonly textContainerId: CuiNullable<string>;
+    readonly typeHandler: string;
+}
+export interface WorkTypes {
+    readonly APPROVAL_WORKS: string;
+    readonly MAIN_WORKS: string;
+    readonly PREPARATORY_WORKS: string;
+}
+export interface FrameActivity<T = WorkTypes> {
+    readonly works: T;
+    readonly carrierStageTreeStructId: string;
+    readonly expansionShiftJobId: string;
+}
+export interface JobContentStructureType {
+    readonly structureType: JobStructureType;
+    readonly jobs?: Job[];
+}
+export interface JobContent {
+    readonly components: JobContentComponents;
+    readonly containersQuantum: string[];
+    readonly divideTask: string;
+    readonly isGenerateSegmentWithOneQuantum: boolean;
+    readonly structureType: string;
+    readonly estimatedTime: string;
+    readonly type: string;
+    readonly treeStructId: string;
+}
+export interface JobContentComponents {
+    readonly TASK_EVALUATION_COMPONENT: JobContentPart;
+    readonly CHECKLIST_ACTIONS_STRUCT_NAVIGATION: JobContentPart;
+    readonly CHECKLIST_ACTIONS: JobContentPart;
+    readonly TEAM_COMPONENT: JobContentPart;
+    readonly PREPARATORY_STEPS: JobContentPart;
+    readonly QUANTUM: JobContentPart;
+    readonly CHECKLIST_EVALUATION: JobContentPart;
+}
+export interface JobContentPart {
+    readonly id: string;
+    readonly componentId: string;
+}

package/shared/models/tree-struct-navigator-api.options.d.ts

@@ -0,0 +1,21 @@
+export declare const enum MovingType {
+    TARGET_TREE_STRUCT = "MOVING_TARGET_TREE_STRUCT",
+    TARGET_NODE = "MOVING_TARGET_ITEM",
+    SINGLE_TARGET_TREE_STRUCT = "MOVING_SINGLE_TARGET_TREE_STRUCT"
+}
+export type MovingRequestBody = MovingTargetTreeStructRequestBody | MovingTargetNodeRequestBody;
+export interface MovingTargetTreeStructRequestBody {
+    readonly type: MovingType.TARGET_TREE_STRUCT;
+    readonly movableItemId: string;
+    readonly treeStructMovableItemId: string;
+    readonly treeStructTargetItemId: string;
+}
+export interface MovingTargetNodeRequestBody {
+    readonly type: MovingType.TARGET_NODE;
+    readonly movableItemId: string;
+    readonly treeStructMovableItemId: string;
+    readonly targetItemId: string;
+    readonly treeStructTargetItemId: string;
+    readonly pointer: MovingTargetNodePointer;
+}
+export type MovingTargetNodePointer = 'BEFORE' | 'AFTER';

package/shared/models/tree-struct-type.options.d.ts

@@ -0,0 +1,10 @@
+export declare const enum TreeStructType {
+    Stage = "STAGE_STORAGE",
+    Quant = "QUANTUM_STORAGE",
+    Operation = "OPERATION_STORAGE",
+    Criteria = "CRITERION_STORAGE",
+    Instruction = "INSTRUCTION_STORAGE",
+    Evaluation = "JOB_STORAGE_EVALUATION",
+    Shift = "JOB_STORAGE_ACTION",
+    Project = "PROJECT_STORAGE"
+}

package/shared/models/tree-struct.options.d.ts

@@ -0,0 +1,14 @@
+import type { Job } from './job.options';
+export interface TreeStructBase {
+    readonly id: string;
+    readonly title: string;
+    readonly description?: string;
+    readonly ancestors: [TreeStructAncestor, ...TreeStructAncestor[]];
+}
+export interface TreeStruct<T = Job> extends TreeStructBase {
+    readonly elements: T[];
+    readonly children: TreeStruct<T>[] | string[];
+}
+export interface TreeStructAncestor {
+    readonly id: string;
+}

package/shared/services/frame-api.service.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { Fragment, Frame, FragmentType } from '../models/frame-api.options';
+import { CuiSharedApiService } from './shared-api.service';
+import * as i0 from "@angular/core";
+export declare class CuiFrameApiService extends CuiSharedApiService {
+    private readonly http;
+    private readonly FRAMER_URL;
+    private readonly FRAGMENT_URL;
+    getFrame(frameId: string): Observable<Frame>;
+    createFrame(): Observable<string>;
+    createFragment(frameId: string, type: FragmentType): Observable<Fragment>;
+    deleteFragment(frameId: string, fragmentId: string): Observable<void>;
+    uploadResource(body: FormData, frameId: string, fragmentId: string): Observable<{
+        resource: string;
+    }>;
+    deleteResource(frameId: string, fragmentId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiFrameApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiFrameApiService>;
+}

package/shared/services/index.d.ts

@@ -0,0 +1,3 @@
+export { CuiFrameApiService } from './frame-api.service';
+export { CuiTreeStructApiService } from './tree-struct-api.service';
+export { CuiTreeStructNavigatorApiService } from './tree-struct-navigator-api.service';

package/shared/services/shared-api.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpContext } from '@angular/common/http';
+import { CuiApiUrl } from '../../constants';
+import * as i0 from "@angular/core";
+export declare class CuiSharedApiService {
+    private CONTEXT_URL;
+    protected readonly SHARED_HTTP_OPTIONS: {
+        context: HttpContext;
+    };
+    setContextUrl(context: CuiApiUrl): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiSharedApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiSharedApiService>;
+}

package/shared/services/tree-struct-api.service.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import { Job, TreeStruct } from '../models';
+import { CuiSharedApiService } from './shared-api.service';
+import * as i0 from "@angular/core";
+export declare class CuiTreeStructApiService extends CuiSharedApiService {
+    private readonly httpClient;
+    private readonly TREE_STRUCT_URL;
+    getById<T = Job>(id: string): Observable<TreeStruct<T>>;
+    getStageStoragesByParent<T = Job>(parentId: string): Observable<TreeStruct<T>>;
+    deleteTreeStructElement(treeStructId: string, elementId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTreeStructApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiTreeStructApiService>;
+}