{
    "source": "core/types/src/index.ts",
    "name": "Flow",
    "type": "object",
    "properties": {
        "id": {
            "required": true,
            "node": {
                "type": "string",
                "title": "Flow.id",
                "description": "A unique identifier for the flow"
            }
        },
        "views": {
            "required": false,
            "node": {
                "type": "array",
                "elementType": {
                    "source": "core/types/src/index.ts",
                    "name": "View<T>",
                    "type": "conditional",
                    "check": {
                        "left": {
                            "type": "unknown"
                        },
                        "right": {
                            "type": "ref",
                            "ref": "Asset",
                            "property": "validation"
                        }
                    },
                    "value": {
                        "true": {
                            "type": "and",
                            "and": [
                                {
                                    "type": "ref",
                                    "ref": "T"
                                },
                                {
                                    "type": "object",
                                    "properties": {
                                        "validation": {
                                            "required": false,
                                            "node": {
                                                "type": "array",
                                                "elementType": {
                                                    "name": "Validation.CrossfieldReference",
                                                    "type": "object",
                                                    "properties": {
                                                        "type": {
                                                            "required": true,
                                                            "node": {
                                                                "type": "string",
                                                                "title": "Reference.type",
                                                                "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                            }
                                                        },
                                                        "message": {
                                                            "required": false,
                                                            "node": {
                                                                "type": "string",
                                                                "title": "Reference.message",
                                                                "description": "An optional means of overriding the default message if the validation is triggered"
                                                            }
                                                        },
                                                        "severity": {
                                                            "required": false,
                                                            "node": {
                                                                "name": "Severity",
                                                                "type": "or",
                                                                "or": [
                                                                    {
                                                                        "type": "string",
                                                                        "const": "error"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "warning"
                                                                    }
                                                                ],
                                                                "title": "Reference.severity",
                                                                "description": "An optional means of overriding the default severity of the validation if triggered"
                                                            }
                                                        },
                                                        "trigger": {
                                                            "required": false,
                                                            "node": {
                                                                "name": "Trigger",
                                                                "type": "or",
                                                                "or": [
                                                                    {
                                                                        "type": "string",
                                                                        "const": "navigation"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "change"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "load"
                                                                    }
                                                                ],
                                                                "title": "Reference.trigger",
                                                                "description": "When to run this particular validation"
                                                            }
                                                        },
                                                        "dataTarget": {
                                                            "required": false,
                                                            "node": {
                                                                "type": "never",
                                                                "title": "CrossfieldReference.dataTarget",
                                                                "description": "Cross-field references and validation must run against the default (deformatted) value"
                                                            }
                                                        },
                                                        "displayTarget": {
                                                            "required": false,
                                                            "node": {
                                                                "name": "DisplayTarget",
                                                                "type": "or",
                                                                "or": [
                                                                    {
                                                                        "type": "string",
                                                                        "const": "page"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "section"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "field"
                                                                    }
                                                                ],
                                                                "title": "Reference.displayTarget",
                                                                "description": "Where the error should be displayed"
                                                            }
                                                        },
                                                        "blocking": {
                                                            "required": false,
                                                            "node": {
                                                                "type": "or",
                                                                "or": [
                                                                    {
                                                                        "type": "boolean",
                                                                        "title": "Reference.blocking"
                                                                    },
                                                                    {
                                                                        "type": "string",
                                                                        "const": "once"
                                                                    }
                                                                ],
                                                                "title": "Reference.blocking",
                                                                "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                                "default": "- true for errors, 'once' for warnings"
                                                            }
                                                        },
                                                        "ref": {
                                                            "required": false,
                                                            "node": {
                                                                "type": "ref",
                                                                "ref": "Binding",
                                                                "title": "CrossfieldReference.ref",
                                                                "description": "The binding to associate this validation with"
                                                            }
                                                        }
                                                    },
                                                    "additionalProperties": {
                                                        "type": "unknown"
                                                    },
                                                    "title": "CrossfieldReference"
                                                },
                                                "title": "validation",
                                                "description": "Each view can optionally supply a list of validations to run against a particular view"
                                            }
                                        }
                                    },
                                    "additionalProperties": false
                                }
                            ]
                        },
                        "false": {
                            "type": "ref",
                            "ref": "T"
                        }
                    },
                    "title": "View",
                    "genericTokens": [
                        {
                            "symbol": "T",
                            "constraints": {
                                "type": "ref",
                                "ref": "Asset"
                            },
                            "default": {
                                "type": "ref",
                                "ref": "Asset"
                            }
                        }
                    ]
                },
                "title": "Flow.views",
                "description": "A list of views (each with an ID) that can be shown to a user"
            }
        },
        "schema": {
            "required": false,
            "node": {
                "name": "Schema.Schema",
                "type": "object",
                "properties": {
                    "ROOT": {
                        "required": true,
                        "node": {
                            "name": "Node",
                            "type": "object",
                            "properties": {},
                            "additionalProperties": {
                                "name": "DataTypes",
                                "type": "or",
                                "or": [
                                    {
                                        "name": "DataType",
                                        "type": "object",
                                        "properties": {
                                            "type": {
                                                "required": true,
                                                "node": {
                                                    "type": "string",
                                                    "title": "DataType.type",
                                                    "description": "The reference of the base type to use"
                                                }
                                            },
                                            "validation": {
                                                "required": false,
                                                "node": {
                                                    "type": "array",
                                                    "elementType": {
                                                        "name": "Validation.Reference",
                                                        "type": "object",
                                                        "properties": {
                                                            "type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.type",
                                                                    "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                                }
                                                            },
                                                            "message": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.message",
                                                                    "description": "An optional means of overriding the default message if the validation is triggered"
                                                                }
                                                            },
                                                            "severity": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Severity",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "error"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "warning"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.severity",
                                                                    "description": "An optional means of overriding the default severity of the validation if triggered"
                                                                }
                                                            },
                                                            "trigger": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Trigger",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "navigation"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "change"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "load"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.trigger",
                                                                    "description": "When to run this particular validation"
                                                                }
                                                            },
                                                            "dataTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "formatted"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "deformatted"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.dataTarget",
                                                                    "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                                }
                                                            },
                                                            "displayTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "DisplayTarget",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "page"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "section"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "field"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.displayTarget",
                                                                    "description": "Where the error should be displayed"
                                                                }
                                                            },
                                                            "blocking": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "boolean",
                                                                            "title": "Reference.blocking"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "once"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.blocking",
                                                                    "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                                    "default": "- true for errors, 'once' for warnings"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "Reference",
                                                        "description": "A reference to a validation object"
                                                    },
                                                    "title": "DataType.validation",
                                                    "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                                }
                                            },
                                            "format": {
                                                "required": false,
                                                "node": {
                                                    "name": "Formatting.Reference",
                                                    "type": "object",
                                                    "properties": {
                                                        "type": {
                                                            "required": true,
                                                            "node": {
                                                                "type": "string",
                                                                "title": "Reference.type",
                                                                "description": "The name of the formatter (and de-formatter) to use"
                                                            }
                                                        }
                                                    },
                                                    "additionalProperties": {
                                                        "type": "unknown"
                                                    },
                                                    "title": "DataType.format",
                                                    "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                                }
                                            },
                                            "default": {
                                                "required": false,
                                                "node": {
                                                    "type": "ref",
                                                    "ref": "T",
                                                    "title": "DataType.default",
                                                    "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                                }
                                            }
                                        },
                                        "additionalProperties": {
                                            "type": "unknown"
                                        },
                                        "title": "DataType",
                                        "description": "Each prop in the object can have a specific DataType",
                                        "genericTokens": [
                                            {
                                                "symbol": "T",
                                                "constraints": {
                                                    "type": "any"
                                                },
                                                "default": {
                                                    "type": "unknown"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        "name": "RecordType",
                                        "type": "object",
                                        "properties": {
                                            "type": {
                                                "required": true,
                                                "node": {
                                                    "type": "string",
                                                    "title": "DataType.type",
                                                    "description": "The reference of the base type to use"
                                                }
                                            },
                                            "validation": {
                                                "required": false,
                                                "node": {
                                                    "type": "array",
                                                    "elementType": {
                                                        "name": "Validation.Reference",
                                                        "type": "object",
                                                        "properties": {
                                                            "type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.type",
                                                                    "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                                }
                                                            },
                                                            "message": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.message",
                                                                    "description": "An optional means of overriding the default message if the validation is triggered"
                                                                }
                                                            },
                                                            "severity": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Severity",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "error"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "warning"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.severity",
                                                                    "description": "An optional means of overriding the default severity of the validation if triggered"
                                                                }
                                                            },
                                                            "trigger": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Trigger",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "navigation"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "change"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "load"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.trigger",
                                                                    "description": "When to run this particular validation"
                                                                }
                                                            },
                                                            "dataTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "formatted"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "deformatted"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.dataTarget",
                                                                    "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                                }
                                                            },
                                                            "displayTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "DisplayTarget",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "page"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "section"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "field"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.displayTarget",
                                                                    "description": "Where the error should be displayed"
                                                                }
                                                            },
                                                            "blocking": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "boolean",
                                                                            "title": "Reference.blocking"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "once"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.blocking",
                                                                    "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                                    "default": "- true for errors, 'once' for warnings"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "Reference",
                                                        "description": "A reference to a validation object"
                                                    },
                                                    "title": "DataType.validation",
                                                    "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                                }
                                            },
                                            "format": {
                                                "required": false,
                                                "node": {
                                                    "name": "Formatting.Reference",
                                                    "type": "object",
                                                    "properties": {
                                                        "type": {
                                                            "required": true,
                                                            "node": {
                                                                "type": "string",
                                                                "title": "Reference.type",
                                                                "description": "The name of the formatter (and de-formatter) to use"
                                                            }
                                                        }
                                                    },
                                                    "additionalProperties": {
                                                        "type": "unknown"
                                                    },
                                                    "title": "DataType.format",
                                                    "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                                }
                                            },
                                            "default": {
                                                "required": false,
                                                "node": {
                                                    "type": "ref",
                                                    "ref": "T",
                                                    "title": "DataType.default",
                                                    "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                                }
                                            },
                                            "isRecord": {
                                                "required": true,
                                                "node": {
                                                    "type": "boolean",
                                                    "title": "RecordType.isRecord",
                                                    "description": "boolean to define if its a record"
                                                }
                                            },
                                            "isArray": {
                                                "required": false,
                                                "node": {
                                                    "type": "never",
                                                    "title": "RecordType.isArray",
                                                    "description": "This property is mutually exclusive with RecordType and can not be used with ArrayType"
                                                }
                                            }
                                        },
                                        "additionalProperties": {
                                            "type": "unknown"
                                        },
                                        "title": "RecordType",
                                        "description": "Determines if the Datatype is a record object"
                                    },
                                    {
                                        "name": "ArrayType",
                                        "type": "object",
                                        "properties": {
                                            "type": {
                                                "required": true,
                                                "node": {
                                                    "type": "string",
                                                    "title": "DataType.type",
                                                    "description": "The reference of the base type to use"
                                                }
                                            },
                                            "validation": {
                                                "required": false,
                                                "node": {
                                                    "type": "array",
                                                    "elementType": {
                                                        "name": "Validation.Reference",
                                                        "type": "object",
                                                        "properties": {
                                                            "type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.type",
                                                                    "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                                }
                                                            },
                                                            "message": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "Reference.message",
                                                                    "description": "An optional means of overriding the default message if the validation is triggered"
                                                                }
                                                            },
                                                            "severity": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Severity",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "error"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "warning"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.severity",
                                                                    "description": "An optional means of overriding the default severity of the validation if triggered"
                                                                }
                                                            },
                                                            "trigger": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "Trigger",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "navigation"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "change"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "load"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.trigger",
                                                                    "description": "When to run this particular validation"
                                                                }
                                                            },
                                                            "dataTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "formatted"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "deformatted"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.dataTarget",
                                                                    "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                                }
                                                            },
                                                            "displayTarget": {
                                                                "required": false,
                                                                "node": {
                                                                    "name": "DisplayTarget",
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "string",
                                                                            "const": "page"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "section"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "field"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.displayTarget",
                                                                    "description": "Where the error should be displayed"
                                                                }
                                                            },
                                                            "blocking": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "boolean",
                                                                            "title": "Reference.blocking"
                                                                        },
                                                                        {
                                                                            "type": "string",
                                                                            "const": "once"
                                                                        }
                                                                    ],
                                                                    "title": "Reference.blocking",
                                                                    "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                                    "default": "- true for errors, 'once' for warnings"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "Reference",
                                                        "description": "A reference to a validation object"
                                                    },
                                                    "title": "DataType.validation",
                                                    "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                                }
                                            },
                                            "format": {
                                                "required": false,
                                                "node": {
                                                    "name": "Formatting.Reference",
                                                    "type": "object",
                                                    "properties": {
                                                        "type": {
                                                            "required": true,
                                                            "node": {
                                                                "type": "string",
                                                                "title": "Reference.type",
                                                                "description": "The name of the formatter (and de-formatter) to use"
                                                            }
                                                        }
                                                    },
                                                    "additionalProperties": {
                                                        "type": "unknown"
                                                    },
                                                    "title": "DataType.format",
                                                    "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                                }
                                            },
                                            "default": {
                                                "required": false,
                                                "node": {
                                                    "type": "ref",
                                                    "ref": "T",
                                                    "title": "DataType.default",
                                                    "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                                }
                                            },
                                            "isArray": {
                                                "required": true,
                                                "node": {
                                                    "type": "boolean",
                                                    "title": "ArrayType.isArray",
                                                    "description": "boolean to define if its an array"
                                                }
                                            },
                                            "isRecord": {
                                                "required": false,
                                                "node": {
                                                    "type": "never",
                                                    "title": "ArrayType.isRecord",
                                                    "description": "This property is mutually exclusive with ArrayType and can not be used with RecordType"
                                                }
                                            }
                                        },
                                        "additionalProperties": {
                                            "type": "unknown"
                                        },
                                        "title": "ArrayType",
                                        "description": "Determines if the DataType is an Array Object"
                                    }
                                ],
                                "title": "DataTypes"
                            },
                            "title": "Schema.ROOT",
                            "description": "The ROOT object is the top level object to use"
                        }
                    }
                },
                "additionalProperties": {
                    "name": "Node",
                    "type": "object",
                    "properties": {},
                    "additionalProperties": {
                        "name": "DataTypes",
                        "type": "or",
                        "or": [
                            {
                                "name": "DataType",
                                "type": "object",
                                "properties": {
                                    "type": {
                                        "required": true,
                                        "node": {
                                            "type": "string",
                                            "title": "DataType.type",
                                            "description": "The reference of the base type to use"
                                        }
                                    },
                                    "validation": {
                                        "required": false,
                                        "node": {
                                            "type": "array",
                                            "elementType": {
                                                "name": "Validation.Reference",
                                                "type": "object",
                                                "properties": {
                                                    "type": {
                                                        "required": true,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.type",
                                                            "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                        }
                                                    },
                                                    "message": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.message",
                                                            "description": "An optional means of overriding the default message if the validation is triggered"
                                                        }
                                                    },
                                                    "severity": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Severity",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "error"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "warning"
                                                                }
                                                            ],
                                                            "title": "Reference.severity",
                                                            "description": "An optional means of overriding the default severity of the validation if triggered"
                                                        }
                                                    },
                                                    "trigger": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Trigger",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "navigation"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "change"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "load"
                                                                }
                                                            ],
                                                            "title": "Reference.trigger",
                                                            "description": "When to run this particular validation"
                                                        }
                                                    },
                                                    "dataTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "formatted"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "deformatted"
                                                                }
                                                            ],
                                                            "title": "Reference.dataTarget",
                                                            "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                        }
                                                    },
                                                    "displayTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "DisplayTarget",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "page"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "section"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "field"
                                                                }
                                                            ],
                                                            "title": "Reference.displayTarget",
                                                            "description": "Where the error should be displayed"
                                                        }
                                                    },
                                                    "blocking": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "boolean",
                                                                    "title": "Reference.blocking"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "once"
                                                                }
                                                            ],
                                                            "title": "Reference.blocking",
                                                            "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                            "default": "- true for errors, 'once' for warnings"
                                                        }
                                                    }
                                                },
                                                "additionalProperties": {
                                                    "type": "unknown"
                                                },
                                                "title": "Reference",
                                                "description": "A reference to a validation object"
                                            },
                                            "title": "DataType.validation",
                                            "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                        }
                                    },
                                    "format": {
                                        "required": false,
                                        "node": {
                                            "name": "Formatting.Reference",
                                            "type": "object",
                                            "properties": {
                                                "type": {
                                                    "required": true,
                                                    "node": {
                                                        "type": "string",
                                                        "title": "Reference.type",
                                                        "description": "The name of the formatter (and de-formatter) to use"
                                                    }
                                                }
                                            },
                                            "additionalProperties": {
                                                "type": "unknown"
                                            },
                                            "title": "DataType.format",
                                            "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                        }
                                    },
                                    "default": {
                                        "required": false,
                                        "node": {
                                            "type": "ref",
                                            "ref": "T",
                                            "title": "DataType.default",
                                            "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                        }
                                    }
                                },
                                "additionalProperties": {
                                    "type": "unknown"
                                },
                                "title": "DataType",
                                "description": "Each prop in the object can have a specific DataType",
                                "genericTokens": [
                                    {
                                        "symbol": "T",
                                        "constraints": {
                                            "type": "any"
                                        },
                                        "default": {
                                            "type": "unknown"
                                        }
                                    }
                                ]
                            },
                            {
                                "name": "RecordType",
                                "type": "object",
                                "properties": {
                                    "type": {
                                        "required": true,
                                        "node": {
                                            "type": "string",
                                            "title": "DataType.type",
                                            "description": "The reference of the base type to use"
                                        }
                                    },
                                    "validation": {
                                        "required": false,
                                        "node": {
                                            "type": "array",
                                            "elementType": {
                                                "name": "Validation.Reference",
                                                "type": "object",
                                                "properties": {
                                                    "type": {
                                                        "required": true,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.type",
                                                            "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                        }
                                                    },
                                                    "message": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.message",
                                                            "description": "An optional means of overriding the default message if the validation is triggered"
                                                        }
                                                    },
                                                    "severity": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Severity",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "error"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "warning"
                                                                }
                                                            ],
                                                            "title": "Reference.severity",
                                                            "description": "An optional means of overriding the default severity of the validation if triggered"
                                                        }
                                                    },
                                                    "trigger": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Trigger",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "navigation"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "change"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "load"
                                                                }
                                                            ],
                                                            "title": "Reference.trigger",
                                                            "description": "When to run this particular validation"
                                                        }
                                                    },
                                                    "dataTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "formatted"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "deformatted"
                                                                }
                                                            ],
                                                            "title": "Reference.dataTarget",
                                                            "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                        }
                                                    },
                                                    "displayTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "DisplayTarget",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "page"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "section"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "field"
                                                                }
                                                            ],
                                                            "title": "Reference.displayTarget",
                                                            "description": "Where the error should be displayed"
                                                        }
                                                    },
                                                    "blocking": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "boolean",
                                                                    "title": "Reference.blocking"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "once"
                                                                }
                                                            ],
                                                            "title": "Reference.blocking",
                                                            "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                            "default": "- true for errors, 'once' for warnings"
                                                        }
                                                    }
                                                },
                                                "additionalProperties": {
                                                    "type": "unknown"
                                                },
                                                "title": "Reference",
                                                "description": "A reference to a validation object"
                                            },
                                            "title": "DataType.validation",
                                            "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                        }
                                    },
                                    "format": {
                                        "required": false,
                                        "node": {
                                            "name": "Formatting.Reference",
                                            "type": "object",
                                            "properties": {
                                                "type": {
                                                    "required": true,
                                                    "node": {
                                                        "type": "string",
                                                        "title": "Reference.type",
                                                        "description": "The name of the formatter (and de-formatter) to use"
                                                    }
                                                }
                                            },
                                            "additionalProperties": {
                                                "type": "unknown"
                                            },
                                            "title": "DataType.format",
                                            "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                        }
                                    },
                                    "default": {
                                        "required": false,
                                        "node": {
                                            "type": "ref",
                                            "ref": "T",
                                            "title": "DataType.default",
                                            "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                        }
                                    },
                                    "isRecord": {
                                        "required": true,
                                        "node": {
                                            "type": "boolean",
                                            "title": "RecordType.isRecord",
                                            "description": "boolean to define if its a record"
                                        }
                                    },
                                    "isArray": {
                                        "required": false,
                                        "node": {
                                            "type": "never",
                                            "title": "RecordType.isArray",
                                            "description": "This property is mutually exclusive with RecordType and can not be used with ArrayType"
                                        }
                                    }
                                },
                                "additionalProperties": {
                                    "type": "unknown"
                                },
                                "title": "RecordType",
                                "description": "Determines if the Datatype is a record object"
                            },
                            {
                                "name": "ArrayType",
                                "type": "object",
                                "properties": {
                                    "type": {
                                        "required": true,
                                        "node": {
                                            "type": "string",
                                            "title": "DataType.type",
                                            "description": "The reference of the base type to use"
                                        }
                                    },
                                    "validation": {
                                        "required": false,
                                        "node": {
                                            "type": "array",
                                            "elementType": {
                                                "name": "Validation.Reference",
                                                "type": "object",
                                                "properties": {
                                                    "type": {
                                                        "required": true,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.type",
                                                            "description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
                                                        }
                                                    },
                                                    "message": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "string",
                                                            "title": "Reference.message",
                                                            "description": "An optional means of overriding the default message if the validation is triggered"
                                                        }
                                                    },
                                                    "severity": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Severity",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "error"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "warning"
                                                                }
                                                            ],
                                                            "title": "Reference.severity",
                                                            "description": "An optional means of overriding the default severity of the validation if triggered"
                                                        }
                                                    },
                                                    "trigger": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "Trigger",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "navigation"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "change"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "load"
                                                                }
                                                            ],
                                                            "title": "Reference.trigger",
                                                            "description": "When to run this particular validation"
                                                        }
                                                    },
                                                    "dataTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "formatted"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "deformatted"
                                                                }
                                                            ],
                                                            "title": "Reference.dataTarget",
                                                            "description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
                                                        }
                                                    },
                                                    "displayTarget": {
                                                        "required": false,
                                                        "node": {
                                                            "name": "DisplayTarget",
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "string",
                                                                    "const": "page"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "section"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "field"
                                                                }
                                                            ],
                                                            "title": "Reference.displayTarget",
                                                            "description": "Where the error should be displayed"
                                                        }
                                                    },
                                                    "blocking": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "or",
                                                            "or": [
                                                                {
                                                                    "type": "boolean",
                                                                    "title": "Reference.blocking"
                                                                },
                                                                {
                                                                    "type": "string",
                                                                    "const": "once"
                                                                }
                                                            ],
                                                            "title": "Reference.blocking",
                                                            "description": "If the validation blocks navigation\ntrue/false - always/never block navigation\nonce - only block navigation if the validation has not been triggered before",
                                                            "default": "- true for errors, 'once' for warnings"
                                                        }
                                                    }
                                                },
                                                "additionalProperties": {
                                                    "type": "unknown"
                                                },
                                                "title": "Reference",
                                                "description": "A reference to a validation object"
                                            },
                                            "title": "DataType.validation",
                                            "description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
                                        }
                                    },
                                    "format": {
                                        "required": false,
                                        "node": {
                                            "name": "Formatting.Reference",
                                            "type": "object",
                                            "properties": {
                                                "type": {
                                                    "required": true,
                                                    "node": {
                                                        "type": "string",
                                                        "title": "Reference.type",
                                                        "description": "The name of the formatter (and de-formatter) to use"
                                                    }
                                                }
                                            },
                                            "additionalProperties": {
                                                "type": "unknown"
                                            },
                                            "title": "DataType.format",
                                            "description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
                                        }
                                    },
                                    "default": {
                                        "required": false,
                                        "node": {
                                            "type": "ref",
                                            "ref": "T",
                                            "title": "DataType.default",
                                            "description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
                                        }
                                    },
                                    "isArray": {
                                        "required": true,
                                        "node": {
                                            "type": "boolean",
                                            "title": "ArrayType.isArray",
                                            "description": "boolean to define if its an array"
                                        }
                                    },
                                    "isRecord": {
                                        "required": false,
                                        "node": {
                                            "type": "never",
                                            "title": "ArrayType.isRecord",
                                            "description": "This property is mutually exclusive with ArrayType and can not be used with RecordType"
                                        }
                                    }
                                },
                                "additionalProperties": {
                                    "type": "unknown"
                                },
                                "title": "ArrayType",
                                "description": "Determines if the DataType is an Array Object"
                            }
                        ],
                        "title": "DataTypes"
                    },
                    "title": "Node",
                    "description": "A Node describes a specific object in the tree"
                },
                "title": "Flow.schema",
                "description": "The schema for the supplied (or referenced data).\nThis is used for validation, formatting, etc"
            }
        },
        "data": {
            "required": false,
            "node": {
                "source": "core/types/src/index.ts",
                "name": "DataModel",
                "type": "record",
                "keyType": {
                    "type": "any"
                },
                "valueType": {
                    "type": "unknown"
                },
                "title": "Flow.data",
                "description": "Any initial data that the flow can use"
            }
        },
        "navigation": {
            "required": true,
            "node": {
                "source": "core/types/src/index.ts",
                "name": "Navigation",
                "type": "and",
                "and": [
                    {
                        "type": "object",
                        "properties": {
                            "BEGIN": {
                                "required": true,
                                "node": {
                                    "type": "string",
                                    "title": "BEGIN",
                                    "description": "The name of the Flow to begin on"
                                }
                            }
                        },
                        "additionalProperties": false
                    },
                    {
                        "type": "record",
                        "keyType": {
                            "type": "string"
                        },
                        "valueType": {
                            "type": "or",
                            "or": [
                                {
                                    "type": "string"
                                },
                                {
                                    "source": "core/types/src/index.ts",
                                    "name": "NavigationFlow",
                                    "type": "object",
                                    "properties": {
                                        "startState": {
                                            "required": true,
                                            "node": {
                                                "type": "string",
                                                "title": "NavigationFlow.startState",
                                                "description": "The first state to kick off the state machine"
                                            }
                                        },
                                        "onStart": {
                                            "required": false,
                                            "node": {
                                                "type": "or",
                                                "or": [
                                                    {
                                                        "type": "ref",
                                                        "ref": "Expression",
                                                        "title": "NavigationFlow.onStart"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "ExpressionObject",
                                                        "type": "object",
                                                        "properties": {
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "ref",
                                                                    "ref": "Expression",
                                                                    "title": "ExpressionObject.exp",
                                                                    "description": "The expression to run"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": false,
                                                        "title": "ExpressionObject",
                                                        "description": "An object with an expression in it"
                                                    }
                                                ],
                                                "title": "NavigationFlow.onStart",
                                                "description": "An optional expression to run when this Flow starts"
                                            }
                                        },
                                        "onEnd": {
                                            "required": false,
                                            "node": {
                                                "type": "or",
                                                "or": [
                                                    {
                                                        "type": "ref",
                                                        "ref": "Expression",
                                                        "title": "NavigationFlow.onEnd"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "ExpressionObject",
                                                        "type": "object",
                                                        "properties": {
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "ref",
                                                                    "ref": "Expression",
                                                                    "title": "ExpressionObject.exp",
                                                                    "description": "The expression to run"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": false,
                                                        "title": "ExpressionObject",
                                                        "description": "An object with an expression in it"
                                                    }
                                                ],
                                                "title": "NavigationFlow.onEnd",
                                                "description": "An optional expression to run when this Flow ends"
                                            }
                                        }
                                    },
                                    "additionalProperties": {
                                        "type": "or",
                                        "or": [
                                            {
                                                "type": "undefined"
                                            },
                                            {
                                                "type": "string"
                                            },
                                            {
                                                "type": "ref",
                                                "ref": "Expression"
                                            },
                                            {
                                                "source": "core/types/src/index.ts",
                                                "name": "ExpressionObject",
                                                "type": "object",
                                                "properties": {
                                                    "exp": {
                                                        "required": false,
                                                        "node": {
                                                            "type": "ref",
                                                            "ref": "Expression",
                                                            "title": "ExpressionObject.exp",
                                                            "description": "The expression to run"
                                                        }
                                                    }
                                                },
                                                "additionalProperties": false,
                                                "title": "ExpressionObject",
                                                "description": "An object with an expression in it"
                                            },
                                            {
                                                "source": "core/types/src/index.ts",
                                                "name": "NavigationFlowState",
                                                "type": "or",
                                                "or": [
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowViewState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "VIEW",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "title": "NavigationBaseState.exp",
                                                                    "type": "never"
                                                                }
                                                            },
                                                            "transitions": {
                                                                "required": true,
                                                                "node": {
                                                                    "source": "core/types/src/index.ts",
                                                                    "name": "NavigationFlowTransition",
                                                                    "type": "record",
                                                                    "keyType": {
                                                                        "type": "string"
                                                                    },
                                                                    "valueType": {
                                                                        "type": "string"
                                                                    },
                                                                    "title": "NavigationFlowTransitionableState.transitions",
                                                                    "description": "A mapping of transition-name to FlowState name"
                                                                }
                                                            },
                                                            "ref": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "NavigationFlowViewState.ref",
                                                                    "description": "An id corresponding to a view from the 'views' array"
                                                                }
                                                            },
                                                            "attributes": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "object",
                                                                    "properties": {},
                                                                    "additionalProperties": {
                                                                        "type": "any"
                                                                    },
                                                                    "title": "NavigationFlowViewState.attributes",
                                                                    "description": "View meta-properties"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "NavigationFlowViewState",
                                                        "description": "A state representing a view"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowEndState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "END",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "title": "NavigationBaseState.exp",
                                                                    "type": "never"
                                                                }
                                                            },
                                                            "outcome": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "NavigationFlowEndState.outcome",
                                                                    "description": "A description of _how_ the flow ended.\nIf this is a flow started from another flow, the outcome determines the flow transition"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "NavigationFlowEndState",
                                                        "description": "An END state of the flow."
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowFlowState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "FLOW",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "title": "NavigationBaseState.exp",
                                                                    "type": "never"
                                                                }
                                                            },
                                                            "transitions": {
                                                                "required": true,
                                                                "node": {
                                                                    "source": "core/types/src/index.ts",
                                                                    "name": "NavigationFlowTransition",
                                                                    "type": "record",
                                                                    "keyType": {
                                                                        "type": "string"
                                                                    },
                                                                    "valueType": {
                                                                        "type": "string"
                                                                    },
                                                                    "title": "NavigationFlowTransitionableState.transitions",
                                                                    "description": "A mapping of transition-name to FlowState name"
                                                                }
                                                            },
                                                            "ref": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "NavigationFlowFlowState.ref",
                                                                    "description": "A reference to a FLOW id state to run"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": false,
                                                        "title": "NavigationFlowFlowState"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowActionState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "ACTION",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "ref",
                                                                    "ref": "Expression",
                                                                    "title": "NavigationFlowActionState.exp",
                                                                    "description": "An expression to execute.\nThe return value determines the transition to take"
                                                                }
                                                            },
                                                            "transitions": {
                                                                "required": true,
                                                                "node": {
                                                                    "source": "core/types/src/index.ts",
                                                                    "name": "NavigationFlowTransition",
                                                                    "type": "record",
                                                                    "keyType": {
                                                                        "type": "string"
                                                                    },
                                                                    "valueType": {
                                                                        "type": "string"
                                                                    },
                                                                    "title": "NavigationFlowTransitionableState.transitions",
                                                                    "description": "A mapping of transition-name to FlowState name"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": false,
                                                        "title": "NavigationFlowActionState",
                                                        "description": "Action states execute an expression to determine the next state to transition to"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowAsyncActionState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "ASYNC_ACTION",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "ref",
                                                                    "ref": "Expression",
                                                                    "title": "NavigationFlowAsyncActionState.exp",
                                                                    "description": "An expression to execute.\nThe return value determines the transition to take"
                                                                }
                                                            },
                                                            "transitions": {
                                                                "required": true,
                                                                "node": {
                                                                    "source": "core/types/src/index.ts",
                                                                    "name": "NavigationFlowTransition",
                                                                    "type": "record",
                                                                    "keyType": {
                                                                        "type": "string"
                                                                    },
                                                                    "valueType": {
                                                                        "type": "string"
                                                                    },
                                                                    "title": "NavigationFlowTransitionableState.transitions",
                                                                    "description": "A mapping of transition-name to FlowState name"
                                                                }
                                                            },
                                                            "await": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "boolean",
                                                                    "title": "NavigationFlowAsyncActionState.await",
                                                                    "description": "Whether the expression(s) should be awaited before transitioning"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": false,
                                                        "title": "NavigationFlowAsyncActionState",
                                                        "description": "Action states execute an expression to determine the next state to transition to"
                                                    },
                                                    {
                                                        "source": "core/types/src/index.ts",
                                                        "name": "NavigationFlowExternalState",
                                                        "type": "object",
                                                        "properties": {
                                                            "_comment": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "CommentBase._comment",
                                                                    "description": "Add comments that will not be processing, but are useful for code explanation"
                                                                }
                                                            },
                                                            "state_type": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "const": "EXTERNAL",
                                                                    "title": "NavigationBaseState.state_type",
                                                                    "description": "A property to determine the type of state this is"
                                                                }
                                                            },
                                                            "onStart": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onStart"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onStart",
                                                                    "description": "An optional expression to run when this view renders"
                                                                }
                                                            },
                                                            "onEnd": {
                                                                "required": false,
                                                                "node": {
                                                                    "type": "or",
                                                                    "or": [
                                                                        {
                                                                            "type": "ref",
                                                                            "ref": "Expression",
                                                                            "title": "NavigationBaseState.onEnd"
                                                                        },
                                                                        {
                                                                            "source": "core/types/src/index.ts",
                                                                            "name": "ExpressionObject",
                                                                            "type": "object",
                                                                            "properties": {
                                                                                "exp": {
                                                                                    "required": false,
                                                                                    "node": {
                                                                                        "type": "ref",
                                                                                        "ref": "Expression",
                                                                                        "title": "ExpressionObject.exp",
                                                                                        "description": "The expression to run"
                                                                                    }
                                                                                }
                                                                            },
                                                                            "additionalProperties": false,
                                                                            "title": "ExpressionObject",
                                                                            "description": "An object with an expression in it"
                                                                        }
                                                                    ],
                                                                    "title": "NavigationBaseState.onEnd",
                                                                    "description": "An optional expression to run before view transition"
                                                                }
                                                            },
                                                            "exp": {
                                                                "required": false,
                                                                "node": {
                                                                    "title": "NavigationBaseState.exp",
                                                                    "type": "never"
                                                                }
                                                            },
                                                            "transitions": {
                                                                "required": true,
                                                                "node": {
                                                                    "source": "core/types/src/index.ts",
                                                                    "name": "NavigationFlowTransition",
                                                                    "type": "record",
                                                                    "keyType": {
                                                                        "type": "string"
                                                                    },
                                                                    "valueType": {
                                                                        "type": "string"
                                                                    },
                                                                    "title": "NavigationFlowTransitionableState.transitions",
                                                                    "description": "A mapping of transition-name to FlowState name"
                                                                }
                                                            },
                                                            "ref": {
                                                                "required": true,
                                                                "node": {
                                                                    "type": "string",
                                                                    "title": "NavigationFlowExternalState.ref",
                                                                    "description": "A reference for this external state"
                                                                }
                                                            }
                                                        },
                                                        "additionalProperties": {
                                                            "type": "unknown"
                                                        },
                                                        "title": "NavigationFlowExternalState",
                                                        "description": "External Flow states represent states in the FSM that can't be resolved internally in Player.\nThe flow will wait for the embedded application to manage moving to the next state via a transition"
                                                    }
                                                ],
                                                "title": "NavigationFlowState"
                                            }
                                        ]
                                    },
                                    "title": "NavigationFlow",
                                    "description": "A state machine in the navigation"
                                }
                            ]
                        }
                    }
                ],
                "title": "Flow.navigation",
                "description": "A state machine to drive a user through the experience"
            }
        }
    },
    "additionalProperties": {
        "type": "unknown"
    },
    "title": "Flow",
    "description": "The JSON payload for running Player",
    "genericTokens": [
        {
            "symbol": "T",
            "constraints": {
                "type": "ref",
                "ref": "Asset"
            },
            "default": {
                "type": "ref",
                "ref": "Asset"
            }
        }
    ]
}