@cuby-ui/api 0.0.249 → 0.0.251

package/factory/models/arrow-work-flow-trasnfer-controller-api.options.d.ts

@@ -0,0 +1,55 @@
+export declare const enum TransferType {
+    Manual = "MANUAL_HANDLING",
+    LogisticVehicle = "LOGISTIC_VEHICLE"
+}
+export type TransferTypeValues = 'MANUAL_HANDLING' | 'LOGISTIC_VEHICLE';
+export declare const enum ArrowWorkFlowTrasferChangeType {
+    InterLogistic = "CHANGE_INTER_LOGISTIC",
+    Optional = "CHANGE_OPTIONAL"
+}
+export interface CreateWorkflowInstructionRequestBody {
+    readonly arrowActionWorkFlowId: string;
+    readonly storageNodeId: string;
+    readonly transferActionWorkFlowId: string;
+}
+export interface CopyWorkflowInstructionRequestBody {
+    readonly arrowActionWorkFlowId: string;
+    readonly transferActionWorkFlowId: string;
+    readonly selectInstructionId: string;
+}
+export interface InsertWorkflowInstructionRequestBody {
+    readonly arrowActionWorkFlowId: string;
+    readonly transferActionWorkFlowId: string;
+    readonly selectInstructionId: string;
+}
+export interface UnbindWorkflowInstructionRequestBody {
+    readonly arrowActionWorkFlowId: string;
+    readonly transferActionWorkFlowId: string;
+    readonly selectInstructionId: string;
+}
+export interface AddArrowWorkFlowTransferBase {
+    readonly type: TransferType;
+    readonly arrowActionWorkFlowId: string;
+}
+export type AddArrowWorkFlowTransferRequestBody = AddArrowWorkFlowVehicleTransferRequestBody | AddArrowWorkFlowManualTransferRequestBody;
+export interface AddArrowWorkFlowVehicleTransferRequestBody extends AddArrowWorkFlowTransferBase {
+    readonly interLogisticsId: string;
+}
+export interface AddArrowWorkFlowManualTransferRequestBody extends AddArrowWorkFlowTransferBase {
+    readonly name: string;
+    readonly numberPeople: number;
+}
+export type UpdateArrowWorkFlowTransferRequestBody = UpdateArrowWorkFlowManualTransfer | UpdateArrowWorkFlowVehicleTransfer;
+export interface UpdateArrowWorkFlowTransderBase {
+    readonly arrowActionWorkFlowId: string;
+    readonly change_type: ArrowWorkFlowTrasferChangeType;
+    readonly oldTransferActionWorkFlowId: string;
+    readonly optionalTransferActionWorkFlowId?: string;
+}
+export interface UpdateArrowWorkFlowVehicleTransfer extends UpdateArrowWorkFlowTransderBase {
+    readonly type: TransferType.LogisticVehicle;
+    readonly interLogisticsId?: string;
+}
+export interface UpdateArrowWorkFlowManualTransfer extends UpdateArrowWorkFlowTransderBase {
+    readonly type: TransferType.Manual;
+}

package/factory/models/consumable.d.ts

@@ -0,0 +1,15 @@
+import { Measurement } from "./measurment";
+export interface Consumable {
+    readonly id?: string;
+    readonly materialId?: string;
+    readonly amountMaterial?: string;
+    readonly period?: ConsumablePeriod;
+    readonly consumableWrapper: any;
+    readonly type?: string;
+    readonly measurement?: Measurement;
+    readonly wearPercentage?: string;
+}
+export interface ConsumablePeriod {
+    readonly unitPeriod: 'MONTHS' | 'YEARS' | 'WEEKS' | 'DAYS';
+    readonly value: number;
+}

package/factory/models/index.d.ts

@@ -0,0 +1,13 @@
+export * from './arrow-work-flow-controller-api.options';
+export * from './arrow-work-flow-component-controller-api.options';
+export * from './arrow-work-flow-component-structure-api.options';
+export * from './arrow-work-flow-controller-api.options';
+export * from './arrow-work-flow-readiness-checklist-api.options';
+export * from './arrow-work-flow-trasnfer-controller-api.options';
+export * from './consumable';
+export * from './intra-logistic';
+export * from './maintenance';
+export * from './manufacturer';
+export * from './measurment';
+export * from './specification';
+export * from './specifications';

package/factory/models/intra-logistic.d.ts

@@ -0,0 +1,44 @@
+import type { CuiNullable } from '@cuby-ui/cdk';
+import { Consumable } from './consumable';
+import { Maintenance } from './maintenance';
+import { Manufacturer } from './manufacturer';
+import { Specification } from './specification';
+import { Specifications } from './specifications';
+export interface IntraLogistic {
+    readonly id: string;
+    readonly type: string;
+    readonly name: string;
+    readonly shortName: string;
+    readonly descriptionId?: CuiNullable<string>;
+    readonly pdmNumber: string;
+    readonly transportSpecifications: TransportSpecifications;
+    readonly manufacturers: Manufacturer[];
+    readonly analogues: string[];
+    readonly isDelete?: boolean;
+    readonly maintainability?: MaintainabilityContent;
+}
+export declare enum MaintainableContentType {
+    MAINTAINABLE = "MAINTAINABLE",
+    UNMAINTAINABLE = "NOT_MAINTAINABLE"
+}
+export interface TransportSpecifications extends Specifications {
+    readonly loadingCapacity: CuiNullable<Specification>;
+}
+export type MaintainabilityContent = MaintainableContent | UnmaintainableContent;
+export interface UnmaintainableContent {
+    readonly id: string;
+    readonly type: MaintainableContentType.UNMAINTAINABLE;
+    readonly isDelete: boolean;
+    readonly resource: null | string;
+}
+export interface MaintainableContent {
+    readonly id: string;
+    readonly type: MaintainableContentType.MAINTAINABLE;
+    readonly isDelete: boolean;
+    readonly maintenances: Maintenance[];
+    readonly spareParts: null | SpareParts;
+}
+export interface SpareParts {
+    readonly servicePeriod: string;
+    readonly consumables: Consumable[];
+}

package/factory/models/maintenance.d.ts

@@ -0,0 +1,12 @@
+import { CuiNullable } from "@cuby-ui/cdk";
+import { Consumable } from "./consumable";
+export interface Maintenance {
+    readonly id: string;
+    readonly interval: {
+        readonly unit: 'HOURS';
+        readonly value: CuiNullable<number>;
+    };
+    readonly duration: string;
+    readonly consumables: Consumable[];
+    readonly holderInstructionStorageId?: string;
+}

package/factory/models/manufacturer.d.ts

@@ -0,0 +1,5 @@
+export interface Manufacturer {
+    readonly id?: string;
+    readonly name: string;
+    readonly link: string;
+}

package/factory/models/measurment.d.ts

@@ -0,0 +1,5 @@
+export interface Measurement {
+    readonly measure: string;
+    readonly unit: string;
+    readonly value: number;
+}

package/factory/models/specification.d.ts

@@ -0,0 +1,4 @@
+export interface Specification {
+    readonly value: number;
+    readonly unit: string;
+}

package/factory/models/specifications.d.ts

@@ -0,0 +1,8 @@
+import { CuiNullable } from "@cuby-ui/cdk";
+import { Specification } from "./specification";
+export interface Specifications {
+    readonly width: CuiNullable<Specification>;
+    readonly height: CuiNullable<Specification>;
+    readonly length: CuiNullable<Specification>;
+    readonly weight: CuiNullable<Specification>;
+}

package/factory/services/arrow-work-flow-actions-api.service.d.ts

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

package/factory/services/arrow-work-flow-component-controller-api.service.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import { WorkflowActionComponent, WorkflowComponentType, WorkflowSuitableAction } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiArrowWorkFlowComponentControllerApiService {
+    private readonly httpClient;
+    private readonly WORKFLOW_URL;
+    createComponent(arrowActionWorkFlowId: string, type: WorkflowComponentType): Observable<WorkflowActionComponent>;
+    getSuitable(arrowActionWorkFlowId: string, type: WorkflowComponentType): Observable<WorkflowSuitableAction[]>;
+    deleteComponent(arrowActionWorkFlowId: string, componentId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiArrowWorkFlowComponentControllerApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiArrowWorkFlowComponentControllerApiService>;
+}

package/factory/services/arrow-work-flow-component-structure-api.service.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import { MoveArrowWorkFlowStructureParams, WorkflowComponentType } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiArrowWorkFlowComponentStructureApiService {
+    private readonly httpClient;
+    private readonly WORKFLOW_URL;
+    moveStructure(arrowActionWorkFlowId: string, params: MoveArrowWorkFlowStructureParams): Observable<void>;
+    deleteStructure(arrowActionWorkFlowId: string, type: WorkflowComponentType, structureId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiArrowWorkFlowComponentStructureApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiArrowWorkFlowComponentStructureApiService>;
+}

package/factory/services/arrow-work-flow-readiness-checklist-api.service.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import { WorkflowChecklistStructure } from '../models';
+import * as i0 from "@angular/core";
+export declare class CuiArrowWorkFlowReadinessChecklistApiService {
+    private readonly httpClient;
+    private readonly WORKFLOW_URL;
+    createChecklist(arrowId: string): Observable<WorkflowChecklistStructure>;
+    injectChecklist(arrowId: string, checklistId: string): Observable<WorkflowChecklistStructure>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiArrowWorkFlowReadinessChecklistApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiArrowWorkFlowReadinessChecklistApiService>;
+}

package/factory/services/arrow-work-flow-trasnfer-controller-api.service.d.ts

@@ -0,0 +1,18 @@
+import type { Observable } from 'rxjs';
+import { AddArrowWorkFlowTransferRequestBody, CopyWorkflowInstructionRequestBody, CreateWorkflowInstructionRequestBody, InsertWorkflowInstructionRequestBody, TransferType, UnbindWorkflowInstructionRequestBody, UpdateArrowWorkFlowTransferRequestBody, WorkflowTransferStructure } from '../models';
+import { StorageObjectInstruction } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class CuiArrowWorkFlowTransferControllerApiService {
+    private readonly httpClient;
+    private readonly WORKFLOW_URL;
+    private readonly TRANSFER_URL;
+    createInstruction(body: CreateWorkflowInstructionRequestBody): Observable<StorageObjectInstruction>;
+    copyInstruction(body: CopyWorkflowInstructionRequestBody): Observable<StorageObjectInstruction>;
+    insertInstruction(body: InsertWorkflowInstructionRequestBody): Observable<StorageObjectInstruction>;
+    unbindInstruction(body: UnbindWorkflowInstructionRequestBody): Observable<StorageObjectInstruction>;
+    addTransfer(body: AddArrowWorkFlowTransferRequestBody): Observable<WorkflowTransferStructure>;
+    updateTransfer(body: UpdateArrowWorkFlowTransferRequestBody): Observable<WorkflowTransferStructure>;
+    insertTransfer(arrowActionWorkFlowId: string, id: string, transferType: TransferType): Observable<WorkflowTransferStructure>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiArrowWorkFlowTransferControllerApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiArrowWorkFlowTransferControllerApiService>;
+}

package/factory/services/index.d.ts

@@ -1 +1,6 @@
 export { CuiInstructionsApiService } from './instructions-api.service';
+export { CuiArrowWorkFlowActionsApiService } from './arrow-work-flow-actions-api.service';
+export { CuiArrowWorkFlowComponentControllerApiService } from './arrow-work-flow-component-controller-api.service';
+export { CuiArrowWorkFlowReadinessChecklistApiService } from './arrow-work-flow-readiness-checklist-api.service';
+export { CuiArrowWorkFlowComponentStructureApiService } from './arrow-work-flow-component-structure-api.service';
+export { CuiArrowWorkFlowTransferControllerApiService } from './arrow-work-flow-trasnfer-controller-api.service';

package/fesm2022/cuby-ui-api.mjs

@@ -5,6 +5,14 @@ import { map } from 'rxjs';
 
 const CUI_API_URL_CONTEXT = new HttpContextToken(() => null);
 
+var SubjectType;
+(function (SubjectType) {
+    SubjectType["Material"] = "MATERIAL";
+    SubjectType["Part"] = "PART";
+    SubjectType["Tool"] = "TOOL";
+    SubjectType["Equipment"] = "EQUIPMENT";
+})(SubjectType || (SubjectType = {}));
+
 class CuiSharedApiService {
     constructor() {
         this.CONTEXT_URL = "cuby-construction" /* CuiApiUrl.Construction */;
@@ -83,6 +91,10 @@ const SHARED_PROJECT_HTTP_OPTIONS = {
     context: new HttpContext().set(CUI_API_URL_CONTEXT, "cuby-project" /* CuiApiUrl.Project */)
 };
 
+const SHARED_FACTORY_HTTP_OPTIONS = {
+    context: new HttpContext().set(CUI_API_URL_CONTEXT, "cuby-factory" /* CuiApiUrl.Factory */)
+};
+
 const CuiStorageObjectType = {
     CREATED: 'CREATED',
     INSERTED: 'INSERTED'
@@ -526,19 +538,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 }]
         }] });
 
+var WorkflowStructureType;
+(function (WorkflowStructureType) {
+    WorkflowStructureType["Mutable"] = "MUTABLE";
+    WorkflowStructureType["Imutable"] = "IMMUTABLE";
+})(WorkflowStructureType || (WorkflowStructureType = {}));
+
+var MaintainableContentType;
+(function (MaintainableContentType) {
+    MaintainableContentType["MAINTAINABLE"] = "MAINTAINABLE";
+    MaintainableContentType["UNMAINTAINABLE"] = "NOT_MAINTAINABLE";
+})(MaintainableContentType || (MaintainableContentType = {}));
+
 class CuiInstructionsApiService {
     constructor() {
         this.httpClient = inject(HttpClient);
         this.INSTRUCTION_URL = 'instruction';
     }
     changeTitle(instructionId, title) {
-        return this.httpClient.patch(`${this.INSTRUCTION_URL}/${instructionId}/title`, {}, { params: { title } });
+        return this.httpClient.patch(`${this.INSTRUCTION_URL}/${instructionId}/title`, {}, { ...SHARED_FACTORY_HTTP_OPTIONS, params: { title } });
     }
     changeDescription(instructionId, shortDescription) {
-        return this.httpClient.patch(`${this.INSTRUCTION_URL}/${instructionId}/short_description`, {}, { params: { shortDescription } });
+        return this.httpClient.patch(`${this.INSTRUCTION_URL}/${instructionId}/short_description`, {}, { ...SHARED_FACTORY_HTTP_OPTIONS, params: { shortDescription } });
     }
     deleteInstruction(listingInstructionId, instructionStorageId) {
-        return this.httpClient.delete(`${this.INSTRUCTION_URL}/${listingInstructionId}/${instructionStorageId}`);
+        return this.httpClient.delete(`${this.INSTRUCTION_URL}/${listingInstructionId}/${instructionStorageId}`, SHARED_FACTORY_HTTP_OPTIONS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiInstructionsApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiInstructionsApiService, providedIn: 'root' }); }
@@ -550,9 +574,143 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 }]
         }] });
 
+class CuiArrowWorkFlowActionsApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.WORKFLOW_ACTION_URL = 'production_technology/arrow/workflow/action';
+    }
+    changeInformation(actionId, body) {
+        return this.httpClient.patch(`${this.WORKFLOW_ACTION_URL}/${actionId}`, body, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowActionsApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowActionsApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowActionsApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CuiArrowWorkFlowComponentControllerApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.WORKFLOW_URL = 'production_technology/arrow/workflow';
+    }
+    createComponent(arrowActionWorkFlowId, type) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/action/${type.toLowerCase()}`, {}, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    getSuitable(arrowActionWorkFlowId, type) {
+        return this.httpClient.get(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/action/${type.toLowerCase()}/suitable`, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    deleteComponent(arrowActionWorkFlowId, componentId) {
+        return this.httpClient.delete(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/action/${componentId}`, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentControllerApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentControllerApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentControllerApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CuiArrowWorkFlowReadinessChecklistApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.WORKFLOW_URL = 'production_technology/arrow/workflow';
+    }
+    createChecklist(arrowId) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${arrowId}/action/checklist_readiness`, { name: 'New Checklist', shortDescription: 'Description' }, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    injectChecklist(arrowId, checklistId) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${arrowId}/action/checklist_readiness/insert/${checklistId}`, {}, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowReadinessChecklistApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowReadinessChecklistApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowReadinessChecklistApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CuiArrowWorkFlowComponentStructureApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.WORKFLOW_URL = 'production_technology/arrow/workflow';
+    }
+    moveStructure(arrowActionWorkFlowId, params) {
+        return this.httpClient.patch(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/action/structure/move`, {}, { ...SHARED_FACTORY_HTTP_OPTIONS, params: { ...params } });
+    }
+    deleteStructure(arrowActionWorkFlowId, type, structureId) {
+        return this.httpClient.delete(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/action/${type}/structure/${structureId}`, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentStructureApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentStructureApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowComponentStructureApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CuiArrowWorkFlowTransferControllerApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.WORKFLOW_URL = 'production_technology/arrow/workflow';
+        this.TRANSFER_URL = 'action/transfer';
+    }
+    createInstruction(body) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${body.arrowActionWorkFlowId}/${this.TRANSFER_URL}/instruction`, {
+            type_operations: "CREATE_INSTRUCTION" /* InstructionTypeOperation.Create */,
+            title: 'New instruction',
+            ...body
+        }, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    copyInstruction(body) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${body.arrowActionWorkFlowId}/${this.TRANSFER_URL}/instruction`, {
+            type_operations: "COPY_SELECT_INSTRUCTION" /* InstructionTypeOperation.Copy */,
+            ...body
+        }, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    insertInstruction(body) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${body.arrowActionWorkFlowId}/${this.TRANSFER_URL}/instruction`, {
+            type_operations: "INSERT_SELECT_INSTRUCTION" /* InstructionTypeOperation.Insert */,
+            ...body
+        }, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    unbindInstruction(body) {
+        return this.httpClient.post(`${this.WORKFLOW_URL}/${body.arrowActionWorkFlowId}/${this.TRANSFER_URL}/instruction`, {
+            type_operations: "UNBIND_SELECT_INSTRUCTION" /* InstructionTypeOperation.Unbind */,
+            ...body
+        }, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    addTransfer(body) {
+        return this.httpClient.patch(`${this.WORKFLOW_URL}/${this.TRANSFER_URL}`, body, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    updateTransfer(body) {
+        return this.httpClient.put(`${this.WORKFLOW_URL}/${this.TRANSFER_URL}/change`, body, SHARED_FACTORY_HTTP_OPTIONS);
+    }
+    insertTransfer(arrowActionWorkFlowId, id, transferType) {
+        return this.httpClient.patch(`${this.WORKFLOW_URL}/${arrowActionWorkFlowId}/${this.TRANSFER_URL}/insert/${id}`, {}, { ...SHARED_FACTORY_HTTP_OPTIONS, params: { transferType } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowTransferControllerApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowTransferControllerApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiArrowWorkFlowTransferControllerApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { CUI_API_URL_CONTEXT, CuiCrewTemplateApiService, CuiDesignJobMainApiService, CuiDesignJobMainGroupApiService, CuiFrameApiService, CuiInstructionsApiService, CuiNodeChecklistApiService, CuiProjectApiService, CuiProjectDetailsPhaseInitApiService, CuiProjectInitPhaseApiService, CuiProjectPhaseDesignTechnologyService, CuiProjectResoursePhaseInitApiService, CuiProjectSchedulePhaseInitApiService, CuiTechnologyPhaseInitApiService, CuiTreeStructApiService, CuiTreeStructNavigatorApiService };
+export { CUI_API_URL_CONTEXT, CuiArrowWorkFlowActionsApiService, CuiArrowWorkFlowComponentControllerApiService, CuiArrowWorkFlowComponentStructureApiService, CuiArrowWorkFlowReadinessChecklistApiService, CuiArrowWorkFlowTransferControllerApiService, CuiCrewTemplateApiService, CuiDesignJobMainApiService, CuiDesignJobMainGroupApiService, CuiFrameApiService, CuiInstructionsApiService, CuiNodeChecklistApiService, CuiProjectApiService, CuiProjectDetailsPhaseInitApiService, CuiProjectInitPhaseApiService, CuiProjectPhaseDesignTechnologyService, CuiProjectResoursePhaseInitApiService, CuiProjectSchedulePhaseInitApiService, CuiTechnologyPhaseInitApiService, CuiTreeStructApiService, CuiTreeStructNavigatorApiService, MaintainableContentType, SubjectType, WorkflowStructureType };
 //# sourceMappingURL=cuby-ui-api.mjs.map