@servicenow/sdk-build-plugins 2.0.1

package/dist/atf/ATFComposer.js

@@ -0,0 +1,2717 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATF = void 0;
+exports.getRecordIdIfRecord = getRecordIdIfRecord;
+exports.getRoleId = getRoleId;
+exports.getRecordId = getRecordId;
+exports.isRecord = isRecord;
+exports.isRole = isRole;
+const db_1 = require("@servicenow/sdk-core/runtime/db");
+const tables_1 = require("@servicenow/sdk-core/runtime/tables");
+const atf = __importStar(require("@servicenow/sdk-core/runtime/atf"));
+function getRecordIdIfRecord(value, context) {
+    if (isRecord(value)) {
+        return getRecordId(value, context);
+    }
+    else if (isRole(value)) {
+        return getRoleId(value, context);
+    }
+    return value;
+}
+function getRoleId(record, context) {
+    return context.keys.registerExplicitId('sys_user_role', record.$id);
+}
+function getRecordId(record, context) {
+    if ('sys_id' in record.data && record.data['sys_id']) {
+        return record.data['sys_id'];
+    }
+    return context.keys.registerExplicitId(record.table, typeof record.$id === 'object' ? record.$id.id : record.$id);
+}
+function isRecord(value) {
+    return typeof value === 'object' && '$id' in value && 'table' in value;
+}
+function isRole(value) {
+    return typeof value === 'object' && '$id' in value && 'name' in value;
+}
+/**
+ * These functions will return record lists instead of the return type property specified in the interface. Hence the explicit any return
+ *
+ */
+class ATF {
+    test;
+    /**
+     * Do not modify directly. Let TestPlugin handle incrementing the value
+     */
+    order;
+    /**
+     * Do not manipulate directly in step functions. Instead create helper creation functions that increment this value
+     *
+     * Modified in the following locations:
+     * ```typescript
+     * function createStepRecord
+     * function _createGemRecords
+     * function _createVariableValueRecord
+     * ```
+     */
+    _records;
+    /**
+     * Used to access previously created steps based on index. Do not manipulate directly unless you are sure of what you are doing
+     *
+     * Modified in the following locations:
+     * ```typescript
+     * createStepRecord
+     * ```
+     */
+    stepRecords;
+    context;
+    constructor(inputObject, context) {
+        this.context = context;
+        this.test = (0, db_1.Record)({
+            $id: inputObject.$id,
+            table: 'sys_atf_test',
+            data: {
+                name: inputObject.name,
+                active: inputObject.active,
+                description: inputObject.description,
+                fail_on_server_error: inputObject.failOnServerError,
+            },
+        });
+        this._records = {};
+        this.order = 1;
+        this.stepRecords = [];
+    }
+    /**
+     * DO NOT CALL DIRECTLY
+     * Unless you know what you are doing do not handle setting the order number. It is handled by TestPlugin
+     */
+    incrementOrder() {
+        this.order++;
+    }
+    parseValue(value) {
+        // Simple object types should be trivial to parse
+        if (typeof value !== 'object') {
+            return value;
+        }
+        // Dont iterate on entities, assume whatever extractor they are using is doing its job
+        if (typeof value?.asRecord !== 'undefined') {
+            return value;
+        }
+        // If the value is a gem value we should replace the gem object with a string in place
+        if (this.isGem(value)) {
+            const refRecord = this.stepRecords[value.__references];
+            if (!refRecord) {
+                throw new Error('Cannot find referenced record');
+            }
+            const stepID = getRecordId(refRecord, this.context);
+            value = `{{step['${stepID}'].${value.__value}}}`;
+            return value;
+        }
+        // Template strings can contain gem values so iterate over them to replace gem values, records, etc, if necessary, but most entries should be string
+        if (this.isTemplateStr(value)) {
+            return `${value.__template.map((entry) => this.parseValue(entry)).join('')}`;
+        }
+        // If the value is a record turn it into a sys_id
+        if (isRecord(value) || isRole(value)) {
+            return this.extractSysIdIfRecord(value);
+        }
+        // Recurse into object and see if any of its descendents need to be parsed
+        const keys = Object.keys(value);
+        for (const key of keys) {
+            const val = value[key];
+            value[key] = this.parseValue(val);
+        }
+        // Return parsed object
+        return value;
+    }
+    isTemplateStr(value) {
+        return typeof value === 'object' && typeof value.__template !== 'undefined';
+    }
+    /**
+     * Determines if gem is used at all in this value or down the nested object. If gem is used it is required to use sys_element_mapping in addition to sys_variable_value
+     */
+    containsGem(value) {
+        if (typeof value !== 'object') {
+            return false;
+        }
+        // Don't recurse on entities we are not interested in their keys or children
+        if (typeof value?.asRecord !== 'undefined') {
+            return false;
+        }
+        if (this.isGem(value)) {
+            return true;
+        }
+        const results = [];
+        const keys = Object.keys(value);
+        for (const key of keys) {
+            const val = value[key];
+            results.push(this.containsGem(val));
+        }
+        return results.includes(true);
+    }
+    /**
+     *
+     * @param value Any value
+     * @returns whether the value is a gem mapping from an output variable
+     */
+    isGem(value) {
+        if (typeof value != 'object') {
+            return false;
+        }
+        return typeof value.__references !== 'undefined' && typeof value.__value !== 'undefined';
+    }
+    createStepRecord(props) {
+        const { stepConfig, name, description = 'A step created by fluent', tableName = '' } = props;
+        const stepRecord = (0, db_1.Record)({
+            $id: `sys_atf_step_${this.test.$id}_${this.order}`, // Id is unique because there is one sys_atf_step record per step qed 1 per order, which ensures this id is unique
+            table: 'sys_atf_step',
+            data: {
+                step_config: stepConfig,
+                display_name: name,
+                sys_name: name,
+                description: description,
+                order: this.order,
+                test: this.test,
+                active: true,
+                table: tableName,
+            },
+        });
+        this.stepRecords.push(stepRecord);
+        const currentStep = getRecordId(stepRecord, this.context);
+        this._records[currentStep] = [];
+        return stepRecord;
+    }
+    /**
+     * All records: test, step, or metadata, which are necessary for the test
+     */
+    get records() {
+        return this._records;
+    }
+    _createGemRecords(props) {
+        const { variable, value, stepRecord, stepConfig } = props;
+        if (typeof value === 'object') {
+            throw Error('Attempted to serialize an object to a value');
+        }
+        const variableValueRecord = this._createVariableValueRecord({ variable, stepRecord, value: '' });
+        const currentStep = getRecordId(stepRecord, this.context);
+        const stepConfigId = getRecordId(stepConfig, this.context);
+        const table = `var__m_atf_input_variable_${stepConfigId}`;
+        const field = variable.data.element ? variable.data.element : '';
+        const elementMappingRecord = (0, db_1.Record)({
+            $id: `sys_element_mapping_${this.test.$id}_${this.order}_${variable.$id}`,
+            table: 'sys_element_mapping',
+            data: {
+                id: currentStep,
+                field,
+                table,
+                value,
+            },
+        });
+        if (!this._records[currentStep]) {
+            this._records[currentStep] = [elementMappingRecord];
+        }
+        else {
+            this._records[currentStep].push(elementMappingRecord);
+        }
+        return { sys_variable_value: variableValueRecord, element_mapping: elementMappingRecord };
+    }
+    /**
+     * Use createVariable instead unless you have good reason to use this
+     * @param props
+     * @returns
+     */
+    _createVariableValueRecord(props) {
+        const { variable, value, stepRecord } = props;
+        if (typeof value === 'object') {
+            throw Error('Attempted to serialize an object to a value');
+        }
+        const currentStep = getRecordId(stepRecord, this.context);
+        const variableRecord = (0, db_1.Record)({
+            table: 'sys_variable_value',
+            $id: `sys_variable_value_${this.test.$id}_${this.order}_${variable.$id}`,
+            data: {
+                document: 'sys_atf_step',
+                document_key: stepRecord,
+                variable,
+                value,
+            },
+        });
+        if (!this._records[currentStep]) {
+            this._records[currentStep] = [variableRecord];
+        }
+        else {
+            this._records[currentStep].push(variableRecord);
+        }
+        return variableRecord;
+    }
+    fieldValuesToQuery(fieldValues) {
+        // This converts records/tables in a field value set to the correct string
+        const valuesObj = this.nameValuePairProcessing(fieldValues);
+        const queries = [];
+        for (const pair of Object.entries(valuesObj)) {
+            const key = pair[0];
+            let value = pair[1];
+            if (typeof value === 'string') {
+                value = value.replaceAll('^', '^^');
+            }
+            else if (value && typeof value === 'object' && '$id' in value) {
+                value = getRecordId(value, this.context);
+            }
+            queries.push(`${key}=${value}`);
+        }
+        return queries.join('^');
+    }
+    recordListToString(recordList) {
+        if (!recordList || recordList.length == 0) {
+            return '';
+        }
+        return recordList
+            .map((entry) => {
+            return this.extractSysIdIfRecord(entry);
+        })
+            .join(',');
+    }
+    /**
+     * Outputs a string value which is either standard_ui or the sys_id of the form view
+     */
+    parseFormUI(formUI) {
+        if (typeof formUI === 'string') {
+            if (atf.FormUI[formUI]) {
+                return typeof atf.FormUI[formUI] === 'string'
+                    ? atf.FormUI[formUI]
+                    : getRecordId(atf.FormUI[formUI], this.context);
+            }
+            return formUI;
+        }
+        return getRecordId(formUI, this.context);
+    }
+    extractSysIdIfRecord(value) {
+        if (isRecord(value)) {
+            return getRecordId(value, this.context);
+        }
+        if (isRole(value)) {
+            return getRoleId(value, this.context);
+        }
+        return value;
+    }
+    secondsToDuration(value) {
+        const ms = value * 1000;
+        const time = new Date();
+        time.setTime(ms);
+        const str = time.toISOString().replace('T', ' ').split('.')[0];
+        return str;
+    }
+    nameValuePairProcessing(nvp) {
+        if (typeof nvp === 'object') {
+            if ('asRecord' in nvp) {
+                return getRecordId(nvp, this.context);
+            }
+            // If Object is an object, iterate over keys and recursively determine the values
+            const objKeys = Object.keys(nvp);
+            for (const key of objKeys) {
+                nvp[key] = this.nameValuePairProcessing(nvp[key]);
+            }
+        }
+        return nvp;
+    }
+    createVariable(props) {
+        const { variable, stepRecord, stringifier, startingValue, stepConfig } = props;
+        // Do this first becaused parseValue can modify the object in place so it may get rid of gem values down a tree
+        const containsGem = this.containsGem(startingValue);
+        const parsedValue = stringifier ? stringifier(this.parseValue(startingValue)) : this.parseValue(startingValue);
+        if (containsGem) {
+            this._createGemRecords({
+                stepConfig,
+                stepRecord,
+                value: parsedValue,
+                variable,
+            });
+        }
+        else {
+            this._createVariableValueRecord({
+                stepRecord,
+                variable,
+                value: parsedValue,
+            });
+        }
+    }
+    // ========
+    // BELOW THIS POINT IS ALL FUNCTIONS DEFINED IN THE TEST INTERFACE WHICH MAP 1:1 WITH TESTS
+    // Define any utility functions above for easy navigation
+    // ========
+    openExistingRecord(inputs) {
+        const { table, view, recordId, formUI, selectedTabIndex } = inputs;
+        const stepConfig = tables_1.StepConfig.OpenAnExistingRecord;
+        const stepRecord = this.createStepRecord({
+            name: 'Open an Existing Record',
+            stepConfig: stepConfig,
+            description: 'Opens an existing record in this table',
+            tableName: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig: stepConfig,
+            variable: tables_1.Variables.OpenExistingRecord.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            variable: tables_1.Variables.OpenExistingRecord.FormUI,
+            stepConfig: stepConfig,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenExistingRecord.RecordPath,
+            startingValue: 'record',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenExistingRecord.RecordId,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenExistingRecord.View,
+            startingValue: view,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenExistingRecord.SelectedTabIndex,
+            startingValue: selectedTabIndex,
+        });
+    }
+    openNewForm(inputs) {
+        const { table: tableName, view = '', formUI } = inputs;
+        const stepConfig = tables_1.StepConfig.OpenANewForm;
+        const stepRecord = this.createStepRecord({
+            name: 'Open a New form',
+            stepConfig: stepConfig,
+            description: `Opens a new form in this table`,
+            tableName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenNewForm.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenNewForm.Table,
+            startingValue: tableName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenNewForm.View,
+            startingValue: view,
+        });
+    }
+    fieldValueValidation(inputs) {
+        const { table: tableName, conditions, formUI } = inputs;
+        const stepConfig = tables_1.StepConfig.FieldValueValidation;
+        const stepRecord = this.createStepRecord({
+            name: 'Field Values Validation',
+            description: `Validates field values on the current form.`,
+            tableName,
+            stepConfig,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.FieldValueValidation.Table,
+            startingValue: tableName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.FieldValueValidation.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.FieldValueValidation.Conditions,
+            startingValue: conditions,
+        });
+    }
+    setFieldValue(inputs) {
+        const { table, fieldValues, formUI } = inputs;
+        const stepConfig = tables_1.StepConfig.SetFieldValues;
+        const stepRecord = this.createStepRecord({
+            name: 'Set Field Values',
+            description: `Set field values on a form.`,
+            stepConfig,
+            tableName: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SetFieldValues.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SetFieldValues.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SetFieldValues.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        });
+    }
+    submitForm(inputs) {
+        const { assertType, formUI } = inputs;
+        const stepConfig = tables_1.StepConfig.SubmitAForm;
+        const stepRecord = this.createStepRecord({
+            name: 'Submit a Form',
+            stepConfig,
+            description: 'Submits the current form.',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SubmitForm.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SubmitForm.AssertType,
+            startingValue: assertType,
+        });
+    }
+    validateOutboundEmailGeneratedByNotification(inputs) {
+        const { sourceNotification, conditions } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateOutboundEmailGeneratedByNotification;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Outbound Email Generated by Notification',
+            stepConfig,
+            description: 'Finds and verifies an outbound email generated by a notification',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByNotification.Table,
+            startingValue: 'sys_email',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByNotification.SourceNotification,
+            startingValue: sourceNotification,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByNotification.Conditions,
+            startingValue: conditions,
+        });
+    }
+    recordUpdate(inputs) {
+        const { table, assertType, enforceSecurity, recordId, fieldValues } = inputs;
+        const assertValue = assertType;
+        const stepConfig = tables_1.StepConfig.RecordUpdate;
+        const stepRecord = this.createStepRecord({
+            name: 'Record Update',
+            stepConfig,
+            description: 'Update a record in the table.',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordUpdate.EnforceSecurity,
+            startingValue: enforceSecurity,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordUpdate.AssertType,
+            startingValue: assertValue,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordUpdate.RecordID,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordUpdate.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordUpdate.Table,
+            startingValue: table,
+        });
+    }
+    generateRandomString(inputs) {
+        const { length } = inputs;
+        const stepConfig = tables_1.StepConfig.GenerateRandomString;
+        const stepRecord = this.createStepRecord({
+            name: 'Generate Random String',
+            stepConfig,
+            description: 'Generate a random string.',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateARandomString.Length,
+            startingValue: length,
+        });
+    }
+    uiActionVisibility(inputs) {
+        const { table, formUI, visible, notVisible } = inputs;
+        const stepConfig = tables_1.StepConfig.UIActionVisibility;
+        const stepRecord = this.createStepRecord({
+            name: 'UI Action Visibility',
+            stepConfig,
+            description: 'Checks if the listed fields are visible or not visible on the form.',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibility.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibility.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibility.Visible,
+            startingValue: visible,
+            stringifier: (value) => this.recordListToString(value),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibility.NotVisible,
+            startingValue: notVisible,
+            stringifier: (value) => this.recordListToString(value),
+        });
+    }
+    validatePriceAndRecurringPrice(inputs) {
+        const { price, recurringPrice, frequency } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidatePriceAndRecurringPrice;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Price and Recurring Price',
+            stepConfig,
+            description: 'Validate Price and Recurring Price of a catalog item',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceAndRecurringPrice.Price,
+            startingValue: price,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceAndRecurringPrice.RecurringPrice,
+            startingValue: recurringPrice,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceAndRecurringPrice.RecurringFrequency,
+            startingValue: frequency,
+        });
+    }
+    assertResponseJSONPayloadIsValid(inputs) {
+        inputs;
+        const stepConfig = tables_1.StepConfig.AssertResponseJSONPayloadIsValid;
+        this.createStepRecord({
+            name: 'Assert Response JSON Payload Is Valid',
+            stepConfig,
+            description: 'Assert the JSON response payload is valid',
+        });
+    }
+    clickModalButton(inputs) {
+        const { formUI, uiPage, assertType, assertTimeout, button } = inputs;
+        const assertTimeoutStr = this.secondsToDuration(assertTimeout);
+        const assertValue = assertType;
+        const stepConfig = tables_1.StepConfig.ClickModalButton;
+        const stepRecord = this.createStepRecord({
+            name: 'Click Modal Button',
+            stepConfig,
+            description: 'Click Modal step presses a button in the modal',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.UIPage,
+            startingValue: uiPage,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.Assert,
+            startingValue: assertValue,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.Button,
+            startingValue: button,
+        });
+        // TODO: ModalAction/ModalVAlues is sketchy cause the user does not set them explicitly in atf so idk if these values can be different
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.ModalAction,
+            startingValue: 'confirm',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.ModalValues,
+            startingValue: '',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickModalButton.AssertionTimeout,
+            startingValue: assertTimeoutStr,
+        });
+    }
+    addItemToShoppingCart(inputs) {
+        const { assert } = inputs;
+        const assertValue = assert;
+        const stepConfig = tables_1.StepConfig.AddItemToShoppingCart;
+        const stepRecord = this.createStepRecord({
+            name: 'Add Item to Shopping Cart',
+            stepConfig,
+            description: 'Add Catalog Item to Shopping Cart',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AddItemToShoppingCart.Assert,
+            startingValue: assertValue,
+        });
+    }
+    moduleVisibility(inputs) {
+        const { navigator, assertNotVisible, assertVisible, notVisibleModules, visibleModules } = inputs;
+        const navigatorValue = navigator;
+        const assertNotVisibleValue = assertNotVisible;
+        const assertVisibleValue = assertVisible[assertVisible];
+        const stepConfig = tables_1.StepConfig.ModuleVisibility;
+        const stepRecord = this.createStepRecord({
+            name: 'Module Visibility',
+            stepConfig,
+            description: 'Verifies visibility of modules in the left navigation bar',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ModuleVisibility.Navigator,
+            startingValue: navigatorValue,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ModuleVisibility.NotVisibleAssert,
+            startingValue: assertNotVisibleValue,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ModuleVisibility.VisibleAssert,
+            startingValue: assertVisibleValue,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ModuleVisibility.VisibleModules,
+            startingValue: visibleModules,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ModuleVisibility.NotVisibleModules,
+            startingValue: notVisibleModules,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    impersonate(inputs) {
+        const { user } = inputs;
+        const descriptionStr = 'Impersonates a specified user in the current session for the duration of the test or until another user is impersonated.';
+        const stepConfig = tables_1.StepConfig.Impersonate;
+        const stepRecord = this.createStepRecord({
+            name: 'Impersonate',
+            stepConfig,
+            description: descriptionStr,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.Impersonate.User,
+            startingValue: user,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+    }
+    openRecordProducer(inputs) {
+        const { catalogItem } = inputs;
+        const descriptionStr = 'Opens a Record Producer.';
+        const stepConfig = tables_1.StepConfig.OpenRecordProducer;
+        const stepRecord = this.createStepRecord({
+            name: 'Open Record Producer',
+            stepConfig,
+            description: descriptionStr,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenRecordProducer.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+    }
+    recordValidation(inputs) {
+        const { enforceSecurity, assertType, recordId, fieldValues, table } = inputs;
+        const stepConfig = tables_1.StepConfig.RecordValidation;
+        const stepRecord = this.createStepRecord({
+            name: 'Record Validation',
+            description: 'Validate a record',
+            tableName: table,
+            stepConfig,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordValidation.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordValidation.EnforceSecurity,
+            startingValue: enforceSecurity,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordValidation.AssertType,
+            startingValue: assertType,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordValidation.RecordId,
+            startingValue: recordId,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordValidation.FieldValues,
+            startingValue: fieldValues,
+        });
+    }
+    setCatalogItemQuantity(inputs) {
+        const { quantity } = inputs;
+        const stepConfig = tables_1.StepConfig.SetCatalogItemQuantity;
+        const descriptionStr = 'Set quantity to ' + quantity.toString();
+        const stepRecord = this.createStepRecord({
+            name: 'Set Catalog Item Quantity',
+            description: descriptionStr,
+            stepConfig,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetCatalogItemQuantity.Quantity,
+            startingValue: quantity,
+        });
+    }
+    orderCatalogItem(inputs) {
+        const { assertType } = inputs;
+        const stepConfig = tables_1.StepConfig.OrderCatalogItem;
+        let descriptionStr = 'Order item and confirm that ordering is canceled in browser';
+        if (assertType === 'form_submitted_to_server') {
+            descriptionStr = 'Order item and confirm that ordering is successful';
+        }
+        const stepRecord = this.createStepRecord({
+            name: 'Order Catalog Item',
+            description: descriptionStr,
+            stepConfig,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OrderCatalogItem.AssertType,
+            startingValue: assertType,
+        });
+    }
+    clickDeclarativeAction(inputs) {
+        const { formUI, declarativeAction, assertType, table } = inputs;
+        const stepConfig = tables_1.StepConfig.ClickADeclarativeAction;
+        const descriptionStr = 'Click a declarative action and confirm any relevant form or page reaction';
+        const stepRecord = this.createStepRecord({
+            name: 'Click a Declarative Action',
+            description: descriptionStr,
+            tableName: table,
+            stepConfig,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickADeclarativeAction.FormUI,
+            startingValue: formUI,
+            stringifier: (str) => this.parseFormUI(str),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickADeclarativeAction.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickADeclarativeAction.DeclarativeAction,
+            startingValue: declarativeAction,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickADeclarativeAction.AssertType,
+            startingValue: assertType,
+        });
+    }
+    assertXMLResponsePayloadElement(inputs) {
+        const { elementPath, responseOperation, elementValue } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertXMLResponsePayloadElement;
+        const descriptionStr = 'Assess the XML Response payload element';
+        const stepRecord = this.createStepRecord({
+            name: 'Assert XML Response Payload Element',
+            description: descriptionStr,
+            stepConfig,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertXMLResponsePayloadElement.ElementPath,
+            startingValue: elementPath,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertXMLResponsePayloadElement.ResponseOperation,
+            startingValue: responseOperation,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertXMLResponsePayloadElement.ElementValue,
+            startingValue: elementValue,
+        });
+    }
+    responsiveDashboardVisibility(inputs) {
+        const { dashboard, assertType } = inputs;
+        const stepConfig = tables_1.StepConfig.ResponsiveDashboardVisibility;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Responsive Dashboard Visibility',
+            description: 'Confirm whether a responsive dashboard is visible or not',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ResponsiveDashboardVisibility.Dashboard,
+            startingValue: dashboard,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ResponsiveDashboardVisibility.AssertType,
+            startingValue: assertType,
+        });
+    }
+    generateInboundReplyEmail(inputs) {
+        const { targetRecord, subject, body, from, to, targetTable } = inputs;
+        const stepConfig = tables_1.StepConfig.GenerateInboundReplyEmail;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Generate Inbound Reply Email',
+            description: 'Generate an email with subject ' + subject,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.TargetRecord,
+            startingValue: targetRecord,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.TargetTable,
+            startingValue: targetTable,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.Body,
+            startingValue: body,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.From,
+            startingValue: from,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.Subject,
+            startingValue: subject,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.GenerateInboundReplyEmail.To,
+            startingValue: to,
+        });
+    }
+    assertStatusCodeName(inputs) {
+        const { responseOperation, codeName } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertStatusCodeName;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Assert Status Code Name',
+            description: 'Assert a response status code name ' + responseOperation + ' ' + codeName,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertStatusCodeName.ResponseOperation,
+            startingValue: responseOperation,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertStatusCodeName.CodeName,
+            startingValue: codeName,
+        });
+    }
+    clickUIAction(inputs) {
+        const { formUI, table, actionType, declarativeAction, uiAction, assertType } = inputs;
+        const stepConfig = tables_1.StepConfig.ClickUIAction;
+        const stepRecord = this.createStepRecord({
+            name: 'Click a UI Action',
+            stepConfig: stepConfig,
+            description: 'Clicks a UI action on the current form',
+            tableName: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.ActionType,
+            startingValue: actionType,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.DeclarativeAction,
+            startingValue: declarativeAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.UIAction,
+            startingValue: uiAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ClickUIAction.AssertType,
+            startingValue: assertType,
+        });
+    }
+    createUser(inputs) {
+        const { fieldValues, groups, roles, impersonate, firstName, lastName } = inputs;
+        const tableName = 'sys_user';
+        const stepConfig = tables_1.StepConfig.CreateAUser;
+        const stepRecord = this.createStepRecord({
+            name: 'Create a User',
+            description: `Create a User`,
+            stepConfig,
+            tableName: tableName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.Groups,
+            startingValue: groups,
+            stringifier: (value) => {
+                return this.recordListToString(value);
+            },
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.Roles,
+            startingValue: roles,
+            stringifier: (value) => {
+                return this.recordListToString(value);
+            },
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.Impersonate,
+            startingValue: impersonate,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.FirstName,
+            startingValue: firstName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.CreateAUser.LastName,
+            startingValue: lastName,
+        });
+    }
+    recordDelete(inputs) {
+        const { enforceSecurity, assertType, table, recordId } = inputs;
+        const stepConfig = tables_1.StepConfig.RecordDelete;
+        const stepRecord = this.createStepRecord({
+            name: 'Record Delete',
+            stepConfig,
+            description: 'Delete a record in the table',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordDelete.EnforceSecurity,
+            startingValue: enforceSecurity,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordDelete.AssertType,
+            startingValue: assertType,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordDelete.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordDelete.RecordId,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    openCatalogItem(inputs) {
+        const { catalogItem } = inputs;
+        const stepConfig = tables_1.StepConfig.OpenACatalogItem;
+        const stepRecord = this.createStepRecord({
+            name: 'Open a catalog item',
+            stepConfig,
+            description: 'Open a catalog item',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenACatalogItem.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    setVariableValue(inputs) {
+        const { catalogItem, variableValues } = inputs;
+        const stepConfig = tables_1.StepConfig.SetVariableValues;
+        const stepRecord = this.createStepRecord({
+            name: 'Set Variable Values',
+            stepConfig,
+            description: 'Set variable values on a Catalog Item page',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SetVariableValues.Item,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SetVariableValues.VariableValues,
+            startingValue: variableValues,
+        });
+    }
+    sendRestRequest(inputs) {
+        const { basicAuthentication, method, path, queryParameters, headers, body } = inputs;
+        const processedParams = this.nameValuePairProcessing(queryParameters);
+        const processedHeaders = this.nameValuePairProcessing(headers);
+        const stepConfig = tables_1.StepConfig.SendRestRequestInbound;
+        const stepRecord = this.createStepRecord({
+            name: 'Send REST Request - Inbound',
+            stepConfig,
+            description: 'Send REST Request - Inbound',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.BasicAuthentication,
+            startingValue: basicAuthentication,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.Method,
+            startingValue: method,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.Path,
+            startingValue: path,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.QueryParameters,
+            startingValue: processedParams,
+            stringifier: (value) => JSON.stringify(value),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.Headers,
+            startingValue: processedHeaders,
+            stringifier: (value) => JSON.stringify(value),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.SendRestRequestInbound.Body,
+            startingValue: body,
+        });
+    }
+    assertStatusCode(inputs) {
+        const { operation, statusCode } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertStatusCode;
+        const stepRecord = this.createStepRecord({
+            name: 'Assert Status Code',
+            stepConfig,
+            description: 'Assert the HTTP response status code is equals to a specified value',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertStatusCode.Operation,
+            startingValue: operation,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertStatusCode.StatusCode,
+            startingValue: statusCode,
+        });
+    }
+    assertResponseXMLPayloadIsWellFormed(inputs) {
+        inputs;
+        const stepConfig = tables_1.StepConfig.AssertResponseXMLPayloadIsWellFormed;
+        this.createStepRecord({
+            name: 'Assert Response XML Payload Is Well-Formed',
+            stepConfig,
+            description: 'Assert the XML response payload is well-formed',
+        });
+    }
+    responsiveDashboardSharing(inputs) {
+        const { dashboard, assertType } = inputs;
+        const descriptionStr = 'Confirm a dashboard can or cannot be shared';
+        const stepConfig = tables_1.StepConfig.ResponsiveDashboardSharing;
+        const stepRecord = this.createStepRecord({
+            name: 'Responsive Dashboard Sharing',
+            stepConfig,
+            description: descriptionStr,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ResponsiveDashboardSharing.Dashboard,
+            startingValue: dashboard,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ResponsiveDashboardSharing.AssertType,
+            startingValue: assertType,
+        });
+    }
+    log(inputs) {
+        const { log } = inputs;
+        const stepConfig = tables_1.StepConfig.Log;
+        const stepRecord = this.createStepRecord({
+            name: 'Log',
+            stepConfig,
+            description: 'Log an output',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.Log.Log,
+            startingValue: log,
+        });
+    }
+    declarativeActionVisibility(inputs) {
+        const { formUI, table, visible, notVisible } = inputs;
+        const stepConfig = tables_1.StepConfig.DeclarativeActionVisibility;
+        const stepRecord = this.createStepRecord({
+            name: 'Declarative Action Visibility',
+            stepConfig,
+            description: 'Validate the visible, not visible fields of the form',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.DeclarativeActionVisibility.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.DeclarativeActionVisibility.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.DeclarativeActionVisibility.Visible,
+            startingValue: visible,
+            stringifier: (value) => {
+                return this.recordListToString(value);
+            },
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.DeclarativeActionVisibility.NotVisible,
+            startingValue: notVisible,
+            stringifier: (value) => {
+                return this.recordListToString(value);
+            },
+        });
+    }
+    navigateToModule(inputs) {
+        const { module } = inputs;
+        const stepConfig = tables_1.StepConfig.NavigateToModule;
+        const stepRecord = this.createStepRecord({
+            name: 'Navigate to Module',
+            stepConfig,
+            description: 'Navigates to a module, as if a user had clicked on it',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.NavigateToModule.Module,
+            startingValue: module,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    applicationMenuVisibility(inputs) {
+        const { navigator, visible, assertNotVisible, assertVisible, notVisible } = inputs;
+        const stepConfig = tables_1.StepConfig.ApplicationMenuVisibility;
+        const stepRecord = this.createStepRecord({
+            name: 'Application Menu Visibility',
+            stepConfig,
+            description: 'Verifies visibility of application menus in the left navigation bar',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ApplicationMenuVisibility.Navigator,
+            startingValue: navigator,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ApplicationMenuVisibility.VisibileAssert,
+            startingValue: assertVisible,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ApplicationMenuVisibility.NotVisibleAssert,
+            startingValue: assertNotVisible,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ApplicationMenuVisibility.VisibleApplications,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ApplicationMenuVisibility.NotVisibleApplications,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    checkoutShoppingCart(inputs) {
+        const { assert, requestedFor, deliveryAddress, specialInstructions } = inputs;
+        const stepConfig = tables_1.StepConfig.CheckoutShoppingCart;
+        const stepRecord = this.createStepRecord({
+            name: 'Checkout Shopping Cart',
+            stepConfig,
+            description: 'Checkout Shopping Cart',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.CheckoutShoppingCart.Assert,
+            startingValue: assert,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.CheckoutShoppingCart.DeliveryAddress,
+            startingValue: deliveryAddress,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.CheckoutShoppingCart.Instructions,
+            startingValue: specialInstructions,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.CheckoutShoppingCart.Requested,
+            startingValue: requestedFor,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    submitRecordProducer(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.SubmitRecordProducer;
+        const stepRecord = this.createStepRecord({
+            name: 'Submit Record Producer',
+            stepConfig,
+            description: 'Submit a Record Producer',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SubmitRecordProducer.Assert,
+            startingValue: assert,
+        });
+    }
+    openRecordProducer_SP(inputs) {
+        const { portal, page, recordProducer, queryParameters } = inputs;
+        const processedParams = this.nameValuePairProcessing(queryParameters);
+        const stepConfig = tables_1.StepConfig.OpenRecordProducer_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Open a Record Producer (SP)',
+            stepConfig,
+            description: 'Open a Record Producer (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenRecordProducer_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenRecordProducer_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenRecordProducer_SP.RecordProducer,
+            startingValue: recordProducer,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenRecordProducer_SP.QueryParam,
+            startingValue: processedParams,
+            stringifier: JSON.stringify,
+        });
+    }
+    openOrderGuide_SP(inputs) {
+        const { portal, page, orderGuide, queryParameters } = inputs;
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters);
+        const stepConfig = tables_1.StepConfig.OpenOrderGuide_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Open an Order Guide (SP)',
+            stepConfig,
+            description: 'Open an Order Guide (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenOrderGuide_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenOrderGuide_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenOrderGuide_SP.OrderGuide,
+            startingValue: orderGuide,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenOrderGuide_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        });
+    }
+    openForm_SP(inputs) {
+        const { portal, page, paramID, view, queryParameters, table } = inputs;
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters);
+        const stepConfig = tables_1.StepConfig.OpenAForm_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Open a Form (SP)',
+            stepConfig,
+            description: 'Open a Form (SP)',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.ParamID,
+            startingValue: paramID,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.View,
+            startingValue: view,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenAForm_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        });
+    }
+    openCatalogItem_SP(inputs) {
+        const { portal, page, catItem, queryParameters } = inputs;
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters);
+        const stepConfig = tables_1.StepConfig.OpenCatalogItem_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Open a Catalog Item (SP)',
+            stepConfig,
+            description: 'Open a Catalog Item (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenCatalogItem_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenCatalogItem_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenCatalogItem_SP.CatalogItem,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OpenCatalogItem_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        });
+    }
+    saveCurrentRowOfMultiRowVariableSet_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.SaveCurrentRowOfMultiRowVariableSet_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Save current row of multi-row variable set (SP)',
+            stepConfig,
+            description: 'Save current row of multi-row variable set (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SaveCurrentRowOfMultiRowVariableSet_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    addRowToMultiRowVariableSet_SP(inputs) {
+        const { catItem, variableSet } = inputs;
+        const stepConfig = tables_1.StepConfig.AddRowToMultiRowVariableSet_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Add row to multi-row variable set (SP)',
+            stepConfig,
+            description: 'Add row to multi-row variable set (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AddRowToMultiRowVariableSet_SP.CatalogItem,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AddRowToMultiRowVariableSet_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    fieldStateValidation(inputs) {
+        const { formUI, visible, notMandatory, notReadOnly, notVisible, readOnly, mandatory, table } = inputs;
+        const stepConfig = tables_1.StepConfig.FieldStateValidation;
+        const stepRecord = this.createStepRecord({
+            name: 'Field State Validation',
+            stepConfig,
+            description: "Assert that fields are or aren't: mandatory, read only, and visible on the form.",
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val), // Since it is a list of strings we can re-use this recordListToString
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.ReadOnly,
+            startingValue: readOnly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation.NotReadOnly,
+            startingValue: notReadOnly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    validateOutboundEmailGeneratedByFlow(inputs) {
+        const { sourceFlow, conditions } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateOutboundEmailGeneratedByFlow;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Outbound Email Generated by Flow',
+            stepConfig,
+            description: 'Finds and verifies an outbound email.',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByFlow.Table,
+            startingValue: 'sys_email',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByFlow.SourceFlow,
+            startingValue: sourceFlow,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateOutboundEmailGeneratedByFlow.Conditions,
+            startingValue: conditions,
+        });
+    }
+    reportVisibility(inputs) {
+        const { report, assertType } = inputs;
+        const stepConfig = tables_1.StepConfig.ReportVisibility;
+        const stepRecord = this.createStepRecord({
+            name: 'Report Visibility',
+            stepConfig,
+            description: 'Assert a report can or cannot be viewed.',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ReportVisibility.Report,
+            startingValue: report,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ReportVisibility.AssertType,
+            startingValue: assertType,
+        });
+    }
+    openServicePortalPage(inputs) {
+        const { portal, page, queryParams } = inputs;
+        const stepConfig = tables_1.StepConfig.OpenServicePortalPage;
+        const processedParams = this.nameValuePairProcessing(queryParams);
+        const stepRecord = this.createStepRecord({
+            name: 'Open Service Portal Page',
+            stepConfig,
+            description: 'Open a page in Service Portal',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenServicePortalPage.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenServicePortalPage.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.OpenServicePortalPage.QueryParams,
+            startingValue: processedParams,
+            stringifier: JSON.stringify,
+        });
+    }
+    recordQuery(inputs) {
+        const { enforceSecurity, assertType, table, fieldValues } = inputs;
+        const stepConfig = tables_1.StepConfig.RecordQuery;
+        const stepRecord = this.createStepRecord({
+            name: 'Record Query',
+            stepConfig,
+            description: 'Select a record and validate field values.',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordQuery.EnforceSecurity,
+            startingValue: enforceSecurity,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordQuery.AssertType,
+            startingValue: assertType,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordQuery.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.RecordQuery.FieldValues,
+            startingValue: fieldValues,
+        });
+    }
+    generateInboundEmail(inputs) {
+        const { from, to, subject, body } = inputs;
+        const stepConfig = tables_1.StepConfig.GenerateInboundEmail;
+        const stepRecord = this.createStepRecord({
+            name: 'Generate Inbound Email',
+            stepConfig,
+            description: 'Generate an inbound email.',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.GenerateInboundEmail.From,
+            startingValue: from,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.GenerateInboundEmail.To,
+            startingValue: to,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.GenerateInboundEmail.Subject,
+            startingValue: subject,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.GenerateInboundEmail.Body,
+            startingValue: body,
+        });
+    }
+    validateVariableValue(inputs) {
+        const { catalogItem, catalogConditions } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateVariableValues;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Variable Values',
+            stepConfig,
+            description: 'Validates Variable values on the Catalog Item.',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateVariableValues.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.ValidateVariableValues.CatalogConditions,
+            startingValue: catalogConditions,
+        });
+    }
+    assertResponseTime(inputs) {
+        const { responseOperation, responseTime } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertResponseTime;
+        const stepRecord = this.createStepRecord({
+            name: 'Assert Response Time',
+            stepConfig,
+            description: 'Assert the HTTP response time is less than or greater than a specified value',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertResponseTime.ResponseOperation,
+            startingValue: responseOperation,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertResponseTime.ResponseTime,
+            startingValue: responseTime,
+        });
+    }
+    assertJsonResponsePayloadElement(inputs) {
+        const { elementName, operation, elementValue } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertJsonResponsePayloadElement;
+        const stepRecord = this.createStepRecord({
+            name: 'Assert JSON Response Payload Element',
+            stepConfig,
+            description: 'Assert the JSON response payload element exists, or the element value is equals to or contains a specified value',
+            tableName: '',
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertJsonResponsePayloadElement.ElementName,
+            startingValue: elementName,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertJsonResponsePayloadElement.ResponseOperation,
+            startingValue: operation,
+        });
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: tables_1.Variables.AssertJsonResponsePayloadElement.ElementValue,
+            startingValue: elementValue,
+        });
+    }
+    setVariableValue_SP(inputs) {
+        const { catItem, variableSet, variableValues } = inputs;
+        const stepConfig = tables_1.StepConfig.SetVariableValues_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Set Variable Values (SP)',
+            stepConfig,
+            description: 'Set Variable Values (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetVariableValues_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetVariableValues_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetVariableValues_SP.VariableValues,
+            startingValue: variableValues,
+        });
+    }
+    validateVariableValue_SP(inputs) {
+        const { catItem, variableSet, variableValues } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateVariableValues_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Variable Values (SP)',
+            stepConfig,
+            description: 'Validates Variable values on the Catalog Item.',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateVariableValues_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateVariableValues_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateVariableValues_SP.Conditions,
+            startingValue: variableValues,
+        });
+    }
+    variableStateValidation_SP(inputs) {
+        const { catItem, variableSet, visible, notMandatory, notReadonly, notVisible, mandatory, readonly } = inputs;
+        const stepConfig = tables_1.StepConfig.VariableStateValidation_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Variable State Validation (SP)',
+            stepConfig,
+            description: "Assert that variables are or aren't: mandatory, read only, and visible in service portal view on the catalog item.",
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.ReadOnly,
+            startingValue: readonly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation_SP.NotReadOnly,
+            startingValue: notReadonly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    validatePriceAndRecurringPrice_SP(inputs) {
+        const { price, recurringPrice, frequency } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidatePriceandRecurringPrice_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Validate Price and Recurring Price (SP)',
+            description: 'Validate Price and Recurring Price (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceandRecurringPrice_SP.Price,
+            startingValue: price,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceandRecurringPrice_SP.RecurringPrice,
+            startingValue: recurringPrice,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidatePriceandRecurringPrice_SP.RecurringFrequency,
+            startingValue: frequency,
+        });
+    }
+    navigatewithinOrderGuide_SP(inputs) {
+        const { guideStep, assert } = inputs;
+        const stepConfig = tables_1.StepConfig.NavigatewithinOrderGuide_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Navigate within Order Guide (SP)',
+            description: 'Navigate in Order Guide (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.NavigatewithinOrderGuide_SP.GuideStep,
+            startingValue: guideStep,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.NavigatewithinOrderGuide_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    setFieldValue_SP(inputs) {
+        const { table, fieldValues } = inputs;
+        const stepConfig = tables_1.StepConfig.SetFieldValues_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Set Field Values (SP)',
+            stepConfig,
+            description: 'Set Field Values (SP)',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetFieldValues_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetFieldValues_SP.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        });
+    }
+    setCatalogItemQuantity_SP(inputs) {
+        const { quantity } = inputs;
+        const stepConfig = tables_1.StepConfig.SetCatalogItemQuantity_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Set Catalog Item Quantity (SP)',
+            description: 'Set Catalog Item Quantity (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SetCatalogItemQuantity_SP.Quantity,
+            startingValue: quantity,
+        });
+    }
+    validateOrderGuideItem_SP(inputs) {
+        const { items } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateOrderGuideItems_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Order Guide Items (SP)',
+            stepConfig,
+            description: 'Validate Order Guide Items (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateOrderGuideItems_SP.Items,
+            startingValue: items,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    reviewOrderGuideSummary_SP(inputs) {
+        const { items, price } = inputs;
+        const stepConfig = tables_1.StepConfig.ReviewOrderGuideSummary_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Review Order Guide Summary (SP)',
+            description: 'Review Order Guide Summary (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ReviewOrderGuideSummary_SP.Price,
+            startingValue: price,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ReviewOrderGuideSummary_SP.Items,
+            startingValue: items,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    fieldValueValidation_SP(inputs) {
+        const { table, conditions } = inputs;
+        const stepConfig = tables_1.StepConfig.FieldValuesValidation_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Field Values Validation (SP)',
+            description: 'Field Values Validation (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldValuesValidation_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldValuesValidation_SP.Conditions,
+            startingValue: conditions,
+        });
+    }
+    fieldStateValidation_SP(inputs) {
+        const { table, mandatory, notMandatory, notReadonly, notVisible, readonly, visible } = inputs;
+        const stepConfig = tables_1.StepConfig.FieldStateValidation_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Field State Validation (SP)',
+            description: 'Field State Validation (SP)',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.ReadOnly,
+            startingValue: readonly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.NotReadOnly,
+            startingValue: notReadonly,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.FieldStateValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    uiActionVisibilityValidation_SP(inputs) {
+        const { table, visible, notVisible } = inputs;
+        const stepConfig = tables_1.StepConfig.UIActionVisibilityValidation_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'UI Action Visibility Validation (SP)',
+            stepConfig,
+            description: 'UI Action Visibility Validation (SP)',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibilityValidation_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibilityValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.UIActionVisibilityValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    reviewIteminOrderGuide_SP(inputs) {
+        const { item, included } = inputs;
+        const stepConfig = tables_1.StepConfig.ReviewIteminOrderGuide_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Review Item in Order Guide (SP)',
+            stepConfig,
+            description: 'Review Item in Order Guide (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ReviewIteminOrderGuide_SP.Item,
+            startingValue: item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ReviewIteminOrderGuide_SP.Included,
+            startingValue: included,
+        });
+    }
+    clickUIAction_SP(inputs) {
+        const { table, uiAction, assert } = inputs;
+        const stepConfig = tables_1.StepConfig.ClickaUIAction_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Click a UI Action (SP)',
+            description: 'Click a UI Action (SP)',
+            tableName: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickaUIAction_SP.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickaUIAction_SP.Assert,
+            startingValue: assert,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ClickaUIAction_SP.UIAction,
+            startingValue: uiAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    submitForm_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.SubmitForm_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Submit a Form (SP)',
+            stepConfig,
+            description: 'Submits the current form.',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SubmitForm_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    addItemtoShoppingCart_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.AddItemtoShoppingCart_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Add Item to Shopping Cart (SP)',
+            description: 'Add Item to Shopping Cart (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AddItemtoShoppingCart_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    addOrderGuidetoShoppingCart_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.AddOrderGuidetoShoppingCart_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Add Order Guide to Shopping Cart (SP)',
+            description: 'Add Order Guide to Shopping Cart (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AddOrderGuidetoShoppingCart_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    submitOrderGuide_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.SubmitOrderGuide_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Submit an Order Guide (SP)',
+            stepConfig,
+            description: 'Submit an Order Guide (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SubmitOrderGuide_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    submitRecordProducer_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.SubmitRecordProducer_SP;
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Submit Record Producer (SP)',
+            description: 'Submit a Record Producer (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SubmitRecordProducer_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    orderCatalogItem_SP(inputs) {
+        const { assert } = inputs;
+        const stepConfig = tables_1.StepConfig.OrderCatalogItem_SP;
+        const stepRecord = this.createStepRecord({
+            name: 'Order a Catalog Item (SP)',
+            stepConfig,
+            description: 'Order a Catalog Item (SP)',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.OrderCatalogItem_SP.Assert,
+            startingValue: assert,
+        });
+    }
+    validateOutboundEmail(inputs) {
+        const { conditions } = inputs;
+        const stepConfig = tables_1.StepConfig.ValidateOutboundEmail;
+        const stepRecord = this.createStepRecord({
+            name: 'Validate Outbound Email',
+            stepConfig,
+            description: 'Filters the Email [sys_email] table to find an email that was sent during testing',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateOutboundEmail.Conditions,
+            startingValue: conditions,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ValidateOutboundEmail.Table,
+            startingValue: 'sys_email',
+        });
+    }
+    recordInsert(inputs) {
+        const { assertType, enforceSecurity, table, fieldValues } = inputs;
+        const stepConfig = tables_1.StepConfig.RecordInsert;
+        const stepRecord = this.createStepRecord({
+            name: 'Record Insert',
+            stepConfig,
+            description: 'Insert a record to the table',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordInsert.AssertType,
+            startingValue: assertType,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordInsert.EnforceSecurity,
+            startingValue: enforceSecurity,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordInsert.Table,
+            startingValue: table,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.RecordInsert.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        });
+    }
+    searchForCatalogItem(inputs) {
+        const { search_in_portal, search_term, catalog, category, assert_item, assert_type } = inputs;
+        const stepConfig = tables_1.StepConfig.SearchForACatalogItem;
+        const stepRecord = this.createStepRecord({
+            name: 'Search for a Catalog Item',
+            stepConfig,
+            description: 'Perform search for a Catalog Item or Record Producer in the specified Catalog and Category',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.SearchInPortalOnly,
+            startingValue: search_in_portal,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.SearchTerm,
+            startingValue: search_term,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.Catalog,
+            startingValue: catalog,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.Category,
+            startingValue: category,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.AssertItem,
+            startingValue: assert_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.SearchForACatalogItem.AssertType,
+            startingValue: assert_type,
+        });
+    }
+    replayRequestItem(inputs) {
+        const { request_item } = inputs;
+        const stepConfig = tables_1.StepConfig.ReplayRequestItem;
+        const stepRecord = this.createStepRecord({
+            name: 'Replay Request Item',
+            stepConfig,
+            description: 'Replays a previously created request item with the same values and options',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.ReplayRequestItem.OriginalRequestItem,
+            startingValue: request_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+    }
+    variableStateValidation(inputs) {
+        const { catalog_item, visible, not_visible, read_only, not_read_only, mandatory, not_mandatory } = inputs;
+        const stepConfig = tables_1.StepConfig.VariableStateValidation;
+        const stepRecord = this.createStepRecord({
+            name: 'Variable State Validation',
+            stepConfig,
+            description: 'Validates states of the desired variables',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.CatalogItem,
+            startingValue: catalog_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.NotVisible,
+            startingValue: not_visible,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.ReadOnly,
+            startingValue: read_only,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.NotReadOnly,
+            startingValue: not_read_only,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.VariableStateValidation.NotMandatory,
+            startingValue: not_mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        });
+    }
+    assertResponseHeader(inputs) {
+        const { header_name, response_operation, header_value } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertResponseHeader;
+        const stepRecord = this.createStepRecord({
+            name: 'Assert Response Header',
+            stepConfig,
+            description: 'Assert an HTTP response header',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertResponseHeader.Header,
+            startingValue: header_name,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertResponseHeader.Operation,
+            startingValue: response_operation,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertResponseHeader.Value,
+            startingValue: header_value,
+        });
+    }
+    assertResponsePayload(inputs) {
+        const { response_body, response_operation } = inputs;
+        const stepConfig = tables_1.StepConfig.AssertResponsePayload;
+        const stepRecord = this.createStepRecord({
+            name: 'Assert Response Payload',
+            stepConfig,
+            description: 'Assert the HTTP response payload is equals to or contains a specified value',
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertResponsePayload.ResponseBody,
+            startingValue: response_body,
+        });
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: tables_1.Variables.AssertResponsePayload.Operation,
+            startingValue: response_operation,
+        });
+    }
+}
+exports.ATF = ATF;
+//# sourceMappingURL=ATFComposer.js.map