@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/flow/plugins/wfa-datapill-plugin.ts

@@ -0,0 +1,213 @@
+import { type Result, Plugin, type Shape, ts } from '@servicenow/sdk-build-core'
+import { getCallExpressionName } from '../../utils'
+import { findAncestorByCalleeName } from '../utils/utils'
+import { DataPillPlugin } from './flow-data-pill-plugin'
+import { BasicSyntaxPlugin } from '../../basic-syntax-plugin'
+import { ForEachItemShape, PillShape } from '../utils/data-pill-shapes'
+import { FLOW_LOGIC } from '../flow-logic/flow-logic-constants'
+
+const DATAPILL_CALLEE = 'wfa.dataPill'
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+/**
+ * Checks if a node is the items argument (first argument) of wfa.flowLogic.forEach()
+ *
+ * Verifies the following conditions:
+ * 1. The immediate parent is a CallExpression
+ * 2. The parent's callee is 'wfa.flowLogic.forEach'
+ * 3. The node is the first argument of that forEach call
+ *
+ * @param node - The node to check
+ * @returns true if the node is the items argument of forEach, false otherwise
+ */
+function isForEachItemsArgument(node: ts.Node): boolean {
+    const parentCall = node.getParentIfKind(ts.SyntaxKind.CallExpression)
+    return (
+        parentCall !== undefined &&
+        getCallExpressionName(parentCall) === FLOW_LOGIC.FOR_EACH &&
+        parentCall.getArguments()[0] === node
+    )
+}
+
+/**
+ * Extracts metadata from the TypeScript type of a data pill expression.
+ * This includes parent table name, column name, and reference table.
+ *
+ * For example, for params.trigger.current.company:
+ * - parentTableName: "user_criteria" (from the record type)
+ * - columnName: "company" (the property being accessed)
+ * - reference: "core_company" (from the column's referenceTable property)
+ */
+function extractMetadataFromType(node: ts.Node): {
+    parentTableName: string | null
+    columnName: string | null
+    reference: string | null
+} {
+    let parentTableName: string | null = null
+    let columnName: string | null = null
+    let reference: string | null = null
+
+    // For property access like params.trigger.current.company or outOfStockAssets.Records
+    if (ts.Node.isPropertyAccessExpression(node)) {
+        // Get the property name (e.g., "company" or "Records")
+        columnName = node.getName()
+
+        // Get the parent expression (e.g., params.trigger.current or outOfStockAssets)
+        const parentExpr = node.getExpression()
+        const parentType = parentExpr.getType()
+        const parentTypeText = parentType.getText()
+
+        // Pattern A: Check for OutputsWithDependentTable<..., "table_name"> from action outputs
+        // e.g., OutputsWithDependentTable<{...}, "alm_hardware"> & {...}
+        // The type text contains nested brackets, so we look for the pattern: }, "table_name"> &
+        if (parentTypeText.includes('OutputsWithDependentTable')) {
+            const outputsDependentMatch = parentTypeText.match(/},\s*["']([^"']+)["']\s*>\s*&/)
+            if (outputsDependentMatch?.[1]) {
+                reference = outputsDependentMatch[1]
+            }
+        }
+
+        // Try to extract the table name from TableAwareRecordRecursive or similar types
+        if (!reference) {
+            const tableMatch = parentTypeText.match(/TableAwareRecord(?:Recursive|WithFallback)?<["']([^"']+)["']/)
+            if (tableMatch?.[1]) {
+                parentTableName = tableMatch[1]
+            }
+        }
+
+        // Get the type of the property being accessed
+        const propertyType = node.getType()
+        const propertyTypeText = propertyType.getText()
+
+        // Try to extract referenceTable from the property type
+        // Pattern 1: Check if the property type is itself a TableAwareRecordRecursive type
+        // e.g., TableAwareRecordRecursive<"core_company", 2>
+        if (!reference) {
+            const tableTypeMatch = propertyTypeText.match(
+                /TableAwareRecord(?:Recursive|WithFallback)?<["']([^"']+)["']/
+            )
+            if (tableTypeMatch?.[1]) {
+                reference = tableTypeMatch[1]
+            }
+        }
+    }
+
+    return { parentTableName, columnName, reference }
+}
+
+// ============================================================================
+// PLUGIN DEFINITION
+// ============================================================================
+
+/**
+ * WfaDataPillPlugin - Handles wfa.dataPill() CallExpressions
+ *
+ * This plugin processes datapill wrapper calls and converts them to PillShape.
+ *
+ * Usage:
+ *   wfa.dataPill(params.trigger.current.active, 'boolean')
+ *   wfa.dataPill(params.flowVariables.userName, 'string')
+ *   wfa.dataPill(actionInstance.output, 'reference')
+ *
+ * The first argument is the PropertyAccessExpression to the data source.
+ * The second argument is the data type string.
+ */
+export const WfaDataPillPlugin = Plugin.create({
+    name: 'WfaDataPillPlugin',
+    nodes: [
+        {
+            node: 'CallExpression',
+            fileTypes: ['fluent'],
+            async toShape(node, { diagnostics, transform }): Promise<Result<Shape>> {
+                const callee = getCallExpressionName(node)
+
+                // Only handle wfa.dataPill() calls
+                if (callee !== DATAPILL_CALLEE) {
+                    return { success: false }
+                }
+
+                // Validate wfa.dataPill is inside a Flow or Subflow call expression
+                const ancestorFlowOrSubflow = findAncestorByCalleeName(node, 'Flow', 'Subflow')
+                if (!ancestorFlowOrSubflow) {
+                    diagnostics.error(node, 'wfa.dataPill() cannot be used outside of a Flow or Subflow context.')
+                    return { success: false }
+                }
+
+                // TODO: This is not working, Even though the debug point is hitting this but not printing the error for some reason, need to fix from core team.
+                // This will be gone once the toSubclass node -> toShape is refactored to toSubclass() with story ref. STRY62776143
+                const ancestorDuration = findAncestorByCalleeName(node, 'Duration')
+                if (ancestorDuration) {
+                    diagnostics.error(node, 'wfa.dataPill() cannot be used inside a Duration().')
+                    return { success: false }
+                }
+
+                const args = node.getArguments()
+
+                let expressionArg = args[0]
+                const typeArg = args[1]
+
+                if (!expressionArg) {
+                    diagnostics.error(node, 'wfa.dataPill: missing required expression argument')
+                    return { success: false }
+                }
+
+                // Check if this pill is used in forEach items argument (computed once, reused throughout)
+                const isForEachItems = isForEachItemsArgument(node)
+
+                // Check for type assertions (as any, as string, etc.) in forEach items argument ONLY
+                if (ts.Node.isAsExpression(expressionArg)) {
+                    if (isForEachItems) {
+                        diagnostics.error(
+                            expressionArg,
+                            'wfa.dataPill: Type assertions (e.g., "as any") are not allowed in forEach items argument.'
+                        )
+                        return { success: false }
+                    }
+                    // For non-forEach uses, unwrap the type assertion to get the underlying expression
+                    expressionArg = expressionArg.getExpression()
+                }
+
+                // Validate first argument is a property access expression or identifier
+                if (
+                    !ts.Node.isPropertyAccessExpression(expressionArg) &&
+                    !ts.Node.isIdentifier(expressionArg) // In ForEach scneario we get identifier like "item"
+                ) {
+                    diagnostics.error(
+                        expressionArg,
+                        'wfa.dataPill: first argument must be a property access expression (e.g., params.trigger.current.active)'
+                    )
+                    return { success: false }
+                }
+
+                // Convert the expression argument to a shape first
+                const shapeResult = await transform.toShape(expressionArg, BasicSyntaxPlugin, DataPillPlugin)
+                if (shapeResult.success) {
+                    if (shapeResult.value instanceof PillShape || shapeResult.value instanceof ForEachItemShape) {
+                        shapeResult.value.setType((typeArg as ts.StringLiteral).getLiteralValue())
+
+                        // Only extract and set metadata if this pill is the items argument of forEach
+                        if (isForEachItems) {
+                            const metadata = extractMetadataFromType(expressionArg)
+                            if (metadata.parentTableName) {
+                                shapeResult.value.setParentTableName(metadata.parentTableName)
+                            }
+                            if (metadata.columnName) {
+                                shapeResult.value.setColumnName(metadata.columnName)
+                            }
+                            if (metadata.reference) {
+                                shapeResult.value.setReference(metadata.reference)
+                            }
+                        }
+                        return { success: true, value: shapeResult.value }
+                    }
+                }
+                diagnostics.error(expressionArg, 'wfa.dataPill: failed to resolve expression or type')
+                return { success: false }
+            },
+        },
+    ],
+    shapes: [],
+})

package/src/flow/utils/approval-rules-processor.ts

@@ -0,0 +1,298 @@
+/**
+ * Utility functions to convert between JSON and string formats for Approval Rules
+ */
+import { APPROVAL_ACTION_TYPE_APPROVE_VALUE, APPROVAL_ACTION_TYPES } from './flow-constants'
+import type {
+    ApprovalConditionRuleType,
+    ApprovalRuleActionType,
+    ApprovalRuleConditionType,
+    ApprovalRuleSetType,
+    ApprovalRulesType,
+} from '@servicenow/sdk-core/runtime/flow'
+
+/**
+ * Converts Approval Rules JSON to string representation
+ * @param {Object} approvalRules - Approval rules JSON containing ruleSets and conditionType attributes
+ * @returns {string} String representation of the Approval Rules
+ */
+export function approvalRulesJsonToString(approvalRules: ApprovalRulesType): string {
+    const { ruleSets = [] } = approvalRules
+    return ruleSetsJsonToString(ruleSets)
+}
+
+/**
+ * Converts a Rule Sets JSON to its string representation
+ * @param {Array} ruleSets - Array of Rule Set objects
+ * @returns {string} String representation of the Rule Sets
+ */
+function ruleSetsJsonToString(ruleSets: Array<ApprovalRuleSetType>): string {
+    if (!ruleSets || !Array.isArray(ruleSets) || ruleSets.length === 0) {
+        return APPROVAL_ACTION_TYPE_APPROVE_VALUE
+    }
+
+    //Iterate through the RuleSets and convert each RuleSet JSON to string
+    return ruleSets
+        .map((ruleSet) => ruleSetJsonToString(ruleSet))
+        .filter(Boolean)
+        .join('Or') //Rule Sets are connected with 'Or' condition
+}
+/**
+ * Converts a Rule Set JSON to its string representation
+ * @param {Object} ruleSet - Rule Set object containg action and rules
+ * @returns {string} String representation of the Rule Set
+ */
+function ruleSetJsonToString(ruleSet: ApprovalRuleSetType): string {
+    const { action, rules = [] } = ruleSet
+
+    //Check if action type is valid
+    if (!action || !APPROVAL_ACTION_TYPES.includes(action)) {
+        return ''
+    }
+
+    //Check if rules are valid
+    if (!rules || !Array.isArray(rules) || rules.length === 0) {
+        return action
+    }
+
+    //Iterate over the rules and convert each rule json (contains list of conditions) to string
+    const rulesString = rules
+        .map((rule) => ruleJSONToString(rule))
+        .filter(Boolean)
+        .join('&') //Rules are connected with & (AND)
+
+    return `${action}${rulesString}`
+}
+/**
+ * Converts a Rule (contains list of conditions) JSON to its string representation
+ * @param {Array} rule - Array of Rule condition objects
+ * @returns {string} String representation of the Rule conditions
+ */
+function ruleJSONToString(rule: Array<ApprovalRuleConditionType>): string {
+    if (!rule || !Array.isArray(rule) || rule.length === 0) {
+        return ''
+    }
+    //Iterate through the rule conditions and convert each rule condition to string
+    const ruleString = rule
+        .map((ruleCondition) => ruleConditionJSONToString(ruleCondition))
+        .filter(Boolean)
+        .join('|') //Rule conditions are connected with | (OR)
+    return ruleString
+}
+
+function ruleConditionJSONToString(ruleCondition: ApprovalRuleConditionType): string {
+    if (!ruleCondition || Object.keys(ruleCondition).length === 0) {
+        return ''
+    }
+    let result = ''
+
+    // Handle Count and Percent
+    if (ruleCondition.ruleType === 'Count' && ruleCondition.count !== undefined) {
+        result = `${ruleCondition.count}#`
+    } else if (ruleCondition.ruleType === 'Percent' && ruleCondition.percent !== undefined) {
+        result = `${ruleCondition.percent}%`
+    } else {
+        // Add rule type
+        result = ruleCondition.ruleType
+    }
+
+    // Handle manual flag
+    if (ruleCondition.manual) {
+        result += 'M'
+        return result
+    }
+
+    // Add users if present
+    if (ruleCondition.users && ruleCondition.users.length > 0) {
+        result += `U[${ruleCondition.users
+            .map((user) => {
+                const trimmed = String(user).trim()
+                // Check if user is already a data pill format (e.g., {{trigger.current.manager.city|string}})
+                const match = trimmed.match(/^\{\{(.*)\}\}$/)
+                if (match) {
+                    return trimmed
+                }
+                return `{{static.${user}}}`
+            })
+            .join(',')}]`
+    }
+
+    // Add groups if present
+    if (ruleCondition.groups && ruleCondition.groups.length > 0) {
+        result += `G[${ruleCondition.groups
+            .map((group) => {
+                const trimmed = String(group).trim()
+                // Check if group is already a data pill format (e.g., {{trigger.current.group_ref|string}})
+                const match = trimmed.match(/^\{\{(.*)\}\}$/)
+                if (match) {
+                    return trimmed
+                }
+                return `{{static.${group}}}`
+            })
+            .join(',')}]`
+    }
+
+    return result
+}
+
+/**
+ * Converts Approval Rules string to JSON representation
+ * @param {string} ruleSetsString - String representation of the Approval Rules
+ * @returns {Object} Approval rules JSON containing ruleSets and conditionType attributes
+ */
+export function approvalRulesStringToJson(ruleSetsString: string): ApprovalRulesType {
+    const EMPTY_RULE_SETS_JSON: ApprovalRulesType = {
+        conditionType: 'OR',
+        ruleSets: [],
+    }
+
+    if (!ruleSetsString || ruleSetsString.length === 0) {
+        return EMPTY_RULE_SETS_JSON
+    }
+
+    // 1. Split by 'Or' to get individual Rule Sets
+    // 2. Iterate through the Rule Sets and convert each Rule Set string to JSON
+    const ruleSetsJson = ruleSetsString.split('Or').map((ruleSetString) => ruleSetStringToJson(ruleSetString))
+    return {
+        ...EMPTY_RULE_SETS_JSON,
+        ruleSets: ruleSetsJson,
+    }
+}
+/**
+ * Converts a Rule Set string to its JSON representation
+ * @param {string} ruleSetString - Rule Set string
+ * @returns {Array} JSON representation of the Rule Set
+ */
+function ruleSetStringToJson(ruleSetString: string): ApprovalRuleSetType {
+    const EMPTY_RULE_SET_JSON: ApprovalRuleSetType = {
+        action: 'Approves',
+        conditionType: 'AND',
+        rules: [],
+    }
+
+    if (!ruleSetString || ruleSetString.length === 0) {
+        return EMPTY_RULE_SET_JSON
+    }
+
+    // Extract action (Approves, Rejects, ApprovesRejects)
+    const actionRegex = /^(ApprovesRejects|Approves|Rejects)/
+    const actionMatch = ruleSetString.match(actionRegex)
+    if (!actionMatch) {
+        return EMPTY_RULE_SET_JSON
+    }
+
+    const action = actionMatch[0] as ApprovalRuleActionType
+
+    // If the string is just the action name, return an empty rule set
+    if (ruleSetString === action) {
+        return { ...EMPTY_RULE_SET_JSON, action }
+    }
+
+    // Remove action from the Rule Set string and extract the rules string
+    const rulesString = ruleSetString.substring(action.length)
+
+    // Split rules by & to get individual rules within the Rule Set
+    const rulesRegex = /[&]/g
+
+    //Iterate through the rules and convert each rule string to JSON
+    const rulesJson = rulesString
+        .split(rulesRegex)
+        .map((ruleString) => ruleStringToJson(ruleString))
+        .filter(Boolean)
+
+    return { ...EMPTY_RULE_SET_JSON, action, rules: rulesJson }
+}
+
+/**
+ * Converts a Rule string to its JSON representation
+ * @param {string} ruleString - Rule string
+ * @returns {Array} JSON representation of the Rule
+ */
+function ruleStringToJson(ruleString: string): Array<ApprovalRuleConditionType> {
+    if (!ruleString || ruleString.length === 0) {
+        return []
+    }
+    const ruleConditionsRegex = /[|]/g
+    const ruleConditionStrings: string[] = []
+
+    ruleString.split(ruleConditionsRegex).forEach((ruleConditionString) => {
+        ruleConditionStrings.push(ruleConditionString)
+    })
+    return ruleConditionStrings
+        .map((ruleConditionString) => ruleConditionStringToJson(ruleConditionString))
+        .filter((ruleConditionJson): ruleConditionJson is ApprovalRuleConditionType => ruleConditionJson !== undefined)
+}
+
+/**
+ * Converts a Rule Condition string to its JSON representation
+ * @param {string} ruleConditionString - Rule Condition string
+ * @returns {Object} JSON representation of the Rule Condition
+ */
+function ruleConditionStringToJson(ruleConditionString: string): ApprovalRuleConditionType | undefined {
+    if (!ruleConditionString || ruleConditionString.length === 0) {
+        return undefined
+    }
+    const ruleConditionJson: ApprovalRuleConditionType = {
+        ruleType: 'Any',
+        users: [],
+        groups: [],
+        manual: false,
+    }
+
+    // Check if manual
+    const hasManual = ruleConditionString.includes('M')
+    if (hasManual) {
+        ruleConditionJson.manual = true
+    }
+
+    // Check for Count or Percent
+    const countMatch = ruleConditionString.match(/(\d+)#/)
+    const percentMatch = ruleConditionString.match(/(\d+)%/)
+
+    if (countMatch?.[1]) {
+        ruleConditionJson.ruleType = 'Count'
+        ruleConditionJson['count'] = parseInt(countMatch[1], 10)
+    } else if (percentMatch?.[1]) {
+        ruleConditionJson.ruleType = 'Percent'
+        ruleConditionJson['percent'] = parseInt(percentMatch[1], 10)
+    } else {
+        // Extract rule type (Any, All, Res)
+        const ruleTypeMatch = ruleConditionString.match(/(Any|All|Res)/)
+        if (ruleTypeMatch) {
+            ruleConditionJson.ruleType = ruleTypeMatch[0] as ApprovalConditionRuleType
+        }
+    }
+    ruleConditionJson.users = getUsersJson(ruleConditionString)
+    ruleConditionJson.groups = getGroupsJson(ruleConditionString)
+
+    return ruleConditionJson
+}
+
+function getUsersJson(ruleConditionString: string) {
+    if (ruleConditionString && ruleConditionString.length > 0) {
+        // Extract users
+        const usersMatch = ruleConditionString.match(/U\[(.*?)\]/)
+        if (usersMatch?.[1]) {
+            const usersString = usersMatch[1]
+            return usersString
+                .split(',')
+                .map((user) => user.replace(/{{static\.(.*?)}}/, '$1').trim())
+                .filter(Boolean)
+        }
+    }
+    return []
+}
+
+function getGroupsJson(ruleConditionString: string) {
+    if (ruleConditionString && ruleConditionString.length > 0) {
+        // Extract groups
+        const groupsMatch = ruleConditionString.match(/G\[(.*?)\]/)
+        if (groupsMatch?.[1]) {
+            const groupsString = groupsMatch[1]
+            return groupsString
+                .split(',')
+                .map((group) => group.replace(/{{static\.(.*?)}}/, '$1').trim())
+                .filter(Boolean)
+        }
+    }
+    return []
+}

package/src/flow/utils/built-in-complex-objects.ts

@@ -0,0 +1,81 @@
+/**
+ * Built-in complex objects that are available globally in Flow Designer.
+ * These are referenced by flows but may not be present in the user's project metadata.
+ */
+
+interface BuiltInComplexObject {
+    $id: string
+    table: 'sys_complex_object'
+    data: {
+        name: string
+        namespace: string
+        scope_name?: string
+        serialized_content: string
+        sys_domain: string
+        sys_policy?: string
+        type: string
+    }
+}
+
+const FDChangeDetails: BuiltInComplexObject = {
+    $id: '239e04950f023300ecf0cc52ff767e0c',
+    table: 'sys_complex_object',
+    data: {
+        name: 'FDChangeDetails',
+        namespace: 'FlowDesigner',
+        scope_name: 'global',
+        serialized_content:
+            '{"FlowDesigner:FDChangeDetails":{"previous_display_value":"String","previous_display_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Previous Display Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"4\\",\\"max_length\\":\\"0\\"}"},"previous_value":"String","previous_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Previous Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"2\\",\\"max_length\\":\\"0\\"}"},"current_display_value":"String","current_display_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Current Display Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"5\\",\\"max_length\\":\\"0\\"}"},"current_value":"String","current_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Current Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"3\\",\\"max_length\\":\\"0\\"}"},"field_name":"String","field_name.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Field Name\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"1\\",\\"max_length\\":\\"0\\"}"}},"FlowDesigner:FDChangeDetails.$type_facets":{"SimpleMapFacet":"{\\"read_only_complex_object\\":\\"true\\",\\"pwd2droppable\\":\\"true\\",\\"default_value\\":\\"\\",\\"label\\":\\"Changed Fields\\",\\"mandatory\\":\\"false\\",\\"child_name\\":\\"FDChangeDetails\\",\\"uiTypeLabel\\":\\"Array.Object\\",\\"co_type_name\\":\\"FDCollection\\",\\"child_label\\":\\"FDChangeDetails\\",\\"child_type_label\\":\\"Object\\",\\"element_mapping_provider\\":\\"com.glide.flow_design.action.data.FlowDesignVariableMapper\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"array.object\\",\\"child_type\\":\\"object\\",\\"order\\":\\"1\\",\\"max_length\\":\\"8000\\"}"}}',
+        sys_domain: 'global',
+        type: 'complex_object_schema',
+    },
+}
+
+const FDSTEPSTATUS: BuiltInComplexObject = {
+    $id: '73720df26f312010bf408271145b3600',
+    table: 'sys_complex_object',
+    data: {
+        name: 'FDSTEPSTATUS',
+        namespace: 'FlowDesigner',
+        scope_name: 'global',
+        serialized_content:
+            '{"FlowDesigner:FDSTEPSTATUS":{"code":"Integer","code.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"Integer\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"integer\\",\\"default_value\\":\\"\\",\\"label\\":\\"Code\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"1\\",\\"max_length\\":\\"40\\"}"},"message":"String","message.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"string\\",\\"default_value\\":null,\\"label\\":\\"Message\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"2\\",\\"max_length\\":\\"4000\\"}"}},"FlowDesigner:FDSTEPSTATUS.$type_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"Object\\",\\"co_type_name\\":\\"FDSTEPSTATUS\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"object\\",\\"default_value\\":\\"\\",\\"label\\":\\"Step Status\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"1\\",\\"max_length\\":\\"0\\"}"}}',
+        sys_domain: 'global',
+        type: 'complex_object_schema',
+    },
+}
+
+const FDACTIONSTATUS: BuiltInComplexObject = {
+    $id: 'b91cc65087022010226ca1bb36cb0be4',
+    table: 'sys_complex_object',
+    data: {
+        name: 'FDACTIONSTATUS',
+        namespace: 'FlowDesigner',
+        serialized_content:
+            '{"FlowDesigner:FDACTIONSTATUS":{"code":"Integer","code.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"Integer\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"integer\\",\\"default_value\\":\\"\\",\\"label\\":\\"Code\\",\\"action_error_output\\":\\"true\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"1\\",\\"max_length\\":\\"40\\"}"},"message":"String","message.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Message\\",\\"action_error_output\\":\\"true\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"2\\",\\"max_length\\":\\"4000\\"}"}},"FlowDesigner:FDACTIONSTATUS.$type_facets":{"SimpleMapFacet":"{\\"default_value\\":\\"\\",\\"label\\":\\"Action Status\\",\\"action_error_output\\":\\"true\\",\\"mandatory\\":\\"false\\",\\"uiUniqueId\\":\\"4adfb7bc-9d67-498d-88d0-8d6c3d584fed\\",\\"uiTypeLabel\\":\\"Object\\",\\"co_type_name\\":\\"FDACTIONSTATUS\\",\\"element_mapping_provider\\":\\"com.glide.flow_design.action.data.FlowDesignVariableMapper\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"object\\",\\"order\\":\\"1\\",\\"max_length\\":\\"65000\\"}"}}',
+        sys_domain: 'global',
+        sys_policy: 'read',
+        type: 'complex_object_schema',
+    },
+}
+
+const FDCollection: BuiltInComplexObject = {
+    $id: 'f4f014150f023300ecf0cc52ff767eed',
+    table: 'sys_complex_object',
+    data: {
+        name: 'FDCollection',
+        namespace: 'FlowDesigner',
+        scope_name: 'global',
+        serialized_content:
+            '{"FlowDesigner:FDCollection":{"$COCollectionField":[{"FDChangeDetails":{"previous_display_value":"String","previous_display_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Previous Display Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"4\\",\\"max_length\\":\\"0\\"}"},"previous_value":"String","previous_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Previous Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"2\\",\\"max_length\\":\\"0\\"}"},"current_display_value":"String","current_display_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Current Display Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"5\\",\\"max_length\\":\\"0\\"}"},"current_value":"String","current_value.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Current Value\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"3\\",\\"max_length\\":\\"0\\"}"},"field_name":"String","field_name.$field_facets":{"SimpleMapFacet":"{\\"uiTypeLabel\\":\\"String\\",\\"read_only\\":\\"false\\",\\"hint\\":\\"\\",\\"uiType\\":\\"string\\",\\"default_value\\":\\"\\",\\"label\\":\\"Field Name\\",\\"mandatory\\":\\"false\\",\\"order\\":\\"1\\",\\"max_length\\":\\"0\\"}"}}}],"$COCollectionField.$type_facets":{"SimpleMapFacet":"{\\"pwd2droppable\\":\\"true\\",\\"default_value\\":\\"\\",\\"label\\":\\"Changed Fields\\",\\"mandatory\\":\\"false\\",\\"child_name\\":\\"FDChangeDetails\\",\\"uiTypeLabel\\":\\"Array.Object\\",\\"co_type_name\\":\\"FDCollection\\",\\"child_label\\":\\"FDChangeDetails\\",\\"child_type_label\\":\\"Object\\",\\"element_mapping_provider\\":\\"com.glide.flow_design.action.data.FlowDesignVariableMapper\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"array.object\\",\\"child_type\\":\\"object\\",\\"order\\":\\"1\\",\\"max_length\\":\\"8000\\"}"},"$COCollectionField.$field_facets":{"SimpleMapFacet":"{\\"up-shift-collection-level\\":\\"true\\"}"}},"FlowDesigner:FDCollection.$type_facets":{"SimpleMapFacet":"{\\"pwd2droppable\\":\\"true\\",\\"default_value\\":\\"\\",\\"label\\":\\"Changed Fields\\",\\"mandatory\\":\\"false\\",\\"child_name\\":\\"FDChangeDetails\\",\\"uiTypeLabel\\":\\"Array.Object\\",\\"co_type_name\\":\\"FDCollection\\",\\"child_label\\":\\"FDChangeDetails\\",\\"child_type_label\\":\\"Object\\",\\"element_mapping_provider\\":\\"com.glide.flow_design.action.data.FlowDesignVariableMapper\\",\\"read_only\\":\\"false\\",\\"hint\\":null,\\"uiType\\":\\"array.object\\",\\"child_type\\":\\"object\\",\\"order\\":\\"1\\",\\"max_length\\":\\"8000\\"}"}}',
+        sys_domain: 'global',
+        type: 'complex_object_collection',
+    },
+}
+
+export const builtInComplexObjects: Record<string, BuiltInComplexObject> = {
+    FDChangeDetails,
+    FDSTEPSTATUS,
+    FDACTIONSTATUS,
+    FDCollection,
+}