@globisnv/cypress-core 0.0.1

package/dist/blueprints/GLO_equipment.js

@@ -0,0 +1,55 @@
+import { close, open } from '../tsHelper.js';
+import { GLO_enterAddressPopup } from './GLO_addressPopup.js';
+export const GLO_enterEquipment = (obj, tabName = 'tabs_70') => {
+    const formName = 'ng$equipment_dtl';
+    const generalFormName = 'ng$equipment_dtl_general';
+    // Relation information
+    cy.GLO_addInput([formName, 'equipment_code'], obj.equipmentCode);
+    cy.GLO_addInput([formName, 'equipment_category_id'], obj.equipmentCategory);
+    if (obj.equipmentCategory && obj.equipmentType)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([formName, 'equipment_type_id'], obj.equipmentType);
+    cy.GLO_addInput([formName, 'shipment_container_type_id'], obj.shipmentContainerType);
+    cy.GLO_addInput([formName, 'shipment_container_subtype_id'], obj.shipmentContainerSubType);
+    cy.GLO_addInput([formName, 'series_nr'], obj.seriesNr);
+    cy.GLO_addInput([formName, 'tarra'], obj.tarraWeight);
+    cy.GLO_popupWindow([formName, 'owner_relation_id'], obj.owner, 'relation_code');
+    cy.GLO_addInput([formName, 'in_use_by_relation_id'], obj.inUseByRelation);
+    cy.GLO_checkbox([formName, 'flag_is_active'], obj.flagIsActive);
+    if (obj.lastKnownAddress) {
+        cy.GLO_clickButton([formName, 'last_known_address_id'], 'fa-search');
+        GLO_enterAddressPopup(obj.lastKnownAddress);
+    }
+    if (obj.damaged) {
+        cy.GLO_selectTab([formName, tabName], 'General', open);
+        cy.GLO_checkbox([generalFormName, 'flag_damaged'], obj.damaged);
+        cy.GLO_selectTab([formName, tabName], 'General', close);
+    }
+    if (obj.rentedOutTo) {
+        cy.GLO_selectTab([formName, tabName], 'General', open);
+        cy.GLO_popupWindow([generalFormName, 'rented_out_relation_id'], obj.rentedOutTo);
+        cy.GLO_selectTab([formName, tabName], 'General', close);
+    }
+    if (obj.oneTimeUse || obj.flagHighValue) {
+        cy.GLO_selectTab([formName, tabName], 'Container', open);
+        cy.GLO_checkbox([`${formName}_container`, 'one_time_use'], obj.oneTimeUse);
+        cy.GLO_checkbox([`${formName}_container`, 'flag_high_value'], obj.flagHighValue);
+        cy.GLO_selectTab([formName, tabName], 'Container', close);
+    }
+    // Road tab
+    if (obj.licensePlate || obj.exteriorHeight || obj.roadTarra) {
+        cy.GLO_selectTab(['ng$equipment_dtl', tabName], 'Road', open);
+        cy.GLO_addInput([`${formName}_road`, 'license_plate'], obj.licensePlate);
+        cy.GLO_addInput([`${formName}_road`, 'equipment_height'], obj.exteriorHeight);
+        cy.GLO_addInput([`${formName}_road`, 'Tarra'], obj.roadTarra);
+        cy.GLO_checkbox([`${formName}_road`, 'flag_dangerous_goods'], obj.flagDangerousGoods);
+        cy.GLO_checkbox([`${formName}_road`, 'flag_high_value'], obj.flagHighValue);
+        cy.GLO_checkbox([`${formName}_road`, 'flag_tcl_allowed'], obj.flagTemperatureContolledAllowed);
+        cy.GLO_checkbox([`${formName}_road`, 'flag_alcohol_allowed'], obj.flagAlcoholAllowed);
+        cy.GLO_checkbox([`${formName}_road`, 'flag_waste_allowed'], obj.flagWasteAllowed);
+        cy.GLO_addInput([`${formName}_road`, 'euro_class'], obj.euroClass);
+        cy.GLO_addInput([`${formName}_road`, 'fuel_type'], obj.fuelType);
+        cy.GLO_addInput([`${formName}_road`, 'nr_of_axles'], obj.numberOfAxles);
+        cy.GLO_selectTab(['ng$equipment_dtl', tabName], 'Road', close);
+    }
+};

package/dist/blueprints/GLO_equipmentCategory.d.ts

@@ -0,0 +1,15 @@
+import type { CheckState } from '../tsHelper.js';
+export type objEquipmentCategory = {
+    equipmentCategoryCode?: string;
+    default?: CheckState;
+    charter?: CheckState;
+    rail?: CheckState;
+    container?: CheckState;
+    towingVehicle?: CheckState;
+    road?: CheckState;
+    air?: CheckState;
+    ocean?: CheckState;
+    ferry?: CheckState;
+    inlandShipping?: CheckState;
+};
+export declare const GLO_enterEquipmentCategory: (obj: objEquipmentCategory) => void;

package/dist/blueprints/GLO_equipmentCategory.js

@@ -0,0 +1,14 @@
+export const GLO_enterEquipmentCategory = (obj) => {
+    const formName = 'ng$equipment_category_dtl';
+    cy.GLO_addInput([formName, 'equipment_category_code'], obj.equipmentCategoryCode);
+    cy.GLO_checkbox([formName, 'checkbox_flag_default'], obj.default);
+    cy.GLO_checkbox([formName, 'checkbox_flag_charter'], obj.charter);
+    cy.GLO_checkbox([formName, 'checkbox_flag_rail'], obj.rail);
+    cy.GLO_checkbox([formName, 'checkbox_flag_container'], obj.container);
+    cy.GLO_checkbox([formName, 'checkbox_flag_towing_vehicle'], obj.towingVehicle);
+    cy.GLO_checkbox([formName, 'checkbox_flag_road'], obj.road);
+    cy.GLO_checkbox([formName, 'checkbox_flag_air'], obj.air);
+    cy.GLO_checkbox([formName, 'checkbox_flag_ocean'], obj.ocean);
+    cy.GLO_checkbox([formName, 'checkbox_flag_ferry'], obj.ferry);
+    cy.GLO_checkbox([formName, 'checkbox_flag_inland_shipping'], obj.inlandShipping);
+};

package/dist/blueprints/GLO_equipmentEntity.d.ts

@@ -0,0 +1,5 @@
+export type objEquipmentEntity = {
+    equipmentCode?: string;
+    logisticContractDetailCode?: string;
+};
+export declare const GLO_enterEquipmentEntity: (obj: objEquipmentEntity) => void;

package/dist/blueprints/GLO_equipmentEntity.js

@@ -0,0 +1,5 @@
+export const GLO_enterEquipmentEntity = (obj) => {
+    const formName = 'ng$equipment_entity_dtl';
+    cy.GLO_addInput([formName, 'equipment_code'], obj.equipmentCode);
+    cy.GLO_addInput([formName, 'logistic_contract_detail_code'], obj.logisticContractDetailCode);
+};

package/dist/blueprints/GLO_equipmentServiceCategory.d.ts

@@ -0,0 +1,13 @@
+import { type CheckState } from '../tsHelper.js';
+export type objEquipmentServiceCategory = {
+    serviceCategory?: string;
+    serviceType?: string;
+    lastService?: string;
+    nextService?: string;
+    temporaryDisabled?: CheckState;
+    serviceUpcoming?: CheckState;
+    serviceRequired?: CheckState;
+    serviceExceeded?: CheckState;
+    active?: CheckState;
+};
+export declare const GLO_enterEquipmentServiceCategory: (obj: objEquipmentServiceCategory) => void;

package/dist/blueprints/GLO_equipmentServiceCategory.js

@@ -0,0 +1,13 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterEquipmentServiceCategory = (obj) => {
+    const formName = 'ng$equipment_service_category$active_dtl';
+    cy.GLO_addDate(input, [formName, 'last_service_date'], obj.lastService);
+    cy.GLO_addDate(input, [formName, 'next_service_date'], obj.nextService);
+    cy.GLO_addInput([formName, 'service_category'], obj.serviceCategory);
+    cy.GLO_addInput([formName, 'service_type'], obj.serviceType);
+    cy.GLO_checkbox([formName, 'flag_temporarily_disabled'], obj.temporaryDisabled);
+    cy.GLO_checkbox([formName, 'flag_service_upcoming'], obj.serviceUpcoming);
+    cy.GLO_checkbox([formName, 'flag_service_required'], obj.serviceRequired);
+    cy.GLO_checkbox([formName, 'flag_service_exceeded'], obj.serviceExceeded);
+    cy.GLO_checkbox([formName, 'flag_active'], obj.active);
+};

package/dist/blueprints/GLO_equipmentType.d.ts

@@ -0,0 +1,21 @@
+import type { CheckState } from '../tsHelper.js';
+export type objEquipmentType = {
+    equipmentTypeCode: string;
+    equipmentCategoryCode?: string;
+    description?: string;
+    externalPlatform?: string;
+    classificationGroup?: string;
+    defaultLoadWeight?: number;
+    defaultLoadWeightUnit?: string;
+    transportMethod?: string;
+    charter?: CheckState;
+    rail?: CheckState;
+    container?: CheckState;
+    towingVehicle?: CheckState;
+    road?: CheckState;
+    air?: CheckState;
+    ocean?: CheckState;
+    ferry?: CheckState;
+    inlandShipping?: CheckState;
+};
+export declare const GLO_enterEquipmentType: (obj: objEquipmentType) => void;

package/dist/blueprints/GLO_equipmentType.js

@@ -0,0 +1,20 @@
+export const GLO_enterEquipmentType = (obj) => {
+    const formName = 'ng$equipment_type_dtl';
+    cy.GLO_addInput([formName, 'textbox_equipment_category'], obj.equipmentCategoryCode);
+    cy.GLO_addInput([formName, 'equipment_type_code'], obj.equipmentTypeCode);
+    cy.GLO_addInput([formName, 'description'], obj.description);
+    cy.GLO_addInput([formName, 'external_platform'], obj.externalPlatform);
+    cy.GLO_addInput([formName, 'classification_group'], obj.classificationGroup);
+    cy.GLO_addInput([formName, 'default_load_weight'], obj.defaultLoadWeight);
+    cy.GLO_addInput([formName, 'weight_unit_id'], obj.defaultLoadWeightUnit);
+    cy.GLO_addInput([formName, 'transport_method'], obj.transportMethod);
+    cy.GLO_checkbox([formName, 'flag_charter'], obj.charter);
+    cy.GLO_checkbox([formName, 'flag_rail'], obj.rail);
+    cy.GLO_checkbox([formName, 'flag_container'], obj.container);
+    cy.GLO_checkbox([formName, 'flag_towing_vehicle'], obj.towingVehicle);
+    cy.GLO_checkbox([formName, 'flag_road'], obj.road);
+    cy.GLO_checkbox([formName, 'flag_air'], obj.air);
+    cy.GLO_checkbox([formName, 'flag_water'], obj.ocean);
+    cy.GLO_checkbox([formName, 'flag_ferry'], obj.ferry);
+    cy.GLO_checkbox([formName, 'flag_inland_shipping'], obj.inlandShipping);
+};

package/dist/blueprints/GLO_equipmentTypeServiceCategory.d.ts

@@ -0,0 +1,13 @@
+import type { CheckState } from '../tsHelper.js';
+export type objEquipmentTypeServiceCategory = {
+    equipmentCategoryCode?: string;
+    equipmentTypeCode?: string;
+    serviceCategoryCode: string;
+    serviceType?: string;
+    noAutomaticCalculation?: CheckState;
+    alertWindowUpcoming?: string;
+    alerWindowRequired?: string;
+    intervalWindow?: string;
+    intervalBase?: string;
+};
+export declare const GLO_enterEquipmentTypeServiceCategory: (obj: objEquipmentTypeServiceCategory) => void;

package/dist/blueprints/GLO_equipmentTypeServiceCategory.js

@@ -0,0 +1,12 @@
+export const GLO_enterEquipmentTypeServiceCategory = (obj) => {
+    const formName = 'ng$equipment_type_service_category_dtl';
+    cy.GLO_addInput([formName, 'equipment_type'], obj.equipmentCategoryCode);
+    cy.GLO_popupWindow([formName, 'equipment_subtype'], obj.equipmentTypeCode);
+    cy.GLO_addInput([formName, 'service_category'], obj.serviceCategoryCode);
+    cy.GLO_addInput([formName, 'service_type'], obj.serviceType);
+    cy.GLO_checkbox([formName, 'flag_no_automatic_calculation'], obj.noAutomaticCalculation);
+    cy.GLO_addInput([formName, 'alert_window_upcoming'], obj.alertWindowUpcoming);
+    cy.GLO_addInput([formName, 'alert_window_required'], obj.alerWindowRequired);
+    cy.GLO_addInput([formName, 'interval_window'], obj.intervalWindow);
+    cy.GLO_addInput([formName, 'interval_base'], obj.intervalBase);
+};

package/dist/blueprints/GLO_fieldInputValidation.d.ts

@@ -0,0 +1,46 @@
+import { type CheckState } from '../tsHelper.js';
+type ParameterType = 'Attribute' | 'Relation' | 'Dynamic attribute';
+type ValidationEvent = 'onPreSave' | 'onDataChange' | 'onEdit' | 'onNew' | 'onNew & onEdit' | 'onDuplicate' | 'onNew & onDuplicate' | 'onEdit & onDuplicate' | 'onNew & onEdit & onDuplicate';
+type ValidationType = 'Content validation' | 'Default value' | 'Editable' | 'Mandatory';
+type DefaultValueSetting = 'Always' | 'When blanc' | 'New' | 'When new and blanc';
+export type objContentValidation = {
+    inputFormat?: string;
+    contentValidationSimple?: string;
+    contentValidationFormula?: string;
+};
+export type objDefaultValue = {
+    defaultValueSetting?: DefaultValueSetting;
+    defaultValueConditionSimple?: string;
+    defaultValueConditionFormula?: string;
+    defaultValueSimple?: string;
+    defaultValueFormula?: string;
+};
+export type objEditable = {
+    flagEditable?: CheckState;
+    editableConditionSimple?: string;
+    editableConditionFormula?: string;
+};
+export type objMandatory = {
+    flagMandatory?: CheckState;
+    mandatoryConditionSimple?: string;
+    mandatoryFormula?: string;
+};
+export type objFieldInputValidation = {
+    program?: string;
+    customView?: string;
+    userGroup?: string;
+    validFrom?: string;
+    validTill?: string;
+    validationType?: ValidationType;
+    setField?: string;
+    setFieldType?: ParameterType;
+    validationEvent?: ValidationEvent;
+    field?: string;
+    fieldType?: ParameterType;
+    contentValidation?: objContentValidation;
+    defaultValue?: objDefaultValue;
+    editable?: objEditable;
+    mandatory?: objMandatory;
+};
+export declare const GLO_enterFieldInputValidation: (obj: objFieldInputValidation) => void;
+export {};

package/dist/blueprints/GLO_fieldInputValidation.js

@@ -0,0 +1,73 @@
+import { input, open } from '../tsHelper.js';
+const formName = 'ng$field_input_validation_dtl';
+export const GLO_enterFieldInputValidation = (obj) => {
+    cy.GLO_addInput([formName, 'program'], obj.program);
+    cy.GLO_popupWindow([formName, 'custom_view'], obj.customView);
+    cy.GLO_addInput([formName, 'sec_group_id'], obj.userGroup);
+    cy.GLO_addDate(input, [formName, 'valid_from'], obj.validFrom);
+    cy.GLO_addDate(input, [formName, 'valid_till'], obj.validTill);
+    cy.GLO_addInput([formName, 'validation_type'], obj.validationType);
+    if (obj.setField) {
+        cy.GLO_clickButton([formName, 'set_field'], 'fa-search');
+        if (obj.setFieldType) {
+            cy.GLO_addInput(['ng$field_input_validation_dataprovider_dlg', 'parameter_type'], obj.setFieldType);
+        }
+        cy.GLO_addInput(['ng$field_input_validation_dataprovider_dlg', 'parameter_attribute'], obj.setField);
+        cy.GLO_clickButton(['ng$field_input_validation_dataprovider_dlg', 'submit_btn']);
+    }
+    cy.GLO_addInput([formName, 'validation_event'], obj.validationEvent);
+    if (obj.field) {
+        cy.GLO_clickButton([formName, 'field'], 'fa-search');
+        if (obj.fieldType) {
+            cy.GLO_addInput(['ng$field_input_validation_dataprovider_dlg', 'parameter_type'], obj.fieldType);
+        }
+        cy.GLO_addInput(['ng$field_input_validation_dataprovider_dlg', 'parameter_attribute'], obj.field);
+        cy.GLO_clickButton(['ng$field_input_validation_dataprovider_dlg', 'submit_btn']);
+    }
+    // Content validation tab
+    if (obj.contentValidation) {
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Content validation', open);
+        enterContentValidation(obj.contentValidation);
+    }
+    // Default value tab
+    if (obj.defaultValue) {
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Default values', open);
+        enterDefaultValue(obj.defaultValue);
+    }
+    // Editable tab
+    if (obj.editable) {
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Editable', open);
+        enterEditable(obj.editable);
+    }
+    // Mandatory tab
+    if (obj.mandatory) {
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Mandatory', open);
+        enterMandatory(obj.mandatory);
+    }
+};
+const enterContentValidation = (obj) => {
+    const tabFormName = 'ng$field_input_validation_dtl_content_validation';
+    cy.GLO_addInput([tabFormName, 'input_format'], obj.inputFormat);
+    cy.GLO_addInput([tabFormName, 'content_validation_simple'], obj.contentValidationSimple);
+    cy.GLO_popupWindow([tabFormName, 'content_validation_formula'], obj.contentValidationFormula);
+};
+const enterDefaultValue = (obj) => {
+    const tabFormName = 'ng$field_input_validation_dtl_default_value';
+    cy.GLO_addInput([tabFormName, 'default_value_setting'], obj.defaultValueSetting);
+    cy.GLO_addInput([tabFormName, 'default_value_condition_simple'], obj.defaultValueConditionSimple);
+    cy.GLO_popupWindow([tabFormName, 'default_value_condition_formula'], obj.defaultValueConditionFormula);
+    cy.GLO_addInput([tabFormName, 'default_value_simple'], obj.defaultValueSimple);
+    cy.GLO_popupWindow([tabFormName, 'default_value_formula'], obj.defaultValueFormula);
+};
+const enterEditable = (obj) => {
+    const tabFormName = 'ng$field_input_validation_dtl_editable';
+    cy.GLO_checkbox([tabFormName, 'flag_editable'], obj.flagEditable);
+    cy.GLO_addInput([tabFormName, 'editable_condition_simple'], obj.editableConditionSimple);
+    cy.GLO_popupWindow([tabFormName, 'editable_condition_formula'], obj.editableConditionFormula);
+};
+const enterMandatory = (obj) => {
+    const tabFormName = 'ng$field_input_validation_dtl_mandatory';
+    cy.GLO_checkbox([tabFormName, 'flag_mandatory'], obj.flagMandatory);
+    cy.GLO_addInput([tabFormName, 'mandatory_condition_simple'], obj.mandatoryConditionSimple);
+    cy.GLO_popupWindow([tabFormName, 'mandatory_formula'], obj.mandatoryFormula);
+};

package/dist/blueprints/GLO_formula.d.ts

@@ -0,0 +1,9 @@
+export type objFormula = {
+    formulaCode?: string;
+    formulaType?: string;
+    ticketNr?: string;
+    formula?: string;
+    featureCode?: string;
+    scenarioCode?: string;
+};
+export declare const GLO_enterFormula: (obj: objFormula) => void;

package/dist/blueprints/GLO_formula.js

@@ -0,0 +1,9 @@
+export const GLO_enterFormula = (obj) => {
+    const formName = 'ng$formula_dtl';
+    cy.GLO_addInput([formName, 'formula_code'], obj.formulaCode);
+    cy.GLO_addInput([formName, 'formula_type'], obj.formulaType);
+    cy.GLO_addInput([formName, 'ticket_nr'], obj.ticketNr);
+    cy.GLO_addInput([formName, 'formula'], obj.formula);
+    cy.GLO_addInput([formName, 'feature_code'], obj.featureCode);
+    cy.GLO_addInput([formName, 'scenario_code'], obj.scenarioCode);
+};

package/dist/blueprints/GLO_gang.d.ts

@@ -0,0 +1,12 @@
+export type objGang = {
+    type?: string;
+    status?: string;
+    terminal?: string;
+    foreman?: string;
+    tallyman?: string;
+    shiftDate?: string;
+    calendarDay?: string;
+    warehouse?: string;
+    description?: string;
+};
+export declare const GLO_createGang: (obj: objGang) => void;

package/dist/blueprints/GLO_gang.js

@@ -0,0 +1,12 @@
+import { select } from '../tsHelper.js';
+export const GLO_createGang = (obj) => {
+    cy.GLO_addInput(['gang_status'], obj.status);
+    cy.GLO_addInput(['gang_type_code'], obj.type);
+    cy.GLO_addInput(['terminal'], obj.terminal);
+    cy.GLO_addInput(['warehouse'], obj.warehouse);
+    cy.GLO_addInput(['foreman_user_id'], obj.foreman);
+    cy.GLO_addInput(['description'], obj.description);
+    cy.GLO_addInput(['tallyman_user_id'], obj.tallyman);
+    cy.GLO_addDate(select, ['ng$gang_dtl', 'shift_date'], obj.shiftDate);
+    cy.GLO_addInput(['calendarday_segment_id'], obj.calendarDay);
+};

package/dist/blueprints/GLO_holiday.d.ts

@@ -0,0 +1,7 @@
+export type objHoliday = {
+    country?: string;
+    date?: string;
+    description?: string;
+    company?: string;
+};
+export declare const GLO_enterHoliday: (obj: objHoliday) => void;

package/dist/blueprints/GLO_holiday.js

@@ -0,0 +1,8 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterHoliday = (obj) => {
+    const formName = 'ng$holidays_dtl';
+    cy.GLO_addInput([formName, 'country_id'], obj.country);
+    cy.GLO_addDate(input, [formName, 'holiday_date'], obj.date);
+    cy.GLO_addInput([formName, 'description'], obj.description);
+    cy.GLO_addInput([formName, 'company_id'], obj.company);
+};

package/dist/blueprints/GLO_journey.d.ts

@@ -0,0 +1,18 @@
+export type objJourney = {
+    journeyCode?: string;
+    transportMethod?: string;
+    equipment?: string;
+    agentCode?: string;
+    shippingAgentCode?: string;
+    agentReference?: string;
+    journeyNr?: string;
+    activityType?: string;
+    handlingStart?: string;
+    handlingEnd?: string;
+    volume?: number;
+    volumeUnit?: string;
+    grossWeight?: number;
+    grossWeightUnit?: string;
+    loadingMeters?: number;
+};
+export declare const GLO_enterJourney: (obj: objJourney) => void;

package/dist/blueprints/GLO_journey.js

@@ -0,0 +1,24 @@
+import { close, input, open } from '../tsHelper.js';
+export const GLO_enterJourney = (obj) => {
+    const formName = 'ng$journey_dtl';
+    const quantitiesFormName = 'ng$journey_dtl_quantitites';
+    cy.GLO_addInput([formName, 'journey_code'], obj.journeyCode);
+    cy.GLO_addInput([formName, 'journey_nr'], obj.journeyNr);
+    cy.GLO_addInput([formName, 'transport_method'], obj.transportMethod);
+    cy.GLO_popupWindow([formName, 'equipment_id'], obj.equipment);
+    cy.GLO_addInput([formName, 'agent'], obj.agentCode);
+    cy.GLO_addInput([formName, 'shipping_agent'], obj.shippingAgentCode);
+    cy.GLO_addInput([formName, 'agent_reference'], obj.agentReference);
+    cy.GLO_addInput([formName, 'time_activity_type'], obj.activityType);
+    cy.GLO_addDate(input, [formName, 'start_handling'], obj.handlingStart);
+    cy.GLO_addDate(input, [formName, 'end_handling'], obj.handlingEnd);
+    if (obj.volume || obj.volumeUnit || obj.grossWeight || obj.grossWeightUnit || obj.loadingMeters) {
+        cy.GLO_selectTab([formName, 'tabs'], 'Quantities', open);
+        cy.GLO_addInput([quantitiesFormName, 'capacity_volume'], obj.volume);
+        cy.GLO_addInput([quantitiesFormName, 'capacity_volume_unit_id'], obj.volumeUnit);
+        cy.GLO_addInput([quantitiesFormName, 'capcacity_gross_weight'], obj.grossWeight);
+        cy.GLO_addInput([quantitiesFormName, 'capacity_gross_weight_unit_id'], obj.grossWeightUnit);
+        cy.GLO_addInput([quantitiesFormName, 'capacity_loading_meters'], obj.loadingMeters);
+        cy.GLO_selectTab([formName, 'tabs'], 'Quantities', close);
+    }
+};

package/dist/blueprints/GLO_journeyStop.d.ts

@@ -0,0 +1,32 @@
+export type objJourneyStop = {
+    logisticLocationId?: string;
+    departureStartBooked?: string;
+    departureEndBooked?: string;
+    departureStartActual?: string;
+    closingBooked?: string;
+    arrivalStartBooked?: string;
+    arrivalStartPlanned?: string;
+    arrivalStartActual?: string;
+    arrivalStartBookedTime?: string;
+    arrivalStartPlannedTime?: string;
+    arrivalStartActualTime?: string;
+    departureEndPlanned?: string;
+    departureEndActual?: string;
+    departureEndBookedTime?: string;
+    departureEndPlannedTime?: string;
+    departureEndActualTime?: string;
+    quayCode?: string;
+    nrOfConsignments?: number;
+    stayNr?: number;
+    grossWeightLoad?: number;
+    grossWeightUnload?: number;
+    colour?: string;
+    goodsClosing?: string;
+    vgmClosing?: string;
+    dgnClosing?: string;
+    stuffingReportClosing?: string;
+    shippingInstructionClosing?: string;
+    portTimePlanned?: string;
+    stopTimezone?: string;
+};
+export declare const GLO_enterJourneyStop: (obj: objJourneyStop) => void;

package/dist/blueprints/GLO_journeyStop.js

@@ -0,0 +1,44 @@
+import { close, equalBool, input, open } from '../tsHelper.js';
+export const GLO_enterJourneyStop = (obj) => {
+    const formName = 'ng$journey_stop_dtl';
+    cy.GLO_popupWindow([formName, 'logistic_location_id'], obj.logisticLocationId, undefined, equalBool);
+    cy.GLO_addInput([formName, 'quay_code_valuelist'], obj.quayCode);
+    cy.GLO_addInput([formName, 'nr_of_consignments'], obj.nrOfConsignments);
+    cy.GLO_addInput([formName, 'stay_nr'], obj.stayNr);
+    cy.GLO_addInput([formName, 'gross_weight_load'], obj.grossWeightLoad);
+    cy.GLO_addInput([formName, 'gross_weight_unload'], obj.grossWeightUnload);
+    cy.GLO_addInput([formName, 'colour'], obj.colour);
+    cy.GLO_addInput([formName, 'port_time_duration_planned'], obj.portTimePlanned);
+    cy.GLO_addDate(input, [formName, 'goods_closing'], obj.goodsClosing);
+    cy.GLO_addDate(input, [formName, 'vgm_closing'], obj.vgmClosing);
+    cy.GLO_addDate(input, [formName, 'dgn_closing'], obj.dgnClosing);
+    cy.GLO_addDate(input, [formName, 'stuffing_report_closing'], obj.stuffingReportClosing);
+    cy.GLO_addDate(input, [formName, 'shipping_instructions_closing'], obj.shippingInstructionClosing);
+    cy.GLO_selectTab([formName, 'tabs_70'], 'Timings', open);
+    GLO_enterJourneyStopTabTimings(obj);
+    cy.GLO_selectTab([formName, 'tabs_70'], 'Timings', close);
+    if (obj.stopTimezone) {
+        const scheduleFormName = 'ng$journey_stop_dtl_schedule';
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Schedule', open);
+        cy.GLO_addInput([scheduleFormName, 'stop_timezone'], obj.stopTimezone);
+        cy.GLO_selectTab([formName, 'tabs_70'], 'Schedule', close);
+    }
+};
+const GLO_enterJourneyStopTabTimings = (obj) => {
+    const formName = 'ng$journey_stop_dtl_timings';
+    cy.GLO_addDate(input, [formName, 'arrival_start_booked'], obj.arrivalStartBooked);
+    cy.GLO_addDate(input, [formName, 'arrival_start_planned'], obj.arrivalStartPlanned);
+    cy.GLO_addDate(input, [formName, 'arrival_start_actual'], obj.arrivalStartActual);
+    cy.GLO_addDate(input, [formName, 'arrival_start_booked_time'], obj.arrivalStartBookedTime);
+    cy.GLO_addDate(input, [formName, 'arrival_start_planned_time'], obj.arrivalStartPlannedTime);
+    cy.GLO_addDate(input, [formName, 'arrival_start_actual_time'], obj.arrivalStartActualTime);
+    cy.GLO_addDate(input, [formName, 'departure_end_booked'], obj.departureEndBooked);
+    cy.GLO_addDate(input, [formName, 'departure_end_planned'], obj.departureEndPlanned);
+    cy.GLO_addDate(input, [formName, 'departure_end_actual'], obj.departureEndActual);
+    cy.GLO_addDate(input, [formName, 'departure_end_booked_time'], obj.departureEndBookedTime);
+    cy.GLO_addDate(input, [formName, 'departure_end_planned_time'], obj.departureEndPlannedTime);
+    cy.GLO_addDate(input, [formName, 'departure_end_actual_time'], obj.departureEndActualTime);
+    cy.GLO_addDate(input, [formName, 'departure_start_actual'], obj.departureStartActual);
+    cy.GLO_addDate(input, [formName, 'departure_start_booked'], obj.departureStartBooked);
+    cy.GLO_addDate(input, [formName, 'closing_booked'], obj.closingBooked);
+};

package/dist/blueprints/GLO_layout.d.ts

@@ -0,0 +1,6 @@
+export type objLayout = {
+    documentType?: string;
+    documentGroup?: string;
+    predefinedQuery?: string;
+};
+export declare const GLO_enterLayout: (obj: objLayout) => void;

package/dist/blueprints/GLO_layout.js

@@ -0,0 +1,6 @@
+export const GLO_enterLayout = (obj) => {
+    const formName = 'ng$layout_dtl';
+    cy.GLO_addInput([formName, 'document_group_id'], obj.documentGroup);
+    cy.GLO_addInput([formName, 'document_type_id'], obj.documentType);
+    cy.GLO_addInput([formName, 'predefined_query'], obj.predefinedQuery);
+};

package/dist/blueprints/GLO_logging.d.ts

@@ -0,0 +1,9 @@
+export type objLogging = {
+    relationContactId?: string;
+    loggingTypeId?: string;
+    loggingSubtypeId?: string;
+    subject?: string;
+    description?: string;
+    internalRemark?: string;
+};
+export declare const GLO_enterLogging: (obj: objLogging) => void;

package/dist/blueprints/GLO_logging.js

@@ -0,0 +1,12 @@
+import { open } from '../tsHelper.js';
+export const GLO_enterLogging = (obj) => {
+    const formName = 'ng$logging_dtl';
+    const formNameGeneral = 'ng$logging_dtl_description';
+    cy.GLO_addInput([formName, 'relation_contact_id'], obj.relationContactId);
+    cy.GLO_addInput([formName, 'logging_type_id'], obj.loggingTypeId);
+    cy.GLO_addInput([formName, 'logging_subtype_id'], obj.loggingSubtypeId);
+    cy.GLO_selectTab([formName, 'tabs_340'], 'Description', open);
+    cy.GLO_addInput([formNameGeneral, 'subject'], obj.subject);
+    cy.GLO_addInput([formNameGeneral, 'description'], obj.description);
+    cy.GLO_addInput([formNameGeneral, 'internal_remark'], obj.internalRemark);
+};

package/dist/blueprints/GLO_logisticConnection.d.ts

@@ -0,0 +1,10 @@
+export type objLogisticConnection = {
+    connectionCode?: string;
+    connectionType?: string;
+    direction?: string;
+    locationFrom?: string;
+    locationTo?: string;
+    validFrom?: string;
+    validTill?: string;
+};
+export declare const GLO_enterLogisticConnection: (obj: objLogisticConnection) => void;

package/dist/blueprints/GLO_logisticConnection.js

@@ -0,0 +1,11 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterLogisticConnection = (obj) => {
+    const formName = 'ng$logistic_conn_dtl';
+    cy.GLO_addInput([formName, 'connection_code'], obj.connectionCode);
+    cy.GLO_addInput([formName, 'connection_type_id'], obj.connectionType);
+    cy.GLO_addInput([formName, 'direction'], obj.direction);
+    cy.GLO_popupWindow([formName, 'local_logistic_loc_from'], obj.locationFrom);
+    cy.GLO_popupWindow([formName, 'local_logistic_loc_to'], obj.locationTo);
+    cy.GLO_addDate(input, [formName, 'valid_from'], obj.validFrom);
+    cy.GLO_addDate(input, [formName, 'valid_till'], obj.validTill);
+};

package/dist/blueprints/GLO_logisticConnectionType.d.ts

@@ -0,0 +1,5 @@
+export type objLogisticConnectionType = {
+    connectionType?: string;
+    transportMethod?: string;
+};
+export declare const GLO_enterLogisticConnectionType: (obj: objLogisticConnectionType) => void;

package/dist/blueprints/GLO_logisticConnectionType.js

@@ -0,0 +1,5 @@
+export const GLO_enterLogisticConnectionType = (obj) => {
+    const formName = 'ng$logistic_conn_type_dtl';
+    cy.GLO_addInput([formName, 'logistic_conn_type_code'], obj.connectionType);
+    cy.GLO_addInput([formName, 'transport_method'], obj.transportMethod);
+};

package/dist/blueprints/GLO_logisticContract.d.ts

@@ -0,0 +1,28 @@
+import { type CheckState } from '../tsHelper.js';
+export type objLogisticContract = {
+    type?: string;
+    subType?: string;
+    subTypeColmun?: string;
+    validFrom?: string;
+    validTill?: string;
+    description?: string;
+    supplierCode?: string;
+    keyAccountManager?: string;
+    accountManager?: string;
+    currency?: string;
+    flagDirectInvoice?: CheckState;
+    flagAutomatedInvoice?: CheckState;
+    flagMergeInvoiceAndPOD?: CheckState;
+    flagElectronicInvoice?: CheckState;
+    generalContractType?: string;
+    flagSpotContract?: CheckState;
+    flagGeneralContract?: CheckState;
+    flagSummaryInvoice?: CheckState;
+    branch?: string;
+    department?: string;
+    businessUnit?: string;
+    dayForAutomaticInvoicing?: number;
+    flagDefWaitingHoursProofRequired?: CheckState;
+    defWaitingHoursThreshold?: string;
+};
+export declare const GLO_enterLogisticContract: (obj: objLogisticContract) => void;