@servicenow/sdk-build-plugins 2.0.1

package/src/atf/ATFComposer.ts

@@ -0,0 +1,3356 @@
+import { Data, Record, TableName } from '@servicenow/sdk-core/runtime/db'
+import type { Role } from '@servicenow/sdk-core/runtime/app'
+import { StepConfig, Variables } from '@servicenow/sdk-core/runtime/tables'
+import { Context, InputObject } from '@servicenow/sdk-build-core'
+import * as atf from '@servicenow/sdk-core/runtime/atf'
+
+export function getRecordIdIfRecord(value: any, context: Context): string {
+    if (isRecord(value)) {
+        return getRecordId(value, context)
+    } else if (isRole(value)) {
+        return getRoleId(value, context)
+    }
+    return value
+}
+
+export function getRoleId(record: Role, context: Context): string {
+    return context.keys.registerExplicitId('sys_user_role', record.$id)
+}
+
+export function getRecordId<T extends TableName>(record: Record<T>, context: Context): string {
+    if ('sys_id' in record.data && record.data['sys_id']) {
+        return record.data['sys_id'] as string
+    }
+
+    return context.keys.registerExplicitId(record.table, typeof record.$id === 'object' ? record.$id.id : record.$id)
+}
+
+export function isRecord(value: any): value is Record {
+    return typeof value === 'object' && '$id' in value && 'table' in value
+}
+
+export function isRole(value: any): value is Role {
+    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
+ *
+ */
+export class ATF implements atf.FlatATF {
+    public test: Record<'sys_atf_test'>
+    /**
+     * Do not modify directly. Let TestPlugin handle incrementing the value
+     */
+    private order: number
+    /**
+     * 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
+     * ```
+     */
+    public _records: {
+        [stepRecord: string]: Record[]
+    }
+
+    /**
+     * 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
+     * ```
+     */
+    public stepRecords: Record<'sys_atf_step'>[]
+    private context: Context
+
+    constructor(
+        inputObject: InputObject & { name: string; description: string; active: boolean; failOnServerError: boolean },
+        context: Context
+    ) {
+        this.context = context
+        this.test = 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
+     */
+    public incrementOrder() {
+        this.order++
+    }
+
+    private parseValue(value: any) {
+        // 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: Record<'sys_atf_step'> | undefined = 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
+    }
+
+    private isTemplateStr(value: any) {
+        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
+     */
+    private containsGem(value: any) {
+        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: boolean[] = []
+        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
+     */
+    private isGem(value: any) {
+        if (typeof value != 'object') {
+            return false
+        }
+        return typeof value.__references !== 'undefined' && typeof value.__value !== 'undefined'
+    }
+
+    private createStepRecord(props: {
+        stepConfig: Record<'sys_atf_step_config'>
+        name: string
+        description?: string
+        tableName?: string
+    }) {
+        const { stepConfig, name, description = 'A step created by fluent', tableName = '' } = props
+        const stepRecord = 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
+    }
+
+    private _createGemRecords(props: {
+        variable: Record<'var_dictionary'>
+        stepConfig: Record<'sys_atf_step_config'>
+        value: any
+        stepRecord: Record<'sys_atf_step'>
+    }): { sys_variable_value: Record<'sys_variable_value'>; element_mapping: Record<'sys_element_mapping'> } {
+        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 = 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
+     */
+    private _createVariableValueRecord(props: {
+        variable: Record<'var_dictionary'>
+        value: any
+        stepRecord: Record<'sys_atf_step'>
+    }): Record<'sys_variable_value'> {
+        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 = 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
+    }
+
+    private fieldValuesToQuery<T extends TableName>(fieldValues: Partial<Data<T>>): string {
+        // This converts records/tables in a field value set to the correct string
+        const valuesObj = this.nameValuePairProcessing(fieldValues)
+        const queries: string[] = []
+
+        for (const pair of Object.entries(valuesObj)) {
+            const key = pair[0] as keyof Data<T>
+            let value = pair[1] as unknown
+
+            if (typeof value === 'string') {
+                value = value.replaceAll('^', '^^')
+            } else if (value && typeof value === 'object' && '$id' in value) {
+                value = getRecordId(value as Record, this.context)
+            }
+
+            queries.push(`${key as string}=${value}`)
+        }
+
+        return queries.join('^')
+    }
+
+    private recordListToString(recordList: (string | Record | Role)[]): string {
+        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
+     */
+    private parseFormUI(formUI: atf.FormUIType): string {
+        if (typeof formUI === 'string') {
+            if (atf.FormUI[formUI]) {
+                return typeof atf.FormUI[formUI] === 'string'
+                    ? (atf.FormUI[formUI] as string)
+                    : getRecordId(atf.FormUI[formUI] as Record, this.context)
+            }
+
+            return formUI
+        }
+        return getRecordId(formUI, this.context)
+    }
+
+    private extractSysIdIfRecord(value: string | Record | Role): string {
+        if (isRecord(value)) {
+            return getRecordId(value, this.context)
+        }
+        if (isRole(value)) {
+            return getRoleId(value, this.context)
+        }
+
+        return value
+    }
+
+    private secondsToDuration(value: number) {
+        const ms = value * 1000
+        const time = new Date()
+        time.setTime(ms)
+        const str = time.toISOString().replace('T', ' ').split('.')[0] as string
+        return str
+    }
+
+    private nameValuePairProcessing(nvp: Record<TableName> | object | string | number | boolean) {
+        if (typeof nvp === 'object') {
+            if ('asRecord' in nvp) {
+                return getRecordId(nvp as Record<TableName>, 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
+    }
+
+    private createVariable<T>(props: {
+        variable: Record<'var_dictionary'>
+        stepRecord: Record<'sys_atf_step'>
+        stepConfig: Record<'sys_atf_step_config'>
+        startingValue: T
+        stringifier?: (value: T) => string
+    }) {
+        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: {
+        formUI: atf.FormUIType
+        view: string
+        recordId: string | Record
+        table: TableName
+        selectedTabIndex: number
+    }) {
+        const { table, view, recordId, formUI, selectedTabIndex } = inputs
+        const stepConfig = 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: Variables.OpenExistingRecord.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            variable: Variables.OpenExistingRecord.FormUI,
+            stepConfig: stepConfig,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenExistingRecord.RecordPath,
+            startingValue: 'record',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenExistingRecord.RecordId,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenExistingRecord.View,
+            startingValue: view,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenExistingRecord.SelectedTabIndex,
+            startingValue: selectedTabIndex,
+        })
+    }
+
+    openNewForm(inputs: { table: TableName; view: string; formUI: atf.FormUIType }) {
+        const { table: tableName, view = '', formUI } = inputs
+        const stepConfig = 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: Variables.OpenNewForm.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenNewForm.Table,
+            startingValue: tableName,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenNewForm.View,
+            startingValue: view,
+        })
+    }
+
+    fieldValueValidation<T extends TableName>(inputs: { table: T; conditions: string; formUI: atf.FormUIType }) {
+        const { table: tableName, conditions, formUI } = inputs
+        const stepConfig = 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: Variables.FieldValueValidation.Table,
+            startingValue: tableName,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.FieldValueValidation.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.FieldValueValidation.Conditions,
+            startingValue: conditions,
+        })
+    }
+
+    setFieldValue<T extends TableName>(inputs: { table: T; fieldValues: Partial<Data<T>>; formUI: atf.FormUIType }) {
+        const { table, fieldValues, formUI } = inputs
+        const stepConfig = 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: Variables.SetFieldValues.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SetFieldValues.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SetFieldValues.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        })
+    }
+
+    submitForm(inputs: { assertType: atf.AssertType; formUI: atf.FormUIType }): any {
+        const { assertType, formUI } = inputs
+        const stepConfig = StepConfig.SubmitAForm
+        const stepRecord = this.createStepRecord({
+            name: 'Submit a Form',
+            stepConfig,
+            description: 'Submits the current form.',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SubmitForm.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SubmitForm.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    validateOutboundEmailGeneratedByNotification(inputs: {
+        sourceNotification: string | Record<'sysevent_email_action'>
+        conditions: string
+    }): any {
+        const { sourceNotification, conditions } = inputs
+        const stepConfig = 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: Variables.ValidateOutboundEmailGeneratedByNotification.Table,
+            startingValue: 'sys_email',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidateOutboundEmailGeneratedByNotification.SourceNotification,
+            startingValue: sourceNotification,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ValidateOutboundEmailGeneratedByNotification.Conditions,
+            startingValue: conditions,
+        })
+    }
+
+    recordUpdate<T extends TableName>(inputs: {
+        assertType: atf.AssertUpdateType
+        enforceSecurity: boolean
+        table: T
+        recordId: string | Record<T>
+        fieldValues: Partial<Data<T>>
+    }): any {
+        const { table, assertType, enforceSecurity, recordId, fieldValues } = inputs
+        const assertValue = assertType
+        const stepConfig = StepConfig.RecordUpdate
+
+        const stepRecord = this.createStepRecord({
+            name: 'Record Update',
+            stepConfig,
+            description: 'Update a record in the table.',
+            tableName: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordUpdate.EnforceSecurity,
+            startingValue: enforceSecurity,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordUpdate.AssertType,
+            startingValue: assertValue,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordUpdate.RecordID,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordUpdate.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordUpdate.Table,
+            startingValue: table,
+        })
+    }
+
+    generateRandomString(inputs: { length: number }): any {
+        const { length } = inputs
+
+        const stepConfig = StepConfig.GenerateRandomString
+
+        const stepRecord = this.createStepRecord({
+            name: 'Generate Random String',
+            stepConfig,
+            description: 'Generate a random string.',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateARandomString.Length,
+            startingValue: length,
+        })
+    }
+
+    uiActionVisibility<T extends TableName>(inputs: {
+        formUI: atf.FormUIType
+        table: T
+        visible: (string | Record<'sys_ui_action'>)[]
+        notVisible: (string | Record<'sys_ui_action'>)[]
+    }): any {
+        const { table, formUI, visible, notVisible } = inputs
+        const stepConfig = 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: Variables.UIActionVisibility.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.UIActionVisibility.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.UIActionVisibility.Visible,
+            startingValue: visible,
+            stringifier: (value) => this.recordListToString(value),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.UIActionVisibility.NotVisible,
+            startingValue: notVisible,
+            stringifier: (value) => this.recordListToString(value),
+        })
+    }
+
+    validatePriceAndRecurringPrice(inputs: {
+        price: string | number
+        recurringPrice: string | number
+        frequency: atf.FrequencyType
+    }): any {
+        const { price, recurringPrice, frequency } = inputs
+        const stepConfig = 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: Variables.ValidatePriceAndRecurringPrice.Price,
+            startingValue: price,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidatePriceAndRecurringPrice.RecurringPrice,
+            startingValue: recurringPrice,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidatePriceAndRecurringPrice.RecurringFrequency,
+            startingValue: frequency,
+        })
+    }
+
+    assertResponseJSONPayloadIsValid(inputs: { [name: string]: never }): any {
+        inputs
+
+        const stepConfig = StepConfig.AssertResponseJSONPayloadIsValid
+        this.createStepRecord({
+            name: 'Assert Response JSON Payload Is Valid',
+            stepConfig,
+            description: 'Assert the JSON response payload is valid',
+        })
+    }
+
+    clickModalButton(inputs: {
+        formUI: atf.FormUIType
+        uiPage: string | Record<'sys_ui_page'>
+        assertType: atf.AssertModalType
+        button: string
+        assertTimeout: number
+    }): any {
+        const { formUI, uiPage, assertType, assertTimeout, button } = inputs
+        const assertTimeoutStr = this.secondsToDuration(assertTimeout)
+        const assertValue = assertType
+        const stepConfig = 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: Variables.ClickModalButton.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickModalButton.UIPage,
+            startingValue: uiPage,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickModalButton.Assert,
+            startingValue: assertValue,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: 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: Variables.ClickModalButton.ModalAction,
+            startingValue: 'confirm',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickModalButton.ModalValues,
+            startingValue: '',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickModalButton.AssertionTimeout,
+            startingValue: assertTimeoutStr,
+        })
+    }
+
+    addItemToShoppingCart(inputs: { assert: atf.AssertShoppingType }): any {
+        const { assert } = inputs
+        const assertValue = assert
+
+        const stepConfig = 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: Variables.AddItemToShoppingCart.Assert,
+            startingValue: assertValue,
+        })
+    }
+
+    moduleVisibility(inputs: {
+        navigator: atf.NavigatorType
+        assertNotVisible: atf.AssertModuleNotVisibleType
+        notVisibleModules: (string | Record<'sys_app_module'>)[]
+        assertVisible: atf.AssertModuleVisibleType
+        visibleModules: (string | Record<'sys_app_module'>)[]
+    }): any {
+        const { navigator, assertNotVisible, assertVisible, notVisibleModules, visibleModules } = inputs
+        const navigatorValue = navigator
+        const assertNotVisibleValue = assertNotVisible
+        const assertVisibleValue = assertVisible[assertVisible]
+        const stepConfig = 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: Variables.ModuleVisibility.Navigator,
+            startingValue: navigatorValue,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ModuleVisibility.NotVisibleAssert,
+            startingValue: assertNotVisibleValue,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ModuleVisibility.VisibleAssert,
+            startingValue: assertVisibleValue,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ModuleVisibility.VisibleModules,
+            startingValue: visibleModules,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ModuleVisibility.NotVisibleModules,
+            startingValue: notVisibleModules,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    impersonate(inputs: { user: string | Record<'sys_user'> }): any {
+        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 = StepConfig.Impersonate
+        const stepRecord = this.createStepRecord({
+            name: 'Impersonate',
+            stepConfig,
+            description: descriptionStr,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.Impersonate.User,
+            startingValue: user,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+    }
+
+    openRecordProducer(inputs: { catalogItem: string | Record<'sc_cat_item_producer'> }): any {
+        const { catalogItem } = inputs
+        const descriptionStr = 'Opens a Record Producer.'
+        const stepConfig = StepConfig.OpenRecordProducer
+        const stepRecord = this.createStepRecord({
+            name: 'Open Record Producer',
+            stepConfig,
+            description: descriptionStr,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenRecordProducer.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+    }
+
+    recordValidation<T extends TableName>(inputs: {
+        enforceSecurity: boolean
+        assertType: atf.AssertRecordValidationType
+        table: T
+        recordId: string | Record
+        fieldValues: string
+    }): any {
+        const { enforceSecurity, assertType, recordId, fieldValues, table } = inputs
+        const stepConfig = StepConfig.RecordValidation
+
+        const stepRecord = this.createStepRecord({
+            name: 'Record Validation',
+            description: 'Validate a record',
+            tableName: table,
+            stepConfig,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordValidation.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordValidation.EnforceSecurity,
+            startingValue: enforceSecurity,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordValidation.AssertType,
+            startingValue: assertType,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordValidation.RecordId,
+            startingValue: recordId,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordValidation.FieldValues,
+            startingValue: fieldValues,
+        })
+    }
+
+    setCatalogItemQuantity(inputs: { quantity: number | string }): any {
+        const { quantity } = inputs
+        const stepConfig = 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: Variables.SetCatalogItemQuantity.Quantity,
+            startingValue: quantity,
+        })
+    }
+
+    orderCatalogItem(inputs: { assertType: atf.AssertOrderCatalogItemType }): any {
+        const { assertType } = inputs
+        const stepConfig = 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: Variables.OrderCatalogItem.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    clickDeclarativeAction<T extends TableName>(inputs: {
+        formUI: atf.FormUIType
+        table: T
+        declarativeAction: string | Record<'sys_declarative_action_assignment'>
+        assertType: atf.AssertDeclarativeActionType
+    }): any {
+        const { formUI, declarativeAction, assertType, table } = inputs
+        const stepConfig = 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: Variables.ClickADeclarativeAction.FormUI,
+            startingValue: formUI,
+            stringifier: (str) => this.parseFormUI(str),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickADeclarativeAction.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickADeclarativeAction.DeclarativeAction,
+            startingValue: declarativeAction,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickADeclarativeAction.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    assertXMLResponsePayloadElement(inputs: {
+        elementPath: string
+        responseOperation: atf.ResponseValueOperationType
+        elementValue: string
+    }): any {
+        const { elementPath, responseOperation, elementValue } = inputs
+        const stepConfig = 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: Variables.AssertXMLResponsePayloadElement.ElementPath,
+            startingValue: elementPath,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertXMLResponsePayloadElement.ResponseOperation,
+            startingValue: responseOperation,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertXMLResponsePayloadElement.ElementValue,
+            startingValue: elementValue,
+        })
+    }
+
+    responsiveDashboardVisibility(inputs: {
+        dashboard: string | Record<'pa_dashboards'>
+        assertType: atf.AssertResponsiveDashboardType
+    }): any {
+        const { dashboard, assertType } = inputs
+        const stepConfig = 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: Variables.ResponsiveDashboardVisibility.Dashboard,
+            startingValue: dashboard,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ResponsiveDashboardVisibility.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    generateInboundReplyEmail<T extends TableName>(inputs: {
+        targetRecord: string | Record<T>
+        subject: string
+        body: string
+        targetTable: T
+        from: string
+        to: string
+    }): any {
+        const { targetRecord, subject, body, from, to, targetTable } = inputs
+        const stepConfig = StepConfig.GenerateInboundReplyEmail
+
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Generate Inbound Reply Email',
+            description: 'Generate an email with subject ' + subject,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.TargetRecord,
+            startingValue: targetRecord,
+            stringifier: (str) => this.extractSysIdIfRecord(str),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.TargetTable,
+            startingValue: targetTable,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.Body,
+            startingValue: body,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.From,
+            startingValue: from,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.Subject,
+            startingValue: subject,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.GenerateInboundReplyEmail.To,
+            startingValue: to,
+        })
+    }
+
+    assertStatusCodeName(inputs: { responseOperation: atf.ResponseOperationValueType; codeName: string }): any {
+        const { responseOperation, codeName } = inputs
+        const stepConfig = 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: Variables.AssertStatusCodeName.ResponseOperation,
+            startingValue: responseOperation,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertStatusCodeName.CodeName,
+            startingValue: codeName,
+        })
+    }
+
+    clickUIAction(inputs: {
+        formUI: atf.FormUIType
+        table: TableName
+        actionType: atf.UIActionType
+        declarativeAction: string | Record<'sys_declarative_action_assignment'>
+        uiAction: string | Record<'sys_ui_action'>
+        assertType: atf.UIActionAssertType
+    }): any {
+        const { formUI, table, actionType, declarativeAction, uiAction, assertType } = inputs
+        const stepConfig = 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: Variables.ClickUIAction.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickUIAction.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickUIAction.ActionType,
+            startingValue: actionType,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickUIAction.DeclarativeAction,
+            startingValue: declarativeAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickUIAction.UIAction,
+            startingValue: uiAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ClickUIAction.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    createUser(inputs: {
+        fieldValues: Partial<Data<'sys_user'>>
+        groups: (string | Record<'sys_user_group'>)[]
+        roles: (string | Role)[]
+        impersonate: boolean
+        firstName: string
+        lastName: string
+    }): any {
+        const { fieldValues, groups, roles, impersonate, firstName, lastName } = inputs
+        const tableName = 'sys_user'
+        const stepConfig = StepConfig.CreateAUser
+
+        const stepRecord = this.createStepRecord({
+            name: 'Create a User',
+            description: `Create a User`,
+            stepConfig,
+            tableName: tableName,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.Groups,
+            startingValue: groups,
+            stringifier: (value) => {
+                return this.recordListToString(value)
+            },
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.Roles,
+            startingValue: roles,
+            stringifier: (value) => {
+                return this.recordListToString(value)
+            },
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.Impersonate,
+            startingValue: impersonate,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.FirstName,
+            startingValue: firstName,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.CreateAUser.LastName,
+            startingValue: lastName,
+        })
+    }
+
+    recordDelete<T extends TableName>(inputs: {
+        enforceSecurity: boolean
+        assertType: atf.RecordDeleteAssertType
+        table: T
+        recordId: string | Record<T>
+    }): any {
+        const { enforceSecurity, assertType, table, recordId } = inputs
+        const stepConfig = StepConfig.RecordDelete
+        const stepRecord = this.createStepRecord({
+            name: 'Record Delete',
+            stepConfig,
+            description: 'Delete a record in the table',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordDelete.EnforceSecurity,
+            startingValue: enforceSecurity,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordDelete.AssertType,
+            startingValue: assertType,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordDelete.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordDelete.RecordId,
+            startingValue: recordId,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    openCatalogItem(inputs: { catalogItem: string | Record<'sc_cat_item'> }): any {
+        const { catalogItem } = inputs
+        const stepConfig = StepConfig.OpenACatalogItem
+        const stepRecord = this.createStepRecord({
+            name: 'Open a catalog item',
+            stepConfig,
+            description: 'Open a catalog item',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenACatalogItem.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    setVariableValue(inputs: {
+        catalogItem: string | Record<'sc_cat_item'> | Record<'sc_cat_item_producer'>
+        variableValues: string
+    }): any {
+        const { catalogItem, variableValues } = inputs
+        const stepConfig = 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: Variables.SetVariableValues.Item,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SetVariableValues.VariableValues,
+            startingValue: variableValues,
+        })
+    }
+
+    sendRestRequest(inputs: {
+        basicAuthentication: string | Record<'sys_auth_profile_basic'>
+        method: atf.HTTPMethodType
+        path: string
+        queryParameters: atf.QueryParam
+        headers: { [name: string]: string | number | boolean }
+        body: string
+    }): any {
+        const { basicAuthentication, method, path, queryParameters, headers, body } = inputs
+        const processedParams = this.nameValuePairProcessing(queryParameters)
+        const processedHeaders = this.nameValuePairProcessing(headers)
+        const stepConfig = StepConfig.SendRestRequestInbound
+
+        const stepRecord = this.createStepRecord({
+            name: 'Send REST Request - Inbound',
+            stepConfig,
+            description: 'Send REST Request - Inbound',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.BasicAuthentication,
+            startingValue: basicAuthentication,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.Method,
+            startingValue: method,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.Path,
+            startingValue: path,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.QueryParameters,
+            startingValue: processedParams,
+            stringifier: (value) => JSON.stringify(value),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.Headers,
+            startingValue: processedHeaders,
+            stringifier: (value) => JSON.stringify(value),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.SendRestRequestInbound.Body,
+            startingValue: body,
+        })
+    }
+
+    assertStatusCode(inputs: { operation: atf.RestStatusOperationType; statusCode: number }) {
+        const { operation, statusCode } = inputs
+        const stepConfig = 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: Variables.AssertStatusCode.Operation,
+            startingValue: operation,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.AssertStatusCode.StatusCode,
+            startingValue: statusCode,
+        })
+    }
+
+    assertResponseXMLPayloadIsWellFormed(inputs: { [name: string]: never }) {
+        inputs
+        const stepConfig = StepConfig.AssertResponseXMLPayloadIsWellFormed
+
+        this.createStepRecord({
+            name: 'Assert Response XML Payload Is Well-Formed',
+            stepConfig,
+            description: 'Assert the XML response payload is well-formed',
+        })
+    }
+
+    responsiveDashboardSharing(inputs: {
+        dashboard: string | Record<'pa_dashboards'>
+        assertType: atf.DashboardSharingAssertType
+    }) {
+        const { dashboard, assertType } = inputs
+        const descriptionStr = 'Confirm a dashboard can or cannot be shared'
+        const stepConfig = StepConfig.ResponsiveDashboardSharing
+        const stepRecord = this.createStepRecord({
+            name: 'Responsive Dashboard Sharing',
+            stepConfig,
+            description: descriptionStr,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ResponsiveDashboardSharing.Dashboard,
+            startingValue: dashboard,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ResponsiveDashboardSharing.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    log(inputs: { log: string }) {
+        const { log } = inputs
+        const stepConfig = StepConfig.Log
+
+        const stepRecord = this.createStepRecord({
+            name: 'Log',
+            stepConfig,
+            description: 'Log an output',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.Log.Log,
+            startingValue: log,
+        })
+    }
+
+    declarativeActionVisibility(inputs: {
+        formUI: atf.FormUIType
+        table: TableName
+        visible: (string | Record<'sys_declarative_action_assignment'>)[]
+        notVisible: (string | Record<'sys_declarative_action_assignment'>)[]
+    }) {
+        const { formUI, table, visible, notVisible } = inputs
+        const stepConfig = 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: Variables.DeclarativeActionVisibility.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.DeclarativeActionVisibility.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.DeclarativeActionVisibility.Visible,
+            startingValue: visible,
+            stringifier: (value) => {
+                return this.recordListToString(value)
+            },
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.DeclarativeActionVisibility.NotVisible,
+            startingValue: notVisible,
+            stringifier: (value) => {
+                return this.recordListToString(value)
+            },
+        })
+    }
+
+    navigateToModule(inputs: { module: string | Record<'sys_app_module'> }) {
+        const { module } = inputs
+        const stepConfig = 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: Variables.NavigateToModule.Module,
+            startingValue: module,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    applicationMenuVisibility(inputs: {
+        navigator: atf.NavigatorType
+        visible: (string | Record<'sys_app_application'>)[]
+        assertVisible: atf.AssertApplicationVisibleType
+        notVisible: (string | Record<'sys_app_application'>)[]
+        assertNotVisible: atf.AssertApplicationNotVisibleType
+    }) {
+        const { navigator, visible, assertNotVisible, assertVisible, notVisible } = inputs
+        const stepConfig = 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: Variables.ApplicationMenuVisibility.Navigator,
+            startingValue: navigator,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ApplicationMenuVisibility.VisibileAssert,
+            startingValue: assertVisible,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ApplicationMenuVisibility.NotVisibleAssert,
+            startingValue: assertNotVisible,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ApplicationMenuVisibility.VisibleApplications,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ApplicationMenuVisibility.NotVisibleApplications,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    checkoutShoppingCart(inputs: {
+        assert: atf.AssertCartType
+        requestedFor: string | Record<'sys_user'>
+        deliveryAddress: string
+        specialInstructions: string
+    }): any {
+        const { assert, requestedFor, deliveryAddress, specialInstructions } = inputs
+        const stepConfig = StepConfig.CheckoutShoppingCart
+
+        const stepRecord = this.createStepRecord({
+            name: 'Checkout Shopping Cart',
+            stepConfig,
+            description: 'Checkout Shopping Cart',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.CheckoutShoppingCart.Assert,
+            startingValue: assert,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.CheckoutShoppingCart.DeliveryAddress,
+            startingValue: deliveryAddress,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.CheckoutShoppingCart.Instructions,
+            startingValue: specialInstructions,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.CheckoutShoppingCart.Requested,
+            startingValue: requestedFor,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    submitRecordProducer(inputs: { assert: atf.AssertProducerType }): any {
+        const { assert } = inputs
+        const stepConfig = StepConfig.SubmitRecordProducer
+
+        const stepRecord = this.createStepRecord({
+            name: 'Submit Record Producer',
+            stepConfig,
+            description: 'Submit a Record Producer',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SubmitRecordProducer.Assert,
+            startingValue: assert,
+        })
+    }
+
+    openRecordProducer_SP(inputs: {
+        portal: string | Record<'sp_portal'>
+        page: string | Record<'sp_page'>
+        recordProducer: string | Record<'sc_cat_item_producer'>
+        queryParameters: atf.QueryParam
+    }) {
+        const { portal, page, recordProducer, queryParameters } = inputs
+        const processedParams = this.nameValuePairProcessing(queryParameters)
+        const stepConfig = 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: Variables.OpenRecordProducer_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenRecordProducer_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenRecordProducer_SP.RecordProducer,
+            startingValue: recordProducer,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenRecordProducer_SP.QueryParam,
+            startingValue: processedParams,
+            stringifier: JSON.stringify,
+        })
+    }
+
+    openOrderGuide_SP(inputs: {
+        portal: string | Record<'sp_portal'>
+        page: string | Record<'sp_page'>
+        orderGuide: string | Record<'sc_cat_item_guide'>
+        queryParameters: atf.QueryParam
+    }): any {
+        const { portal, page, orderGuide, queryParameters } = inputs
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters)
+        const stepConfig = 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: Variables.OpenOrderGuide_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenOrderGuide_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenOrderGuide_SP.OrderGuide,
+            startingValue: orderGuide,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenOrderGuide_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        })
+    }
+
+    openForm_SP<T extends TableName>(inputs: {
+        portal: string | Record<'sp_portal'>
+        page: string | Record<'sp_page'>
+        table: T
+        paramID: string | Record<T>
+        view: string
+        queryParameters: atf.QueryParam
+    }) {
+        const { portal, page, paramID, view, queryParameters, table } = inputs
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters)
+        const stepConfig = 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: Variables.OpenAForm_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenAForm_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenAForm_SP.ParamID,
+            startingValue: paramID,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenAForm_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenAForm_SP.View,
+            startingValue: view,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenAForm_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        })
+    }
+
+    openCatalogItem_SP(inputs: {
+        portal: string | Record<'sp_portal'>
+        page: string | Record<'sp_page'>
+        catItem: string | Record<'sc_cat_item'>
+        queryParameters: atf.QueryParam
+    }) {
+        const { portal, page, catItem, queryParameters } = inputs
+        const queryParametersProcessed = this.nameValuePairProcessing(queryParameters)
+        const stepConfig = 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: Variables.OpenCatalogItem_SP.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenCatalogItem_SP.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenCatalogItem_SP.CatalogItem,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.OpenCatalogItem_SP.QueryParam,
+            startingValue: queryParametersProcessed,
+            stringifier: JSON.stringify,
+        })
+    }
+
+    saveCurrentRowOfMultiRowVariableSet_SP(inputs: { assert: atf.AssertMultiRowType }) {
+        const { assert } = inputs
+        const stepConfig = 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: Variables.SaveCurrentRowOfMultiRowVariableSet_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    addRowToMultiRowVariableSet_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>
+        variableSet: string | Record<'item_option_new_set'>
+    }) {
+        const { catItem, variableSet } = inputs
+        const stepConfig = 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: Variables.AddRowToMultiRowVariableSet_SP.CatalogItem,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AddRowToMultiRowVariableSet_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    fieldStateValidation<T extends TableName>(inputs: {
+        formUI: atf.FormUIType
+        table: T
+        visible: (keyof Data<T> | atf.SomeOtherString)[]
+        notVisible: (keyof Data<T> | atf.SomeOtherString)[]
+        readOnly: (keyof Data<T> | atf.SomeOtherString)[]
+        notReadOnly: (keyof Data<T> | atf.SomeOtherString)[]
+        mandatory: (keyof Data<T> | atf.SomeOtherString)[]
+        notMandatory: (keyof Data<T> | atf.SomeOtherString)[]
+    }) {
+        const { formUI, visible, notMandatory, notReadOnly, notVisible, readOnly, mandatory, table } = inputs
+        const stepConfig = 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: Variables.FieldStateValidation.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.FormUI,
+            startingValue: formUI,
+            stringifier: (val) => this.parseFormUI(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val as string[]), // Since it is a list of strings we can re-use this recordListToString
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.ReadOnly,
+            startingValue: readOnly,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation.NotReadOnly,
+            startingValue: notReadOnly,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+    }
+
+    validateOutboundEmailGeneratedByFlow(inputs: { sourceFlow: string | Record<'sys_hub_flow'>; conditions: string }) {
+        const { sourceFlow, conditions } = inputs
+        const stepConfig = 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: Variables.ValidateOutboundEmailGeneratedByFlow.Table,
+            startingValue: 'sys_email',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ValidateOutboundEmailGeneratedByFlow.SourceFlow,
+            startingValue: sourceFlow,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ValidateOutboundEmailGeneratedByFlow.Conditions,
+            startingValue: conditions,
+        })
+    }
+
+    reportVisibility(inputs: { report: string | Record<'sys_report'>; assertType: atf.AssertReportVisibilityType }) {
+        const { report, assertType } = inputs
+        const stepConfig = 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: Variables.ReportVisibility.Report,
+            startingValue: report,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ReportVisibility.AssertType,
+            startingValue: assertType,
+        })
+    }
+
+    openServicePortalPage(inputs: {
+        portal: string | Record<'sp_portal'>
+        page: string | Record<'sp_page'>
+        queryParams: atf.QueryParam
+    }) {
+        const { portal, page, queryParams } = inputs
+        const stepConfig = 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: Variables.OpenServicePortalPage.Portal,
+            startingValue: portal,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenServicePortalPage.Page,
+            startingValue: page,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.OpenServicePortalPage.QueryParams,
+            startingValue: processedParams,
+            stringifier: JSON.stringify,
+        })
+    }
+
+    recordQuery<T extends TableName>(inputs: {
+        enforceSecurity: boolean
+        assertType: atf.AssertQueryType
+        table: T
+        fieldValues: string
+    }): any {
+        const { enforceSecurity, assertType, table, fieldValues } = inputs
+        const stepConfig = StepConfig.RecordQuery
+
+        const stepRecord = this.createStepRecord({
+            name: 'Record Query',
+            stepConfig,
+            description: 'Select a record and validate field values.',
+            tableName: '',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordQuery.EnforceSecurity,
+            startingValue: enforceSecurity,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordQuery.AssertType,
+            startingValue: assertType,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordQuery.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.RecordQuery.FieldValues,
+            startingValue: fieldValues,
+        })
+    }
+
+    generateInboundEmail(inputs: { from: string; to: string; subject: string; body: string }): any {
+        const { from, to, subject, body } = inputs
+        const stepConfig = StepConfig.GenerateInboundEmail
+        const stepRecord = this.createStepRecord({
+            name: 'Generate Inbound Email',
+            stepConfig,
+            description: 'Generate an inbound email.',
+            tableName: '',
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.GenerateInboundEmail.From,
+            startingValue: from,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.GenerateInboundEmail.To,
+            startingValue: to,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.GenerateInboundEmail.Subject,
+            startingValue: subject,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.GenerateInboundEmail.Body,
+            startingValue: body,
+        })
+    }
+
+    validateVariableValue(inputs: { catalogItem: Record<'sc_cat_item'>; catalogConditions: string }) {
+        const { catalogItem, catalogConditions } = inputs
+        const stepConfig = 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: Variables.ValidateVariableValues.CatalogItem,
+            startingValue: catalogItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.ValidateVariableValues.CatalogConditions,
+            startingValue: catalogConditions,
+        })
+    }
+
+    assertResponseTime(inputs: { responseOperation: atf.ResponseConditionOperationType; responseTime: number }): any {
+        const { responseOperation, responseTime } = inputs
+        const stepConfig = 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: Variables.AssertResponseTime.ResponseOperation,
+            startingValue: responseOperation,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.AssertResponseTime.ResponseTime,
+            startingValue: responseTime,
+        })
+    }
+
+    assertJsonResponsePayloadElement(inputs: {
+        elementName: string
+        operation: atf.AssertResponseOperationType
+        elementValue: string
+    }): any {
+        const { elementName, operation, elementValue } = inputs
+        const stepConfig = 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: Variables.AssertJsonResponsePayloadElement.ElementName,
+            startingValue: elementName,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.AssertJsonResponsePayloadElement.ResponseOperation,
+            startingValue: operation,
+        })
+
+        this.createVariable({
+            stepRecord,
+            stepConfig,
+            variable: Variables.AssertJsonResponsePayloadElement.ElementValue,
+            startingValue: elementValue,
+        })
+    }
+
+    setVariableValue_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'> | Record<'sc_cat_item_producer'>
+        variableSet: string | Record<'item_option_new_set'>
+        variableValues: string
+    }) {
+        const { catItem, variableSet, variableValues } = inputs
+        const stepConfig = StepConfig.SetVariableValues_SP
+
+        const stepRecord = this.createStepRecord({
+            name: 'Set Variable Values (SP)',
+            stepConfig,
+            description: 'Set Variable Values (SP)',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SetVariableValues_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SetVariableValues_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SetVariableValues_SP.VariableValues,
+            startingValue: variableValues,
+        })
+    }
+
+    validateVariableValue_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>
+        variableSet: string | Record<'item_option_new_set'>
+        variableValues: string
+    }) {
+        const { catItem, variableSet, variableValues } = inputs
+        const stepConfig = 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: Variables.ValidateVariableValues_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidateVariableValues_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidateVariableValues_SP.Conditions,
+            startingValue: variableValues,
+        })
+    }
+
+    variableStateValidation_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>
+        variableSet: string | Record<'item_option_new_set'>
+        visible: string[]
+        notVisible: string[]
+        readonly: string[]
+        notReadonly: string[]
+        mandatory: string[]
+        notMandatory: string[]
+    }) {
+        const { catItem, variableSet, visible, notMandatory, notReadonly, notVisible, mandatory, readonly } = inputs
+        const stepConfig = 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: Variables.VariableStateValidation_SP.Item,
+            startingValue: catItem,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.VariableSet,
+            startingValue: variableSet,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.ReadOnly,
+            startingValue: readonly,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation_SP.NotReadOnly,
+            startingValue: notReadonly,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    validatePriceAndRecurringPrice_SP(inputs: {
+        price: string | number
+        recurringPrice: string | number
+        frequency: atf.FrequencyType
+    }) {
+        const { price, recurringPrice, frequency } = inputs
+        const stepConfig = 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: Variables.ValidatePriceandRecurringPrice_SP.Price,
+            startingValue: price,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidatePriceandRecurringPrice_SP.RecurringPrice,
+            startingValue: recurringPrice,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidatePriceandRecurringPrice_SP.RecurringFrequency,
+            startingValue: frequency,
+        })
+    }
+
+    navigatewithinOrderGuide_SP(inputs: { guideStep: atf.GuideStepType; assert: atf.AssertNavigate }) {
+        const { guideStep, assert } = inputs
+        const stepConfig = 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: Variables.NavigatewithinOrderGuide_SP.GuideStep,
+            startingValue: guideStep,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.NavigatewithinOrderGuide_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    setFieldValue_SP<T extends TableName>(inputs: { table: T; fieldValues: Partial<Data<T>> }) {
+        const { table, fieldValues } = inputs
+        const stepConfig = 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: Variables.SetFieldValues_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SetFieldValues_SP.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        })
+    }
+
+    setCatalogItemQuantity_SP(inputs: { quantity: string | number }) {
+        const { quantity } = inputs
+        const stepConfig = 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: Variables.SetCatalogItemQuantity_SP.Quantity,
+            startingValue: quantity,
+        })
+    }
+
+    validateOrderGuideItem_SP(inputs: { items: (string | Record<'sc_cat_item'>)[] }) {
+        const { items } = inputs
+        const stepConfig = 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: Variables.ValidateOrderGuideItems_SP.Items,
+            startingValue: items,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    reviewOrderGuideSummary_SP(inputs: { items: (string | Record<'sc_cat_item'>)[]; price: string | number }) {
+        const { items, price } = inputs
+        const stepConfig = 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: Variables.ReviewOrderGuideSummary_SP.Price,
+            startingValue: price,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ReviewOrderGuideSummary_SP.Items,
+            startingValue: items,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    fieldValueValidation_SP<T extends TableName>(inputs: { table: T; conditions: string }) {
+        const { table, conditions } = inputs
+        const stepConfig = StepConfig.FieldValuesValidation_SP
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Field Values Validation (SP)',
+            description: 'Field Values Validation (SP)',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldValuesValidation_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldValuesValidation_SP.Conditions,
+            startingValue: conditions,
+        })
+    }
+
+    fieldStateValidation_SP<T extends TableName>(inputs: {
+        table: T
+        visible: (keyof Data<T> | atf.SomeOtherString)[]
+        notVisible: (keyof Data<T> | atf.SomeOtherString)[]
+        mandatory: (keyof Data<T> | atf.SomeOtherString)[]
+        notMandatory: (keyof Data<T> | atf.SomeOtherString)[]
+        readonly: (keyof Data<T> | atf.SomeOtherString)[]
+        notReadonly: (keyof Data<T> | atf.SomeOtherString)[]
+    }) {
+        const { table, mandatory, notMandatory, notReadonly, notVisible, readonly, visible } = inputs
+        const stepConfig = 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: Variables.FieldStateValidation_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.NotMandatory,
+            startingValue: notMandatory,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.ReadOnly,
+            startingValue: readonly,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.NotReadOnly,
+            startingValue: notReadonly,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.FieldStateValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val as string[]),
+        })
+    }
+
+    uiActionVisibilityValidation_SP<T extends TableName>(inputs: {
+        table: T
+        visible: (string | Record<'sys_ui_action'>)[]
+        notVisible: (string | Record<'sys_ui_action'>)[]
+    }) {
+        const { table, visible, notVisible } = inputs
+        const stepConfig = 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: Variables.UIActionVisibilityValidation_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.UIActionVisibilityValidation_SP.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.UIActionVisibilityValidation_SP.NotVisible,
+            startingValue: notVisible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    reviewIteminOrderGuide_SP(inputs: { item: string | Record<'sc_cat_item'>; included: boolean }) {
+        const { item, included } = inputs
+        const stepConfig = 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: Variables.ReviewIteminOrderGuide_SP.Item,
+            startingValue: item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ReviewIteminOrderGuide_SP.Included,
+            startingValue: included,
+        })
+    }
+
+    clickUIAction_SP<T extends TableName>(inputs: {
+        table: T
+        uiAction: string | Record<'sys_ui_action'>
+        assert: atf.AssertClickUIActionSP
+    }): any {
+        const { table, uiAction, assert } = inputs
+        const stepConfig = 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: Variables.ClickaUIAction_SP.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickaUIAction_SP.Assert,
+            startingValue: assert,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ClickaUIAction_SP.UIAction,
+            startingValue: uiAction,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    submitForm_SP(inputs: { assert: atf.AssertSubmitFormSP }): any {
+        const { assert } = inputs
+        const stepConfig = StepConfig.SubmitForm_SP
+
+        const stepRecord = this.createStepRecord({
+            name: 'Submit a Form (SP)',
+            stepConfig,
+            description: 'Submits the current form.',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SubmitForm_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    addItemtoShoppingCart_SP(inputs: { assert: atf.AssertAddItemToCartSP }): any {
+        const { assert } = inputs
+        const stepConfig = 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: Variables.AddItemtoShoppingCart_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    addOrderGuidetoShoppingCart_SP(inputs: { assert: atf.AssertAddOrderGuidetoShoppingCart_SP }) {
+        const { assert } = inputs
+        const stepConfig = 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: Variables.AddOrderGuidetoShoppingCart_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    submitOrderGuide_SP(inputs: { assert: atf.AssertSubmitOrderGuideSP }): any {
+        const { assert } = inputs
+        const stepConfig = 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: Variables.SubmitOrderGuide_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    submitRecordProducer_SP(inputs: { assert: atf.AssertRecordProducerSubmitSP }): any {
+        const { assert } = inputs
+        const stepConfig = StepConfig.SubmitRecordProducer_SP
+
+        const stepRecord = this.createStepRecord({
+            stepConfig,
+            name: 'Submit Record Producer (SP)',
+            description: 'Submit a Record Producer (SP)',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SubmitRecordProducer_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    orderCatalogItem_SP(inputs: { assert: atf.AssertOrderCatalogItemSP }): any {
+        const { assert } = inputs
+        const stepConfig = 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: Variables.OrderCatalogItem_SP.Assert,
+            startingValue: assert,
+        })
+    }
+
+    validateOutboundEmail(inputs: { conditions: string }) {
+        const { conditions } = inputs
+        const stepConfig = 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: Variables.ValidateOutboundEmail.Conditions,
+            startingValue: conditions,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.ValidateOutboundEmail.Table,
+            startingValue: 'sys_email',
+        })
+    }
+
+    recordInsert<T extends TableName>(inputs: {
+        assertType: atf.AssertInsert
+        enforceSecurity: boolean
+        table: T
+        fieldValues: Partial<Data<T>>
+    }): any {
+        const { assertType, enforceSecurity, table, fieldValues } = inputs
+        const stepConfig = StepConfig.RecordInsert
+
+        const stepRecord = this.createStepRecord({
+            name: 'Record Insert',
+            stepConfig,
+            description: 'Insert a record to the table',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordInsert.AssertType,
+            startingValue: assertType,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordInsert.EnforceSecurity,
+            startingValue: enforceSecurity,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordInsert.Table,
+            startingValue: table,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.RecordInsert.FieldValues,
+            startingValue: fieldValues,
+            stringifier: (val) => this.fieldValuesToQuery(val),
+        })
+    }
+
+    searchForCatalogItem(inputs: {
+        search_in_portal: boolean
+        search_term: string
+        catalog: string | Record<'sc_catalog'>
+        category: string | Record<'sc_category'>
+        assert_item: string | Record<'sc_cat_item'>
+        assert_type: atf.AssertCatalogItem
+    }): any {
+        const { search_in_portal, search_term, catalog, category, assert_item, assert_type } = inputs
+        const stepConfig = 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: Variables.SearchForACatalogItem.SearchInPortalOnly,
+            startingValue: search_in_portal,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SearchForACatalogItem.SearchTerm,
+            startingValue: search_term,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SearchForACatalogItem.Catalog,
+            startingValue: catalog,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SearchForACatalogItem.Category,
+            startingValue: category,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SearchForACatalogItem.AssertItem,
+            startingValue: assert_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.SearchForACatalogItem.AssertType,
+            startingValue: assert_type,
+        })
+    }
+
+    replayRequestItem(inputs: { request_item: string | Record<'sc_req_item'> }): any {
+        const { request_item } = inputs
+        const stepConfig = 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: Variables.ReplayRequestItem.OriginalRequestItem,
+            startingValue: request_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+    }
+
+    variableStateValidation(inputs: {
+        catalog_item: string | Record<'sc_cat_item'>
+        visible: string[]
+        not_visible: string[]
+        read_only: string[]
+        not_read_only: string[]
+        mandatory: string[]
+        not_mandatory: string[]
+    }) {
+        const { catalog_item, visible, not_visible, read_only, not_read_only, mandatory, not_mandatory } = inputs
+        const stepConfig = StepConfig.VariableStateValidation
+        const stepRecord = this.createStepRecord({
+            name: 'Variable State Validation',
+            stepConfig,
+            description: 'Validates states of the desired variables',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.CatalogItem,
+            startingValue: catalog_item,
+            stringifier: (val) => this.extractSysIdIfRecord(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.Visible,
+            startingValue: visible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.NotVisible,
+            startingValue: not_visible,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.ReadOnly,
+            startingValue: read_only,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.NotReadOnly,
+            startingValue: not_read_only,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.Mandatory,
+            startingValue: mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.VariableStateValidation.NotMandatory,
+            startingValue: not_mandatory,
+            stringifier: (val) => this.recordListToString(val),
+        })
+    }
+
+    assertResponseHeader(inputs: {
+        header_name: string
+        response_operation: atf.AssertResponseHeader
+        header_value: string
+    }) {
+        const { header_name, response_operation, header_value } = inputs
+        const stepConfig = StepConfig.AssertResponseHeader
+
+        const stepRecord = this.createStepRecord({
+            name: 'Assert Response Header',
+            stepConfig,
+            description: 'Assert an HTTP response header',
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertResponseHeader.Header,
+            startingValue: header_name,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertResponseHeader.Operation,
+            startingValue: response_operation,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertResponseHeader.Value,
+            startingValue: header_value,
+        })
+    }
+
+    assertResponsePayload(inputs: { response_body: string; response_operation: atf.AssertResponsePayload }) {
+        const { response_body, response_operation } = inputs
+        const stepConfig = 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: Variables.AssertResponsePayload.ResponseBody,
+            startingValue: response_body,
+        })
+
+        this.createVariable({
+            stepConfig,
+            stepRecord,
+            variable: Variables.AssertResponsePayload.Operation,
+            startingValue: response_operation,
+        })
+    }
+}