@globisnv/cypress-core 0.0.2 → 0.0.4

package/dist/blueprints/GLO_departureScheduleTimes.js

@@ -0,0 +1,61 @@
+import { close, open } from '../tsHelper.js';
+const formName = 'ng$logistic_conn_schedule_times_dtl';
+const addressFormName = 'ng$remark_dtl_logistic_conn_schedule_times';
+const detailTabsName = 'tabs_70';
+export const GLO_enterDepartureScheduleTimes = (obj) => {
+    // Data_cy has 2 inputs so we need the first one and use the raw command
+    cy.GLO_addInput([formName, 'departure_time'], obj.departureTime);
+    cy.GLO_addInput([formName, 'departure_time', 1], obj.departureTimezone);
+    cy.GLO_addInput([formName, 'arrival_time'], obj.arrivalTime);
+    cy.GLO_addInput([formName, 'arrival_time', 1], obj.arrivalTimezone);
+    typeIfPresent('arrival_relative_days', obj.arrivalRelativeDays);
+    typeIfPresent('embark_duration', obj.embarkDuration);
+    typeIfPresent('disembark_duration', obj.disembarkDuration);
+    cy.GLO_addInput([formName, 'pricing_group'], obj.pricingGroup);
+    typeIfPresent('first_drop_relative_days', obj.firstDropRelativeDays);
+    typeIfPresent('first_drop_time', obj.firstDropTime);
+    typeIfPresent('first_drop_dgn_relative_days', obj.firstDropDgnRelativeDays);
+    typeIfPresent('first_drop_dgn_time', obj.firstDropDgnTime);
+    typeIfPresent('last_drop_relative_days', obj.lastDropRelativeDays);
+    typeIfPresent('last_drop_time', obj.lastDropTime);
+    typeIfPresent('last_drop_dgn_relative_days', obj.lastDropDgnRelativeDays);
+    typeIfPresent('last_drop_dgn_time', obj.lastDropDgnTime);
+    typeIfPresent('last_drop_container_relative_days', obj.lastDropContainerRelativeDays);
+    typeIfPresent('last_drop_container_time', obj.lastDropContainerTime);
+    typeIfPresent('last_drop_trailer_relative_days', obj.lastDropTrailerRelativeDays);
+    typeIfPresent('last_drop_trailer_time', obj.lastDropTrailerTime);
+    typeIfPresent('available_after_arrival_time_relative_days', obj.availableAfterArrivalTimeRelativeDays);
+    typeIfPresent('available_lofo_after_arrival_time_relative_days', obj.availableLofoAfterArrivalTimeRelativeDays);
+    cy.GLO_addInput([formName, 'min_nr_of_containers'], obj.minNrOfContainers);
+    cy.GLO_addInput([formName, 'max_nr_of_containers'], obj.maxNrOfContainers);
+    cy.GLO_addInput([formName, 'min_nr_of_trailers'], obj.minNrOfTrailers);
+    cy.GLO_addInput([formName, 'max_nr_of_trailers'], obj.maxNrOfTrailers);
+    cy.GLO_addInput([formName, 'max_anti_theft_capacity'], obj.maxAntiTheftCapacity);
+    cy.GLO_addInput([formName, 'capacity_gross_weight'], obj.capacityGrossWeight);
+    cy.GLO_addInput([formName, 'capacity_gross_weight_unit_id'], obj.capacityGrossWeightUnitId);
+    typeIfPresent('booking_opening_relative_days', obj.bookingOpeningRelativeDays);
+    typeIfPresent('booking_opening_time', obj.bookingOpeningTime);
+    typeIfPresent('booking_closing_relative_days', obj.bookingClosingRelativeDays);
+    typeIfPresent('booking_closing_time', obj.bookingClosingTime);
+    cy.GLO_checkbox([formName, 'flag_operational_active'], obj.flagOperationalActive);
+    cy.GLO_checkbox([formName, 'flag_dgn_allowed'], obj.flagDgnAllowed);
+    cy.GLO_checkbox([formName, 'flag_dgn_limited_quantity_allowed'], obj.flagDgnLimitedQuantityAllowed);
+    cy.GLO_checkbox([formName, 'flag_waste_allowed'], obj.flagWasteAllowed);
+    cy.GLO_checkbox([formName, 'monday'], obj.flagMonday);
+    cy.GLO_checkbox([formName, 'tuesday'], obj.flagTuesday);
+    cy.GLO_checkbox([formName, 'wednesday'], obj.flagWednesday);
+    cy.GLO_checkbox([formName, 'thursday'], obj.flagThursday);
+    cy.GLO_checkbox([formName, 'friday'], obj.flagFriday);
+    cy.GLO_checkbox([formName, 'saturday'], obj.flagSaturday);
+    cy.GLO_checkbox([formName, 'sunday'], obj.flagSunday);
+    if (obj.remark) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Remarks', open);
+        cy.GLO_addInput([addressFormName, 'local_LOG_CONN_SCHED_TIMES_REMARK'], obj.remark);
+        cy.GLO_selectTab([formName, detailTabsName], 'Remarks', close);
+    }
+};
+const typeIfPresent = (fieldName, value) => {
+    if (value) {
+        cy.GLO_getElement([formName, fieldName]).find('.dx-texteditor-input').type(value);
+    }
+};

package/dist/blueprints/GLO_document.d.ts

@@ -0,0 +1,7 @@
+export type objDocument = {
+    documentGroup?: string;
+    documentType?: string;
+    customerApprovalUser?: string;
+    supplierApprovalUser?: string;
+};
+export declare const GLO_enterDocument: (obj: objDocument) => void;

package/dist/blueprints/GLO_document.js

@@ -0,0 +1,7 @@
+export const GLO_enterDocument = (obj) => {
+    const formName = 'ng$document_dtl';
+    cy.GLO_addInput([formName, 'document_group_id'], obj.documentGroup);
+    cy.GLO_addInput([formName, 'document_type_id'], obj.documentType);
+    cy.GLO_addInput([formName, 'customer_approval_user'], obj.customerApprovalUser);
+    cy.GLO_addInput([formName, 'supplier_approval_user'], obj.supplierApprovalUser);
+};

package/dist/blueprints/GLO_documentAttachment.d.ts

@@ -0,0 +1,4 @@
+export type objDocumentAttachment = {
+    clientFilePath?: string;
+};
+export declare const GLO_enterDocumentAttachment: (obj: objDocumentAttachment) => void;

package/dist/blueprints/GLO_documentAttachment.js

@@ -0,0 +1,4 @@
+export const GLO_enterDocumentAttachment = (obj) => {
+    const formName = 'ng$document_attachment_dtl';
+    cy.GLO_addInput([formName, 'client_file_path'], obj.clientFilePath);
+};

package/dist/blueprints/GLO_documentDefinitionEntity.d.ts

@@ -0,0 +1,5 @@
+export type objDocumentDefinitionType = {
+    documentGroup?: string;
+    documentType?: string;
+};
+export declare const GLO_enterDocumentDefinitionType: (obj: objDocumentDefinitionType) => void;

package/dist/blueprints/GLO_documentDefinitionEntity.js

@@ -0,0 +1,5 @@
+export const GLO_enterDocumentDefinitionType = (obj) => {
+    const formName = 'ng$document_definition_entity_dtl';
+    cy.GLO_addInput([formName, 'document_group_id'], obj.documentGroup);
+    cy.GLO_addInput([formName, 'document_type_id'], obj.documentType);
+};

package/dist/blueprints/GLO_documentGroup.d.ts

@@ -0,0 +1,4 @@
+export type objDocumentGroup = {
+    documentGroupCode?: string;
+};
+export declare const GLO_enterDocumentGroup: (obj: objDocumentGroup) => void;

package/dist/blueprints/GLO_documentGroup.js

@@ -0,0 +1,4 @@
+export const GLO_enterDocumentGroup = (obj) => {
+    const formName = 'ng$document_group_dtl';
+    cy.GLO_addInput([formName, 'document_group_code'], obj.documentGroupCode);
+};

package/dist/blueprints/GLO_documentType.d.ts

@@ -0,0 +1,12 @@
+import type { CheckState } from '../tsHelper.js';
+export type objDocumentType = {
+    documentType?: string;
+    documentTypeStatus?: string;
+    referenceForClosingDate?: string;
+    offsetTimeReminderForClosingDate?: string;
+    incomingOutgoing?: string;
+    customerApprovalNeeded?: CheckState;
+    supplierApprovalNeeded?: CheckState;
+    visibleInCustomerPortal?: CheckState;
+};
+export declare const GLO_enterDocumentType: (obj: objDocumentType) => void;

package/dist/blueprints/GLO_documentType.js

@@ -0,0 +1,11 @@
+export const GLO_enterDocumentType = (obj) => {
+    const formName = 'ng$document_type_dtl';
+    cy.GLO_addInput([formName, 'document_type_code'], obj.documentType);
+    cy.GLO_addInput([formName, 'document_type_status'], obj.documentTypeStatus);
+    cy.GLO_addInput([formName, 'reference_for_closing_date'], obj.referenceForClosingDate);
+    cy.GLO_addInput([formName, 'offset_time_reminder_for_closing_date'], obj.offsetTimeReminderForClosingDate);
+    cy.GLO_addInput([formName, 'incoming_outgoing'], obj.incomingOutgoing);
+    cy.GLO_checkbox([formName, 'customer_approval_needed'], obj.customerApprovalNeeded);
+    cy.GLO_checkbox([formName, 'supplier_approval_needed'], obj.supplierApprovalNeeded);
+    cy.GLO_checkbox([formName, 'visible_in_customer_portal'], obj.visibleInCustomerPortal);
+};

package/dist/blueprints/GLO_enterCountry.d.ts

@@ -0,0 +1,21 @@
+import { type CheckState } from '../tsHelper.js';
+export type objCountry = {
+    countryCode?: string;
+    isoCountryCode?: string;
+    isoCountryCode3?: string;
+    vatPrefix?: string;
+    dialCode?: string;
+    isActive?: CheckState;
+    useCounties?: CheckState;
+    useStates?: CheckState;
+    streetFormat?: string;
+    addressBlockFormat?: string;
+    translation?: string;
+    stateName?: string;
+    stateCode?: string;
+    countyName?: string;
+    postalCode?: string;
+    city?: string;
+    contextCountryCode?: string;
+};
+export declare const GLO_enterCountry: (obj: objCountry, part?: string) => void;

package/dist/blueprints/GLO_enterCountry.js

@@ -0,0 +1,47 @@
+import { close, open } from '../tsHelper.js';
+const formName = 'ng$country_dtl';
+const formState = 'ng$country_state_dtl';
+const formPostalcode = 'ng$postalcode_dtl';
+export const GLO_enterCountry = (obj, part = 'country') => {
+    switch (part) {
+        case 'state': {
+            cy.GLO_addInput([formState, 'textbox_state_name'], obj.stateName);
+            cy.GLO_addInput([formState, 'textbox_state_code'], obj.stateCode);
+            cy.GLO_addInput([formState, 'textbox_vat_prefix'], obj.vatPrefix);
+            break;
+        }
+        case 'county': {
+            cy.GLO_addInput(['ng$county_dtl', 'county'], obj.countyName);
+            break;
+        }
+        case 'postalCode': {
+            cy.GLO_addInput([formPostalcode, 'textbox_state'], obj.stateName);
+            cy.GLO_addInput([formPostalcode, 'county_id'], obj.countyName);
+            cy.GLO_addInput([formPostalcode, 'postalcode'], obj.postalCode);
+            cy.GLO_addInput([formPostalcode, 'city'], obj.city);
+            break;
+        }
+        default: {
+            cy.GLO_addInput([formName, 'country_code'], obj.countryCode);
+            cy.GLO_addInput([formName, 'iso_country_code'], obj.isoCountryCode);
+            cy.GLO_addInput([formName, 'iso_country_code_3'], obj.isoCountryCode3);
+            cy.GLO_addInput([formName, 'vat_prefix'], obj.vatPrefix);
+            cy.GLO_addInput([formName, 'international_dial_code'], obj.dialCode);
+            cy.GLO_checkbox([formName, 'is_active'], obj.isActive);
+            cy.GLO_checkbox([formName, 'flag_use_counties'], obj.useCounties);
+            cy.GLO_checkbox([formName, 'checkbox_use_states'], obj.useStates);
+            cy.GLO_addInput([formName, 'street_format'], obj.streetFormat);
+            cy.GLO_addInput([formName, 'textbox_addres_block_format'], obj.addressBlockFormat);
+            cy.GLO_selectTab([formName, 'tabs_70'], 'Translations', open);
+            if (obj.translation !== undefined) {
+                cy.GLO_getElement(['ng$basetabletranslation_uuid_lst_tab', 'grid']).within(() => {
+                    cy.get('.editable-field').each((field) => {
+                        cy.wrap(field).dblclick().type(obj.translation);
+                    });
+                });
+            }
+            cy.GLO_selectTab([formName, 'tabs_70'], 'Translations', close);
+            break;
+        }
+    }
+};

package/dist/blueprints/GLO_enterDiscount.d.ts

@@ -0,0 +1,8 @@
+export type objDiscount = {
+    discountOrigin?: string;
+    discountType?: string;
+    relationCode?: string;
+    validFrom?: string;
+    discountPerc1?: number;
+};
+export declare const GLO_enterDiscount: (obj: objDiscount) => void;

package/dist/blueprints/GLO_enterDiscount.js

@@ -0,0 +1,9 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterDiscount = (obj) => {
+    const formName = 'ng$discounts_dtl';
+    cy.GLO_addInput([formName, 'discount_origin'], obj.discountOrigin);
+    cy.GLO_addInput([formName, 'discount_type'], obj.discountType);
+    cy.GLO_popupWindow([formName, 'btn_select_relation'], obj.relationCode);
+    cy.GLO_addDate(input, [formName, 'valid_from'], obj.validFrom);
+    cy.GLO_addInput([`${formName}_contractual`, 'discount_perc_1'], obj.discountPerc1);
+};

package/dist/blueprints/GLO_equipment.d.ts

@@ -0,0 +1,34 @@
+import { type CheckState } from '../tsHelper.js';
+import { type objAddressPopup } from './GLO_addressPopup.js';
+export type objEquipment = {
+    historyRemark?: string;
+    flagRentedOut?: CheckState;
+    buyer?: string;
+    equipmentCode?: string;
+    equipmentType?: string;
+    licensePlate?: string;
+    owner?: string;
+    equipmentCategory?: string;
+    inUseByRelation?: string;
+    flagIsActive?: CheckState;
+    seriesNr?: string;
+    lastKnownAddress?: objAddressPopup;
+    shipmentContainerType?: string;
+    shipmentContainerSubType?: string;
+    damaged?: CheckState;
+    temperatureControlled?: string;
+    rentedOutTo?: string;
+    oneTimeUse?: CheckState;
+    tarraWeight?: number;
+    flagHighValue?: CheckState;
+    exteriorHeight?: string | number;
+    roadTarra?: string | number;
+    flagDangerousGoods?: CheckState;
+    flagTemperatureContolledAllowed?: CheckState;
+    flagAlcoholAllowed?: CheckState;
+    flagWasteAllowed?: CheckState;
+    numberOfAxles?: string | number;
+    fuelType?: string;
+    euroClass?: string;
+};
+export declare const GLO_enterEquipment: (obj: objEquipment, tabName?: string) => void;

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;