execute_msg.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "ExecuteMsg",
  "description": "Defines all routes in which the contract can be executed.  These are all handled directly in the [contract file](crate::contract::execute).",
  "oneOf": [
    {
      "description": "This route is the primary interaction point for most consumers.  It consumes an asset uuid or scope address, the type of asset corresponding to that scope (heloc, mortgage, payable, etc), and, if all checks pass, attaches an attribute to the provided scope that stages the scope for verification of authenticity by the specified verifier in the request.  The attribute is attached based on the [base_contract_name](self::InitMsg::base_contract_name) specified in the contract, combined with the specified asset type in the request.  Ex: if [base_contract_name](self::InitMsg::base_contract_name) is \"asset\" and the asset type is \"myasset\", the attribute would be assigned under the name of \"myasset.asset\".  All available asset types are queryable, and stored in the contract as [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3) values.  After onboarding is completed, an [AssetScopeAttribute](super::types::asset_scope_attribute::AssetScopeAttribute) will be stored on the scope with an [AssetOnboardingStatus](super::types::asset_onboarding_status::AssetOnboardingStatus) of [Pending](super::types::asset_onboarding_status::AssetOnboardingStatus::Pending), indicating that the asset has been onboarded to the contract but is awaiting verification.",
      "type": "object",
      "required": [
        "onboard_asset"
      ],
      "properties": {
        "onboard_asset": {
          "type": "object",
          "required": [
            "asset_type",
            "identifier",
            "verifier_address"
          ],
          "properties": {
            "access_routes": {
              "description": "An optional parameter that allows the specification of a location to get the underlying asset data for the specified scope.  The [AccessRoute](super::types::access_route::AccessRoute) struct is very generic in its composition for the purpose of allowing various different solutions to fetching asset data.  If the verification process requires generic lookups for each onboarded asset, access routes on the scope's [AssetScopeAttribute](super::types::asset_scope_attribute::AssetScopeAttribute) can be leveraged to easily determine the source of the underlying data.  If these values are omitted at first, but later needed, they can always be added by using the [UpdateAccessRoutes](self::ExecuteMsg::UpdateAccessRoutes) execution route. Note: Access routes can specify a [name](super::types::access_route::AccessRoute::name) parameter, as well, to indicate the reason for the route, but this is entirely optional.",
              "type": [
                "array",
                "null"
              ],
              "items": {
                "$ref": "#/definitions/AccessRoute"
              }
            },
            "add_os_gateway_permission": {
              "description": "An optional parameter that will cause the emitted events to include values that signal to any [Object Store Gateway](https://github.com/FigureTechnologies/object-store-gateway) watching the events that the selected verifier has permission to inspect the identified scope's records via fetch routes.  This will only cause a gateway to grant permissions to a scope to which the gateway itself already has read permissions.  This essentially means that a key held by a gateway instance must have been used to store the scope's records in [Provenance Object Store](https://github.com/provenance-io/object-store).\n\nThis behavior defaults to TRUE.",
              "type": [
                "boolean",
                "null"
              ]
            },
            "asset_type": {
              "description": "A name that must directly match one of the contract's internal [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3) names.  Any request with a specified type not matching an asset definition will be rejected outright.",
              "type": "string"
            },
            "identifier": {
              "description": "Expects an [AssetIdentifier](super::types::asset_identifier::AssetIdentifier)-compatible [SerializedEnum](super::types::serialized_enum::SerializedEnum).",
              "allOf": [
                {
                  "$ref": "#/definitions/SerializedEnum"
                }
              ]
            },
            "verifier_address": {
              "description": "The bech32 address of a Verifier Account associated with the targeted [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3), within its nested vector of [VerifierDetailV2s](super::types::verifier_detail::VerifierDetailV2).",
              "type": "string"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "This route is specifically designed to allow a Verifier specified in the [AssetScopeAttribute](super::types::asset_scope_attribute::AssetScopeAttribute) of a [Provenance Metadata Scope](https://docs.provenance.io/modules/metadata-module#scope-data-structures) to indicate to the owner of the scope whether or not the content within the scope was valid or not.  The Verifier Account, after determining validity of the underlying data, will either mark the classification as a success or failure.  This route will reject all invokers except for Verifiers linked to a scope by the scope attribute, ensuring that only the verifier requested has the permission needed to classify an asset.  In this way, the process for verification ensures that all involved parties' requirements for security are satisfied.  In addition, the verifier used in the process is stored on the scope attribute after the fact, ensuring that external inspectors of the generated attribute can choose which verifications to acknowledge and which to disregard.",
      "type": "object",
      "required": [
        "verify_asset"
      ],
      "properties": {
        "verify_asset": {
          "type": "object",
          "required": [
            "asset_type",
            "identifier",
            "success"
          ],
          "properties": {
            "access_routes": {
              "description": "Like in the [OnboardAsset](self::ExecuteMsg::OnboardAsset) message, this parameter allows the verifier to provide access routes for the assets that it has successfully fetched from the underlying scope data.  This allows for the verifier to define its own subset of [AccessRoute](super::types::access_route::AccessRoute) values to allow actors with permission to easily fetch asset data from a new location, potentially without any Provenance Blockchain interaction, facilitating the process of data interaction.",
              "type": [
                "array",
                "null"
              ],
              "items": {
                "$ref": "#/definitions/AccessRoute"
              }
            },
            "asset_type": {
              "description": "The asset type this verification result is for",
              "type": "string"
            },
            "identifier": {
              "description": "Expects an [AssetIdentifier](super::types::asset_identifier::AssetIdentifier)-compatible [SerializedEnum](super::types::serialized_enum::SerializedEnum).",
              "allOf": [
                {
                  "$ref": "#/definitions/SerializedEnum"
                }
              ]
            },
            "message": {
              "description": "An optional string describing the result of the verification process.  If omitted, a standard message describing success or failure based on the value of `success` will be displayed in the [AssetScopeAttribute](super::types::asset_scope_attribute::AssetScopeAttribute).",
              "type": [
                "string",
                "null"
              ]
            },
            "success": {
              "description": "A boolean indicating whether or not verification was successful.  A value of `false` either indicates that the underlying data was fetched and it did not meet the requirements for a classified asset, or that a failure occurred during the verification process.  Note: Verifiers should be wary of returning false immediately on a code failure, as this incurs additional cost to the onboarding account.  Instead, it is recommended that verification implement some process that retries logic when exceptions or other code execution issues cause a failed verification.",
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address.__  This route allows a new [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3) value to be added to the contract's internal storage.  These asset definitions dictate which asset types are allowed to be onboarded, as well as which verifiers are tied to each asset type.  Each added asset definition must be unique in the following criteria: * Its [asset_type](super::types::asset_definition::AssetDefinitionV3::asset_type) value must not yet be registered in a different asset definition.",
      "type": "object",
      "required": [
        "add_asset_definition"
      ],
      "properties": {
        "add_asset_definition": {
          "type": "object",
          "required": [
            "asset_definition"
          ],
          "properties": {
            "asset_definition": {
              "description": "An asset definition input value defining all of the new [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3)'s values.  The execution route converts the incoming value to an asset definition.",
              "allOf": [
                {
                  "$ref": "#/definitions/AssetDefinitionInputV3"
                }
              ]
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address.__ This route allows an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3) value to be updated.  It works by matching the input's [asset_type](super::types::asset_definition::AssetDefinitionV3::asset_type) to an existing asset definition and overwriting the existing values.  If no asset definition exists for the given type, the request will be rejected.",
      "type": "object",
      "required": [
        "update_asset_definition"
      ],
      "properties": {
        "update_asset_definition": {
          "type": "object",
          "required": [
            "asset_definition"
          ],
          "properties": {
            "asset_definition": {
              "description": "An asset definition input value defining all of the updated [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3)'s values.  The execution route converts the incoming value to an asset definition.",
              "allOf": [
                {
                  "$ref": "#/definitions/AssetDefinitionInputV3"
                }
              ]
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address.__ This route toggles an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3) from enabled to disabled, or disabled to enabled.  When disabled, an asset definition will no longer allow new assets to be onboarded to the contract.  Existing assets already onboarded to the contract and in pending status will still be allowed to be verified, but new values will be rejected.  This same functionality could be achieved with an invocation of the [UpdateAssetDefinition](self::ExecuteMsg::UpdateAssetDefinition) route but swapping the [enabled](super::types::asset_definition::AssetDefinitionV3::enabled) value on the `asset_definition` parameter, but this route is significantly simpler and prevents accidental data mutation due to it not requiring the entirety of the definition's values.",
      "type": "object",
      "required": [
        "toggle_asset_definition"
      ],
      "properties": {
        "toggle_asset_definition": {
          "type": "object",
          "required": [
            "asset_type",
            "expected_result"
          ],
          "properties": {
            "asset_type": {
              "description": "The type of asset for which the definition's [enabled](super::types::asset_definition::AssetDefinitionV3::enabled) value will be toggled.  As the asset type value on each asset definition is guaranteed to be unique, this key is all that is needed to find the target definition.",
              "type": "string"
            },
            "expected_result": {
              "description": "The value of [enabled](super::types::asset_definition::AssetDefinitionV3::enabled) after the toggle takes place.  This value is required to ensure that multiple toggles executed in succession (either by accident or by various unrelated callers) will only be honored if the asset definition is in the intended state during the execution of the route.",
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address or the address of the verifier being updated.__ This route adds a new [VerifierDetailV2](super::types::verifier_detail::VerifierDetailV2) to an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3).  This route is intended to register new verifiers without the bulky requirements of the [UpdateAssetDefinition](self::ExecuteMsg::UpdateAssetDefinition) execution route.  This route will reject verifiers added with addresses that match any other verifiers on the target asset definition.",
      "type": "object",
      "required": [
        "add_asset_verifier"
      ],
      "properties": {
        "add_asset_verifier": {
          "type": "object",
          "required": [
            "asset_type",
            "verifier"
          ],
          "properties": {
            "asset_type": {
              "description": "The type of asset for which the new [VerifierDetailV2](super::types::verifier_detail::VerifierDetailV2) will be added. This must refer to an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3)'s [asset_type](super::types::asset_definition::AssetDefinitionV3::asset_type) value, or the request will be rejected.",
              "type": "string"
            },
            "verifier": {
              "description": "The new verifier detail to be added to the asset definition, with all of its required values.  No verifiers within the existing asset definition must have the same [address](super::types::verifier_detail::VerifierDetailV2::address) value of this parameter, or the request will be rejected.",
              "allOf": [
                {
                  "$ref": "#/definitions/VerifierDetailV2"
                }
              ]
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address.__ This route updates an existing [VerifierDetailV2](super::types::verifier_detail::VerifierDetailV2) in an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3).  This route is intended to be used when the values of a single verifier detail need to change, but not the entire asset definition.  The request will be rejected if the referenced asset definition is not present within the contract, or if a verifier does not exist within the asset definition that matches the address of the provided verifier data.",
      "type": "object",
      "required": [
        "update_asset_verifier"
      ],
      "properties": {
        "update_asset_verifier": {
          "type": "object",
          "required": [
            "asset_type",
            "verifier"
          ],
          "properties": {
            "asset_type": {
              "description": "The type of asset for which the [VerifierDetailV2](super::types::verifier_detail::VerifierDetailV2) will be updated. This must refer to an existing [AssetDefinitionV3](super::types::asset_definition::AssetDefinitionV3)'s [asset_type](super::types::asset_definition::AssetDefinitionV3::asset_type) value, or the request will be rejected.",
              "type": "string"
            },
            "verifier": {
              "description": "The updated verifier detail to be modified in the asset definition. An existing verifier detail within the target asset definition must have a matching [address](super::types::verifier_detail::VerifierDetailV2::address) value, or the request will be rejected.",
              "allOf": [
                {
                  "$ref": "#/definitions/VerifierDetailV2"
                }
              ]
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address OR to the owner of the access routes being updated.__ This route will swap all existing access routes for a specific owner for a specific scope to the provided values. These access routes either correspond to those created during the onboarding process, or those created during the verification process.",
      "type": "object",
      "required": [
        "update_access_routes"
      ],
      "properties": {
        "update_access_routes": {
          "type": "object",
          "required": [
            "access_routes",
            "asset_type",
            "identifier",
            "owner_address"
          ],
          "properties": {
            "access_routes": {
              "description": "A vector of [AccessRoute](super::types::access_route::AccessRoute) to be used instead of the existing routes. If other existing routes need to be maintained and the updated is intended to simply add a new route, then the existing routes need to be included in the request alongside the new route(s).",
              "type": "array",
              "items": {
                "$ref": "#/definitions/AccessRoute"
              }
            },
            "asset_type": {
              "description": "The asset type to update access routes for",
              "type": "string"
            },
            "identifier": {
              "description": "Expects an [AssetIdentifier](super::types::asset_identifier::AssetIdentifier)-compatible [SerializedEnum](super::types::serialized_enum::SerializedEnum).",
              "allOf": [
                {
                  "$ref": "#/definitions/SerializedEnum"
                }
              ]
            },
            "owner_address": {
              "description": "Corresponds to the bech32 address of the account that originally created the [AccessRoutes](super::types::access_route::AccessRoute). These values can be found in the [AccessDefinition](super::types::access_definition::AccessDefinition) of the [AssetScopeAttribute](super::types::asset_scope_attribute::AssetScopeAttribute) tied to a scope after the onboarding process occurs.",
              "type": "string"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    {
      "description": "__This route is only accessible to the contract's admin address.__ This route facilitates the removal of bad data. IMPORTANT: If an asset definition is completely removed, all contract references to it will fail to function.  This can cause assets currently in the onboarding process for a deleted type to have failures when interactions occur with them.  This functionality should only be used for an unused type!",
      "type": "object",
      "required": [
        "delete_asset_definition"
      ],
      "properties": {
        "delete_asset_definition": {
          "type": "object",
          "required": [
            "asset_type"
          ],
          "properties": {
            "asset_type": {
              "description": "The asset type to delete the definition for",
              "type": "string"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    }
  ],
  "definitions": {
    "AccessRoute": {
      "description": "Defines a method of obtaining underlying asset data for a scope.",
      "type": "object",
      "required": [
        "route"
      ],
      "properties": {
        "name": {
          "description": "An optional name parameter, allowing the creator of the route to give it a definition or to label it for external resources to identify it.",
          "type": [
            "string",
            "null"
          ]
        },
        "route": {
          "description": "A path to a resource that can provide underlying asset data for a scope.  Can be anything: http path, grpc, etc.",
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "AssetDefinitionInputV3": {
      "description": "Allows the user to optionally specify the enabled flag on an asset definition, versus forcing it to be added manually on every request, when it will likely always be specified as `true`.",
      "type": "object",
      "required": [
        "asset_type",
        "verifiers"
      ],
      "properties": {
        "asset_type": {
          "description": "The name of the asset associated with the definition.  This value must be unique across all instances persisted in contract storage, or requests to add will be rejected.",
          "type": "string"
        },
        "bind_name": {
          "description": "Whether or not to bind a Provenance Blockchain Name Module name to this contract when this struct is used to add a new asset type to the contract.  If this value is omitted OR set to true in a request that adds an asset definition, the name derived by combining the [base_contract_name](crate::core::state::StateV2::base_contract_name) and the `asset_type` will be bound to the contract.  For example, if the base name is \"pb\" and the asset type is \"myasset,\" the resulting bound name would be \"myasset.pb\".",
          "type": [
            "boolean",
            "null"
          ]
        },
        "display_name": {
          "description": "A pretty human-readable name for this asset type (vs a typically snake_case asset_type name)",
          "type": [
            "string",
            "null"
          ]
        },
        "enabled": {
          "description": "Indicates whether or not the asset definition is enabled for use in the contract.  If disabled, requests to onboard assets of this type will be rejected.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "verifiers": {
          "description": "Individual verifier definitions.  There can be many verifiers for a single asset type.  Each value must have a unique `address` property or requests to add will be rejected.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/VerifierDetailV2"
          }
        }
      },
      "additionalProperties": false
    },
    "EntityDetail": {
      "description": "Various fields describing an entity, which could be an organization, account, etc.",
      "type": "object",
      "properties": {
        "description": {
          "description": "A short description of the entity's purpose.",
          "type": [
            "string",
            "null"
          ]
        },
        "home_url": {
          "description": "A web link that can send observers to the organization that the entity belongs to.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "description": "A short name describing the entity.",
          "type": [
            "string",
            "null"
          ]
        },
        "source_url": {
          "description": "A web link that can send observers to the source code of the entity for increased transparency.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "FeeDestinationV2": {
      "description": "Defines an external account designated as a recipient of funds during the verification process.",
      "type": "object",
      "required": [
        "address",
        "fee_amount"
      ],
      "properties": {
        "address": {
          "description": "The Provenance Blockchain bech32 address belonging to the account.",
          "type": "string"
        },
        "entity_detail": {
          "description": "An optional set of fields that define the fee destination, including its name and home URL location.",
          "anyOf": [
            {
              "$ref": "#/definitions/EntityDetail"
            },
            {
              "type": "null"
            }
          ]
        },
        "fee_amount": {
          "description": "The amount to be distributed to this account from the designated total [onboarding_cost](super::verifier_detail::VerifierDetailV2::onboarding_cost) of the containing [VerifierDetailV2](super::verifier_detail::VerifierDetailV2).  This number should always sum with the other fee destinations to be less than or at most equal to the total onboarding cost.",
          "allOf": [
            {
              "$ref": "#/definitions/Uint128"
            }
          ]
        }
      },
      "additionalProperties": false
    },
    "OnboardingCost": {
      "description": "Defines costs used to onboard an asset to the contract for classification.",
      "type": "object",
      "required": [
        "cost",
        "fee_destinations"
      ],
      "properties": {
        "cost": {
          "description": "The amount of coin to be paid when an asset is sent to the [onboard_asset execute function](crate::execute::onboard_asset::onboard_asset).",
          "allOf": [
            {
              "$ref": "#/definitions/Uint128"
            }
          ]
        },
        "fee_destinations": {
          "description": "Any specific fee destinations that should be sent to sources other than the selected [verifier](super::verifier_detail::VerifierDetailV2).",
          "type": "array",
          "items": {
            "$ref": "#/definitions/FeeDestinationV2"
          }
        }
      },
      "additionalProperties": false
    },
    "SerializedEnum": {
      "description": "There is a bug in cosmwasm 1.0.0's interaction with serde-json-wasm that causes floating point operations to be added into the compiled wasm, so the previous solution of using things like AssetIdentifier directly and specifying them with a tag and content param in their serde annotation is impossible as of 1.0.0.  This solution will allow existing requests to remain identical, but not generate floating point errors.  It makes the schema less useful, but it's a hack to fix a bug, so...\n\nIt's also worth noting that this solution can only create enum switches that have Strings as their values.  Anything different will not work for this solution and will require further adaptation and hackery.",
      "type": "object",
      "required": [
        "type",
        "value"
      ],
      "properties": {
        "type": {
          "description": "Specifies the type of enum to deserialize into. Maps into one of the values specified in the impl for this struct.",
          "type": "string"
        },
        "value": {
          "description": "Specifies the string value to be used for the type.",
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "SubsequentClassificationDetail": {
      "description": "The root subsequent classifications node for a [VerifierDetailV2](super::verifier_detail::VerifierDetailV2). Contains the default subsequent costs for onboarding an asset with this verifier after already classifying it as a different type with the same verifier.",
      "type": "object",
      "properties": {
        "applicable_asset_types": {
          "description": "Specifies the asset types that an asset can be to have the subsequent classification cost apply to them.  If an asset has been classified as any of the types in this list, the cost will be used.  If the list is supplied as a None variant, any subsequent classifications will use the cost.  This value will be rejected if it is supplied as an empty vector.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "cost": {
          "description": "The onboarding cost to use when classifying an asset using the associated verifier after having already classified it as a different type with the same verifier.  If not set, the default verifier costs are used.",
          "anyOf": [
            {
              "$ref": "#/definitions/OnboardingCost"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "additionalProperties": false
    },
    "Uint128": {
      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
      "type": "string"
    },
    "VerifierDetailV2": {
      "description": "Defines the fees and addresses for a single verifier account for an [AssetDefinitionV3](super::asset_definition::AssetDefinitionV3).",
      "type": "object",
      "required": [
        "address",
        "fee_destinations",
        "onboarding_cost",
        "onboarding_denom"
      ],
      "properties": {
        "address": {
          "description": "The Provenance Blockchain bech32 address of the verifier account.",
          "type": "string"
        },
        "entity_detail": {
          "description": "An optional set of fields that define the verifier, including its name and home URL location.",
          "anyOf": [
            {
              "$ref": "#/definitions/EntityDetail"
            },
            {
              "type": "null"
            }
          ]
        },
        "fee_destinations": {
          "description": "Each account that should receive fees when onboarding a new scope to the contract. All of these destinations' individual [fee_amount](super::fee_destination::FeeDestinationV2::fee_amount) properties should sum to an amount less than or equal to the [onboarding_cost](super::verifier_detail::VerifierDetailV2::onboarding_cost). Amounts not precisely equal in sum will cause this verifier detail to be considered invalid and rejected in requests that include it.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/FeeDestinationV2"
          }
        },
        "onboarding_cost": {
          "description": "The total amount charged to use the onboarding process of this verifier.",
          "allOf": [
            {
              "$ref": "#/definitions/Uint128"
            }
          ]
        },
        "onboarding_denom": {
          "description": "The coin denomination used for this onboarding process.",
          "type": "string"
        },
        "retry_cost": {
          "description": "Defines the cost to use in place of the root [onboarding_cost](self::VerifierDetailV2::onboarding_cost) and [fee_destinations](self::VerifierDetailV2::fee_destinations) when retrying classification for a failed verification.  If not present, the original values used for the first verification will be used.",
          "anyOf": [
            {
              "$ref": "#/definitions/OnboardingCost"
            },
            {
              "type": "null"
            }
          ]
        },
        "subsequent_classification_detail": {
          "description": "An optional set of fields that define behaviors when classification is being run for an asset that is already classified as a different type.",
          "anyOf": [
            {
              "$ref": "#/definitions/SubsequentClassificationDetail"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "additionalProperties": false
    }
  }
}