coremsgs

Documentation

Index

• Variables

Variables

var (
	CoreSystemNSDescription = ffm("core.systemNSDescription", "FireFly system namespace (legacy - no longer used by newer versions)")

	APIParamsConfigRecordKeyUpdate          = ffm("api.params.configRecordKey.update", "The configuration key to update. This should use dot notation to reference a key documented in https://hyperledger.github.io/firefly/latest/reference/config/")
	APIParamsConfigRecordKeyGet             = ffm("api.params.configRecordKey.get", "The configuration key to get. This should use dot notation to reference a key documented in https://hyperledger.github.io/firefly/latest/reference/config/")
	APIParamsOperationIDGet                 = ffm("api.params.operationID.get", "The operation ID key to get")
	APIParamsOperationNamespacedID          = ffm("api.params.spiOperationID", "The operation ID as passed to the connector when the operation was performed, including the 'namespace:' prefix")
	APIParamsNamespace                      = ffm("api.params.namespace", "The namespace which scopes this request")
	APIParamsContractListenerNameOrID       = ffm("api.params.contractListenerNameOrID", "The contract listener name or ID")
	APIParamsContractListenerID             = ffm("api.params.contractListenerID", "The contract listener ID")
	APIParamsSubscriptionID                 = ffm("api.params.subscriptionID", "The subscription ID")
	APIParamsBatchID                        = ffm("api.params.batchId", "The batch ID")
	APIParamsBlockchainEventID              = ffm("api.params.blockchainEventID", "The blockchain event ID")
	APIParamsCollectionID                   = ffm("api.params.collectionID", "The collection ID")
	APIParamsContractAPIName                = ffm("api.params.contractAPIName", "The name of the contract API")
	APIParamsContractInterfaceName          = ffm("api.params.contractInterfaceName", "The name of the contract interface")
	APIParamsContractInterfaceVersion       = ffm("api.params.contractInterfaceVersion", "The version of the contract interface")
	APIParamsContractInterfaceID            = ffm("api.params.contractInterfaceID", "The ID of the contract interface")
	APIParamsContractInterfaceFetchChildren = ffm("api.params.contractInterfaceFetchChildren", "When set, the API will return the full FireFly Interface document including all methods, events, and parameters")
	APIParamsNSIncludeInitializing          = ffm("api.params.nsIncludeInitializing", "When set, the API will return namespaces even if they are not yet initialized, including in error cases where an initializationError is included")
	APIParamsBlobID                         = ffm("api.params.blobID", "The blob ID")
	APIParamsDataID                         = ffm("api.params.dataID", "The data item ID")
	APIParamsDatatypeName                   = ffm("api.params.datatypeName", "The name of the datatype")
	APIParamsDatatypeVersion                = ffm("api.params.datatypeVersion", "The version of the datatype")
	APIParamsDataParentPath                 = ffm("api.params.dataParentPath", "The parent path to query")
	APIParamsEventID                        = ffm("api.params.eventID", "The event ID")
	APIParamsFetchReferences                = ffm("api.params.fetchReferences", "When set, the API will return the record that this item references in its 'reference' field")
	APIParamsFetchReference                 = ffm("api.params.fetchReference", "When set, the API will return the record that this item references in its 'reference' field")
	APIParamsGroupHash                      = ffm("api.params.groupID", "The hash of the group")
	APIParamsFetchVerifiers                 = ffm("api.params.fetchVerifiers", "When set, the API will return the verifier for this identity")
	APIParamsIdentityID                     = ffm("api.params.identityID", "The identity ID, which is a UUID generated by FireFly")
	APIParamsMessageID                      = ffm("api.params.messageID", "The message ID")
	APIParamsDID                            = ffm("api.params.DID", "The identity DID")
	APIParamsNodeNameOrID                   = ffm("api.params.nodeNameOrID", "The name or ID of the node")
	APIParamsOrgNameOrID                    = ffm("api.params.orgNameOrID", "The name or ID of the org")
	APIParamsTokenAccountKey                = ffm("api.params.tokenAccountKey", "The key for the token account. The exact format may vary based on the token connector use")
	APIParamsTokenPoolNameOrID              = ffm("api.params.tokenPoolNameOrID", "The token pool name or ID")
	APIParamsTokenTransferFromOrTo          = ffm("api.params.tokenTransferFromOrTo", "The sending or receiving token account for a token transfer")
	APIParamsTokenTransferID                = ffm("api.params.tokenTransferID", "The token transfer ID")
	APIParamsTransactionID                  = ffm("api.params.transactionID", "The transaction ID")
	APIParamsVerifierHash                   = ffm("api.params.verifierID", "The hash of the verifier")
	APIParamsMethodPath                     = ffm("api.params.methodPath", "The name or uniquely generated path name of a method on a smart contract")
	APIParamsEventPath                      = ffm("api.params.eventPath", "The name or uniquely generated path name of a event on a smart contract")
	APIParamsInterfaceID                    = ffm("api.params.interfaceID", "The contract interface ID")
	APIParamsValidator                      = ffm("api.params.validator", "The validator type for this data item. Options are: \"json\", \"none\", or \"definition\"")
	APIParamsMetadata                       = ffm("api.params.metadata", "Metadata associated with this data item")
	APIParamsAutometa                       = ffm("api.params.autometa", "When set, FireFly will automatically generate JSON metadata with the upload details")
	APIParamsContractAPIID                  = ffm("api.params.contractAPIID", "The ID of the contract API")
	APIParamsFetchStatus                    = ffm("api.params.fetchStatus", "When set, the API will return additional status information if available")

	APIEndpointsAdminGetNamespaceByName = ffm("api.endpoints.adminGetNamespaceByName", "Gets a namespace by name")
	APIEndpointsAdminGetNamespaces      = ffm("api.endpoints.adminGetNamespaces", "List namespaces")
	APIEndpointsAdminGetOpByID          = ffm("api.endpoints.adminGetOpByID", "Gets an operation by ID")
	APIEndpointsAdminGetOps             = ffm("api.endpoints.adminGetOps", "Lists operations")
	APIEndpointsAdminPostReset          = ffm("api.endpoints.adminPostResetConfig", "Restarts FireFly Core HTTP servers and apply all configuration updates")
	APIEndpointsAdminPatchOpByID        = ffm("api.endpoints.adminPatchOpByID", "Updates an operation by ID")
	APIEndpointsAdminGetListenerByID    = ffm("api.endpoints.adminGetListenerByID", "Gets a contract listener by ID")
	APIEndpointsAdminGetListeners       = ffm("api.endpoints.adminGetListeners", "Lists contract listeners")

	APIEndpointsDeleteContractAPI               = ffm("api.endpoints.deleteContractAPI", "Delete a contract API")
	APIEndpointsDeleteContractInterface         = ffm("api.endpoints.deleteContractInterface", "Delete a contract interface")
	APIEndpointsDeleteContractListener          = ffm("api.endpoints.deleteContractListener", "Deletes a contract listener referenced by its name or its ID")
	APIEndpointsDeleteSubscription              = ffm("api.endpoints.deleteSubscription", "Deletes a subscription")
	APIEndpointsDeleteTokenPool                 = ffm("api.endpoints.deleteTokenPool", "Delete a token pool")
	APIEndpointsGetBatchBbyID                   = ffm("api.endpoints.getBatchByID", "Gets a message batch")
	APIEndpointsGetBatches                      = ffm("api.endpoints.getBatches", "Gets a list of message batches")
	APIEndpointsGetBlockchainEventByID          = ffm("api.endpoints.getBlockchainEventByID", "Gets a blockchain event")
	APIEndpointsListBlockchainEvents            = ffm("api.endpoints.getBlockchainEvents", "Gets a list of blockchain events")
	APIEndpointsGetChartHistogram               = ffm("api.endpoints.getChartHistogram", "Gets a JSON object containing statistics data that can be used to build a graphical representation of recent activity in a given database collection")
	APIEndpointsGetContractAPIByName            = ffm("api.endpoints.getContractAPIByName", "Gets information about a contract API, including the URLs for the OpenAPI Spec and Swagger UI for the API")
	APIEndpointsGetContractAPIs                 = ffm("api.endpoints.getContractAPIs", "Gets a list of contract APIs that have been published")
	APIEndpointsGetContractInterfaceNameVersion = ffm("api.endpoints.getContractInterfaceNameVersion", "Gets a contract interface by its name and version")
	APIEndpointsGetContractInterface            = ffm("api.endpoints.getContractInterface", "Gets a contract interface by its ID")
	APIEndpointsGetContractInterfaces           = ffm("api.endpoints.getContractInterfaces", "Gets a list of contract interfaces that have been published")
	APIEndpointsGetContractListenerByNameOrID   = ffm("api.endpoints.getContractListenerByNameOrID", "Gets a contract listener by its name or ID")
	APIEndpointsGetContractListeners            = ffm("api.endpoints.getContractListeners", "Gets a list of contract listeners")
	APIEndpointsGetDataBlob                     = ffm("api.endpoints.getDataBlob", "Downloads the original file that was previously uploaded or received")
	APIEndpointsGetDataValue                    = ffm("api.endpoints.getDataValue", "Downloads the JSON value of the data resource, without the associated metadata")
	APIEndpointsGetDataByID                     = ffm("api.endpoints.getDataByID", "Gets a data item by its ID, including metadata about this item")
	APIEndpointsDeleteData                      = ffm("api.endpoints.deleteData", "Deletes a data item by its ID, including metadata about this item")
	APIEndpointsGetDataMsgs                     = ffm("api.endpoints.getDataMsgs", "Gets a list of the messages associated with a data item")
	APIEndpointsGetData                         = ffm("api.endpoints.getData", "Gets a list of data items")
	APIEndpointsGetDataSubPaths                 = ffm("api.endpoints.getDataSubPaths", "Gets a list of path names of named blob data, underneath a given parent path ('/' path prefixes are automatically pre-prepended)")
	APIEndpointsGetDatatypeByName               = ffm("api.endpoints.getDatatypeByName", "Gets a datatype by its name and version")
	APIEndpointsGetDatatypes                    = ffm("api.endpoints.getDatatypes", "Gets a list of datatypes that have been published")
	APIEndpointsGetEventByID                    = ffm("api.endpoints.eventID", "Gets an event by its ID")
	APIEndpointsGetEvents                       = ffm("api.endpoints.getEvents", "Gets a list of events")
	APIEndpointsGetGroupByHash                  = ffm("api.endpoints.getGroupByHash", "Gets a group by its ID (hash)")
	APIEndpointsGetGroups                       = ffm("api.endpoints.getGroups", "Gets a list of groups")
	APIEndpointsGetIdentities                   = ffm("api.endpoints.getIdentities", "Gets a list of all identities that have been registered in the namespace")
	APIEndpointsGetIdentityByID                 = ffm("api.endpoints.getIdentityByID", "Gets an identity by its ID")
	APIEndpointsGetIdentityDID                  = ffm("api.endpoints.getIdentityDID", "Gets the DID for an identity based on its ID")
	APIEndpointsGetIdentityVerifiers            = ffm("api.endpoints.getIdentityVerifiers", "Gets the verifiers for an identity")
	APIEndpointsGetMsgByID                      = ffm("api.endpoints.getMsgByID", "Gets a message by its ID")
	APIEndpointsGetMsgData                      = ffm("api.endpoints.getMsgData", "Gets the list of data items that are attached to a message")
	APIEndpointsGetMsgEvents                    = ffm("api.endpoints.getMsgEvents", "Gets the list of events for a message")
	APIEndpointsGetMsgTxn                       = ffm("api.endpoints.getMsgTxn", "Gets the transaction for a message")
	APIEndpointsGetMsgs                         = ffm("api.endpoints.getMsgs", "Gets a list of messages")
	APIEndpointsGetNamespace                    = ffm("api.endpoints.getNamespace", "Gets a namespace")
	APIEndpointsGetNamespaces                   = ffm("api.endpoints.getNamespaces", "Gets a list of namespaces")
	APIEndpointsGetNetworkIdentityByDID         = ffm("api.endpoints.getNetworkIdentityByDID", "Gets an identity by its DID (deprecated - use /identities/{did} instead of /network/identities/{did})")
	APIEndpointsGetIdentityByDID                = ffm("api.endpoints.getIdentityByDID", "Gets an identity by its DID")
	APIEndpointsGetDIDDocByDID                  = ffm("api.endpoints.getDIDDocByDID", "Gets a DID document by its DID")
	APIEndpointsGetNetworkIdentities            = ffm("api.endpoints.getNetworkIdentities", "Gets the list of identities in the network (deprecated - use /identities instead of /network/identities")
	APIEndpointsGetNetworkNode                  = ffm("api.endpoints.getNetworkNode", "Gets information about a specific node in the network")
	APIEndpointsGetNetworkNodes                 = ffm("api.endpoints.getNetworkNodes", "Gets a list of nodes in the network")
	APIEndpointsGetNetworkOrg                   = ffm("api.endpoints.getNetworkOrg", "Gets information about a specific org in the network")
	APIEndpointsGetNetworkOrgs                  = ffm("api.endpoints.APIEndpointsGetNetworkOrgs", "Gets a list of orgs in the network")
	APIEndpointsGetOpByID                       = ffm("api.endpoints.getOpByID", "Gets an operation by ID")
	APIEndpointsGetOps                          = ffm("api.endpoints.getOps", "Gets a a list of operations")
	APIEndpointsGetStatusBatchManager           = ffm("api.endpoints.getStatusBatchManager", "Gets the status of the batch manager")
	APIEndpointsGetPins                         = ffm("api.endpoints.getPins", "Queries the list of pins received from the blockchain")
	APIEndpointsGetNextPins                     = ffm("api.endpoints.getNextPins", "Queries the list of next-pins that determine the next masked message sequence for each member of a privacy group, on each context/topic")
	APIEndpointsGetWebSockets                   = ffm("api.endpoints.getStatusWebSockets", "Gets a list of the current WebSocket connections to this node")
	APIEndpointsGetStatus                       = ffm("api.endpoints.getStatus", "Gets the status of this namespace")
	APIEndpointsGetMultipartyStatus             = ffm("api.endpoints.getMultipartyStatus", "Gets the registration status of this organization and node on the configured multiparty network")
	APIEndpointsGetSubscriptionByID             = ffm("api.endpoints.getSubscriptionByID", "Gets a subscription by its ID")
	APIEndpointsGetSubscriptionEventsFiltered   = ffm("api.endpoints.getSubscriptionEventsFiltered", "Gets a collection of events filtered by the subscription for further filtering")
	APIEndpointsGetSubscriptions                = ffm("api.endpoints.getSubscriptions", "Gets a list of subscriptions")
	APIEndpointsGetTokenAccountPools            = ffm("api.endpoints.getTokenAccountPools", "Gets a list of token pools that contain a given token account key")
	APIEndpointsGetTokenAccounts                = ffm("api.endpoints.getTokenAccounts", "Gets a list of token accounts")
	APIEndpointsGetTokenApprovals               = ffm("api.endpoints.getTokenApprovals", "Gets a list of token approvals")
	APIEndpointsGetTokenBalances                = ffm("api.endpoints.getTokenBalances", "Gets a list of token balances")
	APIEndpointsGetTokenConnectors              = ffm("api.endpoints.getTokenConnectors", "Gets the list of token connectors currently in use")
	APIEndpointsGetTokenPoolByNameOrID          = ffm("api.endpoints.getTokenPoolByNameOrID", "Gets a token pool by its name or its ID")
	APIEndpointsGetTokenPools                   = ffm("api.endpoints.getTokenPools", "Gets a list of token pools")
	APIEndpointsGetTokenTransferByID            = ffm("api.endpoints.getTokenTransferByID", "Gets a token transfer by its ID")
	APIEndpointsGetTokenTransfers               = ffm("api.endpoints.getTokenTransfers", "Gets a list of token transfers")
	APIEndpointsGetTxnBlockchainEvents          = ffm("api.endpoints.getTxnBlockchainEvents", "Gets a list blockchain events for a specific transaction")
	APIEndpointsGetTxnByID                      = ffm("api.endpoints.getTxnByID", "Gets a transaction by its ID")
	APIEndpointsGetTxnOps                       = ffm("api.endpoints.getTxnOps", "Gets a list of operations in a specific transaction")
	APIEndpointsGetTxnStatus                    = ffm("api.endpoints.getTxnStatus", "Gets the status of a transaction")
	APIEndpointsGetTxns                         = ffm("api.endpoints.getTxns", "Gets a list of transactions")
	APIEndpointsGetVerifierByHash               = ffm("api.endpoints.getVerifierByHash", "Gets a verifier by its hash")
	APIEndpointsGetVerifiers                    = ffm("api.endpoints.getVerifiers", "Gets a list of verifiers")
	APIEndpointsPatchUpdateIdentity             = ffm("api.endpoints.patchUpdateIdentity", "Updates an identity")
	APIEndpointsPostBatchCancel                 = ffm("api.endpoints.postBatchCancel", "Cancel a batch that has failed to dispatch")
	APIEndpointsPostContractDeploy              = ffm("api.endpoints.postContractDeploy", "Deploy a new smart contract")
	APIEndpointsPostContractAPIInvoke           = ffm("api.endpoints.postContractAPIInvoke", "Invokes a method on a smart contract API. Performs a blockchain transaction.")
	APIEndpointsPostContractAPIPublish          = ffm("api.endpoints.postContractAPIPublish", "Publish a contract API to all other members of the multiparty network")
	APIEndpointsPostContractAPIQuery            = ffm("api.endpoints.postContractAPIQuery", "Queries a method on a smart contract API. Performs a read-only query.")
	APIEndpointsPostContractInterfaceGenerate   = ffm("api.endpoints.postContractInterfaceGenerate", "A convenience method to convert a blockchain specific smart contract format into a FireFly Interface format. The specific blockchain plugin in use must support this functionality.")
	APIEndpointsPostContractInterfaceInvoke     = ffm("api.endpoints.postContractInterfaceInvoke", "Invokes a method on a smart contract that matches a given contract interface. Performs a blockchain transaction.")
	APIEndpointsPostContractInterfaceQuery      = ffm("api.endpoints.postContractInterfaceQuery", "Queries a method on a smart contract that matches a given contract interface. Performs a read-only query.")
	APIEndpointsPostContractInterfacePublish    = ffm("api.endpoints.postContractInterfacePublish", "Publish a contract interface to all other members of the multiparty network")
	APIEndpointsPostContractInvoke              = ffm("api.endpoints.postContractInvoke", "Invokes a method on a smart contract. Performs a blockchain transaction.")
	APIEndpointsPostContractQuery               = ffm("api.endpoints.postContractQuery", "Queries a method on a smart contract. Performs a read-only query.")
	APIEndpointsPostData                        = ffm("api.endpoints.postData", "Creates a new data item in this FireFly node")
	APIEndpointsPostDataValuePublish            = ffm("api.endpoints.postDataValuePublish", "Publishes the JSON value from the specified data resource, to shared storage")
	APIEndpointsPostDataBlobPublish             = ffm("api.endpoints.postDataBlobPublish", "Publishes the binary blob attachment stored in your local data exchange, to shared storage")
	APIEndpointsPostNewContractAPI              = ffm("api.endpoints.postNewContractAPI", "Creates and broadcasts a new custom smart contract API")
	APIEndpointsPostNewContractInterface        = ffm("api.endpoints.postNewContractInterface", "Creates and broadcasts a new custom smart contract interface")
	APIEndpointsPostNewContractListener         = ffm("api.endpoints.postNewContractListener", "Creates a new blockchain listener for events emitted by custom smart contracts")
	APIEndpointsPostContractListenerHash        = ffm("api.endpoints.postContractListenerHash", "Calculates the hash of a blockchain listener filters and events")
	APIEndpointsPostNewDatatype                 = ffm("api.endpoints.postNewDatatype", "Creates and broadcasts a new datatype")
	APIEndpointsPostNewIdentity                 = ffm("api.endpoints.postNewIdentity", "Registers a new identity in the network")
	APIEndpointsPostNewMessageBroadcast         = ffm("api.endpoints.postNewMessageBroadcast", "Broadcasts a message to all members in the network")
	APIEndpointsPostNewMessagePrivate           = ffm("api.endpoints.postNewMessagePrivate", "Privately sends a message to one or more members in the network")
	APIEndpointsPostNewMessageRequestReply      = ffm("api.endpoints.postNewMessageRequestReply", "Sends a message with a blocking HTTP request, waits for a reply to that message, then sends the reply as the HTTP response.")
	APIEndpointsPostNewNamespace                = ffm("api.endpoints.postNewNamespace", "Creates and broadcasts a new namespace")
	APIEndpointsPostNodesSelf                   = ffm("api.endpoints.postNodesSelf", "Instructs this FireFly node to register itself on the network")
	APIEndpointsPostNewOrganizationSelf         = ffm("api.endpoints.postNewOrganizationSelf", "Instructs this FireFly node to register its org on the network")
	APIEndpointsPostNewOrganization             = ffm("api.endpoints.postNewOrganization", "Registers a new org in the network")
	APIEndpointsPostNewSubscription             = ffm("api.endpoints.postNewSubscription", "Creates a new subscription for an application to receive events from FireFly")
	APIEndpointsPostOpRetry                     = ffm("api.endpoints.postOpRetry", "Retries a failed operation")
	APIEndpointsPostPinsRewind                  = ffm("api.endpoints.postPinsRewind", "Force a rewind of the event aggregator to a previous position, to re-evaluate (and possibly dispatch) that pin and others after it. Only accepts a sequence or batch ID for a currently undispatched pin")
	APIEndpointsPostTokenApproval               = ffm("api.endpoints.postTokenApproval", "Creates a token approval")
	APIEndpointsPostTokenBurn                   = ffm("api.endpoints.postTokenBurn", "Burns some tokens")
	APIEndpointsPostTokenMint                   = ffm("api.endpoints.postTokenMint", "Mints some tokens")
	APIEndpointsPostTokenPool                   = ffm("api.endpoints.postTokenPool", "Creates a new token pool")
	APIEndpointsPostTokenPoolPublish            = ffm("api.endpoints.postTokenPoolPublish", "Publish a token pool to all other members of the multiparty network")
	APIEndpointsPostTokenTransfer               = ffm("api.endpoints.postTokenTransfer", "Transfers some tokens")
	APIEndpointsPutContractAPI                  = ffm("api.endpoints.putContractAPI", "Updates an existing contract API")
	APIEndpointsPutSubscription                 = ffm("api.endpoints.putSubscription", "Update an existing subscription")
	APIEndpointsGetContractAPIInterface         = ffm("api.endpoints.getContractAPIInterface", "Gets a contract interface for a contract API")
	APIEndpointsPostNetworkAction               = ffm("api.endpoints.postNetworkAction", "Notify all nodes in the network of a new governance action")
	APIEndpointsPostVerifiersResolve            = ffm("api.endpoints.postVerifiersResolve", "Resolves an input key to a signing key")

	APIFilterParamDesc         = ffm("api.filterParam", "Data filter field. Prefixes supported: > >= < <= @ ^ ! !@ !^")
	APIFilterSortDesc          = ffm("api.filterSort", "Sort field. For multi-field sort use comma separated values (or multiple query values) with '-' prefix for descending")
	APIFilterAscendingDesc     = ffm("api.filterAscending", "Ascending sort order (overrides all fields in a multi-field sort)")
	APIFilterDescendingDesc    = ffm("api.filterDescending", "Descending sort order (overrides all fields in a multi-field sort)")
	APIFilterSkipDesc          = ffm("api.filterSkip", "The number of records to skip (max: %d). Unsuitable for bulk operations")
	APIFilterLimitDesc         = ffm("api.filterLimit", "The maximum number of records to return (max: %d)")
	APIFilterCountDesc         = ffm("api.filterCount", "Return a total count as well as items (adds extra database processing)")
	APIFetchDataDesc           = ffm("api.fetchData", "Fetch the data and include it in the messages returned")
	APIConfirmMsgQueryParam    = ffm("api.confirmMsgQueryParam", "When true the HTTP request blocks until the message is confirmed")
	APIConfirmInvokeQueryParam = ffm("api.confirmInvokeQueryParam", "When true the HTTP request blocks until the blockchain transaction is confirmed")
	APIPublishQueryParam       = ffm("api.publishQueryParam", "When true the definition will be published to all other members of the multiparty network")
	APIHistogramStartTimeParam = ffm("api.histogramStartTime", "Start time of the data to be fetched")
	APIHistogramEndTimeParam   = ffm("api.histogramEndTime", "End time of the data to be fetched")
	APIHistogramBucketsParam   = ffm("api.histogramBuckets", "Number of buckets between start time and end time")

	APISmartContractDetails      = ffm("api.smartContractDetails", "Additional smart contract details")
	APISmartContractDetailsKey   = ffm("api.smartContractDetailsKey", "Key")
	APISmartContractDetailsValue = ffm("api.smartContractDetailsValue", "Value")

	APISubscriptionStartSequenceID = ffm("api.startsequenceid", "The sequence ID in the raw event stream to start indexing through events from. Leave blank to start indexing from the most recent events")
	APISubscriptionEndSequenceID   = ffm("api.endsequenceid", "The sequence ID in the raw event stream to stop indexing through events at. Leave blank to start indexing from the most recent events")
)

var (
	ConfigGlobalMigrationsAuto      = ffc("config.global.migrations.auto", "Enables automatic database migrations", i18n.BooleanType)
	ConfigGlobalMigrationsDirectory = ffc("config.global.migrations.directory", "The directory containing the numerically ordered migration DDL files to apply to the database", i18n.StringType)
	ConfigGlobalShutdownTimeout     = ffc("config.global.shutdownTimeout", "The maximum amount of time to wait for any open HTTP requests to finish before shutting down the HTTP server", i18n.TimeDurationType)

	ConfigEventRetryFactor       = ffc("config.global.eventRetry.factor", "The retry backoff factor, for event processing", i18n.FloatType)
	ConfigEventRetryInitialDelay = ffc("config.global.eventRetry.initialDelay", "The initial retry delay, for event processing", i18n.TimeDurationType)
	ConfigEventRetryMaxDelay     = ffc("config.global.eventRetry.maxDelay", "The maximum retry delay, for event processing", i18n.TimeDurationType)

	ConfigConfigAutoReload = ffc("config.config.autoReload", "Monitor the configuration file for changes, and automatically add/remove/reload namespaces and plugins", i18n.BooleanType)

	ConfigLegacyAdmin     = ffc("config.admin.enabled", "Deprecated - use spi.enabled instead", i18n.BooleanType)
	ConfigSPIAddress      = ffc("config.spi.address", "The IP address on which the admin HTTP API should listen", "IP Address "+i18n.StringType)
	ConfigSPIEnabled      = ffc("config.spi.enabled", "Enables the admin HTTP API", i18n.BooleanType)
	ConfigSPIPort         = ffc("config.spi.port", "The port on which the admin HTTP API should listen", i18n.IntType)
	ConfigSPIPublicURL    = ffc("config.spi.publicURL", "The fully qualified public URL for the admin API. This is used for building URLs in HTTP responses and in OpenAPI Spec generation", urlStringType)
	ConfigSPIReadTimeout  = ffc("config.spi.readTimeout", "The maximum time to wait when reading from an HTTP connection", i18n.TimeDurationType)
	ConfigSPIWriteTimeout = ffc("config.spi.writeTimeout", "The maximum time to wait when writing to an HTTP connection", i18n.TimeDurationType)

	ConfigAPIDefaultFilterLimit = ffc("config.api.defaultFilterLimit", "The maximum number of rows to return if no limit is specified on an API request", i18n.IntType)
	ConfigAPIMaxFilterLimit     = ffc("config.api.maxFilterLimit", "The largest value of `limit` that an HTTP client can specify in a request", i18n.IntType)
	ConfigAPIRequestMaxTimeout  = ffc("config.api.requestMaxTimeout", "The maximum amount of time that an HTTP client can specify in a `Request-Timeout` header to keep a specific request open", i18n.TimeDurationType)
	ConfigAPIPassthroughHeaders = ffc("config.api.passthroughHeaders", "A list of HTTP request headers to pass through to dependency microservices", i18n.ArrayStringType)

	ConfigAssetManagerKeyNormalization = ffc("config.asset.manager.keyNormalization", "Mechanism to normalize keys before using them. Valid options are `blockchain_plugin` - use blockchain plugin (default) or `none` - do not attempt normalization (deprecated - use namespaces.predefined[].asset.manager.keyNormalization)", i18n.StringType)

	ConfigBatchManagerMinimumPollDelay = ffc("config.batch.manager.minimumPollDelay", "The minimum time the batch manager waits between polls on the DB - to prevent thrashing", i18n.TimeDurationType)
	ConfigBatchManagerPollTimeout      = ffc("config.batch.manager.pollTimeout", "How long to wait without any notifications of new messages before doing a page query", i18n.TimeDurationType)
	ConfigBatchManagerReadPageSize     = ffc("config.batch.manager.readPageSize", "The size of each page of messages read from the database into memory when assembling batches", i18n.IntType)

	ConfigBlobreceiverWorkerBatchMaxInserts = ffc("config.blobreceiver.worker.batchMaxInserts", "The maximum number of items the blob receiver worker will insert in a batch", i18n.IntType)
	ConfigBlobreceiverWorkerBatchTimeout    = ffc("config.blobreceiver.worker.batchTimeout", "The maximum amount of the the blob receiver worker will wait", i18n.TimeDurationType)
	ConfigBlobreceiverWorkerCount           = ffc("config.blobreceiver.worker.count", "The number of blob receiver workers", i18n.IntType)

	ConfigBlockchainType = ffc("config.blockchain.type", "A string defining which type of blockchain plugin to use. This tells FireFly which type of configuration to load for the rest of the `blockchain` section", i18n.StringType)

	ConfigBlockchainEthereumAddressResolverAlwaysResolve         = ffc("config.blockchain.ethereum.addressResolver.alwaysResolve", "Causes the address resolver to be invoked on every API call that submits a signing key, regardless of whether the input string conforms to an 0x address. Also disables any result caching", i18n.BooleanType)
	ConfigBlockchainEthereumAddressResolverBodyTemplate          = ffc("config.blockchain.ethereum.addressResolver.bodyTemplate", "The body go template string to use when making HTTP requests", i18n.GoTemplateType)
	ConfigBlockchainEthereumAddressResolverCustomClient          = ffc("config.blockchain.ethereum.addressResolver.customClient", "Used for testing purposes only", i18n.IgnoredType)
	ConfigBlockchainEthereumAddressResolverExpectContinueTimeout = ffc("config.blockchain.ethereum.addressResolver.expectContinueTimeout", "See [ExpectContinueTimeout in the Go docs](https://pkg.go.dev/net/http#Transport)", i18n.TimeDurationType)
	ConfigBlockchainEthereumAddressResolverHeaders               = ffc("config.blockchain.ethereum.addressResolver.headers", "Adds custom headers to HTTP requests", i18n.StringType)
	ConfigBlockchainEthereumAddressResolverIdleTimeout           = ffc("config.blockchain.ethereum.addressResolver.idleTimeout", "The max duration to hold a HTTP keepalive connection between calls", i18n.TimeDurationType)
	ConfigBlockchainEthereumAddressResolverMaxIdleConns          = ffc("config.blockchain.ethereum.addressResolver.maxIdleConns", "The max number of idle connections to hold pooled", i18n.IntType)
	ConfigBlockchainEthereumAddressResolverMethod                = ffc("config.blockchain.ethereum.addressResolver.method", "The HTTP method to use when making requests to the Address Resolver", i18n.StringType)

	ConfigBlockchainEthereumAddressResolverResponseField  = ffc("config.blockchain.ethereum.addressResolver.responseField", "The name of a JSON field that is provided in the response, that contains the ethereum address (default `address`)", i18n.StringType)
	ConfigBlockchainEthereumAddressResolverRetainOriginal = ffc("config.blockchain.ethereum.addressResolver.retainOriginal", "When true the original pre-resolved string is retained after the lookup, and passed down to Ethconnect as the from address", i18n.BooleanType)
	ConfigBlockchainEthereumAddressResolverURL            = ffc("config.blockchain.ethereum.addressResolver.url", "The URL of the Address Resolver", i18n.StringType)
	ConfigBlockchainEthereumAddressResolverURLTemplate    = ffc("config.blockchain.ethereum.addressResolver.urlTemplate", "The URL Go template string to use when calling the Address Resolver. The template input contains '.Key' and '.Intent' string variables", i18n.GoTemplateType)
	ConfigBlockchainEthereumAddressResolverProxyURL       = ffc("config.blockchain.ethereum.addressResolver.proxy.url", "Optional HTTP proxy server to use when connecting to the Address Resolver", urlStringType)

	ConfigBlockchainEthereumEthconnectBatchSize    = ffc("config.blockchain.ethereum.ethconnect.batchSize", "The number of events Ethconnect should batch together for delivery to FireFly core. Only applies when automatically creating a new event stream", i18n.IntType)
	ConfigBlockchainEthereumEthconnectBatchTimeout = ffc("config.blockchain.ethereum.ethconnect.batchTimeout", "How long Ethconnect should wait for new events to arrive and fill a batch, before sending the batch to FireFly core. Only applies when automatically creating a new event stream", i18n.TimeDurationType)
	ConfigBlockchainEthereumEthconnectInstance     = ffc("config.blockchain.ethereum.ethconnect.instance", "The Ethereum address of the FireFly BatchPin smart contract that has been deployed to the blockchain (deprecated - use namespaces.predefined[].multiparty.contract[].location.address)", addressStringType)
	ConfigBlockchainEthereumEthconnectFromBlock    = ffc("config.blockchain.ethereum.ethconnect.fromBlock", "The first event this FireFly instance should listen to from the BatchPin smart contract. Default=0. Only affects initial creation of the event stream (deprecated - use namespaces.predefined[].multiparty.contract[].location.firstEvent)", addressStringType)
	ConfigBlockchainEthereumEthconnectPrefixLong   = ffc("config.blockchain.ethereum.ethconnect.prefixLong", "The prefix that will be used for Ethconnect specific HTTP headers when FireFly makes requests to Ethconnect", i18n.StringType)
	ConfigBlockchainEthereumEthconnectPrefixShort  = ffc("config.blockchain.ethereum.ethconnect.prefixShort", "The prefix that will be used for Ethconnect specific query parameters when FireFly makes requests to Ethconnect", i18n.StringType)
	ConfigBlockchainEthereumEthconnectTopic        = ffc("config.blockchain.ethereum.ethconnect.topic", "The websocket listen topic that the node should register on, which is important if there are multiple nodes using a single ethconnect", i18n.StringType)
	ConfigBlockchainEthereumEthconnectURL          = ffc("config.blockchain.ethereum.ethconnect.url", "The URL of the Ethconnect instance", urlStringType)
	ConfigBlockchainEthereumEthconnectProxyURL     = ffc("config.blockchain.ethereum.ethconnect.proxy.url", "Optional HTTP proxy server to use when connecting to Ethconnect", urlStringType)

	ConfigBlockchainEthereumFFTMURL      = ffc("config.blockchain.ethereum.fftm.url", "The URL of the FireFly Transaction Manager runtime, if enabled", i18n.StringType)
	ConfigBlockchainEthereumFFTMProxyURL = ffc("config.blockchain.ethereum.fftm.proxy.url", "Optional HTTP proxy server to use when connecting to the Transaction Manager", i18n.StringType)

	ConfigBlockchainFabricFabconnectBatchSize    = ffc("config.blockchain.fabric.fabconnect.batchSize", "The number of events Fabconnect should batch together for delivery to FireFly core. Only applies when automatically creating a new event stream", i18n.IntType)
	ConfigBlockchainFabricFabconnectBatchTimeout = ffc("config.blockchain.fabric.fabconnect.batchTimeout", "The maximum amount of time to wait for a batch to complete", i18n.TimeDurationType)
	ConfigBlockchainFabricFabconnectChaincode    = ffc("config.blockchain.fabric.fabconnect.chaincode", "The name of the Fabric chaincode that FireFly will use for BatchPin transactions (deprecated - use namespaces.predefined[].multiparty.contract[].location.chaincode)", i18n.StringType)
	ConfigBlockchainFabricFabconnectChannel      = ffc("config.blockchain.fabric.fabconnect.channel", "The Fabric channel that FireFly will use for BatchPin transactions (deprecated - use namespaces.predefined[].multiparty.contract[].location.channel)", i18n.StringType)
	ConfigBlockchainFabricFabconnectPrefixLong   = ffc("config.blockchain.fabric.fabconnect.prefixLong", "The prefix that will be used for Fabconnect specific HTTP headers when FireFly makes requests to Fabconnect", i18n.StringType)
	ConfigBlockchainFabricFabconnectPrefixShort  = ffc("config.blockchain.fabric.fabconnect.prefixShort", "The prefix that will be used for Fabconnect specific query parameters when FireFly makes requests to Fabconnect", i18n.StringType)
	ConfigBlockchainFabricFabconnectSigner       = ffc("config.blockchain.fabric.fabconnect.signer", "The Fabric signing key to use when submitting transactions to Fabconnect", i18n.StringType)
	ConfigBlockchainFabricFabconnectTopic        = ffc("config.blockchain.fabric.fabconnect.topic", "The websocket listen topic that the node should register on, which is important if there are multiple nodes using a single Fabconnect", i18n.StringType)
	ConfigBlockchainFabricFabconnectURL          = ffc("config.blockchain.fabric.fabconnect.url", "The URL of the Fabconnect instance", urlStringType)
	ConfigBlockchainFabricFabconnectProxyURL     = ffc("config.blockchain.fabric.fabconnect.proxy.url", "Optional HTTP proxy server to use when connecting to Fabconnect", urlStringType)

	ConfigCacheEnabled = ffc("config.cache.enabled", "Enables caching, defaults to true", i18n.BooleanType)

	ConfigCacheAddressResolverLimit    = ffc("config.cache.addressresolver.limit", "Max number of cached items for address resolver", i18n.IntType)
	ConfigCacheAddressResolverTTL      = ffc("config.cache.addressresolver.ttl", "Time to live of cached items for address resolver", i18n.StringType)
	ConfigCacheBatchLimit              = ffc("config.cache.batch.limit", "Max number of cached items for batches", i18n.IntType)
	ConfigCacheBatchTTL                = ffc("config.cache.batch.ttl", "Time to live of cache items for batches", i18n.StringType)
	ConfigCacheBlockchainEventLimit    = ffc("config.cache.blockchainevent.limit", "Max number of cached blockchain events for transactions", i18n.IntType)
	ConfigCacheBlockchainEventTTL      = ffc("config.cache.blockchainevent.ttl", "Time to live of cached blockchain events for transactions", i18n.StringType)
	ConfigCacheTransactionSize         = ffc("config.cache.transaction.size", "Max size of cached transactions", i18n.ByteSizeType)
	ConfigCacheTransactionTTL          = ffc("config.cache.transaction.ttl", "Time to live of cached transactions", i18n.StringType)
	ConfigCacheEventListenerTopicLimit = ffc("config.cache.eventlistenertopic.limit", "Max number of cached items for blockchain listener topics", i18n.IntType)
	ConfigCacheEventListenerTopicTTL   = ffc("config.cache.eventlistenertopic.ttl", "Time to live of cached items for blockchain listener topics", i18n.StringType)
	ConfigCacheGroupLimit              = ffc("config.cache.group.limit", "Max number of cached items for groups", i18n.IntType)
	ConfigCacheGroupTTL                = ffc("config.cache.group.ttl", "Time to live of cached items for groups", i18n.StringType)
	ConfigCacheIdentityLimit           = ffc("config.cache.identity.limit", "Max number of cached identities for identity manager", i18n.IntType)
	ConfigCacheIdentityTTL             = ffc("config.cache.identity.ttl", "Time to live of cached identities for identity manager", i18n.StringType)
	ConfigCacheSigningKeyLimit         = ffc("config.cache.signingkey.limit", "Max number of cached signing keys for identity manager", i18n.IntType)
	ConfigCacheSigningKeyTTL           = ffc("config.cache.signingkey.ttl", "Time to live of cached signing keys for identity manager", i18n.StringType)
	ConfigCacheMessageSize             = ffc("config.cache.message.size", "Max size of cached messages for data manager", i18n.ByteSizeType)
	ConfigCacheMessageTTL              = ffc("config.cache.message.ttl", "Time to live of cached messages for data manager", i18n.StringType)
	ConfigCacheValidatorSize           = ffc("config.cache.validator.size", "Max size of cached validators for data manager", i18n.ByteSizeType)
	ConfigCacheValidatorTTL            = ffc("config.cache.validator.ttl", "Time to live of cached validators for data manager", i18n.StringType)
	ConfigCacheBlockchainLimit         = ffc("config.cache.blockchain.limit", "Max number of cached items for blockchain", i18n.IntType)
	ConfigCacheBlockchainTTL           = ffc("config.cache.blockchain.ttl", "Time to live of cached items for blockchain", i18n.StringType)
	ConfigCacheOperationsLimit         = ffc("config.cache.operations.limit", "Max number of cached items for operations", i18n.IntType)
	ConfigCacheOperationsTTL           = ffc("config.cache.operations.ttl", "Time to live of cached items for operations", i18n.StringType)
	ConfigCacheTokenPoolLimit          = ffc("config.cache.tokenpool.limit", "Max number of cached items for token pools", i18n.IntType)
	ConfigCacheTokenPoolTTL            = ffc("config.cache.tokenpool.ttl", "Time to live of cached items for token pool", i18n.StringType)
	ConfigCacheMethodsLimit            = ffc("config.cache.methods.limit", "Max number of cached items for schema validations on blockchain methods", i18n.IntType)
	ConfigCacheMethodsTTL              = ffc("config.cache.methods.ttl", "Time to live of cached items for schema validations on blockchain methods", i18n.StringType)

	ConfigPluginDatabase     = ffc("config.plugins.database", "The list of configured Database plugins", i18n.StringType)
	ConfigPluginDatabaseName = ffc("config.plugins.database[].name", "The name of the Database plugin", i18n.StringType)
	ConfigPluginDatabaseType = ffc("config.plugins.database[].type", "The type of the configured Database plugin", i18n.StringType)

	ConfigPluginDatabasePostgresMaxConnIdleTime = ffc("config.plugins.database[].postgres.maxConnIdleTime", "The maximum amount of time a database connection can be idle", i18n.TimeDurationType)
	ConfigPluginDatabasePostgresMaxConnLifetime = ffc("config.plugins.database[].postgres.maxConnLifetime", "The maximum amount of time to keep a database connection open", i18n.TimeDurationType)
	ConfigPluginDatabasePostgresMaxConns        = ffc("config.plugins.database[].postgres.maxConns", "Maximum connections to the database", i18n.IntType)
	ConfigPluginDatabasePostgresMaxIdleConns    = ffc("config.plugins.database[].postgres.maxIdleConns", "The maximum number of idle connections to the database", i18n.IntType)
	ConfigPluginDatabasePostgresURL             = ffc("config.plugins.database[].postgres.url", "The PostgreSQL connection string for the database", i18n.StringType)

	ConfigPluginDatabaseSqlite3MaxConnIdleTime = ffc("config.plugins.database[].sqlite3.maxConnIdleTime", "The maximum amount of time a database connection can be idle", i18n.TimeDurationType)
	ConfigPluginDatabaseSqlite3MaxConnLifetime = ffc("config.plugins.database[].sqlite3.maxConnLifetime", "The maximum amount of time to keep a database connection open", i18n.TimeDurationType)
	ConfigPluginDatabaseSqlite3MaxConns        = ffc("config.plugins.database[].sqlite3.maxConns", "Maximum connections to the database", i18n.IntType)
	ConfigPluginDatabaseSqlite3MaxIdleConns    = ffc("config.plugins.database[].sqlite3.maxIdleConns", "The maximum number of idle connections to the database", i18n.IntType)
	ConfigPluginDatabaseSqlite3URL             = ffc("config.plugins.database[].sqlite3.url", "The SQLite connection string for the database", i18n.StringType)

	ConfigPluginBlockchain     = ffc("config.plugins.blockchain", "The list of configured Blockchain plugins", i18n.StringType)
	ConfigPluginBlockchainName = ffc("config.plugins.blockchain[].name", "The name of the configured Blockchain plugin", i18n.StringType)
	ConfigPluginBlockchainType = ffc("config.plugins.blockchain[].type", "The type of the configured Blockchain Connector plugin", i18n.StringType)

	ConfigPluginBlockchainEthereumAddressResolverAlwaysResolve         = ffc("config.plugins.blockchain[].ethereum.addressResolver.alwaysResolve", "Causes the address resolver to be invoked on every API call that submits a signing key, regardless of whether the input string conforms to an 0x address. Also disables any result caching", i18n.BooleanType)
	ConfigPluginBlockchainEthereumAddressResolverBodyTemplate          = ffc("config.plugins.blockchain[].ethereum.addressResolver.bodyTemplate", "The body go template string to use when making HTTP requests. The template input contains '.Key' and '.Intent' string variables.", i18n.GoTemplateType)
	ConfigPluginBlockchainEthereumAddressResolverCustomClient          = ffc("config.plugins.blockchain[].ethereum.addressResolver.customClient", "Used for testing purposes only", i18n.IgnoredType)
	ConfigPluginBlockchainEthereumAddressResolverExpectContinueTimeout = ffc("config.plugins.blockchain[].ethereum.addressResolver.expectContinueTimeout", "See [ExpectContinueTimeout in the Go docs](https://pkg.go.dev/net/http#Transport)", i18n.TimeDurationType)
	ConfigPluginBlockchainEthereumAddressResolverHeaders               = ffc("config.plugins.blockchain[].ethereum.addressResolver.headers", "Adds custom headers to HTTP requests", i18n.StringType)
	ConfigPluginBlockchainEthereumAddressResolverIdleTimeout           = ffc("config.plugins.blockchain[].ethereum.addressResolver.idleTimeout", "The max duration to hold a HTTP keepalive connection between calls", i18n.TimeDurationType)
	ConfigPluginBlockchainEthereumAddressResolverMaxIdleConns          = ffc("config.plugins.blockchain[].ethereum.addressResolver.maxIdleConns", "The max number of idle connections to hold pooled", i18n.IntType)
	ConfigPluginBlockchainEthereumAddressResolverMethod                = ffc("config.plugins.blockchain[].ethereum.addressResolver.method", "The HTTP method to use when making requests to the Address Resolver", i18n.StringType)

	ConfigPluginBlockchainEthereumAddressResolverResponseField  = ffc("config.plugins.blockchain[].ethereum.addressResolver.responseField", "The name of a JSON field that is provided in the response, that contains the ethereum address (default `address`)", i18n.StringType)
	ConfigPluginBlockchainEthereumAddressResolverRetainOriginal = ffc("config.plugins.blockchain[].ethereum.addressResolver.retainOriginal", "When true the original pre-resolved string is retained after the lookup, and passed down to Ethconnect as the from address", i18n.BooleanType)
	ConfigPluginBlockchainEthereumAddressResolverURL            = ffc("config.plugins.blockchain[].ethereum.addressResolver.url", "The URL of the Address Resolver", i18n.StringType)
	ConfigPluginBlockchainEthereumAddressResolverURLTemplate    = ffc("config.plugins.blockchain[].ethereum.addressResolver.urlTemplate", "The URL Go template string to use when calling the Address Resolver. The template input contains '.Key' and '.Intent' string variables.", i18n.GoTemplateType)

	ConfigPluginBlockchainEthereumAddressResolverProxyURL = ffc("config.plugins.blockchain[].ethereum.addressResolver.proxy.url", "Optional HTTP proxy server to use when connecting to the Address Resolver", urlStringType)

	ConfigPluginBlockchainEthereumEthconnectBackgroundStart             = ffc("config.plugins.blockchain[].ethereum.ethconnect.backgroundStart.enabled", "Start the Ethconnect plugin in the background and enter retry loop if failed to start", i18n.BooleanType)
	ConfigPluginBlockchainEthereumEthconnectBackgroundStartInitialDelay = ffc("config.plugins.blockchain[].ethereum.ethconnect.backgroundStart.initialDelay", "Delay between restarts in the case where we retry to restart the ethereum plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainEthereumEthconnectBackgroundStartMaxDelay     = ffc("config.plugins.blockchain[].ethereum.ethconnect.backgroundStart.maxDelay", "Max delay between restarts in the case where we retry to restart the ethereum plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainEthereumEthconnectBackgroundStartFactor       = ffc("config.plugins.blockchain[].ethereum.ethconnect.backgroundStart.factor", "Set the factor by which the delay increases when retrying", i18n.FloatType)
	ConfigPluginBlockchainEthereumEthconnectBatchSize                   = ffc("config.plugins.blockchain[].ethereum.ethconnect.batchSize", "The number of events Ethconnect should batch together for delivery to FireFly core. Only applies when automatically creating a new event stream", i18n.IntType)
	ConfigPluginBlockchainEthereumEthconnectBatchTimeout                = ffc("config.plugins.blockchain[].ethereum.ethconnect.batchTimeout", "How long Ethconnect should wait for new events to arrive and fill a batch, before sending the batch to FireFly core. Only applies when automatically creating a new event stream", i18n.TimeDurationType)
	ConfigPluginBlockchainEthereumEthconnectInstance                    = ffc("config.plugins.blockchain[].ethereum.ethconnect.instance", "The Ethereum address of the FireFly BatchPin smart contract that has been deployed to the blockchain", addressStringType)
	ConfigPluginBlockchainEthereumEthconnectFromBlock                   = ffc("config.plugins.blockchain[].ethereum.ethconnect.fromBlock", "The first event this FireFly instance should listen to from the BatchPin smart contract. Default=0. Only affects initial creation of the event stream", addressStringType)
	ConfigPluginBlockchainEthereumEthconnectPrefixLong                  = ffc("config.plugins.blockchain[].ethereum.ethconnect.prefixLong", "The prefix that will be used for Ethconnect specific HTTP headers when FireFly makes requests to Ethconnect", i18n.StringType)
	ConfigPluginBlockchainEthereumEthconnectPrefixShort                 = ffc("config.plugins.blockchain[].ethereum.ethconnect.prefixShort", "The prefix that will be used for Ethconnect specific query parameters when FireFly makes requests to Ethconnect", i18n.StringType)
	ConfigPluginBlockchainEthereumEthconnectTopic                       = ffc("config.plugins.blockchain[].ethereum.ethconnect.topic", "The websocket listen topic that the node should register on, which is important if there are multiple nodes using a single ethconnect", i18n.StringType)
	ConfigPluginBlockchainEthereumEthconnectURL                         = ffc("config.plugins.blockchain[].ethereum.ethconnect.url", "The URL of the Ethconnect instance", urlStringType)
	ConfigPluginBlockchainEthereumEthconnectProxyURL                    = ffc("config.plugins.blockchain[].ethereum.ethconnect.proxy.url", "Optional HTTP proxy server to use when connecting to Ethconnect", urlStringType)

	ConfigPluginBlockchainEthereumFFTMURL      = ffc("config.plugins.blockchain[].ethereum.fftm.url", "The URL of the FireFly Transaction Manager runtime, if enabled", i18n.StringType)
	ConfigPluginBlockchainEthereumFFTMProxyURL = ffc("config.plugins.blockchain[].ethereum.fftm.proxy.url", "Optional HTTP proxy server to use when connecting to the Transaction Manager", i18n.StringType)

	ConfigPluginBlockchainTezosAddressResolverAlwaysResolve = ffc("config.plugins.blockchain[].tezos.addressResolver.alwaysResolve", "Causes the address resolver to be invoked on every API call that submits a signing key. Also disables any result caching", i18n.BooleanType)

	ConfigPluginBlockchainTezosAddressResolverResponseField  = ffc("config.plugins.blockchain[].tezos.addressResolver.responseField", "The name of a JSON field that is provided in the response, that contains the tezos address (default `address`)", i18n.StringType)
	ConfigPluginBlockchainTezosAddressResolverRetainOriginal = ffc("config.plugins.blockchain[].tezos.addressResolver.retainOriginal", "When true the original pre-resolved string is retained after the lookup, and passed down to Tezosconnect as the from address", i18n.BooleanType)
	ConfigPluginBlockchainTezosAddressResolverURL            = ffc("config.plugins.blockchain[].tezos.addressResolver.url", "The URL of the Address Resolver", i18n.StringType)
	ConfigPluginBlockchainTezosAddressResolverURLTemplate    = ffc("config.plugins.blockchain[].tezos.addressResolver.urlTemplate", "The URL Go template string to use when calling the Address Resolver. The template input contains '.Key' and '.Intent' string variables.", i18n.GoTemplateType)

	ConfigPluginBlockchainTezosTezosconnectBackgroundStart             = ffc("config.plugins.blockchain[].tezos.tezosconnect.backgroundStart.enabled", "Start the Tezosconnect plugin in the background and enter retry loop if failed to start", i18n.BooleanType)
	ConfigPluginBlockchainTezosTezosconnectBackgroundStartInitialDelay = ffc("config.plugins.blockchain[].tezos.tezosconnect.backgroundStart.initialDelay", "Delay between restarts in the case where we retry to restart the tezos plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainTezosTezosconnectBackgroundStartMaxDelay     = ffc("config.plugins.blockchain[].tezos.tezosconnect.backgroundStart.maxDelay", "Max delay between restarts in the case where we retry to restart the tezos plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainTezosTezosconnectBackgroundStartFactor       = ffc("config.plugins.blockchain[].tezos.tezosconnect.backgroundStart.factor", "Set the factor by which the delay increases when retrying", i18n.FloatType)
	ConfigPluginBlockchainTezosTezosconnectBatchSize                   = ffc("config.plugins.blockchain[].tezos.tezosconnect.batchSize", "The number of events Tezosconnect should batch together for delivery to FireFly core. Only applies when automatically creating a new event stream", i18n.IntType)
	ConfigPluginBlockchainTezosTezosconnectBatchTimeout                = ffc("config.plugins.blockchain[].tezos.tezosconnect.batchTimeout", "How long Tezosconnect should wait for new events to arrive and fill a batch, before sending the batch to FireFly core. Only applies when automatically creating a new event stream", i18n.TimeDurationType)
	ConfigPluginBlockchainTezosTezosconnectInstance                    = ffc("config.plugins.blockchain[].tezos.tezosconnect.instance", "The Tezosconnect address of the FireFly BatchPin smart contract that has been deployed to the blockchain", addressStringType)
	ConfigPluginBlockchainTezosTezosconnectFromBlock                   = ffc("config.plugins.blockchain[].tezos.tezosconnect.fromBlock", "The first event this FireFly instance should listen to from the BatchPin smart contract. Default=0. Only affects initial creation of the event stream", addressStringType)
	ConfigPluginBlockchainTezosTezosconnectPrefixLong                  = ffc("config.plugins.blockchain[].tezos.tezosconnect.prefixLong", "The prefix that will be used for Tezosconnect specific HTTP headers when FireFly makes requests to Tezosconnect", i18n.StringType)
	ConfigPluginBlockchainTezosTezosconnectPrefixShort                 = ffc("config.plugins.blockchain[].tezos.tezosconnect.prefixShort", "The prefix that will be used for Tezosconnect specific query parameters when FireFly makes requests to Tezosconnect", i18n.StringType)
	ConfigPluginBlockchainTezosTezosconnectTopic                       = ffc("config.plugins.blockchain[].tezos.tezosconnect.topic", "The websocket listen topic that the node should register on, which is important if there are multiple nodes using a single tezosconnect", i18n.StringType)
	ConfigPluginBlockchainTezosTezosconnectURL                         = ffc("config.plugins.blockchain[].tezos.tezosconnect.url", "The URL of the Tezosconnect instance", urlStringType)
	ConfigPluginBlockchainTezosTezosconnectProxyURL                    = ffc("config.plugins.blockchain[].tezos.tezosconnect.proxy.url", "Optional HTTP proxy server to use when connecting to Tezosconnect", urlStringType)

	ConfigPluginBlockchainFabricFabconnectBackgroundStart             = ffc("config.plugins.blockchain[].fabric.fabconnect.backgroundStart.enabled", "Start the fabric plugin in the background and enter retry loop if failed to start", i18n.BooleanType)
	ConfigPluginBlockchainFabricFabconnectBackgroundStartInitialDelay = ffc("config.plugins.blockchain[].fabric.fabconnect.backgroundStart.initialDelay", "Delay between restarts in the case where we retry to restart the fabric plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainFabricFabconnectBackgroundStartMaxDelay     = ffc("config.plugins.blockchain[].fabric.fabconnect.backgroundStart.maxDelay", "Max delay between restarts in the case where we retry to restart the fabric plugin", i18n.TimeDurationType)
	ConfigPluginBlockchainFabricFabconnectBackgroundStartFactor       = ffc("config.plugins.blockchain[].fabric.fabconnect.backgroundStart.factor", "Set the factor by which the delay increases when retrying", i18n.FloatType)
	ConfigPluginBlockchainFabricFabconnectBatchSize                   = ffc("config.plugins.blockchain[].fabric.fabconnect.batchSize", "The number of events Fabconnect should batch together for delivery to FireFly core. Only applies when automatically creating a new event stream", i18n.IntType)
	ConfigPluginBlockchainFabricFabconnectBatchTimeout                = ffc("config.plugins.blockchain[].fabric.fabconnect.batchTimeout", "The maximum amount of time to wait for a batch to complete", i18n.TimeDurationType)
	ConfigPluginBlockchainFabricFabconnectPrefixLong                  = ffc("config.plugins.blockchain[].fabric.fabconnect.prefixLong", "The prefix that will be used for Fabconnect specific HTTP headers when FireFly makes requests to Fabconnect", i18n.StringType)
	ConfigPluginBlockchainFabricFabconnectPrefixShort                 = ffc("config.plugins.blockchain[].fabric.fabconnect.prefixShort", "The prefix that will be used for Fabconnect specific query parameters when FireFly makes requests to Fabconnect", i18n.StringType)
	ConfigPluginBlockchainFabricFabconnectSigner                      = ffc("config.plugins.blockchain[].fabric.fabconnect.signer", "The Fabric signing key to use when submitting transactions to Fabconnect", i18n.StringType)
	ConfigPluginBlockchainFabricFabconnectTopic                       = ffc("config.plugins.blockchain[].fabric.fabconnect.topic", "The websocket listen topic that the node should register on, which is important if there are multiple nodes using a single Fabconnect", i18n.StringType)
	ConfigPluginBlockchainFabricFabconnectURL                         = ffc("config.plugins.blockchain[].fabric.fabconnect.url", "The URL of the Fabconnect instance", urlStringType)
	ConfigPluginBlockchainFabricFabconnectProxyURL                    = ffc("config.plugins.blockchain[].fabric.fabconnect.proxy.url", "Optional HTTP proxy server to use when connecting to Fabconnect", urlStringType)
	ConfigPluginBlockchainFabricFabconnectChaincode                   = ffc("config.plugins.blockchain[].fabric.fabconnect.chaincode", "The name of the Fabric chaincode that FireFly will use for BatchPin transactions (deprecated - use fireflyContract[].chaincode)", i18n.StringType)
	ConfigPluginBlockchainFabricFabconnectChannel                     = ffc("config.plugins.blockchain[].fabric.fabconnect.channel", "The Fabric channel that FireFly will use for BatchPin transactions", i18n.StringType)

	ConfigBroadcastBatchAgentTimeout = ffc("config.broadcast.batch.agentTimeout", "How long to keep around a batching agent for a sending identity before disposal", i18n.StringType)
	ConfigBroadcastBatchPayloadLimit = ffc("config.broadcast.batch.payloadLimit", "The maximum payload size of a batch for broadcast messages", i18n.ByteSizeType)
	ConfigBroadcastBatchSize         = ffc("config.broadcast.batch.size", "The maximum number of messages that can be packed into a batch", i18n.IntType)
	ConfigBroadcastBatchTimeout      = ffc("config.broadcast.batch.timeout", "The timeout to wait for a batch to fill, before sending", i18n.TimeDurationType)

	ConfigDatabaseType = ffc("config.database.type", "The type of the database interface plugin to use", i18n.IntType)

	ConfigDatabasePostgresMaxConnIdleTime = ffc("config.database.postgres.maxConnIdleTime", "The maximum amount of time a database connection can be idle", i18n.TimeDurationType)
	ConfigDatabasePostgresMaxConnLifetime = ffc("config.database.postgres.maxConnLifetime", "The maximum amount of time to keep a database connection open", i18n.TimeDurationType)
	ConfigDatabasePostgresMaxConns        = ffc("config.database.postgres.maxConns", "Maximum connections to the database", i18n.IntType)
	ConfigDatabasePostgresMaxIdleConns    = ffc("config.database.postgres.maxIdleConns", "The maximum number of idle connections to the database", i18n.IntType)
	ConfigDatabasePostgresURL             = ffc("config.database.postgres.url", "The PostgreSQL connection string for the database", i18n.StringType)

	ConfigDatabaseSqlite3MaxConnIdleTime = ffc("config.database.sqlite3.maxConnIdleTime", "The maximum amount of time a database connection can be idle", i18n.TimeDurationType)
	ConfigDatabaseSqlite3MaxConnLifetime = ffc("config.database.sqlite3.maxConnLifetime", "The maximum amount of time to keep a database connection open", i18n.TimeDurationType)
	ConfigDatabaseSqlite3MaxConns        = ffc("config.database.sqlite3.maxConns", "Maximum connections to the database", i18n.IntType)
	ConfigDatabaseSqlite3MaxIdleConns    = ffc("config.database.sqlite3.maxIdleConns", "The maximum number of idle connections to the database", i18n.IntType)
	ConfigDatabaseSqlite3URL             = ffc("config.database.sqlite3.url", "The SQLite connection string for the database", i18n.StringType)

	ConfigDataexchangeType = ffc("config.dataexchange.type", "The Data Exchange plugin to use", i18n.StringType)

	ConfigDataexchangeFfdxInitEnabled     = ffc("config.dataexchange.ffdx.initEnabled", "Instructs FireFly to always post all current nodes to the `/init` API before connecting or reconnecting to the connector", i18n.BooleanType)
	ConfigDataexchangeFfdxManifestEnabled = ffc("config.dataexchange.ffdx.manifestEnabled", "Determines whether to require+validate a manifest from other DX instances in the network. Must be supported by the connector", i18n.StringType)
	ConfigDataexchangeFfdxURL             = ffc("config.dataexchange.ffdx.url", "The URL of the Data Exchange instance", urlStringType)

	ConfigDataexchangeFfdxProxyURL = ffc("config.dataexchange.ffdx.proxy.url", "Optional HTTP proxy server to use when connecting to the Data Exchange", urlStringType)

	ConfigPluginDataexchange     = ffc("config.plugins.dataexchange", "The array of configured Data Exchange plugins ", i18n.StringType)
	ConfigPluginDataexchangeType = ffc("config.plugins.dataexchange[].type", "The Data Exchange plugin to use", i18n.StringType)
	ConfigPluginDataexchangeName = ffc("config.plugins.dataexchange[].name", "The name of the configured Data Exchange plugin", i18n.StringType)

	ConfigPluginDataexchangeFfdxInitEnabled                 = ffc("config.plugins.dataexchange[].ffdx.initEnabled", "Instructs FireFly to always post all current nodes to the `/init` API before connecting or reconnecting to the connector", i18n.BooleanType)
	ConfigPluginDataexchangeFfdxManifestEnabled             = ffc("config.plugins.dataexchange[].ffdx.manifestEnabled", "Determines whether to require+validate a manifest from other DX instances in the network. Must be supported by the connector", i18n.StringType)
	ConfigPluginDataexchangeFfdxURL                         = ffc("config.plugins.dataexchange[].ffdx.url", "The URL of the Data Exchange instance", urlStringType)
	ConfigPluginDataexchangeFfdxBackgroundStart             = ffc("config.plugins.dataexchange[].ffdx.backgroundStart.enabled", "Start the data exchange plugin in the background and enter retry loop if failed to start", i18n.BooleanType)
	ConfigPluginDataexchangeFfdxBackgroundStartInitialDelay = ffc("config.plugins.dataexchange[].ffdx.backgroundStart.initialDelay", "Delay between restarts in the case where we retry to restart the data exchange plugin", i18n.TimeDurationType)
	ConfigPluginDataexchangeFfdxBackgroundStartMaxDelay     = ffc("config.plugins.dataexchange[].ffdx.backgroundStart.maxDelay", "Max delay between restarts in the case where we retry to restart the data exchange plugin", i18n.TimeDurationType)
	ConfigPluginDataexchangeFfdxBackgroundStartFactor       = ffc("config.plugins.dataexchange[].ffdx.backgroundStart.factor", "Set the factor by which the delay increases when retrying", i18n.FloatType)

	ConfigPluginDataexchangeFfdxProxyURL = ffc("config.plugins.dataexchange[].ffdx.proxy.url", "Optional HTTP proxy server to use when connecting to the Data Exchange", urlStringType)

	ConfigDebugPort    = ffc("config.debug.port", "An HTTP port on which to enable the go debugger", i18n.IntType)
	ConfigDebugAddress = ffc("config.debug.address", "The HTTP interface the go debugger binds to", i18n.StringType)

	ConfigDownloadWorkerCount       = ffc("config.download.worker.count", "The number of download workers", i18n.IntType)
	ConfigDownloadWorkerQueueLength = ffc("config.download.worker.queueLength", "The length of the work queue in the channel to the workers - defaults to 2x the worker count", i18n.IntType)

	ConfigEventAggregatorBatchSize         = ffc("config.event.aggregator.batchSize", "The maximum number of records to read from the DB before performing an aggregation run", i18n.ByteSizeType)
	ConfigEventAggregatorBatchTimeout      = ffc("config.event.aggregator.batchTimeout", "How long to wait for new events to arrive before performing aggregation on a page of events", i18n.TimeDurationType)
	ConfigEventAggregatorFirstEvent        = ffc("config.event.aggregator.firstEvent", "The first event the aggregator should process, if no previous offest is stored in the DB. Valid options are `oldest` or `newest`", i18n.StringType)
	ConfigEventAggregatorPollTimeout       = ffc("config.event.aggregator.pollTimeout", "The time to wait without a notification of new events, before trying a select on the table", i18n.TimeDurationType)
	ConfigEventAggregatorRewindQueueLength = ffc("config.event.aggregator.rewindQueueLength", "The size of the queue into the rewind dispatcher", i18n.IntType)
	ConfigEventAggregatorRewindTimout      = ffc("config.event.aggregator.rewindTimeout", "The minimum time to wait for rewinds to accumulate before resolving them", i18n.TimeDurationType)
	ConfigEventAggregatorRewindQueryLimit  = ffc("config.event.aggregator.rewindQueryLimit", "Safety limit on the maximum number of records to search when performing queries to search for rewinds", i18n.IntType)
	ConfigEventDbeventsBufferSize          = ffc("config.event.dbevents.bufferSize", "The size of the buffer of change events", i18n.ByteSizeType)

	ConfigEventDispatcherBatchTimeout = ffc("config.event.dispatcher.batchTimeout", "A short time to wait for new events to arrive before re-polling for new events", i18n.TimeDurationType)
	ConfigEventDispatcherBufferLength = ffc("config.event.dispatcher.bufferLength", "The number of events + attachments an individual dispatcher should hold in memory ready for delivery to the subscription", i18n.IntType)
	ConfigEventDispatcherPollTimeout  = ffc("config.event.dispatcher.pollTimeout", "The time to wait without a notification of new events, before trying a select on the table", i18n.TimeDurationType)

	ConfigEventTransportsDefault = ffc("config.event.transports.default", "The default event transport for new subscriptions", i18n.StringType)
	ConfigEventTransportsEnabled = ffc("config.event.transports.enabled", "Which event interface plugins are enabled", i18n.BooleanType)

	ConfigHistogramsMaxChartRows = ffc("config.histograms.maxChartRows", "The maximum rows to fetch for each histogram bucket", i18n.IntType)

	ConfigHTTPAddress      = ffc("config.http.address", "The IP address on which the HTTP API should listen", "IP Address "+i18n.StringType)
	ConfigHTTPPort         = ffc("config.http.port", "The port on which the HTTP API should listen", i18n.IntType)
	ConfigHTTPPublicURL    = ffc("config.http.publicURL", "The fully qualified public URL for the API. This is used for building URLs in HTTP responses and in OpenAPI Spec generation", urlStringType)
	ConfigHTTPReadTimeout  = ffc("config.http.readTimeout", "The maximum time to wait when reading from an HTTP connection", i18n.TimeDurationType)
	ConfigHTTPWriteTimeout = ffc("config.http.writeTimeout", "The maximum time to wait when writing to an HTTP connection", i18n.TimeDurationType)

	ConfigPluginIdentity     = ffc("config.plugins.identity", "The list of available Identity plugins", i18n.StringType)
	ConfigPluginIdentityType = ffc("config.plugins.identity[].type", "The type of a configured Identity plugin", i18n.StringType)
	ConfigPluginIdentityName = ffc("config.plugins.identity[].name", "The name of a configured Identity plugin", i18n.StringType)

	ConfigIdentityManagerLegacySystemIdentitites = ffc("config.identity.manager.legacySystemIdentities", "Whether the identity manager should resolve legacy identities registered on the ff_system namespace", i18n.BooleanType)

	ConfigLogCompress   = ffc("config.log.compress", "Determines if the rotated log files should be compressed using gzip", i18n.BooleanType)
	ConfigLogFilename   = ffc("config.log.filename", "Filename is the file to write logs to.  Backup log files will be retained in the same directory", i18n.StringType)
	ConfigLogFilesize   = ffc("config.log.filesize", "MaxSize is the maximum size the log file before it gets rotated", i18n.ByteSizeType)
	ConfigLogForceColor = ffc("config.log.forceColor", "Force color to be enabled, even when a non-TTY output is detected", i18n.BooleanType)
	ConfigLogLevel      = ffc("config.log.level", "The log level - error, warn, info, debug, trace", i18n.StringType)
	ConfigLogMaxAge     = ffc("config.log.maxAge", "The maximum time to retain old log files based on the timestamp encoded in their filename", i18n.TimeDurationType)
	ConfigLogMaxBackups = ffc("config.log.maxBackups", "Maximum number of old log files to retain", i18n.IntType)
	ConfigLogNoColor    = ffc("config.log.noColor", "Force color to be disabled, event when TTY output is detected", i18n.BooleanType)
	ConfigLogTimeFormat = ffc("config.log.timeFormat", "Custom time format for logs", i18n.TimeFormatType)
	ConfigLogUtc        = ffc("config.log.utc", "Use UTC timestamps for logs", i18n.BooleanType)

	ConfigMessageWriterBatchMaxInserts = ffc("config.message.writer.batchMaxInserts", "The maximum number of database inserts to include when writing a single batch of messages + data", i18n.IntType)
	ConfigMessageWriterBatchTimeout    = ffc("config.message.writer.batchTimeout", "How long to wait for more messages to arrive before flushing the batch", i18n.TimeDurationType)
	ConfigMessageWriterCount           = ffc("config.message.writer.count", "The number of message writer workers", i18n.IntType)

	ConfigTransactionWriterBatchMaxTransactions = ffc("config.transaction.writer.batchMaxTransactions", "The maximum number of transaction inserts to include in a batch", i18n.IntType)
	ConfigTransactionWriterBatchTimeout         = ffc("config.transaction.writer.batchTimeout", "How long to wait for more transactions to arrive before flushing the batch", i18n.TimeDurationType)
	ConfigTransactionWriterCount                = ffc("config.transaction.writer.count", "The number of message writer workers", i18n.IntType)

	ConfigMetricsAddress      = ffc("config.metrics.address", "The IP address on which the metrics HTTP API should listen", i18n.IntType)
	ConfigMetricsEnabled      = ffc("config.metrics.enabled", "Enables the metrics API", i18n.BooleanType)
	ConfigMetricsPath         = ffc("config.metrics.path", "The path from which to serve the Prometheus metrics", i18n.StringType)
	ConfigMetricsPort         = ffc("config.metrics.port", "The port on which the metrics HTTP API should listen", i18n.IntType)
	ConfigMetricsPublicURL    = ffc("config.metrics.publicURL", "The fully qualified public URL for the metrics API. This is used for building URLs in HTTP responses and in OpenAPI Spec generation", urlStringType)
	ConfigMetricsReadTimeout  = ffc("config.metrics.readTimeout", "The maximum time to wait when reading from an HTTP connection", i18n.TimeDurationType)
	ConfigMetricsWriteTimeout = ffc("config.metrics.writeTimeout", "The maximum time to wait when writing to an HTTP connection", i18n.TimeDurationType)

	ConfigNamespacesDefault                    = ffc("config.namespaces.default", "The default namespace - must be in the predefined list", i18n.StringType)
	ConfigNamespacesPredefined                 = ffc("config.namespaces.predefined", "A list of namespaces to ensure exists, without requiring a broadcast from the network", "List "+i18n.StringType)
	ConfigNamespacesPredefinedName             = ffc("config.namespaces.predefined[].name", "The name of the namespace (must be unique)", i18n.StringType)
	ConfigNamespacesPredefinedDescription      = ffc("config.namespaces.predefined[].description", "A description for the namespace", i18n.StringType)
	ConfigNamespacesPredefinedPlugins          = ffc("config.namespaces.predefined[].plugins", "The list of plugins for this namespace", i18n.StringType)
	ConfigNamespacesPredefinedDefaultKey       = ffc("config.namespaces.predefined[].defaultKey", "A default signing key for blockchain transactions within this namespace", i18n.StringType)
	ConfigNamespacesPredefinedKeyNormalization = ffc("config.namespaces.predefined[].asset.manager.keyNormalization", "Mechanism to normalize keys before using them. Valid options are `blockchain_plugin` - use blockchain plugin (default) or `none` - do not attempt normalization", i18n.StringType)
	ConfigNamespacesPredefinedTLSConfigs       = ffc("config.namespaces.predefined[].tlsConfigs", "Supply a set of tls certificates to be used by subscriptions for this namespace", "List "+i18n.StringType)
	ConfigNamespacesPredefinedTLSConfigsName   = ffc("config.namespaces.predefined[].tlsConfigs[].name", "Name of the TLS Config", i18n.StringType)
	// ConfigNamespacesPredefinedTLSConfigsTLS      = ffc("config.namespaces.predefined[].tlsConfigs[].tls", "Specify the path to a CA, Cert and Key for TLS communication", i18n.StringType)
	ConfigNamespacesMultipartyEnabled            = ffc("config.namespaces.predefined[].multiparty.enabled", "Enables multi-party mode for this namespace (defaults to true if an org name or key is configured, either here or at the root level)", i18n.BooleanType)
	ConfigNamespacesMultipartyNetworkNamespace   = ffc("config.namespaces.predefined[].multiparty.networknamespace", "The shared namespace name to be sent in multiparty messages, if it differs from the local namespace name", i18n.StringType)
	ConfigNamespacesMultipartyOrgName            = ffc("config.namespaces.predefined[].multiparty.org.name", "A short name for the local root organization within this namespace", i18n.StringType)
	ConfigNamespacesMultipartyOrgDesc            = ffc("config.namespaces.predefined[].multiparty.org.description", "A description for the local root organization within this namespace", i18n.StringType)
	ConfigNamespacesMultipartyOrgKey             = ffc("config.namespaces.predefined[].multiparty.org.key", "The signing key allocated to the root organization within this namespace", i18n.StringType)
	ConfigNamespacesMultipartyNodeName           = ffc("config.namespaces.predefined[].multiparty.node.name", "The node name for this namespace", i18n.StringType)
	ConfigNamespacesMultipartyNodeDescription    = ffc("config.namespaces.predefined[].multiparty.node.description", "A description for the node in this namespace", i18n.StringType)
	ConfigNamespacesMultipartyContract           = ffc("config.namespaces.predefined[].contract", "A list containing configuration for the multi-party blockchain contract", i18n.StringType)
	ConfigNamespacesMultipartyContractFirstEvent = ffc("config.namespaces.predefined[].multiparty.contract[].firstEvent", "The first event the contract should process. Valid options are `oldest` or `newest`", i18n.StringType)
	ConfigNamespacesMultipartyContractLocation   = ffc("config.namespaces.predefined[].multiparty.contract[].location", "A blockchain-specific contract location. For example, an Ethereum contract address, or a Fabric chaincode name and channel", i18n.StringType)
	ConfigNamespacesMultipartyContractOptions    = ffc("config.namespaces.predefined[].multiparty.contract[].options", "Blockchain-specific contract options", i18n.StringType)

	ConfigNodeDescription = ffc("config.node.description", "The description of this FireFly node", i18n.StringType)
	ConfigNodeName        = ffc("config.node.name", "The name of this FireFly node", i18n.StringType)

	ConfigOpupdateWorkerBatchMaxInserts = ffc("config.opupdate.worker.batchMaxInserts", "The maximum number of database inserts to include when writing a single batch of messages + data", i18n.IntType)
	ConfigOpupdateWorkerBatchTimeout    = ffc("config.opupdate.worker.batchTimeout", "How long to wait for more messages to arrive before flushing the batch", i18n.TimeDurationType)
	ConfigOpupdateWorkerCount           = ffc("config.opupdate.worker.count", "The number of operation update works", i18n.IntType)
	ConfigOpupdateWorkerQueueLength     = ffc("config.opupdate.worker.queueLength", "The size of the queue for the Operation Update worker", i18n.IntType)

	ConfigOrchestratorStartupAttempts = ffc("config.orchestrator.startupAttempts", "The number of times to attempt to connect to core infrastructure on startup", i18n.StringType)

	ConfigOrgDescription = ffc("config.org.description", "A description of the organization to which this FireFly node belongs (deprecated - should be set on each multi-party namespace instead)", i18n.StringType)
	ConfigOrgKey         = ffc("config.org.key", "The signing key allocated to the organization (deprecated - should be set on each multi-party namespace instead)", i18n.StringType)
	ConfigOrgName        = ffc("config.org.name", "The name of the organization to which this FireFly node belongs (deprecated - should be set on each multi-party namespace instead)", i18n.StringType)

	ConfigPrivatemessagingBatchAgentTimeout = ffc("config.privatemessaging.batch.agentTimeout", "How long to keep around a batching agent for a sending identity before disposal", i18n.TimeDurationType)
	ConfigPrivatemessagingBatchPayloadLimit = ffc("config.privatemessaging.batch.payloadLimit", "The maximum payload size of a private message Data Exchange payload", i18n.ByteSizeType)
	ConfigPrivatemessagingBatchSize         = ffc("config.privatemessaging.batch.size", "The maximum number of messages in a batch for private messages", i18n.IntType)
	ConfigPrivatemessagingBatchTimeout      = ffc("config.privatemessaging.batch.timeout", "The timeout to wait for a batch to fill, before sending", i18n.TimeDurationType)

	ConfigSharedstorageType                = ffc("config.sharedstorage.type", "The Shared Storage plugin to use", i18n.StringType)
	ConfigSharedstorageIpfsAPIURL          = ffc("config.sharedstorage.ipfs.api.url", "The URL for the IPFS API", urlStringType)
	ConfigSharedstorageIpfsAPIProxyURL     = ffc("config.sharedstorage.ipfs.api.proxy.url", "Optional HTTP proxy server to use when connecting to the IPFS API", urlStringType)
	ConfigSharedstorageIpfsGatewayURL      = ffc("config.sharedstorage.ipfs.gateway.url", "The URL for the IPFS Gateway", urlStringType)
	ConfigSharedstorageIpfsGatewayProxyURL = ffc("config.sharedstorage.ipfs.gateway.proxy.url", "Optional HTTP proxy server to use when connecting to the IPFS Gateway", urlStringType)

	ConfigPluginSharedstorage                    = ffc("config.plugins.sharedstorage", "The list of configured Shared Storage plugins", i18n.StringType)
	ConfigPluginSharedstorageName                = ffc("config.plugins.sharedstorage[].name", "The name of the Shared Storage plugin to use", i18n.StringType)
	ConfigPluginSharedstorageType                = ffc("config.plugins.sharedstorage[].type", "The Shared Storage plugin to use", i18n.StringType)
	ConfigPluginSharedstorageIpfsAPIURL          = ffc("config.plugins.sharedstorage[].ipfs.api.url", "The URL for the IPFS API", urlStringType)
	ConfigPluginSharedstorageIpfsAPIProxyURL     = ffc("config.plugins.sharedstorage[].ipfs.api.proxy.url", "Optional HTTP proxy server to use when connecting to the IPFS API", urlStringType)
	ConfigPluginSharedstorageIpfsGatewayURL      = ffc("config.plugins.sharedstorage[].ipfs.gateway.url", "The URL for the IPFS Gateway", urlStringType)
	ConfigPluginSharedstorageIpfsGatewayProxyURL = ffc("config.plugins.sharedstorage[].ipfs.gateway.proxy.url", "Optional HTTP proxy server to use when connecting to the IPFS Gateway", urlStringType)

	ConfigSubscriptionMax                          = ffc("config.subscription.max", "The maximum number of pre-defined subscriptions that can exist (note for high fan-out consider connecting a dedicated pub/sub broker to the dispatcher)", i18n.IntType)
	ConfigSubscriptionDefaultsBatchSize            = ffc("config.subscription.defaults.batchSize", "Default read ahead to enable for subscriptions that do not explicitly configure readahead", i18n.IntType)
	ConfigSubscriptionDefaultsBatchTimeout         = ffc("config.subscription.defaults.batchTimeout", "Default batch timeout", i18n.IntType)
	ConfigSubscriptionMaxHistoricalEventScanLength = ffc("config.subscription.events.maxScanLength", "The maximum number of events a search for historical events matching a subscription will index from the database", i18n.IntType)

	ConfigTokensName     = ffc("config.tokens[].name", "A name to identify this token plugin", i18n.StringType)
	ConfigTokensPlugin   = ffc("config.tokens[].plugin", "The type of the token plugin to use", i18n.StringType)
	ConfigTokensURL      = ffc("config.tokens[].url", "The URL of the token connector", urlStringType)
	ConfigTokensProxyURL = ffc("config.tokens[].proxy.url", "Optional HTTP proxy server to use when connecting to the token connector", urlStringType)

	ConfigPluginTokens                            = ffc("config.plugins.tokens", "The token plugin configurations", i18n.StringType)
	ConfigPluginTokensName                        = ffc("config.plugins.tokens[].name", "A name to identify this token plugin", i18n.StringType)
	ConfigPluginTokensBroadcastName               = ffc("config.plugins.tokens[].broadcastName", "The name to be used in broadcast messages related to this token plugin, if it differs from the local plugin name", i18n.StringType)
	ConfigPluginTokensType                        = ffc("config.plugins.tokens[].type", "The type of the token plugin to use", i18n.StringType)
	ConfigPluginTokensURL                         = ffc("config.plugins.tokens[].fftokens.url", "The URL of the token connector", urlStringType)
	ConfigPluginTokensProxyURL                    = ffc("config.plugins.tokens[].fftokens.proxy.url", "Optional HTTP proxy server to use when connecting to the token connector", urlStringType)
	ConfigPluginTokensBackgroundStart             = ffc("config.plugins.tokens[].fftokens.backgroundStart.enabled", "Start the tokens plugin in the background and enter retry loop if failed to start", i18n.BooleanType)
	ConfigPluginTokensBackgroundStartInitialDelay = ffc("config.plugins.tokens[].fftokens.backgroundStart.initialDelay", "Delay between restarts in the case where we retry to restart the token plugin", i18n.TimeDurationType)
	ConfigPluginTokensBackgroundStartMaxDelay     = ffc("config.plugins.tokens[].fftokens.backgroundStart.maxDelay", "Max delay between restarts in the case where we retry to restart the token plugin", i18n.TimeDurationType)
	ConfigPluginTokensBackgroundStartFactor       = ffc("config.plugins.tokens[].fftokens.backgroundStart.factor", "Set the factor by which the delay increases when retrying", i18n.FloatType)

	ConfigUIEnabled = ffc("config.ui.enabled", "Enables the web user interface", i18n.BooleanType)
	ConfigUIPath    = ffc("config.ui.path", "The file system path which contains the static HTML, CSS, and JavaScript files for the user interface", i18n.StringType)

	ConfigAPIOASPanicOnMissingDescription = ffc("config.api.oas.panicOnMissingDescription", "Used for testing purposes only", i18n.IgnoredType)

	ConfigSPIWebSocketBlockedWarnInternal = ffc("config.spi.ws.blockedWarnInterval", "How often to log warnings in core, when an admin change event listener falls behind the stream they requested and misses events", i18n.TimeDurationType)
	ConfigSPIWebSocketEventQueueLength    = ffc("config.spi.ws.eventQueueLength", "Server-side queue length for events waiting for delivery over an admin change event listener websocket", i18n.IntType)

	ConfigPluginsAuth     = ffc("config.plugins.auth", "Authorization plugin configuration", i18n.MapStringStringType)
	ConfigPluginsAuthName = ffc("config.plugins.auth[].name", "The name of the auth plugin to use", i18n.StringType)
	ConfigPluginsAuthType = ffc("config.plugins.auth[].type", "The type of the auth plugin to use", i18n.StringType)

	ConfigPluginsEventSystemReadAhead           = ffc("config.events.system.readAhead", "", i18n.IgnoredType)
	ConfigPluginsEventWebhooksURL               = ffc("config.events.webhooks.url", "", i18n.IgnoredType)
	ConfigPluginsEventWebSocketsReadBufferSize  = ffc("config.events.websockets.readBufferSize", "WebSocket read buffer size", i18n.ByteSizeType)
	ConfigPluginsEventWebSocketsWriteBufferSize = ffc("config.events.websockets.writeBufferSize", "WebSocket write buffer size", i18n.ByteSizeType)
)

var (
	MsgConfigFailed                            = ffe("FF10101", "Failed to read config")
	MsgJSONDecodeFailed                        = ffe("FF10103", "Failed to decode input JSON")
	MsgTLSConfigFailed                         = ffe("FF10105", "Failed to initialize TLS configuration")
	MsgWebsocketClientError                    = ffe("FF10108", "Error received from WebSocket client: %s")
	Msg404NotFound                             = ffe("FF10109", "Not found", 404)
	MsgUnknownBlockchainPlugin                 = ffe("FF10110", "Unknown blockchain plugin: %s")
	MsgEthConnectorRESTErr                     = ffe("FF10111", "Error from ethereum connector: %s")
	MsgDBInitFailed                            = ffe("FF10112", "Database initialization failed")
	MsgDBQueryBuildFailed                      = ffe("FF10113", "Database query builder failed")
	MsgDBBeginFailed                           = ffe("FF10114", "Database begin transaction failed")
	MsgDBQueryFailed                           = ffe("FF10115", "Database query failed")
	MsgDBInsertFailed                          = ffe("FF10116", "Database insert failed")
	MsgDBUpdateFailed                          = ffe("FF10117", "Database update failed")
	MsgDBDeleteFailed                          = ffe("FF10118", "Database delete failed")
	MsgDBCommitFailed                          = ffe("FF10119", "Database commit failed")
	MsgDBMissingJoin                           = ffe("FF10120", "Database missing expected join entry in table '%s' for id '%s'")
	MsgDBReadErr                               = ffe("FF10121", "Database resultset read error from table '%s'")
	MsgUnknownDatabasePlugin                   = ffe("FF10122", "Unknown database plugin '%s'")
	MsgNullDataReferenceID                     = ffe("FF10123", "Data id is null in message data reference %d")
	MsgDupDataReferenceID                      = ffe("FF10124", "Duplicate data ID in message '%s'", 409)
	MsgScanFailed                              = ffe("FF10125", "Failed to restore type '%T' into '%T'")
	MsgUnregisteredBatchType                   = ffe("FF10126", "Unregistered batch type '%s'")
	MsgBatchDispatchTimeout                    = ffe("FF10127", "Timed out dispatching work to batch")
	MsgInitializationNilDepError               = ffe("FF10128", "Initialization failed in %s due to unmet dependency")
	MsgNilResponseNon204                       = ffe("FF10129", "No output from API call")
	MsgDataNotFound                            = ffe("FF10133", "Data not found for message %s", 400)
	MsgUnknownSharedStoragePlugin              = ffe("FF10134", "Unknown Shared Storage plugin '%s'")
	MsgIPFSHashDecodeFailed                    = ffe("FF10135", "Failed to decode IPFS hash into 32byte value '%s'")
	MsgIPFSRESTErr                             = ffe("FF10136", "Error from IPFS: %s")
	MsgSerializationFailed                     = ffe("FF10137", "Serialization failed")
	MsgMissingPluginConfig                     = ffe("FF10138", "Missing configuration '%s' for %s")
	MsgMissingDataHashIndex                    = ffe("FF10139", "Missing data hash for index '%d' in message", 400)
	MsgInvalidEthAddress                       = ffe("FF10141", "Supplied ethereum address is invalid", 400)
	MsgInvalidTezosAddress                     = ffe("FF10142", "Supplied tezos address is invalid", 400)
	Msg404NoResult                             = ffe("FF10143", "No result found", 404)
	MsgUnsupportedSQLOpInFilter                = ffe("FF10150", "No SQL mapping implemented for filter operator '%s'", 400)
	MsgFilterSortDesc                          = ffe("FF10154", "Sort field. For multi-field sort use comma separated values (or multiple query values) with '-' prefix for descending")
	MsgContextCanceled                         = ffe("FF00154", "Context cancelled")
	MsgDBMigrationFailed                       = ffe("FF10163", "Database migration failed")
	MsgHashMismatch                            = ffe("FF10164", "Hash mismatch")
	MsgDefaultNamespaceNotFound                = ffe("FF10166", "namespaces.default '%s' must be included in the namespaces.predefined configuration")
	MsgEventTypesParseFail                     = ffe("FF10168", "Unable to parse list of event types", 400)
	MsgUnknownEventType                        = ffe("FF10169", "Unknown event type '%s'", 400)
	MsgIDMismatch                              = ffe("FF10170", "ID mismatch")
	MsgRegexpCompileFailed                     = ffe("FF10171", "Unable to compile '%s' regexp '%s'")
	MsgUnknownEventTransportPlugin             = ffe("FF10172", "Unknown event transport plugin: %s")
	MsgWSConnectionNotActive                   = ffe("FF10173", "Websocket connection '%s' no longer active")
	MsgWSSubAlreadyInFlight                    = ffe("FF10174", "Websocket subscription '%s' already has a message in flight")
	MsgWSMsgSubNotMatched                      = ffe("FF10175", "Acknowledgment does not match an inflight event + subscription")
	MsgWSClientSentInvalidData                 = ffe("FF10176", "Invalid data")
	MsgWSClientUnknownAction                   = ffe("FF10177", "Unknown action '%s'")
	MsgWSInvalidStartAction                    = ffe("FF10178", "A start action must set namespace and either a name or ephemeral=true")
	MsgWSAutoAckChanged                        = ffe("FF10179", "The autoack option must be set consistently on all start requests")
	MsgWSAutoAckEnabled                        = ffe("FF10180", "The autoack option is enabled on this connection")
	MsgConnSubscriptionNotStarted              = ffe("FF10181", "Subscription %v is not started on connection")
	MsgDispatcherClosing                       = ffe("FF10182", "Event dispatcher closing")
	MsgMaxFilterSkip                           = ffe("FF10183", "You have reached the maximum pagination limit for this query (%d)", 400)
	MsgMaxFilterLimit                          = ffe("FF10184", "Your query exceeds the maximum filter limit (%d)", 400)
	MsgAPIServerStaticFail                     = ffe("FF10185", "An error occurred loading static content", 500)
	MsgEventListenerClosing                    = ffe("FF10186", "Event listener closing")
	MsgNamespaceDoesNotExist                   = ffe("FF10187", "Namespace does not exist", 404)
	MsgInvalidSubscription                     = ffe("FF10189", "Invalid subscription", 400)
	MsgMismatchedTransport                     = ffe("FF10190", "Connection ID '%s' appears not to be unique between transport '%s' and '%s'", 400)
	MsgInvalidFirstEvent                       = ffe("FF10191", "Invalid firstEvent definition - must be 'newest','oldest' or a sequence number", 400)
	MsgNumberMustBeGreaterEqual                = ffe("FF10192", "Number must be greater than or equal to %d", 400)
	MsgAlreadyExists                           = ffe("FF10193", "A %s with name '%s:%s' already exists", 409)
	MsgJSONValidatorBadRef                     = ffe("FF10194", "Cannot use JSON validator for data with type '%s' and validator reference '%v'", 400)
	MsgDatatypeNotFound                        = ffe("FF10195", "Datatype '%v' not found", 400)
	MsgSchemaLoadFailed                        = ffe("FF10196", "Datatype '%s' schema invalid", 400)
	MsgDataCannotBeValidated                   = ffe("FF10197", "Data cannot be validated", 400)
	MsgJSONDataInvalidPerSchema                = ffe("FF10198", "Data does not conform to the JSON schema of datatype '%s': %s", 400)
	MsgDataValueIsNull                         = ffe("FF10199", "Data value is null", 400)
	MsgDataInvalidHash                         = ffe("FF10201", "Invalid data: hashes do not match Hash=%s Expected=%s", 400)
	MsgDataReferenceUnresolvable               = ffe("FF10204", "Data reference %d cannot be resolved", 400)
	MsgDataMissing                             = ffe("FF10205", "Data entry %d has neither 'id' to refer to existing data, or 'value' to include in-line JSON data", 400)
	MsgAuthorInvalid                           = ffe("FF10206", "Invalid author specified", 400)
	MsgMessageNotFound                         = ffe("FF10207", "Message '%s' not found", 404)
	MsgBatchNotFound                           = ffe("FF10209", "Batch '%s' not found for message", 404)
	MsgMessageTXNotSet                         = ffe("FF10210", "Message '%s' does not have an assigned transaction", 404)
	MsgOwnerMissing                            = ffe("FF10211", "Owner missing", 400)
	MsgUnknownIdentityPlugin                   = ffe("FF10212", "Unknown Identity plugin '%s'")
	MsgUnknownDataExchangePlugin               = ffe("FF10213", "Unknown Data Exchange plugin '%s'")
	MsgParentIdentityNotFound                  = ffe("FF10214", "Identity '%s' not found in identity chain for %s '%s'")
	MsgInvalidSigningIdentity                  = ffe("FF10215", "Invalid signing identity")
	MsgNodeAndOrgIDMustBeSet                   = ffe("FF10216", "node.name, org.name and org.key must be configured first", 409)
	MsgBlobStreamingFailed                     = ffe("FF10217", "Blob streaming terminated with error", 500)
	MsgNodeNotFound                            = ffe("FF10224", "Node with name or identity '%s' not found", 400)
	MsgLocalNodeNotSet                         = ffe("FF10225", "Unable to resolve the local node. Please ensure node.name is configured", 500)
	MsgGroupNotFound                           = ffe("FF10226", "Group '%s' not found", 404)
	MsgDXRESTErr                               = ffe("FF10229", "Error from data exchange: %s")
	MsgInvalidHex                              = ffe("FF10231", "Invalid hex supplied", 400)
	MsgInvalidWrongLenB32                      = ffe("FF00107", "Byte length must be 32 (64 hex characters)", 400)
	MsgNodeNotFoundInOrg                       = ffe("FF10233", "Unable to find any nodes owned by org '%s', or parent orgs", 400)
	MsgDXBadResponse                           = ffe("FF10237", "Unexpected '%s' in data exchange response: %s")
	MsgDXBadHash                               = ffe("FF10238", "Unexpected hash returned from data exchange upload. Hash=%s Expected=%s")
	MsgBlobNotFound                            = ffe("FF10239", "No blob has been uploaded or confirmed received, with hash=%s", 404)
	MsgDownloadBlobFailed                      = ffe("FF10240", "Error download blob with reference '%s' from local data exchange")
	MsgDataDoesNotHaveBlob                     = ffe("FF10241", "Data does not have a blob attachment", 404)
	MsgWebhookURLEmpty                         = ffe("FF10242", "Webhook subscription option 'url' cannot be empty", 400)
	MsgWebhookInvalidStringMap                 = ffe("FF10243", "Webhook subscription option '%s' must be map of string values. %s=%T", 400)
	MsgWebsocketsNoData                        = ffe("FF10244", "Websockets subscriptions do not support streaming the full data payload, just the references (withData must be false)", 400)
	MsgWebhooksWithData                        = ffe("FF10245", "Webhook subscriptions require the full data payload (withData must be true)", 400)
	MsgWebhooksReplyBadJSON                    = ffe("FF10257", "Failed to process reply from webhook as JSON")
	MsgRequestTimeout                          = ffe("FF10260", "The request with id '%s' timed out after %.2fms", 408)
	MsgRequestReplyTagRequired                 = ffe("FF10261", "For request messages 'header.tag' must be set on the request message to route it to a suitable responder", 400)
	MsgRequestCannotHaveCID                    = ffe("FF10262", "For request messages 'header.cid' must be unset", 400)
	MsgSystemTransportInternal                 = ffe("FF10266", "You cannot create subscriptions on the system events transport")
	MsgFilterCountNotSupported                 = ffe("FF10267", "This query does not support generating a count of all results")
	MsgRejected                                = ffe("FF10269", "Message with ID '%s' was rejected. Please check the FireFly logs for more information")
	MsgRequestMustBePrivate                    = ffe("FF10271", "For request messages you must specify a group of private recipients", 400)
	MsgUnknownTokensPlugin                     = ffe("FF10272", "Unknown tokens plugin '%s'", 400)
	MsgMissingTokensPluginConfig               = ffe("FF10273", "Invalid tokens configuration - name and plugin are required", 400)
	MsgTokensRESTErr                           = ffe("FF10274", "Error from tokens service: %s")
	MsgTokenPoolDuplicate                      = ffe("FF10275", "Duplicate token pool: %s", 409)
	MsgTokenPoolRejected                       = ffe("FF10276", "Token pool with ID '%s' was rejected. Please check the FireFly logs for more information")
	MsgIdentityNotFoundByString                = ffe("FF10277", "Identity could not be resolved via lookup string '%s'")
	MsgAuthorOrgSigningKeyMismatch             = ffe("FF10279", "Author organization '%s' is not associated with signing key '%s'")
	MsgCannotTransferToSelf                    = ffe("FF10280", "From and to addresses must be different", 400)
	MsgLocalOrgNotSet                          = ffe("FF10281", "Unable to resolve the local root org. Please ensure org.name is configured", 500)
	MsgTezosconnectRESTErr                     = ffe("FF10283", "Error from tezos connector: %s")
	MsgFabconnectRESTErr                       = ffe("FF10284", "Error from fabconnect: %s")
	MsgInvalidIdentity                         = ffe("FF10285", "Supplied Fabric signer identity is invalid", 400)
	MsgFailedToDecodeCertificate               = ffe("FF10286", "Failed to decode certificate: %s", 500)
	MsgInvalidMessageType                      = ffe("FF10287", "Invalid message type - allowed types are %s", 400)
	MsgWSClosed                                = ffe("FF10290", "Websocket closed")
	MsgFieldNotSpecified                       = ffe("FF10292", "Field '%s' must be specified", 400)
	MsgTokenPoolNotActive                      = ffe("FF10293", "Token pool is not yet activated")
	MsgHistogramCollectionParam                = ffe("FF10297", "Collection to fetch")
	MsgInvalidNumberOfIntervals                = ffe("FF10298", "Number of time intervals must be between %d and %d", 400)
	MsgInvalidChartNumberParam                 = ffe("FF10299", "Invalid %s. Must be a number.", 400)
	MsgHistogramInvalidTimes                   = ffe("FF10300", "Start time must be before end time", 400)
	MsgUnsupportedCollection                   = ffe("FF10301", "%s collection is not supported", 400)
	MsgContractInterfaceExists                 = ffe("FF10302", "A contract interface already exists in the namespace: '%s' with name: '%s' and version: '%s'", 409)
	MsgContractInterfaceNotFound               = ffe("FF10303", "Contract interface %s not found", 404)
	MsgContractMissingInputArgument            = ffe("FF10304", "Missing required input argument '%s'", 400)
	MsgContractWrongInputType                  = ffe("FF10305", "Input '%v' is of type '%v' not expected type of '%v'", 400)
	MsgContractMissingInputField               = ffe("FF10306", "Expected object of type '%v' to contain field named '%v' but it was missing", 400)
	MsgContractMapInputType                    = ffe("FF10307", "Unable to map input type '%v' to known FireFly type - was expecting '%v'", 400)
	MsgContractByteDecode                      = ffe("FF10308", "Unable to decode field '%v' as bytes", 400)
	MsgContractInternalType                    = ffe("FF10309", "Input '%v' of type '%v' is not compatible blockchain internalType of '%v'", 400)
	MsgContractLocationInvalid                 = ffe("FF10310", "Failed to validate contract location: %v", 400)
	MsgContractParamInvalid                    = ffe("FF10311", "Failed to validate contract param: %v", 400)
	MsgContractListenerNameExists              = ffe("FF10312", "A contract listener already exists in the namespace: '%s' with name: '%s'", 409)
	MsgContractMethodNotSet                    = ffe("FF10313", "Either an interface reference and method path, or in-line method definition, must be supplied on invoke contract request", 400)
	MsgContractMethodResolveError              = ffe("FF10315", "Unable to resolve contract method: %s", 400)
	MsgContractLocationExists                  = ffe("FF10316", "The contract location cannot be changed after it is created", 400)
	MsgListenerNoEvent                         = ffe("FF10317", "Either an interface reference and event path, or in-line event definition must be supplied when creating a contract listener", 400)
	MsgListenerEventNotFound                   = ffe("FF10318", "No event was found in namespace '%s' with id '%s'", 400)
	MsgEventNameMustBeSet                      = ffe("FF10319", "Event name must be set", 400)
	MsgMethodNameMustBeSet                     = ffe("FF10320", "Method name must be set", 400)
	MsgContractEventResolveError               = ffe("FF10321", "Unable to resolve contract event", 400)
	MsgQueryOpUnsupportedMod                   = ffe("FF10322", "Operation '%s' on '%s' does not support modifiers", 400)
	MsgDXBadSize                               = ffe("FF10323", "Unexpected size returned from data exchange upload. Size=%d Expected=%d")
	MsgTooLargeBroadcast                       = ffe("FF10327", "Message size %.2fkb is too large for the max broadcast batch size of %.2fkb", 400)
	MsgTooLargePrivate                         = ffe("FF10328", "Message size %.2fkb is too large for the max private message size of %.2fkb", 400)
	MsgManifestMismatch                        = ffe("FF10329", "Manifest mismatch overriding '%s' status as failure: '%s'", 400)
	MsgFFIValidationFail                       = ffe("FF10331", "Field '%s' does not validate against the provided schema", 400)
	MsgFFISchemaParseFail                      = ffe("FF10332", "Failed to parse schema for param '%s'", 400)
	MsgFFISchemaCompileFail                    = ffe("FF10333", "Failed compile schema for param '%s'", 400)
	MsgPluginInitializationFailed              = ffe("FF10334", "Plugin initialization error", 500)
	MsgUnknownTransactionType                  = ffe("FF10336", "Unknown transaction type '%s'", 400)
	MsgGoTemplateCompileFailed                 = ffe("FF10337", "Go template compilation for '%s' failed: %s", 500)
	MsgGoTemplateExecuteFailed                 = ffe("FF10338", "Go template execution for '%s' failed: %s", 500)
	MsgAddressResolveFailed                    = ffe("FF10339", "Failed to resolve signing key string '%s': %s", 500)
	MsgAddressResolveBadStatus                 = ffe("FF10340", "Failed to resolve signing key string '%s' [%d]: %s", 500)
	MsgAddressResolveBadResData                = ffe("FF10341", "Failed to resolve signing key string '%s' - invalid address returned '%s': %s", 500)
	MsgDXNotInitialized                        = ffe("FF10342", "Data exchange is initializing")
	MsgDBLockFailed                            = ffe("FF10345", "Database lock failed")
	MsgFFIGenerationFailed                     = ffe("FF10346", "Error generating smart contract interface: %s", 400)
	MsgFFIGenerationUnsupported                = ffe("FF10347", "Smart contract interface generation is not supported by this blockchain plugin", 400)
	MsgBlobHashMismatch                        = ffe("FF10348", "Blob hash mismatch sent=%s received=%s", 400)
	MsgDIDResolverUnknown                      = ffe("FF10349", "DID resolver unknown for DID: %s", 400)
	MsgIdentityNotOrg                          = ffe("FF10350", "Identity '%s' with DID '%s' is not an organization", 400)
	MsgIdentityNotNode                         = ffe("FF10351", "Identity '%s' with DID '%s' is not a node", 400)
	MsgBlockchainKeyNotSet                     = ffe("FF10352", "No blockchain key specified", 400)
	MsgNoVerifierForIdentity                   = ffe("FF10353", "No %s verifier registered for identity %s", 400)
	MsgNodeMissingBlockchainKey                = ffe("FF10354", "No signing key was specified, and no default signing key or organization signing key is configured for this namespace", 400)
	MsgAuthorRegistrationMismatch              = ffe("FF10355", "Verifier '%s' cannot be used for signing with author '%s'. Verifier registered to '%s'", 400)
	MsgAuthorMissingForKey                     = ffe("FF10356", "Key '%s' has not been registered by any identity, and a separate 'author' was not supplied", 404)
	MsgAuthorIncorrectForRootReg               = ffe("FF10357", "Author namespace '%s' and DID '%s' combination invalid for root organization registration", 400)
	MsgKeyIdentityMissing                      = ffe("FF10358", "Identity owner of key '%s' not found", 500)
	MsgIdentityChainLoop                       = ffe("FF10364", "Loop detected on identity %s in chain for %s (%s)", 400)
	MsgInvalidIdentityParentType               = ffe("FF10365", "Parent %s (%s) of type %s is invalid for child %s (%s) of type", 400)
	MsgParentIdentityMissingClaim              = ffe("FF10366", "Parent %s (%s) is invalid (missing claim)", 400)
	MsgDXInfoMissingID                         = ffe("FF10367", "Data exchange endpoint info missing 'id' field", 500)
	MsgEventNotFound                           = ffe("FF10370", "Event with name '%s' not found", 400)
	MsgOperationNotSupported                   = ffe("FF10371", "Operation not supported: %s", 400)
	MsgFailedToRetrieve                        = ffe("FF10372", "Failed to retrieve %s %s", 500)
	MsgBlobMissingPublic                       = ffe("FF10373", "Blob for data %s missing public payload reference while flushing batch", 500)
	MsgDBMultiRowConfigError                   = ffe("FF10374", "Database invalid configuration - using multi-row insert on DB plugin that does not support query syntax for input")
	MsgDBNoSequence                            = ffe("FF10375", "Failed to retrieve sequence for insert row %d (could mean duplicate insert)", 500)
	MsgDownloadSharedFailed                    = ffe("FF10376", "Error downloading data with reference '%s' from shared storage")
	MsgDownloadBatchMaxBytes                   = ffe("FF10377", "Error downloading batch with reference '%s' from shared storage - maximum size limit reached")
	MsgOperationDataIncorrect                  = ffe("FF10378", "Operation data type incorrect: %T", 400)
	MsgDataMissingBlobHash                     = ffe("FF10379", "Blob for data %s cannot be transferred as it is missing a hash", 500)
	MsgUnexpectedDXMessageType                 = ffe("FF10380", "Unexpected websocket event type from DX plugin: %s", 500)
	MsgContractListenerExists                  = ffe("FF10383", "A contract listener already exists for this combination of topic + filters (location + event)", 409)
	MsgInvalidOutputOption                     = ffe("FF10385", "invalid output option '%s'")
	MsgInvalidPluginConfiguration              = ffe("FF10386", "Invalid %s plugin configuration - name and type are required")
	MsgReferenceMarkdownMissing                = ffe("FF10387", "Reference markdown file missing: '%s'")
	MsgFFSystemReservedName                    = ffe("FF10388", "Invalid namespace configuration - %s is a reserved name")
	MsgInvalidNamespaceMode                    = ffe("FF10389", "Invalid %s namespace configuration - unknown mode")
	MsgNamespaceUnknownPlugin                  = ffe("FF10390", "Invalid %s namespace configuration - unknown plugin %s")
	MsgNamespaceWrongPluginsMultiparty         = ffe("FF10391", "Invalid %s namespace configuration - multiparty mode requires database, blockchain, shared storage, and data exchange plugins")
	MsgNamespaceNoDatabase                     = ffe("FF10392", "Invalid %s namespace configuration - a database plugin is required")
	MsgNamespaceMultiplePluginType             = ffe("FF10394", "Invalid %s namespace configuration - multiple %s plugins provided")
	MsgDuplicatePluginName                     = ffe("FF10395", "Invalid plugin configuration - plugin with name %s already exists", 409)
	MsgInvalidFireFlyContractIndex             = ffe("FF10396", "No configuration found for FireFly contract at %s")
	MsgUnrecognizedNetworkAction               = ffe("FF10397", "Unrecognized network action: %s", 400)
	MsgOverrideExistingFieldCustomOption       = ffe("FF10398", "Cannot override existing field with custom option named '%s'", 400)
	MsgTerminateNotSupported                   = ffe("FF10399", "The 'terminate' operation to mark a switchover of smart contracts is not supported on namespace %s", 400)
	MsgDefRejectedBadPayload                   = ffe("FF10400", "Rejected %s message '%s' - invalid payload")
	MsgDefRejectedAuthorBlank                  = ffe("FF10401", "Rejected %s message '%s' - author is blank")
	MsgDefRejectedSignatureMismatch            = ffe("FF10402", "Rejected %s message '%s' - signature mismatch")
	MsgDefRejectedValidateFail                 = ffe("FF10403", "Rejected %s '%s' - validate failed")
	MsgDefRejectedIDMismatch                   = ffe("FF10404", "Rejected %s '%s' - ID mismatch with existing record")
	MsgDefRejectedLocationMismatch             = ffe("FF10405", "Rejected %s '%s' - location mismatch with existing record")
	MsgDefRejectedSchemaFail                   = ffe("FF10406", "Rejected %s '%s' - schema check: %s")
	MsgDefRejectedConflict                     = ffe("FF10407", "Rejected %s '%s' - conflicts with existing: %s", 409)
	MsgDefRejectedIdentityNotFound             = ffe("FF10408", "Rejected %s '%s' - identity not found: %s")
	MsgDefRejectedWrongAuthor                  = ffe("FF10409", "Rejected %s '%s' - wrong author: %s")
	MsgDefRejectedHashMismatch                 = ffe("FF10410", "Rejected %s '%s' - hash mismatch: %s != %s")
	MsgInvalidNamespaceUUID                    = ffe("FF10411", "Expected 'namespace:' prefix on ID '%s'", 400)
	MsgBadNetworkVersion                       = ffe("FF10412", "Bad network version: %s")
	MsgDefinitionRejected                      = ffe("FF10413", "Definition rejected")
	MsgActionNotSupported                      = ffe("FF10414", "This action is not supported in this namespace", 400)
	MsgMessagesNotSupported                    = ffe("FF10415", "Messages are not supported in this namespace", 400)
	MsgInvalidSubscriptionForNetwork           = ffe("FF10416", "Subscription name '%s' is invalid according to multiparty network rules in effect (network version=%d)")
	MsgBlockchainNotConfigured                 = ffe("FF10417", "No blockchain plugin configured")
	MsgInvalidBatchPinEvent                    = ffe("FF10418", "BatchPin event is not valid - %s (%s): %s")
	MsgDuplicatePluginBroadcastName            = ffe("FF10419", "Invalid %s plugin broadcast name: %s - broadcast names must be unique", 409)
	MsgInvalidConnectorName                    = ffe("FF10420", "Could not find name %s for %s connector")
	MsgCannotInitLegacyNS                      = ffe("FF10421", "could not initialize legacy '%s' namespace - found conflicting V1 multi-party config in %s")
	MsgInvalidGroupMember                      = ffe("FF10422", "invalid group member - node '%s' is not owned by '%s' or any of its ancestors")
	MsgContractListenerStatusInvalid           = ffe("FF10423", "Failed to validate contract listener status: %v", 400)
	MsgCacheMissSizeLimitKeyInternal           = ffe("FF10424", "could not initialize cache - size limit config key is not provided")
	MsgCacheMissTTLKeyInternal                 = ffe("FF10425", "could not initialize cache - ttl config key is not provided")
	MsgCacheConfigKeyMismatchInternal          = ffe("FF10426", "could not initialize cache - '%s' and '%s' do not have identical prefix, mismatching prefixes are: '%s','%s'")
	MsgCacheUnexpectedSizeKeyNameInternal      = ffe("FF10427", "could not initialize cache - '%s' is not an expected size configuration key suffix. Expected values are: 'size', 'limit'")
	MsgUnknownVerifierType                     = ffe("FF10428", "Unknown verifier type", 400)
	MsgNotSupportedByBlockchainPlugin          = ffe("FF10429", "Not supported by blockchain plugin", 400)
	MsgIdempotencyKeyDuplicateMessage          = ffe("FF10430", "Idempotency key '%s' already used for message '%s'", 409)
	MsgIdempotencyKeyDuplicateTransaction      = ffe("FF10431", "Idempotency key '%s' already used for transaction '%s'", 409)
	MsgNonIdempotencyKeyConflictTxInsert       = ffe("FF10432", "Conflict on insert of transaction '%s'. No existing transaction matching idempotency key '%s' found", 409)
	MsgErrorNameMustBeSet                      = ffe("FF10433", "The name of the error must be set", 400)
	MsgContractErrorsResolveError              = ffe("FF10434", "Unable to resolve contract errors: %s", 400)
	MsgUnknownInterfaceFormat                  = ffe("FF10435", "Unknown interface format: %s", 400)
	MsgUnknownNamespace                        = ffe("FF10436", "Unknown namespace '%s'", 404)
	MsgMissingNamespace                        = ffe("FF10437", "Missing namespace in request", 400)
	MsgDeprecatedResetWithAutoReload           = ffe("FF10438", "The deprecated reset API cannot be used when dynamic config reload is enabled", 409)
	MsgConfigArrayVsRawConfigMismatch          = ffe("FF10439", "Error processing configuration - mismatch between raw and processed array lengths")
	MsgDefaultChannelNotConfigured             = ffe("FF10440", "No default channel configured for this namespace", 400)
	MsgNamespaceInitializing                   = ffe("FF10441", "Namespace '%s' is initializing", 412)
	MsgPinsNotAssigned                         = ffe("FF10442", "Message cannot be sent because pins have not been assigned")
	MsgMethodDoesNotSupportPinning             = ffe("FF10443", "This method does not support passing a payload for pinning")
	MsgOperationNotFoundInTransaction          = ffe("FF10444", "No operation of type %s was found in transaction '%s'")
	MsgCannotSetParameterWithMessage           = ffe("FF10445", "Cannot provide a value for '%s' when pinning a message", 400)
	MsgNamespaceNotStarted                     = ffe("FF10446", "Namespace '%s' is not started", 412)
	MsgNameExists                              = ffe("FF10447", "Name already exists", 409)
	MsgNetworkNameExists                       = ffe("FF10448", "Network name already exists", 409)
	MsgCannotDeletePublished                   = ffe("FF10449", "Cannot delete an item that has been published", 409)
	MsgAlreadyPublished                        = ffe("FF10450", "Item has already been published", 409)
	MsgContractInterfaceNotPublished           = ffe("FF10451", "Contract interface '%s' has not been published", 409)
	MsgInvalidMessageSigner                    = ffe("FF10452", "Invalid message '%s'. Key '%s' does not match the signer of the pin: %s")
	MsgInvalidMessageIdentity                  = ffe("FF10453", "Invalid message '%s'. Author '%s' does not match identity registered to %s: %s (%s)")
	MsgDuplicateTLSConfig                      = ffe("FF10454", "Found duplicate TLS Config '%s'", 400)
	MsgNotFoundTLSConfig                       = ffe("FF10455", "Provided TLS Config name '%s' not found for namespace '%s'", 400)
	MsgSQLInsertManyOutsideTransaction         = ffe("FF10456", "Attempt to perform insert many outside of a transaction", 500)
	MsgUnexpectedInterfaceType                 = ffe("FF10457", "Unexpected interface type: %T", 500)
	MsgBlockchainConnectorRESTErrConflict      = ffe("FF10458", "Conflict from blockchain connector: %s", 409)
	MsgTokensRESTErrConflict                   = ffe("FF10459", "Conflict from tokens service: %s", 409)
	MsgBatchWithDataNotSupported               = ffe("FF10460", "Provided subscription '%s' enables batching and withData which is not supported", 400)
	MsgBatchDeliveryNotSupported               = ffe("FF10461", "Batch delivery not supported by transport '%s'", 400)
	MsgWSWrongNamespace                        = ffe("FF10462", "Websocket request received on a namespace scoped connection but the provided namespace does not match")
	MsgMaxSubscriptionEventScanLimitBreached   = ffe("FF10463", "Event scan limit breached with start sequence ID %d and end sequence ID %d. Please restrict your query to a narrower range", 400)
	MsgSequenceIDDidNotParseToInt              = ffe("FF10464", "Could not parse provided %s to an integer sequence ID", 400)
	MsgInternalServerError                     = ffe("FF10465", "Internal server error: %s", 500)
	MsgCannotCancelBatchType                   = ffe("FF10466", "Cannot cancel batch of type: %s", 400)
	MsgErrorLoadingBatch                       = ffe("FF10467", "Error loading batch messages")
	MsgBatchNotDispatching                     = ffe("FF10468", "Batch %s is not currently dispatching - current: %s", 400)
	MsgNoRegistrationMessageData               = ffe("FF10469", "Unable to check message registration data for org %s", 500)
	MsgUnexpectedRegistrationType              = ffe("FF10470", "Unexpected type checking registration status: %s", 500)
	MsgUnableToParseRegistrationData           = ffe("FF10471", "Unable to parse registration message data: %s", 500)
	MsgInvalidLastEventProtocolID              = ffe("FF10472", "Unable to parse protocol ID of previous event: %s", 500)
	MsgInvalidFromBlockNumber                  = ffe("FF10473", "Unable to parse block number: %s", 500)
	MsgFiltersAndRootEventError                = ffe("FF10474", "Cannot provide both filters and deprecated event path, please only provide one option.", 500)
	MsgFiltersEmpty                            = ffe("FF10475", "No filters specified in contract listener: %s.", 500)
	MsgContractListenerBlockchainFilterLimit   = ffe("FF10476", "Blockchain plugin only supports one filter for contract listener: %s.", 500)
	MsgDuplicateContractListenerFilterLocation = ffe("FF10477", "Duplicate filter provided for contract listener for location", 400)
)

var (
	// MessageHeader field descriptions
	MessageHeaderID        = ffm("MessageHeader.id", "The UUID of the message. Unique to each message")
	MessageHeaderCID       = ffm("MessageHeader.cid", "The correlation ID of the message. Set this when a message is a response to another message")
	MessageHeaderType      = ffm("MessageHeader.type", "The type of the message")
	MessageHeaderTxType    = ffm("MessageHeader.txtype", "The type of transaction used to order/deliver this message")
	MessageHeaderCreated   = ffm("MessageHeader.created", "The creation time of the message")
	MessageHeaderNamespace = ffm("MessageHeader.namespace", "The namespace of the message within the multiparty network")
	MessageHeaderGroup     = ffm("MessageHeader.group", "Private messages only - the identifier hash of the privacy group. Derived from the name and member list of the group")
	MessageHeaderTopics    = ffm("MessageHeader.topics", "A message topic associates this message with an ordered stream of data. A custom topic should be assigned - using the default topic is discouraged")
	MessageHeaderTag       = ffm("MessageHeader.tag", "The message tag indicates the purpose of the message to the applications that process it")
	MessageHeaderDataHash  = ffm("MessageHeader.datahash", "A single hash representing all data in the message. Derived from the array of data ids+hashes attached to this message")
	MessageTxParent        = ffm("MessageHeader.txparent", "The parent transaction that originally triggered this message")

	// Message field descriptions
	MessageHeader         = ffm("Message.header", "The message header contains all fields that are used to build the message hash")
	MessageLocalNamespace = ffm("Message.localNamespace", "The local namespace of the message")
	MessageHash           = ffm("Message.hash", "The hash of the message. Derived from the header, which includes the data hash")
	MessageBatchID        = ffm("Message.batch", "The UUID of the batch in which the message was pinned/transferred")
	MessageState          = ffm("Message.state", "The current state of the message")
	MessageConfirmed      = ffm("Message.confirmed", "The timestamp of when the message was confirmed/rejected")
	MessageRejectReason   = ffm("Message.rejectReason", "If a message was rejected, provides details on the rejection reason")
	MessageData           = ffm("Message.data", "The list of data elements attached to the message")
	MessagePins           = ffm("Message.pins", "For private messages, a unique pin hash:nonce is assigned for each topic")
	MessageTransactionID  = ffm("Message.txid", "The ID of the transaction used to order/deliver this message")
	MessageIdempotencyKey = ffm("Message.idempotencyKey", "An optional unique identifier for a message. Cannot be duplicated within a namespace, thus allowing idempotent submission of messages to the API. Local only - not transferred when the message is sent to other members of the network")

	// MessageInOut field descriptions
	MessageInOutData  = ffm("MessageInOut.data", "For input allows you to specify data in-line in the message, that will be turned into data attachments. For output when fetchdata is used on API calls, includes the in-line data payloads of all data attachments")
	MessageInOutGroup = ffm("MessageInOut.group", "Allows you to specify details of the private group of recipients in-line in the message. Alternative to using the header.group to specify the hash of a group that has been previously resolved")

	// InputGroup field descriptions
	InputGroupName    = ffm("InputGroup.name", "Optional name for the group. Allows you to have multiple separate groups with the same list of participants")
	InputGroupMembers = ffm("InputGroup.members", "An array of members of the group. If no identities local to the sending node are included, then the organization owner of the local node is added automatically")

	// DataRefOrValue field descriptions
	DataRefOrValueValidator = ffm("DataRefOrValue.validator", "The data validator type to use for in-line data")
	DataRefOrValueDatatype  = ffm("DataRefOrValue.datatype", "The optional datatype to use for validation of the in-line data")
	DataRefOrValueValue     = ffm("DataRefOrValue.value", "The in-line value for the data. Can be any JSON type - object, array, string, number or boolean")
	DataRefOrValueBlob      = ffm("DataRefOrValue.blob", "An optional in-line hash reference to a previously uploaded binary data blob")

	// MessageRef field descriptions
	MessageRefID   = ffm("MessageRef.id", "The UUID of the referenced message")
	MessageRefHash = ffm("MessageRef.hash", "The hash of the referenced message")

	// Group field descriptions
	GroupNamespace      = ffm("Group.namespace", "The namespace of the group within the multiparty network")
	GroupLocalNamespace = ffm("Group.localNamespace", "The local namespace of the group")
	GroupName           = ffm("Group.name", "The optional name of the group, allowing multiple unique groups to exist with the same list of recipients")
	GroupMembers        = ffm("Group.members", "The list of members in this privacy group")
	GroupMessage        = ffm("Group.message", "The message used to broadcast this group privately to the members")
	GroupHash           = ffm("Group.hash", "The identifier hash of this group. Derived from the name and group members")
	GroupCreated        = ffm("Group.created", "The time when the group was first used to send a message in the network")

	// MemberInput field descriptions
	MemberInputIdentity = ffm("MemberInput.identity", "The DID of the group member. On input can be a UUID or org name, and will be resolved to a DID")
	MemberInputNode     = ffm("MemberInput.node", "The UUID of the node that will receive a copy of the off-chain message for the identity. The first applicable node for the identity will be picked automatically on input if not specified")

	// Member field descriptions
	MemberIdentity = ffm("Member.identity", "The DID of the group member")
	MemberNode     = ffm("Member.node", "The UUID of the node that receives a copy of the off-chain message for the identity")

	// DataRef field descriptions
	DataRefID   = ffm("DataRef.id", "The UUID of the referenced data resource")
	DataRefHash = ffm("DataRef.hash", "The hash of the referenced data")

	// BlobRef field descriptions
	BlobRefHash   = ffm("BlobRef.hash", "The hash of the binary blob data")
	BlobRefSize   = ffm("BlobRef.size", "The size of the binary data")
	BlobRefName   = ffm("BlobRef.name", "The name field from the metadata attached to the blob, commonly used as a path/filename, and indexed for search")
	BlobRefPath   = ffm("BlobRef.path", "If a name is specified, this field stores the '/' prefixed and separated path extracted from the full name")
	BlobRefPublic = ffm("BlobRef.public", "If the blob data has been published to shared storage, this field is the id of the data in the shared storage plugin (IPFS hash etc.)")

	// Data field descriptions
	DataID        = ffm("Data.id", "The UUID of the data resource")
	DataValidator = ffm("Data.validator", "The data validator type")
	DataNamespace = ffm("Data.namespace", "The namespace of the data resource")
	DataHash      = ffm("Data.hash", "The hash of the data resource. Derived from the value and the hash of any binary blob attachment")
	DataCreated   = ffm("Data.created", "The creation time of the data resource")
	DataDatatype  = ffm("Data.datatype", "The optional datatype to use of validation of this data")
	DataValue     = ffm("Data.value", "The value for the data, stored in the FireFly core database. Can be any JSON type - object, array, string, number or boolean. Can be combined with a binary blob attachment")
	DataBlob      = ffm("Data.blob", "An optional hash reference to a binary blob attachment")
	DataPublic    = ffm("Data.public", "If the JSON value has been published to shared storage, this field is the id of the data in the shared storage plugin (IPFS hash etc.)")

	// DatatypeRef field descriptions
	DatatypeRefName    = ffm("DatatypeRef.name", "The name of the datatype")
	DatatypeRefVersion = ffm("DatatypeRef.version", "The version of the datatype. Semantic versioning is encouraged, such as v1.0.1")

	// Datatype field descriptions
	DatatypeID        = ffm("Datatype.id", "The UUID of the datatype")
	DatatypeMessage   = ffm("Datatype.message", "The UUID of the broadcast message that was used to publish this datatype to the network")
	DatatypeValidator = ffm("Datatype.validator", "The validator that should be used to verify this datatype")
	DatatypeNamespace = ffm("Datatype.namespace", "The namespace of the datatype. Data resources can only be created referencing datatypes in the same namespace")
	DatatypeName      = ffm("Datatype.name", "The name of the datatype")
	DatatypeVersion   = ffm("Datatype.version", "The version of the datatype. Multiple versions can exist with the same name. Use of semantic versioning is encourages, such as v1.0.1")
	DatatypeHash      = ffm("Datatype.hash", "The hash of the value, such as the JSON schema. Allows all parties to be confident they have the exact same rules for verifying data created against a datatype")
	DatatypeCreated   = ffm("Datatype.created", "The time the datatype was created")
	DatatypeValue     = ffm("Datatype.value", "The definition of the datatype, in the syntax supported by the validator (such as a JSON Schema definition)")

	// SignerRef field descriptions
	SignerRefAuthor = ffm("SignerRef.author", "The DID of identity of the submitter")
	SignerRefKey    = ffm("SignerRef.key", "The on-chain signing key used to sign the transaction")

	// MessageManifestEntry field descriptions
	MessageManifestEntry = ffm("MessageManifestEntry.topics", "The count of topics in the message")

	// BatchHeader field descriptions
	BatchHeaderID        = ffm("BatchHeader.id", "The UUID of the batch")
	BatchHeaderType      = ffm("BatchHeader.type", "The type of the batch")
	BatchHeaderNamespace = ffm("BatchHeader.namespace", "The namespace of the batch")
	BatchHeaderNode      = ffm("BatchHeader.node", "The UUID of the node that generated the batch")
	BatchHeaderGroup     = ffm("BatchHeader.group", "The privacy group the batch is sent to, for private batches")
	BatchHeaderCreated   = ffm("BatchHeader.created", "The time the batch was sealed")

	// BatchManifest field descriptions
	BatchManifestVersion  = ffm("BatchManifest.version", "The version of the manifest generated")
	BatchManifestID       = ffm("BatchManifest.id", "The UUID of the batch")
	BatchManifestTX       = ffm("BatchManifest.tx", "The FireFly transaction associated with this batch")
	BatchManifestMessages = ffm("BatchManifest.messages", "Array of manifest entries, succinctly summarizing the messages in the batch")
	BatchManifestData     = ffm("BatchManifest.data", "Array of manifest entries, succinctly summarizing the data in the batch")

	// BatchPersisted field descriptions
	BatchPersistedHash       = ffm("Batch.hash", "The hash of the manifest of the batch")
	BatchPersistedManifest   = ffm("Batch.manifest", "The manifest of the batch")
	BatchPersistedTX         = ffm("Batch.tx", "The FireFly transaction associated with this batch")
	BatchPersistedPayloadRef = ffm("Batch.payloadRef", "For broadcast batches, this is the reference to the binary batch in shared storage")
	BatchPersistedConfirmed  = ffm("Batch.confirmed", "The time when the batch was confirmed")

	// Transaction field descriptions
	TransactionID             = ffm("Transaction.id", "The UUID of the FireFly transaction")
	TransactionType           = ffm("Transaction.type", "The type of the FireFly transaction")
	TransactionNamespace      = ffm("Transaction.namespace", "The namespace of the FireFly transaction")
	TransactionCreated        = ffm("Transaction.created", "The time the transaction was created on this node. Note the transaction is individually created with the same UUID on each participant in the FireFly transaction")
	TransactionIdempotencyKey = ffm("Transaction.idempotencyKey", "An optional unique identifier for a transaction. Cannot be duplicated within a namespace, thus allowing idempotent submission of transactions to the API")
	TransactionBlockchainID   = ffm("Transaction.blockchainId", "The blockchain transaction ID, in the format specific to the blockchain involved in the transaction. Not all FireFly transactions include a blockchain")
	TransactionBlockchainIDs  = ffm("Transaction.blockchainIds", "The blockchain transaction ID, in the format specific to the blockchain involved in the transaction. Not all FireFly transactions include a blockchain. FireFly transactions are extensible to support multiple blockchain transactions")

	// Operation field description
	OperationID          = ffm("Operation.id", "The UUID of the operation")
	OperationNamespace   = ffm("Operation.namespace", "The namespace of the operation")
	OperationTransaction = ffm("Operation.tx", "The UUID of the FireFly transaction the operation is part of")
	OperationType        = ffm("Operation.type", "The type of the operation")
	OperationStatus      = ffm("Operation.status", "The current status of the operation")
	OperationPlugin      = ffm("Operation.plugin", "The plugin responsible for performing the operation")
	OperationInput       = ffm("Operation.input", "The input to this operation")
	OperationOutput      = ffm("Operation.output", "Any output reported back from the plugin for this operation")
	OperationError       = ffm("Operation.error", "Any error reported back from the plugin for this operation")
	OperationCreated     = ffm("Operation.created", "The time the operation was created")
	OperationUpdated     = ffm("Operation.updated", "The last update time of the operation")
	OperationRetry       = ffm("Operation.retry", "If this operation was initiated as a retry to a previous operation, this field points to the UUID of the operation being retried")

	// OperationWithDetail field description
	OperationWithDetail = ffm("OperationWithDetail.detail", "Additional detailed information about an operation provided by the connector")

	// BlockchainEvent field descriptions
	BlockchainEventID         = ffm("BlockchainEvent.id", "The UUID assigned to the event by FireFly")
	BlockchainEventSource     = ffm("BlockchainEvent.source", "The blockchain plugin or token service that detected the event")
	BlockchainEventNamespace  = ffm("BlockchainEvent.namespace", "The namespace of the listener that detected this blockchain event")
	BlockchainEventName       = ffm("BlockchainEvent.name", "The name of the event in the blockchain smart contract")
	BlockchainEventListener   = ffm("BlockchainEvent.listener", "The UUID of the listener that detected this event, or nil for built-in events in the system namespace")
	BlockchainEventProtocolID = ffm("BlockchainEvent.protocolId", "An alphanumerically sortable string that represents this event uniquely on the blockchain (convention for plugins is zero-padded values BLOCKNUMBER/TXN_INDEX/EVENT_INDEX)")
	BlockchainEventOutput     = ffm("BlockchainEvent.output", "The data output by the event, parsed to JSON according to the interface of the smart contract")
	BlockchainEventInfo       = ffm("BlockchainEvent.info", "Detailed blockchain specific information about the event, as generated by the blockchain connector")
	BlockchainEventTimestamp  = ffm("BlockchainEvent.timestamp", "The time allocated to this event by the blockchain. This is the block timestamp for most blockchain connectors")
	BlockchainEventTX         = ffm("BlockchainEvent.tx", "If this blockchain event is coorelated to FireFly transaction such as a FireFly submitted token transfer, this field is set to the UUID of the FireFly transaction")

	// ChartHistogram field descriptions
	ChartHistogramCount     = ffm("ChartHistogram.count", "Total count of entries in this time bucket within the histogram")
	ChartHistogramTimestamp = ffm("ChartHistogram.timestamp", "Starting timestamp for the bucket")
	ChartHistogramTypes     = ffm("ChartHistogram.types", "Array of separate counts for individual types of record within the bucket")
	ChartHistogramIsCapped  = ffm("ChartHistogram.isCapped", "Indicates whether there are more results in this bucket that are not being displayed")

	// ChartHistogramType field descriptions
	ChartHistogramTypeCount = ffm("ChartHistogramType.count", "Count of entries of a given type within a bucket")
	ChartHistogramTypeType  = ffm("ChartHistogramType.type", "Name of the type")

	// ContractAPI field descriptions
	ContractAPIID          = ffm("ContractAPI.id", "The UUID of the contract API")
	ContractAPINamespace   = ffm("ContractAPI.namespace", "The namespace of the contract API")
	ContractAPIInterface   = ffm("ContractAPI.interface", "Reference to the FireFly Interface definition associated with the contract API")
	ContractAPILocation    = ffm("ContractAPI.location", "If this API is tied to an individual instance of a smart contract, this field can include a blockchain specific contract identifier. For example an Ethereum contract address, or a Fabric chaincode name and channel")
	ContractAPIName        = ffm("ContractAPI.name", "The name that is used in the URL to access the API")
	ContractAPINetworkName = ffm("ContractAPI.networkName", "The published name of the API within the multiparty network")
	ContractAPIMessage     = ffm("ContractAPI.message", "The UUID of the broadcast message that was used to publish this API to the network")
	ContractAPIURLs        = ffm("ContractAPI.urls", "The URLs to use to access the API")
	ContractAPIPublished   = ffm("ContractAPI.published", "Indicates if the API is published to other members of the multiparty network")

	// ContractURLs field descriptions
	ContractURLsAPI     = ffm("ContractURLs.api", "The URL to use to invoke the API")
	ContractURLsOpenAPI = ffm("ContractURLs.openapi", "The URL to download the OpenAPI v3 (Swagger) description for the API generated in JSON or YAML format")
	ContractURLsUI      = ffm("ContractURLs.ui", "The URL to use in a web browser to access the SwaggerUI explorer/exerciser for the API")

	// FFIReference field descriptions
	FFIReferenceID      = ffm("FFIReference.id", "The UUID of the FireFly interface")
	FFIReferenceName    = ffm("FFIReference.name", "The name of the FireFly interface")
	FFIReferenceVersion = ffm("FFIReference.version", "The version of the FireFly interface")

	// FFI field descriptions
	FFIID          = ffm("FFI.id", "The UUID of the FireFly interface (FFI) smart contract definition")
	FFIMessage     = ffm("FFI.message", "The UUID of the broadcast message that was used to publish this FFI to the network")
	FFINamespace   = ffm("FFI.namespace", "The namespace of the FFI")
	FFIName        = ffm("FFI.name", "The name of the FFI - usually matching the smart contract name")
	FFINetworkName = ffm("FFI.networkName", "The published name of the FFI within the multiparty network")
	FFIDescription = ffm("FFI.description", "A description of the smart contract this FFI represents")
	FFIVersion     = ffm("FFI.version", "A version for the FFI - use of semantic versioning such as 'v1.0.1' is encouraged")
	FFIMethods     = ffm("FFI.methods", "An array of smart contract method definitions")
	FFIEvents      = ffm("FFI.events", "An array of smart contract event definitions")
	FFIErrors      = ffm("FFI.errors", "An array of smart contract error definitions")
	FFIPublished   = ffm("FFI.published", "Indicates if the FFI is published to other members of the multiparty network")

	// FFIMethod field descriptions
	FFIMethodID          = ffm("FFIMethod.id", "The UUID of the FFI method definition")
	FFIMethodInterface   = ffm("FFIMethod.interface", "The UUID of the FFI smart contract definition that this method is part of")
	FFIMethodName        = ffm("FFIMethod.name", "The name of the method")
	FFIMethodNamespace   = ffm("FFIMethod.namespace", "The namespace of the FFI")
	FFIMethodPathname    = ffm("FFIMethod.pathname", "The unique name allocated to this method within the FFI for use on URL paths. Supports contracts that have multiple method overrides with the same name")
	FFIMethodDescription = ffm("FFIMethod.description", "A description of the smart contract method")
	FFIMethodParams      = ffm("FFIMethod.params", "An array of method parameter/argument definitions")
	FFIMethodReturns     = ffm("FFIMethod.returns", "An array of method return definitions")
	FFIMethodDetails     = ffm("FFIMethod.details", "Additional blockchain specific fields about this method from the original smart contract. Used by the blockchain plugin and for documentation generation.")

	// FFIEvent field descriptions
	FFIEventID          = ffm("FFIEvent.id", "The UUID of the FFI event definition")
	FFIEventInterface   = ffm("FFIEvent.interface", "The UUID of the FFI smart contract definition that this event is part of")
	FFIEventName        = ffm("FFIEvent.name", "The name of the event")
	FFIEventNamespace   = ffm("FFIEvent.namespace", "The namespace of the FFI")
	FFIEventPathname    = ffm("FFIEvent.pathname", "The unique name allocated to this event within the FFI for use on URL paths. Supports contracts that have multiple event overrides with the same name")
	FFIEventDescription = ffm("FFIEvent.description", "A description of the smart contract event")
	FFIEventParams      = ffm("FFIEvent.params", "An array of event parameter/argument definitions")
	FFIEventSignature   = ffm("FFIEvent.signature", "The stringified signature of the event, as computed by the blockchain plugin")
	FFIEventDetails     = ffm("FFIEvent.details", "Additional blockchain specific fields about this event from the original smart contract. Used by the blockchain plugin and for documentation generation.")

	// FFIError field descriptions
	FFIErrorID          = ffm("FFIError.id", "The UUID of the FFI error definition")
	FFIErrorInterface   = ffm("FFIError.interface", "The UUID of the FFI smart contract definition that this error is part of")
	FFIErrorName        = ffm("FFIError.name", "The name of the error")
	FFIErrorNamespace   = ffm("FFIError.namespace", "The namespace of the FFI")
	FFIErrorPathname    = ffm("FFIError.pathname", "The unique name allocated to this error within the FFI for use on URL paths")
	FFIErrorDescription = ffm("FFIError.description", "A description of the smart contract error")
	FFIErrorParams      = ffm("FFIError.params", "An array of error parameter/argument definitions")
	FFIErrorSignature   = ffm("FFIError.signature", "The stringified signature of the error, as computed by the blockchain plugin")
	FFIErrorDetails     = ffm("FFIError.details", "Additional blockchain specific fields about this error from the original smart contract. Used by the blockchain plugin and for documentation generation.")

	// FFIParam field descriptions
	FFIParamName   = ffm("FFIParam.name", "The name of the parameter. Note that parameters must be ordered correctly on the FFI, according to the order in the blockchain smart contract")
	FFIParamSchema = ffm("FFIParam.schema", "FireFly uses an extended subset of JSON Schema to describe parameters, similar to OpenAPI/Swagger. Converters are available for native blockchain interface definitions / type systems - such as an Ethereum ABI. See the documentation for more detail")

	// FFIGenerationRequest field descriptions
	FFIGenerationRequestNamespace   = ffm("FFIGenerationRequest.namespace", "The namespace into which the FFI will be generated")
	FFIGenerationRequestName        = ffm("FFIGenerationRequest.name", "The name of the FFI to generate")
	FFIGenerationRequestDescription = ffm("FFIGenerationRequest.description", "The description of the FFI to be generated. Defaults to the description extracted by the blockchain specific converter utility")
	FFIGenerationRequestVersion     = ffm("FFIGenerationRequest.version", "The version of the FFI to generate")
	FFIGenerationRequestInput       = ffm("FFIGenerationRequest.input", "A blockchain connector specific payload. For example in Ethereum this is a JSON structure containing an 'abi' array, and optionally a 'devdocs' array.")

	// ContractListener field descriptions
	ContractListenerID        = ffm("ContractListener.id", "The UUID of the smart contract listener")
	ContractListenerInterface = ffm("ContractListener.interface", "Deprecated: Please use 'interface' in the array of 'filters' instead")
	ContractListenerNamespace = ffm("ContractListener.namespace", "The namespace of the listener, which defines the namespace of all blockchain events detected by this listener")
	ContractListenerName      = ffm("ContractListener.name", "A descriptive name for the listener")
	ContractListenerBackendID = ffm("ContractListener.backendId", "An ID assigned by the blockchain connector to this listener")
	ContractListenerLocation  = ffm("ContractListener.location", "Deprecated: Please use 'location' in the array of 'filters' instead")
	ContractListenerCreated   = ffm("ContractListener.created", "The creation time of the listener")
	ContractListenerEvent     = ffm("ContractListener.event", "Deprecated: Please use 'event' in the array of 'filters' instead")
	ContractListenerFilters   = ffm("ContractListener.filters", "A list of filters for the contract listener. Each filter is made up of an Event and an optional Location. Events matching these filters will always be emitted in the order determined by the blockchain.")
	ContractListenerTopic     = ffm("ContractListener.topic", "A topic to set on the FireFly event that is emitted each time a blockchain event is detected from the blockchain. Setting this topic on a number of listeners allows applications to easily subscribe to all events they need")
	ContractListenerOptions   = ffm("ContractListener.options", "Options that control how the listener subscribes to events from the underlying blockchain")
	ContractListenerEventPath = ffm("ContractListener.eventPath", "Deprecated: Please use 'eventPath' in the array of 'filters' instead")
	ContractListenerSignature = ffm("ContractListener.signature", "A concatenation of all the stringified signature of the event and location, as computed by the blockchain plugin")
	ContractListenerState     = ffm("ContractListener.state", "This field is provided for the event listener implementation of the blockchain provider to record state, such as checkpoint information")

	// ContractListenerOptions field descriptions
	ContractListenerOptionsFirstEvent = ffm("ContractListenerOptions.firstEvent", "A blockchain specific string, such as a block number, to start listening from. The special strings 'oldest' and 'newest' are supported by all blockchain connectors. Default is 'newest'")

	ListenerFilterInterface = ffm("ListenerFilter.interface", "A reference to an existing FFI, containing pre-registered type information for the event")
	ListenerFilterEvent     = ffm("ListenerFilter.event", "The definition of the event, either provided in-line when creating the listener, or extracted from the referenced FFI")
	ListenerFilterEventPath = ffm("ListenerFilter.eventPath", "When creating a listener from an existing FFI, this is the pathname of the event on that FFI to be detected by this listener")
	ListenerFilterLocation  = ffm("ListenerFilter.location", "A blockchain specific contract identifier. For example an Ethereum contract address, or a Fabric chaincode name and channel")
	ListenerFilterSignature = ffm("ListenerFilter.signature", "The stringified signature of the event and location, as computed by the blockchain plugin")

	// DIDDocument field descriptions
	DIDDocumentContext            = ffm("DIDDocument.@context", "See https://www.w3.org/TR/did-core/#json-ld")
	DIDDocumentID                 = ffm("DIDDocument.id", "See https://www.w3.org/TR/did-core/#did-document-properties")
	DIDDocumentAuthentication     = ffm("DIDDocument.authentication", "See https://www.w3.org/TR/did-core/#did-document-properties")
	DIDDocumentVerificationMethod = ffm("DIDDocument.verificationMethod", "See https://www.w3.org/TR/did-core/#did-document-properties")

	// DIDVerificationMethod field descriptions
	DIDVerificationMethodID                  = ffm("DIDVerificationMethod.id", "See https://www.w3.org/TR/did-core/#service-properties")
	DIDVerificationMethodController          = ffm("DIDVerificationMethod.controller", "See https://www.w3.org/TR/did-core/#service-properties")
	DIDVerificationMethodType                = ffm("DIDVerificationMethod.type", "See https://www.w3.org/TR/did-core/#service-properties")
	DIDVerificationMethodBlockchainAccountID = ffm("DIDVerificationMethod.blockchainAcountId", "For blockchains like Ethereum that represent signing identities directly by their public key summarized in an account string")
	DIDVerificationMethodMSPIdentityString   = ffm("DIDVerificationMethod.mspIdentityString", "For Hyperledger Fabric where the signing identity is represented by an MSP identifier (containing X509 certificate DN strings) that were validated by your local MSP")
	DIDVerificationMethodDataExchangePeerID  = ffm("DIDVerificationMethod.dataExchangePeerID", "A string provided by your Data Exchange plugin, that it uses a technology specific mechanism to validate against when messages arrive from this identity")

	// Event field descriptions
	EventID          = ffm("Event.id", "The UUID assigned to this event by your local FireFly node")
	EventSequence    = ffm("Event.sequence", "A sequence indicating the order in which events are delivered to your application. Assure to be unique per event in your local FireFly database (unlike the created timestamp)")
	EventType        = ffm("Event.type", "All interesting activity in FireFly is emitted as a FireFly event, of a given type. The 'type' combined with the 'reference' can be used to determine how to process the event within your application")
	EventNamespace   = ffm("Event.namespace", "The namespace of the event. Your application must subscribe to events within a namespace")
	EventReference   = ffm("Event.reference", "The UUID of an resource that is the subject of this event. The event type determines what type of resource is referenced, and whether this field might be unset")
	EventCorrelator  = ffm("Event.correlator", "For message events, this is the 'header.cid' field from the referenced message. For certain other event types, a secondary object is referenced such as a token pool")
	EventTransaction = ffm("Event.tx", "The UUID of a transaction that is event is part of. Not all events are part of a transaction")
	EventTopic       = ffm("Event.topic", "A stream of information this event relates to. For message confirmation events, a separate event is emitted for each topic in the message. For blockchain events, the listener specifies the topic. Rules exist for how the topic is set for other event types")
	EventCreated     = ffm("Event.created", "The time the event was emitted. Not guaranteed to be unique, or to increase between events in the same order as the final sequence events are delivered to your application. As such, the 'sequence' field should be used instead of the 'created' field for querying events in the exact order they are delivered to applications")

	// EnrichedEvent field descriptions
	EnrichedEventBlockchainEvent   = ffm("EnrichedEvent.blockchainEvent", "A blockchain event if referenced by the FireFly event")
	EnrichedEventContractAPI       = ffm("EnrichedEvent.contractAPI", "A Contract API if referenced by the FireFly event")
	EnrichedEventContractInterface = ffm("EnrichedEvent.contractInterface", "A Contract Interface (FFI) if referenced by the FireFly event")
	EnrichedEventDatatype          = ffm("EnrichedEvent.datatype", "A Datatype if referenced by the FireFly event")
	EnrichedEventIdentity          = ffm("EnrichedEvent.identity", "An Identity if referenced by the FireFly event")
	EnrichedEventMessage           = ffm("EnrichedEvent.message", "A Message if  referenced by the FireFly event")
	EnrichedEventNamespaceDetails  = ffm("EnrichedEvent.namespaceDetails", "Full resource detail of a Namespace if referenced by the FireFly event")
	EnrichedEventTokenApproval     = ffm("EnrichedEvent.tokenApproval", "A Token Approval if referenced by the FireFly event")
	EnrichedEventTokenPool         = ffm("EnrichedEvent.tokenPool", "A Token Pool if referenced by the FireFly event")
	EnrichedEventTokenTransfer     = ffm("EnrichedEvent.tokenTransfer", "A Token Transfer if referenced by the FireFly event")
	EnrichedEventTransaction       = ffm("EnrichedEvent.transaction", "A Transaction if associated with the FireFly event")

	// IdentityMessages field descriptions
	IdentityMessagesClaim        = ffm("IdentityMessages.claim", "The UUID of claim message")
	IdentityMessagesVerification = ffm("IdentityMessages.verification", "The UUID of claim message. Unset for root organization identities")
	IdentityMessagesUpdate       = ffm("IdentityMessages.update", "The UUID of the most recently applied update message. Unset if no updates have been confirmed")

	// Identity field descriptions
	IdentityID        = ffm("Identity.id", "The UUID of the identity")
	IdentityDID       = ffm("Identity.did", "The DID of the identity. Unique across namespaces within a FireFly network")
	IdentityType      = ffm("Identity.type", "The type of the identity")
	IdentityParent    = ffm("Identity.parent", "The UUID of the parent identity. Unset for root organization identities")
	IdentityNamespace = ffm("Identity.namespace", "The namespace of the identity. Organization and node identities are always defined in the ff_system namespace")
	IdentityName      = ffm("Identity.name", "The name of the identity. The name must be unique within the type and namespace")
	IdentityMessages  = ffm("Identity.messages", "References to the broadcast messages that established this identity and proved ownership of the associated verifiers (keys)")
	IdentityCreated   = ffm("Identity.created", "The creation time of the identity")
	IdentityUpdated   = ffm("Identity.updated", "The last update time of the identity profile")

	// IdentityProfile field descriptions
	IdentityProfileProfile     = ffm("IdentityProfile.profile", "A set of metadata for the identity. Part of the updatable profile information of an identity")
	IdentityProfileDescription = ffm("IdentityProfile.description", "A description of the identity. Part of the updatable profile information of an identity")

	// IdentityWithVerifiers field descriptions
	IdentityWithVerifiersVerifiers = ffm("IdentityWithVerifiers.verifiers", "The verifiers, such as blockchain signing keys, that have been bound to this identity and can be used to prove data orignates from that identity")

	// IdentityCreateDTO field descriptions
	IdentityCreateDTOParent = ffm("IdentityCreateDTO.parent", "On input the parent can be specified directly as the UUID of and existing identity, or as a DID to resolve to that identity, or an organization name. The parent must already have been registered, and its blockchain signing key must be available to the local node to sign the verification")
	IdentityCreateDTOKey    = ffm("IdentityCreateDTO.key", "The blockchain signing key to use to make the claim to the identity. Must be available to the local node to sign the identity claim. Will become a verifier on the established identity")

	// IdentityClaim field descriptions
	IdentityClaimIdentity = ffm("IdentityClaim.identity", "The identity being claimed")

	// IdentityVerification field descriptions
	IdentityVerificationClaim    = ffm("IdentityVerification.claim", "The UUID of the message containing the identity claim being verified")
	IdentityVerificationIdentity = ffm("IdentityVerification.identity", "The identity being verified")

	// IdentityUpdate field descriptions
	IdentityUpdateIdentity = ffm("IdentityUpdate.identity", "The identity being updated")
	IdentityUpdateProfile  = ffm("IdentityUpdate.profile", "The new profile, which is replaced in its entirety when the update is confirmed")

	// Verifier field descriptions
	VerifierHash      = ffm("Verifier.hash", "Hash used as a globally consistent identifier for this namespace + type + value combination on every node in the network")
	VerifierIdentity  = ffm("Verifier.identity", "The UUID of the parent identity that has claimed this verifier")
	VerifierType      = ffm("Verifier.type", "The type of the verifier")
	VerifierValue     = ffm("Verifier.value", "The verifier string, such as an Ethereum address, or Fabric MSP identifier")
	VerifierNamespace = ffm("Verifier.namespace", "The namespace of the verifier")
	VerifierCreated   = ffm("Verifier.created", "The time this verifier was created on this node")

	// Namespace field descriptions
	NamespaceName                  = ffm("Namespace.name", "The local namespace name")
	NamespaceNetworkName           = ffm("Namespace.networkName", "The shared namespace name within the multiparty network")
	NamespaceDescription           = ffm("Namespace.description", "A description of the namespace")
	NamespaceCreated               = ffm("Namespace.created", "The time the namespace was created")
	MultipartyContractsActive      = ffm("MultipartyContracts.active", "The currently active FireFly smart contract")
	MultipartyContractsTerminated  = ffm("MultipartyContracts.terminated", "Previously-terminated FireFly smart contracts")
	MultipartyContractIndex        = ffm("MultipartyContract.index", "The index of this contract in the config file")
	MultipartyContractVersion      = ffm("MultipartyContract.version", "The version of this multiparty contract")
	MultipartyContractFinalEvent   = ffm("MultipartyContract.finalEvent", "The identifier for the final blockchain event received from this contract before termination")
	MultipartyContractFirstEvent   = ffm("MultipartyContract.firstEvent", "A blockchain specific string, such as a block number, to start listening from. The special strings 'oldest' and 'newest' are supported by all blockchain connectors")
	MultipartyContractLocation     = ffm("MultipartyContract.location", "A blockchain specific contract identifier. For example an Ethereum contract address, or a Fabric chaincode name and channel")
	MultipartyContractSubscription = ffm("MultipartyContract.subscription", "The backend identifier of the subscription for the FireFly BatchPin contract")
	MultipartyContractStatus       = ffm("MultipartyContract.status", "The status of the contract listener. One of 'syncing', 'synced', or 'unknown'")
	MultipartyContractInfo         = ffm("MultipartyContract.info", "Additional info about the current status of the multi-party contract")
	NetworkActionType              = ffm("NetworkAction.type", "The action to be performed")

	// NamespaceWithInitStatus field descriptions
	NamespaceWithInitStatusInitializing        = ffm("NamespaceWithInitStatus.initializing", "Set to true if the namespace is still initializing")
	NamespaceWithInitStatusInitializationError = ffm("NamespaceWithInitStatus.initializationError", "Set to a non-empty string in the case that the namespace is currently failing to initialize")

	// NamespaceStatus field descriptions
	NodeNamespace       = ffm("NamespaceStatus.namespace", "The namespace that this status applies to")
	NamespaceStatusNode = ffm("NamespaceStatus.node", "Details of the local node")
	NamespaceStatusOrg  = ffm("NamespaceStatus.org", "Details of the root organization identity registered for this namespace on the local node")
	NamespacePlugins    = ffm("NamespaceStatus.plugins", "Information about plugins configured on this namespace")
	NamespaceMultiparty = ffm("NamespaceStatus.multiparty", "Information about the multi-party system configured on this namespace")

	// NamespaceStatusNode field descriptions
	NamespaceStatusNodeName                  = ffm("NamespaceStatusNode.name", "The name of this node, as specified in the local configuration")
	NamespaceStatusNodeRegistered            = ffm("NamespaceStatusNode.registered", "Whether the node has been successfully registered")
	NamespaceStatusNodeStatus                = ffm("NamespaceStatusNode.status", "The status of the node registration, one of 'unregistered', 'registering', 'registered', and 'unknown'")
	NamespaceStatusNodeRegistrationMessageID = ffm("NamespaceStatusNode.pendingRegistrationMessageId", "The ID of the pending message that broadcast the identity claim to the network")
	NamespaceStatusNodeID                    = ffm("NamespaceStatusNode.id", "The UUID of the node, if registered")

	// NamespaceStatusOrg field descriptions
	NamespaceStatusOrgName                  = ffm("NamespaceStatusOrg.name", "The name of the node operator organization, as specified in the local configuration")
	NamespaceStatusOrgRegistered            = ffm("NamespaceStatusOrg.registered", "Whether the organization has been successfully registered")
	NamespaceStatusOrgStatus                = ffm("NamespaceStatusOrg.status", "The status of the organization registration, one of 'unregistered', 'registering', 'registered', and 'unknown'")
	NamespaceStatusOrgRegistrationMessageID = ffm("NamespaceStatusOrg.pendingRegistrationMessageId", "The ID of the pending message that broadcast the identity claim to the network")
	NamespaceStatusOrgDID                   = ffm("NamespaceStatusOrg.did", "The DID of the organization identity, if registered")
	NamespaceStatusOrgID                    = ffm("NamespaceStatusOrg.id", "The UUID of the organization, if registered")
	NamespaceStatusOrgVerifiers             = ffm("NamespaceStatusOrg.verifiers", "Array of verifiers (blockchain keys) owned by this identity")

	// NamespaceStatusDefaults field descriptions
	NamespaceStatusDefaultsNamespace = ffm("NamespaceStatusDefaults.namespace", "The default namespace on this node")

	// NamespaceStatusPlugins field descriptions
	NamespaceStatusPluginsBlockchain    = ffm("NamespaceStatusPlugins.blockchain", "The blockchain plugins on this namespace")
	NamespaceStatusPluginsDatabase      = ffm("NamespaceStatusPlugins.database", "The database plugins on this namespace")
	NamespaceStatusPluginsDataExchange  = ffm("NamespaceStatusPlugins.dataExchange", "The data exchange plugins on this namespace")
	NamespacePluginsEvents              = ffm("NamespaceStatusPlugins.events", "The event plugins on this namespace")
	NamespaceStatusPluginsIdentity      = ffm("NamespaceStatusPlugins.identity", "The identity plugins on this namespace")
	NamespaceStatusPluginsSharedStorage = ffm("NamespaceStatusPlugins.sharedStorage", "The shared storage plugins on this namespace")
	NamespaceStatusPluginsTokens        = ffm("NamespaceStatusPlugins.tokens", "The token plugins on this namespace")

	// NamespaceStatusPlugin field descriptions
	NamespaceStatusPluginName = ffm("NamespaceStatusPlugin.name", "The name of the plugin")
	NamespaceStatusPluginType = ffm("NamespaceStatusPlugin.pluginType", "The type of the plugin")

	// NamespaceStatusMultiparty field descriptions
	NamespaceMultipartyEnabled  = ffm("NamespaceStatusMultiparty.enabled", "Whether multi-party mode is enabled for this namespace")
	NamespaceMultipartyContract = ffm("NamespaceStatusMultiparty.contract", "Information about the multi-party smart contract configured for this namespace")

	// NamespaceMultipartyStatus field descriptions
	NamespaceMultipartyStatusEnabled   = ffm("NamespaceMultipartyStatus.enabled", "Whether multi-party mode is enabled for this namespace")
	NamespaceMultipartyStatusNode      = ffm("NamespaceMultipartyStatus.node", "Details of the local node")
	NamespaceMultipartyStatusOrg       = ffm("NamespaceMultipartyStatus.org", "Details of the root organization identity registered for this namespace on the local node")
	NamespaceMultipartyStatusContracts = ffm("NamespaceMultipartyStatus.contracts", "Information about the active and terminated multi-party smart contracts configured for this namespace")

	// BatchManagerStatus field descriptions
	BatchManagerStatusProcessors = ffm("BatchManagerStatus.processors", "An array of currently active batch processors")

	// BatchProcessorStatus field descriptions
	BatchProcessorStatusDispatcher = ffm("BatchProcessorStatus.dispatcher", "The type of dispatcher for this processor")
	BatchProcessorStatusName       = ffm("BatchProcessorStatus.name", "The name of the processor, which includes details of the attributes of message are allocated to this processor")
	BatchProcessorStatusStatus     = ffm("BatchProcessorStatus.status", "The flush status for this batch processor")

	// BatchFlushStatus field descriptions
	BatchFlushStatusLastFlushTime        = ffm("BatchFlushStatus.lastFlushStartTime", "The last time a flush was performed")
	BatchFlushStatusFlushing             = ffm("BatchFlushStatus.flushing", "If a flush is in progress, this is the UUID of the batch being flushed")
	BatchFlushStatusBlocked              = ffm("BatchFlushStatus.blocked", "True if the batch flush is in a retry loop, due to errors being returned by the plugins")
	BatchFlushStatusCancelled            = ffm("BatchFlushStatus.cancelled", "True if the current batch flush has been cancelled")
	BatchFlushStatusLastFlushError       = ffm("BatchFlushStatus.lastFlushError", "The last error received by this batch processor while flushing")
	BatchFlushStatusLastFlushErrorTime   = ffm("BatchFlushStatus.lastFlushErrorTime", "The time of the last flush")
	BatchFlushStatusAverageBatchBytes    = ffm("BatchFlushStatus.averageBatchBytes", "The average byte size of each batch")
	BatchFlushStatusAverageBatchMessages = ffm("BatchFlushStatus.averageBatchMessages", "The average number of messages included in each batch")
	BatchFlushStatusAverageBatchData     = ffm("BatchFlushStatus.averageBatchData", "The average number of data attachments included in each batch")
	BatchFlushStatusAverageFlushTimeMS   = ffm("BatchFlushStatus.averageFlushTimeMS", "The average amount of time spent flushing each batch")
	BatchFlushStatusTotalBatches         = ffm("BatchFlushStatus.totalBatches", "The total count of batches flushed by this processor since it started")
	BatchFlushStatusTotalErrors          = ffm("BatchFlushStatus.totalErrors", "The total count of error flushed encountered by this processor since it started")

	// Pin field descriptions
	PinSequence       = ffm("Pin.sequence", "The order of the pin in the local FireFly database, which matches the order in which pins were delivered to FireFly by the blockchain connector event stream")
	PinNamespace      = ffm("Pin.namespace", "The namespace of the pin")
	PinMasked         = ffm("Pin.masked", "True if the pin is for a private message, and hence is masked with the group ID and salted with a nonce so observers of the blockchain cannot use pin hash to match this transaction to other transactions or participants")
	PinHash           = ffm("Pin.hash", "The hash represents a topic within a message in the batch. If a message has multiple topics, then multiple pins are created. If the message is private, the hash is masked for privacy")
	PinBatch          = ffm("Pin.batch", "The UUID of the batch of messages this pin is part of")
	PinBatchHash      = ffm("Pin.batchHash", "The manifest hash batch of messages this pin is part of")
	PinIndex          = ffm("Pin.index", "The index of this pin within the batch. One pin is created for each topic, of each message in the batch")
	PinDispatched     = ffm("Pin.dispatched", "Once true, this pin has been processed and will not be processed again")
	PinSigner         = ffm("Pin.signer", "The blockchain signing key that submitted this transaction, as passed through to FireFly by the smart contract that emitted the blockchain event")
	PinCreated        = ffm("Pin.created", "The time the FireFly node created the pin")
	PinRewindSequence = ffm("PinRewind.sequence", "The sequence of the pin to which the event aggregator should rewind. Either sequence or batch must be specified")
	PinRewindBatch    = ffm("PinRewind.batch", "The ID of the batch to which the event aggregator should rewind. Either sequence or batch must be specified")

	// NextPin field descriptions
	NextPinNamespace = ffm("NextPin.namespace", "The namespace of the next-pin")
	NextPinContext   = ffm("NextPin.context", "The context the next-pin applies to - the hash of the privacy group-hash + topic. The group-hash is only known to the participants (can itself contain a salt in the group-name). This context is combined with the member and nonce to determine the final hash that is written on-chain")
	NextPinIdentity  = ffm("NextPin.identity", "The member of the privacy group the next-pin applies to")
	NextPinHash      = ffm("NextPin.hash", "The unique masked pin string")
	NextPinNonce     = ffm("NextPin.nonce", "The numeric index - which is monotonically increasing for each member of the privacy group")

	// Subscription field descriptions
	SubscriptionID        = ffm("Subscription.id", "The UUID of the subscription")
	SubscriptionNamespace = ffm("Subscription.namespace", "The namespace of the subscription. A subscription will only receive events generated in the namespace of the subscription")
	SubscriptionName      = ffm("Subscription.name", "The name of the subscription. The application specifies this name when it connects, in order to attach to the subscription and receive events that arrived while it was disconnected. If multiple apps connect to the same subscription, events are workload balanced across the connected application instances")
	SubscriptionTransport = ffm("Subscription.transport", "The transport plugin responsible for event delivery (WebSockets, Webhooks, JMS, NATS etc.)")
	SubscriptionFilter    = ffm("Subscription.filter", "Server-side filter to apply to events")
	SubscriptionOptions   = ffm("Subscription.options", "Subscription options")
	SubscriptionEphemeral = ffm("Subscription.ephemeral", "Ephemeral subscriptions only exist as long as the application is connected, and as such will miss events that occur while the application is disconnected, and cannot be created administratively. You can create one over over a connected WebSocket connection")
	SubscriptionCreated   = ffm("Subscription.created", "Creation time of the subscription")
	SubscriptionUpdated   = ffm("Subscription.updated", "Last time the subscription was updated")

	// SubscriptionFilter field descriptions
	SubscriptionFilterEvents           = ffm("SubscriptionFilter.events", "Regular expression to apply to the event type, to subscribe to a subset of event types")
	SubscriptionFilterTopic            = ffm("SubscriptionFilter.topic", "Regular expression to apply to the topic of the event, to subscribe to a subset of topics. Note for messages sent with multiple topics, a separate event is emitted for each topic")
	SubscriptionFilterMessage          = ffm("SubscriptionFilter.message", "Filters specific to message events. If an event is not a message event, these filters are ignored")
	SubscriptionFilterTransaction      = ffm("SubscriptionFilter.transaction", "Filters specific to events with a transaction. If an event is not associated with a transaction, this filter is ignored")
	SubscriptionFilterBlockchainEvent  = ffm("SubscriptionFilter.blockchainevent", "Filters specific to blockchain events. If an event is not a blockchain event, these filters are ignored")
	SubscriptionFilterDeprecatedTopics = ffm("SubscriptionFilter.topics", "Deprecated: Please use 'topic' instead")
	SubscriptionFilterDeprecatedTag    = ffm("SubscriptionFilter.tag", "Deprecated: Please use 'message.tag' instead")
	SubscriptionFilterDeprecatedGroup  = ffm("SubscriptionFilter.group", "Deprecated: Please use 'message.group' instead")
	SubscriptionFilterDeprecatedAuthor = ffm("SubscriptionFilter.author", "Deprecated: Please use 'message.author' instead")

	// SubscriptionMessageFilter field descriptions
	SubscriptionMessageFilterTag    = ffm("SubscriptionMessageFilter.tag", "Regular expression to apply to the message 'header.tag' field")
	SubscriptionMessageFilterGroup  = ffm("SubscriptionMessageFilter.group", "Regular expression to apply to the message 'header.group' field")
	SubscriptionMessageFilterAuthor = ffm("SubscriptionMessageFilter.author", "Regular expression to apply to the message 'header.author' field")

	// SubscriptionTransactionFilter field descriptions
	SubscriptionTransactionFilterType = ffm("SubscriptionTransactionFilter.type", "Regular expression to apply to the transaction 'type' field")

	// SubscriptionBlockchainEventFilter field descriptions
	SubscriptionBlockchainEventFilterName     = ffm("SubscriptionBlockchainEventFilter.name", "Regular expression to apply to the blockchain event 'name' field, which is the name of the event in the underlying blockchain smart contract")
	SubscriptionBlockchainEventFilterListener = ffm("SubscriptionBlockchainEventFilter.listener", "Regular expression to apply to the blockchain event 'listener' field, which is the UUID of the event listener. So you can restrict your subscription to certain blockchain listeners. Alternatively to avoid your application need to know listener UUIDs you can set the 'topic' field of blockchain event listeners, and use a topic filter on your subscriptions")

	// SubscriptionCoreOptions field descriptions
	SubscriptionCoreOptionsFirstEvent   = ffm("SubscriptionCoreOptions.firstEvent", "Whether your application would like to receive events from the 'oldest' event emitted by your FireFly node (from the beginning of time), or the 'newest' event (from now), or a specific event sequence. Default is 'newest'")
	SubscriptionCoreOptionsReadAhead    = ffm("SubscriptionCoreOptions.readAhead", "The number of events to stream ahead to your application, while waiting for confirmation of consumption of those events. At least once delivery semantics are used in FireFly, so if your application crashes/reconnects this is the maximum number of events you would expect to be redelivered after it restarts")
	SubscriptionCoreOptionsWithData     = ffm("SubscriptionCoreOptions.withData", "Whether message events delivered over the subscription, should be packaged with the full data of those messages in-line as part of the event JSON payload. Or if the application should make separate REST calls to download that data. May not be supported on some transports.")
	SubscriptionCoreOptionsBatch        = ffm("SubscriptionCoreOptions.batch", "Events are delivered in batches in an ordered array. The batch size is capped to the readAhead limit. The event payload is always an array even if there is a single event in the batch, allowing client-side optimizations when processing the events in a group. Available for both Webhooks and WebSockets.")
	SubscriptionCoreOptionsBatchTimeout = ffm("SubscriptionCoreOptions.batchTimeout", "When batching is enabled, the optional timeout to send events even when the batch hasn't filled.")

	// TokenApproval field descriptions
	TokenApprovalLocalID         = ffm("TokenApproval.localId", "The UUID of this token approval, in the local FireFly node")
	TokenApprovalPool            = ffm("TokenApproval.pool", "The UUID the token pool this approval applies to")
	TokenApprovalConnector       = ffm("TokenApproval.connector", "The name of the token connector, as specified in the FireFly core configuration file. Required on input when there are more than one token connectors configured")
	TokenApprovalKey             = ffm("TokenApproval.key", "The blockchain signing key for the approval request. On input defaults to the first signing key of the organization that operates the node")
	TokenApprovalOperator        = ffm("TokenApproval.operator", "The blockchain identity that is granted the approval")
	TokenApprovalApproved        = ffm("TokenApproval.approved", "Whether this record grants permission for an operator to perform actions on the token balance (true), or revokes permission (false)")
	TokenApprovalInfo            = ffm("TokenApproval.info", "Token connector specific information about the approval operation, such as whether it applied to a limited balance of a fungible token. See your chosen token connector documentation for details")
	TokenApprovalNamespace       = ffm("TokenApproval.namespace", "The namespace for the approval, which must match the namespace of the token pool")
	TokenApprovalProtocolID      = ffm("TokenApproval.protocolId", "An alphanumerically sortable string that represents this event uniquely with respect to the blockchain")
	TokenApprovalSubject         = ffm("TokenApproval.subject", "A string identifying the parties and entities in the scope of this approval, as provided by the token connector")
	TokenApprovalActive          = ffm("TokenApproval.active", "Indicates if this approval is currently active (only one approval can be active per subject)")
	TokenApprovalMessage         = ffm("TokenApproval.message", "The UUID of a message that has been correlated with this approval using the data field of the approval in a compatible token connector")
	TokenApprovalMessageHash     = ffm("TokenApproval.messageHash", "The hash of a message that has been correlated with this approval using the data field of the approval in a compatible token connector")
	TokenApprovalCreated         = ffm("TokenApproval.created", "The creation time of the token approval")
	TokenApprovalTX              = ffm("TokenApproval.tx", "If submitted via FireFly, this will reference the UUID of the FireFly transaction (if the token connector in use supports attaching data)")
	TokenApprovalBlockchainEvent = ffm("TokenApproval.blockchainEvent", "The UUID of the blockchain event")
	TokenApprovalConfig          = ffm("TokenApproval.config", "Input only field, with token connector specific configuration of the approval.  See your chosen token connector documentation for details")

	// TokenApprovalInput field descriptions
	TokenApprovalInputMessage        = ffm("TokenApprovalInput.message", "You can specify a message to correlate with the approval, which can be of type broadcast or private. Your chosen token connector and on-chain smart contract must support on-chain/off-chain correlation by taking a `data` input on the approval")
	TokenApprovalInputPool           = ffm("TokenApprovalInput.pool", "The name or UUID of a token pool. Required if more than one pool exists.")
	TokenApprovalInputIdempotencyKey = ffm("TokenApprovalInput.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// TokenBalance field descriptions
	TokenBalancePool       = ffm("TokenBalance.pool", "The UUID the token pool this balance entry applies to")
	TokenBalanceTokenIndex = ffm("TokenBalance.tokenIndex", "The index of the token within the pool that this balance applies to")
	TokenBalanceURI        = ffm("TokenBalance.uri", "The URI of the token this balance entry applies to")
	TokenBalanceConnector  = ffm("TokenBalance.connector", "The token connector that is responsible for the token pool of this balance entry")
	TokenBalanceNamespace  = ffm("TokenBalance.namespace", "The namespace of the token pool for this balance entry")
	TokenBalanceKey        = ffm("TokenBalance.key", "The blockchain signing identity this balance applies to")
	TokenBalanceBalance    = ffm("TokenBalance.balance", "The numeric balance. For non-fungible tokens will always be 1. For fungible tokens, the number of decimals for the token pool should be considered when interpreting the balance. For example, with 18 decimals a fractional balance of 10.234 will be returned as 10,234,000,000,000,000,000")
	TokenBalanceUpdated    = ffm("TokenBalance.updated", "The last time the balance was updated by applying a transfer event")

	// TokenBalance field descriptions
	TokenConnectorName = ffm("TokenConnector.name", "The name of the token connector, as configured in the FireFly core configuration file")

	// TokenPool field descriptions
	TokenPoolID              = ffm("TokenPool.id", "The UUID of the token pool")
	TokenPoolType            = ffm("TokenPool.type", "The type of token the pool contains, such as fungible/non-fungible")
	TokenPoolNamespace       = ffm("TokenPool.namespace", "The namespace for the token pool")
	TokenPoolName            = ffm("TokenPool.name", "The name of the token pool. Note the name is not validated against the description of the token on the blockchain")
	TokenPoolNetworkName     = ffm("TokenPool.networkName", "The published name of the token pool within the multiparty network")
	TokenPoolStandard        = ffm("TokenPool.standard", "The ERC standard the token pool conforms to, as reported by the token connector")
	TokenPoolLocator         = ffm("TokenPool.locator", "A unique identifier for the pool, as provided by the token connector")
	TokenPoolKey             = ffm("TokenPool.key", "The signing key used to create the token pool. On input for token connectors that support on-chain deployment of new tokens (vs. only index existing ones) this determines the signing key used to create the token on-chain")
	TokenPoolSymbol          = ffm("TokenPool.symbol", "The token symbol. If supplied on input for an existing on-chain token, this must match the on-chain information")
	TokenPoolDecimals        = ffm("TokenPool.decimals", "Number of decimal places that this token has")
	TokenPoolConnector       = ffm("TokenPool.connector", "The name of the token connector, as specified in the FireFly core configuration file that is responsible for the token pool. Required on input when multiple token connectors are configured")
	TokenPoolMessage         = ffm("TokenPool.message", "The UUID of the broadcast message used to inform the network about this pool")
	TokenPoolActive          = ffm("TokenPool.active", "Indicates whether the pool has been successfully activated with the token connector")
	TokenPoolCreated         = ffm("TokenPool.created", "The creation time of the pool")
	TokenPoolConfig          = ffm("TokenPool.config", "Input only field, with token connector specific configuration of the pool, such as an existing Ethereum address and block number to used to index the pool. See your chosen token connector documentation for details")
	TokenPoolInfo            = ffm("TokenPool.info", "Token connector specific information about the pool. See your chosen token connector documentation for details")
	TokenPoolTX              = ffm("TokenPool.tx", "Reference to the FireFly transaction used to create and broadcast this pool to the network")
	TokenPoolInterface       = ffm("TokenPool.interface", "A reference to an existing FFI, containing pre-registered type information for the token contract")
	TokenPoolInterfaceFormat = ffm("TokenPool.interfaceFormat", "The interface encoding format supported by the connector for this token pool")
	TokenPoolMethods         = ffm("TokenPool.methods", "The method definitions resolved by the token connector to be used by each token operation")
	TokenPoolPublished       = ffm("TokenPool.published", "Indicates if the token pool is published to other members of the multiparty network")

	// TokenPoolInput field descriptions
	TokenPoolInputIdempotencyKey = ffm("TokenPoolInput.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// TokenTransfer field descriptions
	TokenTransferType            = ffm("TokenTransfer.type", "The type of transfer such as mint/burn/transfer")
	TokenTransferLocalID         = ffm("TokenTransfer.localId", "The UUID of this token transfer, in the local FireFly node")
	TokenTransferPool            = ffm("TokenTransfer.pool", "The UUID the token pool this transfer applies to")
	TokenTransferTokenIndex      = ffm("TokenTransfer.tokenIndex", "The index of the token within the pool that this transfer applies to")
	TokenTransferURI             = ffm("TokenTransfer.uri", "The URI of the token this transfer applies to")
	TokenTransferConnector       = ffm("TokenTransfer.connector", "The name of the token connector, as specified in the FireFly core configuration file. Required on input when there are more than one token connectors configured")
	TokenTransferNamespace       = ffm("TokenTransfer.namespace", "The namespace for the transfer, which must match the namespace of the token pool")
	TokenTransferKey             = ffm("TokenTransfer.key", "The blockchain signing key for the transfer. On input defaults to the first signing key of the organization that operates the node")
	TokenTransferFrom            = ffm("TokenTransfer.from", "The source account for the transfer. On input defaults to the value of 'key'")
	TokenTransferTo              = ffm("TokenTransfer.to", "The target account for the transfer. On input defaults to the value of 'key'")
	TokenTransferAmount          = ffm("TokenTransfer.amount", "The amount for the transfer. For non-fungible tokens will always be 1. For fungible tokens, the number of decimals for the token pool should be considered when inputting the amount. For example, with 18 decimals a fractional balance of 10.234 will be specified as 10,234,000,000,000,000,000")
	TokenTransferProtocolID      = ffm("TokenTransfer.protocolId", "An alphanumerically sortable string that represents this event uniquely with respect to the blockchain")
	TokenTransferMessage         = ffm("TokenTransfer.message", "The UUID of a message that has been correlated with this transfer using the data field of the transfer in a compatible token connector")
	TokenTransferMessageHash     = ffm("TokenTransfer.messageHash", "The hash of a message that has been correlated with this transfer using the data field of the transfer in a compatible token connector")
	TokenTransferCreated         = ffm("TokenTransfer.created", "The creation time of the transfer")
	TokenTransferTX              = ffm("TokenTransfer.tx", "If submitted via FireFly, this will reference the UUID of the FireFly transaction (if the token connector in use supports attaching data)")
	TokenTransferBlockchainEvent = ffm("TokenTransfer.blockchainEvent", "The UUID of the blockchain event")
	TokenTransferConfig          = ffm("TokenTransfer.config", "Input only field, with token connector specific configuration of the transfer. See your chosen token connector documentation for details")

	// TokenTransferInput field descriptions
	TokenTransferInputMessage        = ffm("TokenTransferInput.message", "You can specify a message to correlate with the transfer, which can be of type broadcast or private. Your chosen token connector and on-chain smart contract must support on-chain/off-chain correlation by taking a `data` input on the transfer")
	TokenTransferInputPool           = ffm("TokenTransferInput.pool", "The name or UUID of a token pool")
	TokenTransferInputIdempotencyKey = ffm("TokenTransferInput.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// TransactionStatus field descriptions
	TransactionStatusStatus  = ffm("TransactionStatus.status", "The overall computed status of the transaction, after analyzing the details during the API call")
	TransactionStatusDetails = ffm("TransactionStatus.details", "A set of records describing the activities within the transaction known by the local FireFly node")

	// TransactionStatusDetails field descriptions
	TransactionStatusDetailsType      = ffm("TransactionStatusDetails.type", "The type of the transaction status detail record")
	TransactionStatusDetailsSubType   = ffm("TransactionStatusDetails.subtype", "A sub-type, such as an operation type, or an event type")
	TransactionStatusDetailsStatus    = ffm("TransactionStatusDetails.status", "The status of the detail record. Cases where an event is required for completion, but has not arrived yet are marked with a 'pending' record")
	TransactionStatusDetailsTimestamp = ffm("TransactionStatusDetails.timestamp", "The time relevant to when the record was updated, such as the time an event was created, or the last update time of an operation")
	TransactionStatusDetailsID        = ffm("TransactionStatusDetails.id", "The UUID of the entry referenced by this detail. The type of this record can be inferred from the entry type")
	TransactionStatusDetailsError     = ffm("TransactionStatusDetails.error", "If an error occurred related to the detail entry, it is included here")
	TransactionStatusDetailsInfo      = ffm("TransactionStatusDetails.info", "Output details for this entry")

	// ContractDeployRequest field descriptions
	ContractDeployRequestKey            = ffm("ContractDeployRequest.key", "The blockchain signing key that will be used to deploy the contract. Defaults to the first signing key of the organization that operates the node")
	ContractDeployRequestInput          = ffm("ContractDeployRequest.input", "An optional array of inputs passed to the smart contract's constructor, if applicable")
	ContractDeployRequestDefinition     = ffm("ContractDeployRequest.definition", "The definition of the smart contract")
	ContractDeployRequestContract       = ffm("ContractDeployRequest.contract", "The smart contract to deploy. This should be pre-compiled if required by the blockchain connector")
	ContractDeployRequestErrors         = ffm("ContractDeployRequest.errors", "An in-line FFI errors definition for the constructor")
	ContractDeployRequestOptions        = ffm("ContractDeployRequest.options", "A map of named inputs that will be passed through to the blockchain connector")
	ContractDeployRequestIdempotencyKey = ffm("ContractDeployRequest.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// ContractCallRequest field descriptions
	ContractCallRequestType       = ffm("ContractCallRequest.type", "Invocations cause transactions on the blockchain. Whereas queries simply execute logic in your local node to query data at a given current/historical block")
	ContractCallRequestInterface  = ffm("ContractCallRequest.interface", "The UUID of a method within a pre-configured FireFly interface (FFI) definition for a smart contract. Required if the 'method' is omitted. Also see Contract APIs as a way to configure a dedicated API for your FFI, including all methods and an OpenAPI/Swagger interface")
	ContractCallRequestLocation   = ffm("ContractCallRequest.location", "A blockchain specific contract identifier. For example an Ethereum contract address, or a Fabric chaincode name and channel")
	ContractCallRequestKey        = ffm("ContractCallRequest.key", "The blockchain signing key that will sign the invocation. Defaults to the first signing key of the organization that operates the node")
	ContractCallRequestMethod     = ffm("ContractCallRequest.method", "An in-line FFI method definition for the method to invoke. Required when FFI is not specified")
	ContractCallRequestMethodPath = ffm("ContractCallRequest.methodPath", "The pathname of the method on the specified FFI")
	ContractCallRequestErrors     = ffm("ContractCallRequest.errors", "An in-line FFI errors definition for the method to invoke. Alternative to specifying FFI")
	ContractCallRequestInput      = ffm("ContractCallRequest.input", "A map of named inputs. The name and type of each input must be compatible with the FFI description of the method, so that FireFly knows how to serialize it to the blockchain via the connector")
	ContractCallRequestOutput     = ffm("ContractCallRequest.output", "A map of named outputs")
	ContractCallRequestOptions    = ffm("ContractCallRequest.options", "A map of named inputs that will be passed through to the blockchain connector")
	ContractCallMessage           = ffm("ContractCallRequest.message", "You can specify a message to correlate with the invocation, which can be of type broadcast or private. Your specified method must support on-chain/off-chain correlation by taking a data input on the call")
	ContractCallIdempotencyKey    = ffm("ContractCallRequest.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// WebSocketStatus field descriptions
	WebSocketStatusEnabled     = ffm("WebSocketStatus.enabled", "Indicates whether the websockets plugin is enabled")
	WebSocketStatusConnections = ffm("WebSocketStatus.connections", "List of currently active websocket client connections")

	// WSConnectionStatus field descriptions
	WSConnectionStatusID            = ffm("WSConnectionStatus.id", "The unique ID assigned to this client connection")
	WSConnectionStatusRemoteAddress = ffm("WSConnectionStatus.remoteAddress", "The remote address of the connected client (if available)")
	WSConnectionStatusUserAgent     = ffm("WSConnectionStatus.userAgent", "The user agent of the connected client (if available)")
	WSConnectionStatusSubscriptions = ffm("WSConnectionStatus.subscriptions", "List of subscriptions currently started by this client")

	// WSSubscriptionStatus field descriptions
	WSSubscriptionStatusEphemeral = ffm("WSSubscriptionStatus.ephemeral", "Indicates whether the subscription is ephemeral (vs durable)")
	WSSubscriptionStatusNamespace = ffm("WSSubscriptionStatus.namespace", "The subscription namespace")
	WSSubscriptionStatusName      = ffm("WSSubscriptionStatus.name", "The subscription name (for durable subscriptions only)")
	WSSubscriptionStatusFilter    = ffm("WSSubscriptionStatus.filter", "The subscription filter specification")
	WSSubscriptionStatusStartTime = ffm("WSSubscriptionStatus.startTime", "The time the subscription started (reset on dynamic namespace reload)")

	WebhooksOptJSON                     = ffm("WebhookSubOptions.json", "Webhooks only: Whether to assume the response body is JSON, regardless of the returned Content-Type")
	WebhooksOptReply                    = ffm("WebhookSubOptions.reply", "Webhooks only: Whether to automatically send a reply event, using the body returned by the webhook")
	WebhooksOptHeaders                  = ffm("WebhookSubOptions.headers", "Webhooks only: Static headers to set on the webhook request")
	WebhooksOptQuery                    = ffm("WebhookSubOptions.query", "Webhooks only: Static query params to set on the webhook request")
	WebhooksOptInput                    = ffm("WebhookSubOptions.input", "Webhooks only: A set of options to extract data from the first JSON input data in the incoming message. Only applies if withData=true")
	WebhooksOptFastAck                  = ffm("WebhookSubOptions.fastack", "Webhooks only: When true the event will be acknowledged before the webhook is invoked, allowing parallel invocations")
	WebhooksOptURL                      = ffm("WebhookSubOptions.url", "Webhooks only: HTTP url to invoke. Can be relative if a base URL is set in the webhook plugin config")
	WebhooksOptMethod                   = ffm("WebhookSubOptions.method", "Webhooks only: HTTP method to invoke. Default=POST")
	WebhooksOptReplyTag                 = ffm("WebhookSubOptions.replytag", "Webhooks only: The tag to set on the reply message")
	WebhooksOptReplyTx                  = ffm("WebhookSubOptions.replytx", "Webhooks only: The transaction type to set on the reply message")
	WebhooksOptTLSConfigName            = ffm("WebhookSubOptions.tlsConfigName", "The name of an existing TLS configuration associated to the namespace to use")
	WebhooksOptHTTPOptions              = ffm("WebhookSubOptions.httpOptions", "Webhooks only: a set of options for HTTP")
	WebhooksOptHTTPRetry                = ffm("WebhookSubOptions.retry", "Webhooks only: a set of options for retrying the webhook call")
	WebhooksOptInputQuery               = ffm("WebhookInputOptions.query", "A top-level property of the first data input, to use for query parameters")
	WebhooksOptInputHeaders             = ffm("WebhookInputOptions.headers", "A top-level property of the first data input, to use for headers")
	WebhooksOptInputBody                = ffm("WebhookInputOptions.body", "A top-level property of the first data input, to use for the request body. Default is the whole first body")
	WebhooksOptInputPath                = ffm("WebhookInputOptions.path", "A top-level property of the first data input, to use for a path to append with escaping to the webhook path")
	WebhooksOptInputReplyTx             = ffm("WebhookInputOptions.replytx", "A top-level property of the first data input, to use to dynamically set whether to pin the response (so the requester can choose)")
	WebhooksOptRetryEnabled             = ffm("WebhookRetryOptions.enabled", "Enables retry on HTTP calls, defaults to false")
	WebhooksOptRetryCount               = ffm("WebhookRetryOptions.count", "Number of times to retry the webhook call in case of failure")
	WebhooksOptRetryInitialDelay        = ffm("WebhookRetryOptions.initialDelay", "Initial delay between retries when we retry the webhook call")
	WebhooksOptRetryMaxDelay            = ffm("WebhookRetryOptions.maxDelay", "Max delay between retries when we retry the webhookcall")
	WebhookOptHTTPExpectContinueTimeout = ffm("WebhookHTTPOptions.expectContinueTimeout", "See [ExpectContinueTimeout in the Go docs](https://pkg.go.dev/net/http#Transport)")
	WebhookOptHTTPIdleTimeout           = ffm("WebhookHTTPOptions.idleTimeout", "The max duration to hold a HTTP keepalive connection between calls")
	WebhookOptHTTPMaxIdleConns          = ffm("WebhookHTTPOptions.maxIdleConns", "The max number of idle connections to hold pooled")
	WebhookOptHTTPConnectionTimeout     = ffm("WebhookHTTPOptions.connectionTimeout", "The maximum amount of time that a connection is allowed to remain with no data transmitted.")
	WebhookOptHTTPTLSHandshakeTimeout   = ffm("WebhookHTTPOptions.tlsHandshakeTimeout", "The max duration to hold a TLS handshake alive")
	WebhookOptHTTPRequestTimeout        = ffm("WebhookHTTPOptions.requestTimeout", "The max duration to hold a TLS handshake alive")
	WebhookOptHTTPProxyURL              = ffm("WebhookHTTPOptions.proxyURL", "HTTP proxy URL to use for outbound requests to the webhook")

	// PublishInput field descriptions
	PublishInputIdempotencyKey = ffm("PublishInput.idempotencyKey", "An optional identifier to allow idempotent submission of requests. Stored on the transaction uniquely within a namespace")

	// DefinitionPublish field descriptions
	DefinitionPublishNetworkName = ffm("DefinitionPublish.networkName", "An optional name to be used for publishing this definition to the multiparty network, which may differ from the local name")
)