@globisnv/cypress-core 0.0.1

package/dist/blueprints/GLO_countryVatZone.d.ts

@@ -0,0 +1,8 @@
+export type objCountryVatZone = {
+    company?: string;
+    countryState?: string;
+    vatZone?: string;
+    customsUnion?: string;
+    validFrom?: string;
+};
+export declare const GLO_enterCountryVatZone: (obj: objCountryVatZone) => void;

package/dist/blueprints/GLO_countryVatZone.js

@@ -0,0 +1,9 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterCountryVatZone = (obj) => {
+    const formName = 'ng$country_vat_zone_dtl';
+    cy.GLO_addInput([formName, 'company_id'], obj.company);
+    cy.GLO_addInput([formName, 'country_state'], obj.countryState);
+    cy.GLO_addInput([formName, 'vat_zone_id'], obj.vatZone);
+    cy.GLO_addInput([formName, 'customs_union_id'], obj.customsUnion);
+    cy.GLO_addDate(input, [formName, 'startdate'], obj.validFrom);
+};

package/dist/blueprints/GLO_currencyDeviation.d.ts

@@ -0,0 +1,14 @@
+export type objCurrencyDeviation = {
+    currencyCode?: string;
+    relationCode?: string;
+    dateFrom?: string;
+    percentagePurchaseInvoiceNegativeAllowed?: number;
+    amountPurchaseInvoiceNegativeAllowed?: number;
+    percentagePurchaseInvoicePositiveAllowed?: number;
+    amountPurchaseInvoicePositiveAllowed?: number;
+    percentagePurchaseInvoicelineNegativeAllowed?: number;
+    amountPurchaseInvoicelineNegativeAllowed?: number;
+    percentagePurchaseInvoicelinePositiveAllowed?: number;
+    amountPurchaseInvoicelinePositiveAllowed?: number;
+};
+export declare const GLO_enterCurrencyDeviation: (obj: objCurrencyDeviation) => void;

package/dist/blueprints/GLO_currencyDeviation.js

@@ -0,0 +1,15 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterCurrencyDeviation = (obj) => {
+    const formName = 'ng$currency_deviation_dtl';
+    cy.GLO_addInput([formName, 'currency_id'], obj.currencyCode);
+    cy.GLO_addInput([formName, 'relation_id'], obj.relationCode);
+    cy.GLO_addDate(input, [formName, 'date_from'], obj.dateFrom);
+    cy.GLO_addInput([formName, 'purchase_invoice_neg_allowed_diff_perc'], obj.percentagePurchaseInvoiceNegativeAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoice_neg_allowed_diff_amount'], obj.amountPurchaseInvoiceNegativeAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoice_pos_allowed_diff_perc'], obj.percentagePurchaseInvoicePositiveAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoice_pos_allowed_diff_amount'], obj.amountPurchaseInvoicePositiveAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoiceline_neg_allowed_diff_perc'], obj.percentagePurchaseInvoicelineNegativeAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoiceline_neg_allowed_diff_amount'], obj.amountPurchaseInvoicelineNegativeAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoiceline_pos_allowed_diff_perc'], obj.percentagePurchaseInvoicelinePositiveAllowed);
+    cy.GLO_addInput([formName, 'purchase_invoiceline_pos_allowed_diff_amount'], obj.amountPurchaseInvoicelinePositiveAllowed);
+};

package/dist/blueprints/GLO_customerArticle.d.ts

@@ -0,0 +1,12 @@
+export type objCustomerArticle = {
+    customerCode?: string;
+    customerArticleCode?: string;
+    customerArticleCustomerArticleCode?: string;
+    customerArticleMinimumQuantityToOrder?: number;
+    customerArticleContractQuantity?: number;
+    customerArticlePrice?: string;
+    customerArticleVersion?: string;
+    customerDefaultCustomsStatus?: string;
+    containerSubtype?: string;
+};
+export declare const GLO_addCustomerArticle: (obj: objCustomerArticle) => void;

package/dist/blueprints/GLO_customerArticle.js

@@ -0,0 +1,15 @@
+const customerArticleMainForm = 'ng$customer_article_dtl';
+export const GLO_addCustomerArticle = (obj) => {
+    cy.GLO_popupWindow([customerArticleMainForm, 'relation_code'], obj.customerCode);
+    if (obj.customerArticleCode) {
+        cy.GLO_addInput([customerArticleMainForm, 'article_code'], obj.customerArticleCode);
+        cy.GLO_checkLoadingIndicator();
+    }
+    cy.GLO_addInput([customerArticleMainForm, 'customer_article_code'], obj.customerArticleCustomerArticleCode);
+    cy.GLO_addInput([customerArticleMainForm, 'minimum_orderquantity'], obj.customerArticleMinimumQuantityToOrder);
+    cy.GLO_addInput([customerArticleMainForm, 'quantity'], obj.customerArticleContractQuantity);
+    cy.GLO_addInput([customerArticleMainForm, 'price'], obj.customerArticlePrice);
+    cy.GLO_addInput([customerArticleMainForm, 'articleversion_code'], obj.customerArticleVersion);
+    cy.GLO_addInput([customerArticleMainForm, 'default_customs_status'], obj.customerDefaultCustomsStatus);
+    cy.GLO_addInput([customerArticleMainForm, 'container_subtype'], obj.containerSubtype);
+};

package/dist/blueprints/GLO_customsFlow.d.ts

@@ -0,0 +1,8 @@
+import { type CheckState } from '../tsHelper.js';
+export type objCustomsFlow = {
+    customsFlowCode?: string;
+    sequenceNr?: number;
+    flagActive?: CheckState;
+    translation?: string;
+};
+export declare const GLO_enterCustomsFlow: (obj: objCustomsFlow) => void;

package/dist/blueprints/GLO_customsFlow.js

@@ -0,0 +1,19 @@
+import { close, open } from '../tsHelper.js';
+export const GLO_enterCustomsFlow = (obj) => {
+    const formName = 'ng$customs_flow_dtl';
+    const tabs = 'tabs_70';
+    const translationGrid = 'ng$basetabletranslation_uuid_lst_tab';
+    cy.GLO_addInput([formName, 'customs_flow_code'], obj.customsFlowCode);
+    cy.GLO_addInput([formName, 'sequence_nr'], obj.sequenceNr);
+    cy.GLO_checkbox([formName, 'flag_active'], obj.flagActive);
+    if (obj.translation) {
+        const translation = obj.translation;
+        cy.GLO_selectTab([formName, tabs], 'Translations', open);
+        cy.GLO_getElement([translationGrid, 'grid']).within(() => {
+            cy.get('.editable-field').each((field) => {
+                cy.wrap(field).dblclick().type(translation);
+            });
+        });
+        cy.GLO_selectTab([formName, tabs], 'Translations', close);
+    }
+};

package/dist/blueprints/GLO_customsFlowDefinition.d.ts

@@ -0,0 +1,15 @@
+import type { CheckState } from '../tsHelper.js';
+export type objCustomsFlowDefinition = {
+    sequenceNr?: number;
+    definitionCode?: string;
+    customsType?: string;
+    customsResponsibility?: string;
+    customsOfficeDefinition?: string;
+    outboundStopDefinition?: string;
+    outboundDocumentType?: string;
+    inboundStopDefinition?: string;
+    inboundDocumentType?: string;
+    remarks?: string;
+    flagActive?: CheckState;
+};
+export declare const GLO_enterCustomsFlowDefinition: (obj: objCustomsFlowDefinition) => void;

package/dist/blueprints/GLO_customsFlowDefinition.js

@@ -0,0 +1,14 @@
+export const GLO_enterCustomsFlowDefinition = (obj) => {
+    const formName = 'ng$customs_flow_definition_dtl';
+    cy.GLO_addInput([formName, 'sequence_nr'], obj.sequenceNr);
+    cy.GLO_addInput([formName, 'customs_flow_definition_code'], obj.definitionCode);
+    cy.GLO_addInput([formName, 'customs_type'], obj.customsType);
+    cy.GLO_addInput([formName, 'customs_responsibility'], obj.customsResponsibility);
+    cy.GLO_addInput([formName, 'customs_office_definition'], obj.customsOfficeDefinition);
+    cy.GLO_addInput([formName, 'outbound_stop_definition'], obj.outboundStopDefinition);
+    cy.GLO_addInput([formName, 'outbound_document_type_id'], obj.outboundDocumentType);
+    cy.GLO_addInput([formName, 'inbound_stop_definition'], obj.inboundStopDefinition);
+    cy.GLO_addInput([formName, 'inbound_document_type_id'], obj.inboundDocumentType);
+    cy.GLO_addInput([formName, 'remarks'], obj.remarks);
+    cy.GLO_checkbox([formName, 'flag_active'], obj.flagActive);
+};

package/dist/blueprints/GLO_customsUnion.d.ts

@@ -0,0 +1,4 @@
+export type objCustomsUnion = {
+    customsUnionCode?: string;
+};
+export declare const GLO_enterCustomsUnion: (obj: objCustomsUnion) => void;

package/dist/blueprints/GLO_customsUnion.js

@@ -0,0 +1,4 @@
+export const GLO_enterCustomsUnion = (obj) => {
+    const formName = 'ng$customs_union_dtl';
+    cy.GLO_addInput([formName, 'customs_union_code'], obj.customsUnionCode);
+};

package/dist/blueprints/GLO_deliveryReceipt.d.ts

@@ -0,0 +1,10 @@
+export type objDeliveryReceipt = {
+    relationCode?: number | string;
+    deliveredEuroPallets?: number;
+    deliveredMeloPallets?: number;
+    deliveredSinglePallets?: number;
+    retourEuroPallets?: number;
+    retourMeloPallets?: number;
+    retourSinglePallets?: number;
+};
+export declare const GLO_enterDeliveryReceipt: (obj: objDeliveryReceipt) => void;

package/dist/blueprints/GLO_deliveryReceipt.js

@@ -0,0 +1,22 @@
+import { close, open } from '../tsHelper.js';
+export const GLO_enterDeliveryReceipt = (obj) => {
+    const formName = 'ng$delivery_dtl';
+    const detailTabsName = 'tabs_70';
+    if (obj.relationCode) {
+        cy.GLO_selectTab([formName, detailTabsName], 'General', open);
+        cy.GLO_addInput(['ng$delivery_dtl_general', 'relation_code'], obj.relationCode);
+        cy.GLO_checkLoadingIndicator(); // Loading data
+        cy.GLO_dialogChoice('Yes');
+        cy.GLO_selectTab([formName, detailTabsName], 'General', close);
+    }
+    if (obj.deliveredEuroPallets || obj.deliveredMeloPallets || obj.deliveredSinglePallets || obj.retourEuroPallets || obj.retourMeloPallets || obj.deliveredSinglePallets) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Attributes', open);
+        cy.GLO_addInput(['attribute_value_b1fe5ae8_7bd6_4e1d_932e_4fbc94ee5aac'], obj.deliveredEuroPallets);
+        cy.GLO_addInput(['attribute_value_af15d164_55d2_4824_a9c3_38e1b7bdd731'], obj.deliveredMeloPallets);
+        cy.GLO_addInput(['attribute_value_122511ba_516a_4f39_8359_bc47e9b6cd6d'], obj.deliveredSinglePallets);
+        cy.GLO_addInput(['attribute_value_b8efaae0_2890_424d_9bf1_e774cd0334e1'], obj.retourEuroPallets);
+        cy.GLO_addInput(['attribute_value_7a21c397_9223_4af6_b961_05478a1c4341'], obj.retourMeloPallets);
+        cy.GLO_addInput(['attribute_value_11f832aa_c149_4036_815f_b650918413c9'], obj.retourSinglePallets);
+        cy.GLO_selectTab([formName, detailTabsName], 'Attributes', close);
+    }
+};

package/dist/blueprints/GLO_departureSchedule.d.ts

@@ -0,0 +1,27 @@
+import { type CheckState } from '../tsHelper.js';
+export type objDepartureSchedule = {
+    logisticConnection?: string;
+    supplier?: string;
+    validFrom?: string;
+    validTill?: string;
+    logisticContractDetail?: string;
+    operationalActive?: CheckState;
+    dgnAllowed?: CheckState;
+    comment?: string;
+    scheduleComment?: string;
+    userInSimulation?: CheckState;
+    useInPriceCalculation?: CheckState;
+    automaticCreation?: CheckState;
+    automaticCreationWeeks?: string;
+    departureAddress?: string;
+    arrivalAddress?: string;
+    distance?: number;
+    bookingOpeningRelativeDays?: string;
+    bookingOpeningTime?: string;
+    bookingClosingRelativeDays?: string;
+    bookingClosingTime?: string;
+    flagDgnAllowed?: CheckState;
+    flagDgnLimitedQuantityAllowed?: CheckState;
+    flagWasteAllowed?: CheckState;
+};
+export declare const GLO_enterDepartureSchedule: (obj: objDepartureSchedule) => void;

package/dist/blueprints/GLO_departureSchedule.js

@@ -0,0 +1,57 @@
+import { close, input, open } from '../tsHelper.js';
+export const GLO_enterDepartureSchedule = (obj) => {
+    const formName = 'ng$logistic_conn_schedule_dtl';
+    const addressFormName = 'ng$logistic_conn_schedule_dtl_address_time';
+    const defaultsFormName = 'ng$logistic_conn_schedule_dtl_defaults';
+    const remarkFormName = 'ng$remark_dtl_logistic_conn_schedule';
+    const detailTabsName = 'tabs_70';
+    cy.GLO_popupWindow([formName, 'local_logistic_conn_code'], obj.logisticConnection);
+    cy.GLO_popupWindow([formName, 'local_supplier_code'], obj.supplier);
+    cy.GLO_addDate(input, [formName, 'valid_from'], obj.validFrom);
+    cy.GLO_addDate(input, [formName, 'valid_till'], obj.validTill);
+    cy.GLO_popupWindow([formName, 'local_logistic_contract_detail_code'], obj.logisticContractDetail);
+    cy.GLO_checkbox([formName, 'flag_operational_active'], obj.operationalActive);
+    cy.GLO_checkbox([formName, 'flag_dgn_allowed'], obj.dgnAllowed);
+    cy.GLO_addInput([formName, 'comment1'], obj.comment);
+    cy.GLO_checkbox([formName, 'flag_sim'], obj.userInSimulation);
+    cy.GLO_checkbox([formName, 'flag_calc'], obj.useInPriceCalculation);
+    cy.GLO_checkbox([formName, 'flag_automatic_creation'], obj.automaticCreation);
+    cy.GLO_addInput([formName, 'automatic_creation_weeks'], obj.automaticCreationWeeks);
+    if (obj.departureAddress || obj.arrivalAddress || obj.distance) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Address and duration', open);
+        cy.GLO_popupWindow([addressFormName, 'relation_address_from'], obj.departureAddress);
+        cy.GLO_popupWindow([addressFormName, 'relation_address_to'], obj.arrivalAddress);
+        cy.GLO_addInput([addressFormName, 'distance_in_km'], obj.distance);
+        cy.GLO_selectTab([formName, detailTabsName], 'Address and duration', close);
+    }
+    if (obj.bookingOpeningRelativeDays ||
+        obj.bookingOpeningTime ||
+        obj.bookingClosingRelativeDays ||
+        obj.bookingClosingTime ||
+        obj.flagDgnAllowed ||
+        obj.flagDgnLimitedQuantityAllowed ||
+        obj.flagWasteAllowed) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Defaults', open);
+        if (obj.bookingOpeningRelativeDays) {
+            cy.GLO_getElement([defaultsFormName, 'booking_opening_relative_days']).find('.dx-texteditor-input').type(obj.bookingOpeningRelativeDays);
+        }
+        if (obj.bookingOpeningTime) {
+            cy.GLO_getElement([defaultsFormName, 'booking_opening_time']).find('.dx-texteditor-input').type(obj.bookingOpeningTime);
+        }
+        if (obj.bookingClosingRelativeDays) {
+            cy.GLO_getElement([defaultsFormName, 'booking_closing_relative_days']).find('.dx-texteditor-input').type(obj.bookingClosingRelativeDays);
+        }
+        if (obj.bookingClosingTime) {
+            cy.GLO_getElement([defaultsFormName, 'booking_closing_time']).find('.dx-texteditor-input').type(obj.bookingClosingTime);
+        }
+        cy.GLO_checkbox([defaultsFormName, 'flag_dgn_allowed'], obj.flagDgnAllowed);
+        cy.GLO_checkbox([defaultsFormName, 'flag_dgn_limited_quantity_allowed'], obj.flagDgnLimitedQuantityAllowed);
+        cy.GLO_checkbox([defaultsFormName, 'flag_waste_allowed'], obj.flagWasteAllowed);
+        cy.GLO_selectTab([formName, detailTabsName], 'Defaults', close);
+    }
+    if (obj.scheduleComment) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Remarks', open);
+        cy.GLO_addInput([remarkFormName, 'local_LOG_CONN_SCHED_REMARK'], obj.scheduleComment);
+        cy.GLO_selectTab([formName, detailTabsName], 'Remarks', close);
+    }
+};

package/dist/blueprints/GLO_departureScheduleTimes.d.ts

@@ -0,0 +1,49 @@
+import { type CheckState } from '../tsHelper.js';
+export type objDepartureScheduleTimes = {
+    departureTime?: string;
+    departureTimezone?: string;
+    arrivalTime?: string;
+    arrivalTimezone?: string;
+    remark?: string;
+    bookingOpeningRelativeDays?: string;
+    bookingOpeningTime?: string;
+    bookingClosingRelativeDays?: string;
+    bookingClosingTime?: string;
+    flagOperationalActive?: CheckState;
+    flagDgnAllowed?: CheckState;
+    flagDgnLimitedQuantityAllowed?: CheckState;
+    flagWasteAllowed?: CheckState;
+    arrivalRelativeDays?: string;
+    embarkDuration?: string;
+    disembarkDuration?: string;
+    firstDropRelativeDays?: string;
+    firstDropTime?: string;
+    firstDropDgnRelativeDays?: string;
+    firstDropDgnTime?: string;
+    lastDropRelativeDays?: string;
+    lastDropTime?: string;
+    lastDropDgnRelativeDays?: string;
+    lastDropDgnTime?: string;
+    lastDropContainerRelativeDays?: string;
+    lastDropContainerTime?: string;
+    lastDropTrailerRelativeDays?: string;
+    lastDropTrailerTime?: string;
+    availableAfterArrivalTimeRelativeDays?: string;
+    availableLofoAfterArrivalTimeRelativeDays?: string;
+    minNrOfContainers?: number;
+    maxNrOfContainers?: number;
+    minNrOfTrailers?: number;
+    maxNrOfTrailers?: number;
+    maxAntiTheftCapacity?: number;
+    capacityGrossWeight?: number;
+    capacityGrossWeightUnitId?: string;
+    flagMonday?: CheckState;
+    flagTuesday?: CheckState;
+    flagWednesday?: CheckState;
+    flagThursday?: CheckState;
+    flagFriday?: CheckState;
+    flagSaturday?: CheckState;
+    flagSunday?: CheckState;
+    pricingGroup?: string;
+};
+export declare const GLO_enterDepartureScheduleTimes: (obj: objDepartureScheduleTimes) => void;

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;