sdk

type APIClient struct {
	AnalyticsApi *AnalyticsApiService

	HealthApi *HealthApiService

	NodeApi *NodeApiService

	WalletApi *WalletApiService
	// contains filtered or unexported fields
}

type APIKey struct {
	Key    string
	Prefix string
}

type APIResponse struct {
	*http.Response `json:"-"`
	Message        string `json:"message,omitempty"`
	// Operation is the name of the OpenAPI operation.
	Operation string `json:"operation,omitempty"`
	// RequestURL is the request URL. This value is always available, even if the
	// embedded *http.Response is nil.
	RequestURL string `json:"url,omitempty"`
	// Method is the HTTP method used for the request.  This value is always
	// available, even if the embedded *http.Response is nil.
	Method string `json:"method,omitempty"`
	// Payload holds the contents of the response body (which may be nil or empty).
	// This is provided here as the raw response.Body() reader will have already
	// been drained.
	Payload []byte `json:"-"`
}

type AnalyticIssueWalletTx struct {
	// Boolean signifying whether the Assets were issued to the Wallet in question
	IsIncoming bool `json:"is_incoming,omitempty"`
	// Boolean signifying whether the Wallet used to issue the Assets is the Wallet in question
	IssuedBySelf bool `json:"issued_by_self,omitempty"`
	// The public key of the Wallet that was used to issue the Assets
	SenderId string `json:"sender_id,omitempty"`
	// The Address the Assets were issued to
	RecipientAddress string `json:"recipient_address,omitempty"`
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id,omitempty"`
	// The amount of Assets issued
	Amount int32 `json:"amount,omitempty"`
	// Boolean signifying whether the Issuance was done confidentially
	IsConfidential bool `json:"is_confidential,omitempty"`
	// The private memo attached to the Issuance
	Memo string `json:"memo,omitempty"`
}

type AnalyticRuleWalletTx struct {
	// Boolean signifying whether the Rule was created by the Wallet in question
	SignedBySelf bool `json:"signed_by_self,omitempty"`
	// Boolean signifying whether the Rule granted permissions to the Wallet in question
	RuleAffectSelf bool `json:"rule_affect_self,omitempty"`
	// The public key of the Wallet that was used to create the Rule
	TxSigner string                        `json:"tx_signer,omitempty"`
	Rule     AnalyticsRuleWalletDefinition `json:"rule,omitempty"`
}

type AnalyticTransaction struct {
	Metadata AnalyticsTxMetadata `json:"metadata,omitempty"`
	// The detailed content of the transaction; format differs depending on the transaction type
	Content map[string]interface{} `json:"content,omitempty"`
}

type AnalyticTransferWalletTx struct {
	// Boolean signifying whether the Assets were transferred to the Wallet in question; false of the Assets were transferred from the Wallet into another
	IsIncoming bool `json:"is_incoming,omitempty"`
	// The public key of the Wallet the Assets were transferred from
	SenderId string `json:"sender_id,omitempty"`
	// The address of the Wallet the Assets were transferred to
	RecipientAddress string `json:"recipient_address,omitempty"`
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id,omitempty"`
	// The amount of Assets transferred
	Amount int32 `json:"amount,omitempty"`
	// The private memo attached to the Transfer
	Memo string `json:"memo,omitempty"`
}

type AnalyticWalletMetadata struct {
	Type AnalyticsTxType `json:"type,omitempty"`
	// The QEDIT-generated hash of the transaction
	TxHash string `json:"tx_hash,omitempty"`
	// UTC time of creation of the time the Block containing the transaction was created in RFC-3339 format
	Timestamp string `json:"timestamp,omitempty"`
}

type AnalyticWalletTx struct {
	Metadata AnalyticWalletMetadata `json:"metadata,omitempty"`
	// The detailed information of the transaction; structure depends on the type of transaction
	Content map[string]interface{} `json:"content,omitempty"`
}

type AnalyticsApiService service

type AnalyticsAssetConverterProofDescription struct {
	// The commitment to both the Asset Type and amount of the Note
	InputCv string `json:"input_cv,omitempty"`
	// The commitment to the Asset amount
	AmountCv string `json:"amount_cv,omitempty"`
	// The commitment to the ID of the Asset Type
	AssetCv string `json:"asset_cv,omitempty"`
	// The Proof that the commitment contents match
	Zkproof string `json:"zkproof,omitempty"`
}

type AnalyticsConfidentialIssuanceDescription struct {
	// The commitment to both the Asset Type and amount of the issued Note
	Casset string `json:"casset,omitempty"`
	// A `Namespace` describes what Asset IDs can be issued in an Issuance Rule. It is a string in the same format as `AssetId`. Additionally, if it ends with a wildcard character `*`, then the namespace covers all asset IDs with the namespace as a prefix. Without a final wildcard, the namespace covers exactly one asset ID. Example: The namespace `currencies.dollar` covers only this exact asset type, while `currencies.*` covers all asset types that start with `currencies.`.
	Namespace string `json:"namespace,omitempty"`
	// The Proof that the issued Asset Type indeed matches the reported Rule
	Zkproof string `json:"zkproof,omitempty"`
}

type AnalyticsContent struct {
	TxType string `json:"tx_type"`
}

type AnalyticsIssueTx struct {
	// The data of the Assets issued (multiple Assets may potentially be issued in a single Issuance transaction)
	Outputs []AnalyticsOutput `json:"outputs,omitempty"`
	// The public key of the Wallet that performed the Issuance
	PublicKey string `json:"public_key,omitempty"`
	// The signature on the transaction by the secret key of the Wallet that performed the Issuance
	Signature string `json:"signature,omitempty"`
}

type AnalyticsIssueTxAllOf struct {
	Outputs   []AnalyticsOutput `json:"outputs,omitempty"`
	PublicKey string            `json:"public_key,omitempty"`
	Signature string            `json:"signature,omitempty"`
}

type AnalyticsMultiTransferTx struct {
	// The (potentially several) Transfers within the transaction
	Transfers []AnalyticsTransferTx `json:"transfers,omitempty"`
}

type AnalyticsOutput struct {
	// Boolean signifying whether the Issuance was done confidentially; false if the Issuance was done publicly
	IsConfidential                  bool                                     `json:"is_confidential,omitempty"`
	PublicIssuanceDescription       AnalyticsPublicIssuanceDescription       `json:"public_issuance_description,omitempty"`
	ConfidentialIssuanceDescription AnalyticsConfidentialIssuanceDescription `json:"confidential_issuance_description,omitempty"`
	OutputDescription               AnalyticsOutputDescription               `json:"output_description,omitempty"`
}

type AnalyticsOutputDescription struct {
	// The commitment to both the Asset Type and amount of the Note
	Cv string `json:"cv,omitempty"`
	// The commitment to the entire Note
	Cm string `json:"cm,omitempty"`
	// The Proof that the commitments match
	Zkproof string `json:"zkproof,omitempty"`
	// The ephemeral public key used to encrypt the Note contents for the receiver
	Epk string `json:"epk,omitempty"`
	// The Note encryption for the receiver
	EncNote string `json:"enc_note,omitempty"`
	// The Note encryption for the sender
	EncSender string `json:"enc_sender,omitempty"`
}

type AnalyticsPublicIssuanceDescription struct {
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id"`
	// The amount of Assets issued
	Amount int32 `json:"amount"`
}

type AnalyticsRule struct {
	// A `Namespace` describes what Asset IDs can be issued in an Issuance Rule. It is a string in the same format as `AssetId`. Additionally, if it ends with a wildcard character `*`, then the namespace covers all asset IDs with the namespace as a prefix. Without a final wildcard, the namespace covers exactly one asset ID. Example: The namespace `currencies.dollar` covers only this exact asset type, while `currencies.*` covers all asset types that start with `currencies.`.
	Namespace string `json:"namespace"`
}

type AnalyticsRuleDefinition struct {
	// The public key of the Wallet that is being granted rights in this Rule
	PublicKey string `json:"public_key,omitempty"`
	// Boolean signifying whether the Rule grants admin rights
	IsAdmin bool `json:"is_admin,omitempty"`
	// A `Namespace` describes what Asset IDs can be issued in an Issuance Rule. It is a string in the same format as `AssetId`. Additionally, if it ends with a wildcard character `*`, then the namespace covers all asset IDs with the namespace as a prefix. Without a final wildcard, the namespace covers exactly one asset ID. Example: The namespace `currencies.dollar` covers only this exact asset type, while `currencies.*` covers all asset types that start with `currencies.`.
	Namespace string `json:"namespace,omitempty"`
	// Boolean signifying whether the Rule grants confidentialy issuance rights; if true, then both public and confidential issuance right are granted; if false, then only public issuance rights are granted
	CanIssueConfidentially bool `json:"can_issue_confidentially,omitempty"`
}

type AnalyticsRuleTx struct {
	// The public key of the Wallet used to create the Rule
	SenderPublicKey string `json:"sender_public_key,omitempty"`
	// The details of the Rules added in this transaction
	RulesToAdd []AnalyticsRuleDefinition `json:"rules_to_add,omitempty"`
	// The details of the Rules deleted in this transaction
	RulesToDelete []AnalyticsRuleDefinition `json:"rules_to_delete,omitempty"`
	// The nonce used to make this Rule transaction unique
	Nonce int32 `json:"nonce,omitempty"`
	// The signature authorizing the Rule changes, made by the Wallet that made the Rule changes
	Signature string `json:"signature,omitempty"`
}

type AnalyticsRuleTxAllOf struct {
	SenderPublicKey string                  `json:"sender_public_key,omitempty"`
	RulesToAdd      AnalyticsRuleDefinition `json:"rules_to_add,omitempty"`
	RulesToDelete   AnalyticsRuleDefinition `json:"rules_to_delete,omitempty"`
	Nonce           int32                   `json:"nonce,omitempty"`
	Signature       string                  `json:"signature,omitempty"`
}

type AnalyticsRuleWalletDefinition struct {
	// The public key of the Wallet that is being granted rights in this Rule
	PublicKey string `json:"public_key,omitempty"`
	// Boolean signifying whether the Rule grants admin rights
	IsAdmin bool `json:"is_admin,omitempty"`
	// A `Namespace` describes what Asset IDs can be issued in an Issuance Rule. It is a string in the same format as `AssetId`. Additionally, if it ends with a wildcard character `*`, then the namespace covers all asset IDs with the namespace as a prefix. Without a final wildcard, the namespace covers exactly one asset ID. Example: The namespace `currencies.dollar` covers only this exact asset type, while `currencies.*` covers all asset types that start with `currencies.`.
	Namespace string `json:"namespace,omitempty"`
	// Boolean signifying whether the Rule grants confidentialy issuance rights; if true, then both public and confidential issuance right are granted; if false, then only public issuance rights are granted
	CanIssueConfidentially bool `json:"can_issue_confidentially,omitempty"`
	// Operation of the transaction, which can be rule creation or deletion
	Operation string `json:"operation,omitempty"`
}

type AnalyticsSpendDescription struct {
	// The commitment to both the Asset Type and amount of the Note
	Cv string `json:"cv,omitempty"`
	// The anchor (root) of the Merkle tree used in the Proof
	Anchor string `json:"anchor,omitempty"`
	// The Note's Nullifier
	Nullifier string `json:"nullifier,omitempty"`
	// The Proof that the Note indeed exists in the Merkle tree and belongs to the spender
	Zkproof string `json:"zkproof,omitempty"`
}

type AnalyticsTransferTx struct {
	// The information and Proofs associated with the Assets spent in the Transfer
	Spends []AnalyticsSpendDescription `json:"spends,omitempty"`
	// The information and Proofs associated with the Assets output from the Transfer
	Outputs []AnalyticsOutputDescription `json:"outputs,omitempty"`
	// The re-randomized public key of the Wallet which created the Transfer
	Rk string `json:"rk,omitempty"`
	// The signature authorizing the spend of the Assets spent in the Transfer
	SpendAuthSig string `json:"spend_auth_sig,omitempty"`
	// The signature binding the spent and output Assets and verifying the balance
	BindingSig string `json:"binding_sig,omitempty"`
}

type AnalyticsTransferTxAllOf struct {
	AssetConverterDescriptions AnalyticsAssetConverterProofDescription `json:"asset_converter_descriptions,omitempty"`
	Spends                     []AnalyticsSpendDescription             `json:"spends,omitempty"`
	Outputs                    []AnalyticsOutputDescription            `json:"outputs,omitempty"`
	BindingSig                 string                                  `json:"binding_sig,omitempty"`
	SpendAuthSigs              []string                                `json:"spend_auth_sigs,omitempty"`
}

type AnalyticsTxMetadata struct {
	Type AnalyticsTxType `json:"type,omitempty"`
	// the QEDIT-generated hash of the transaction
	TxHash string `json:"tx_hash,omitempty"`
	// The height of the Block (inside the Blockchain) that the transaction is a part of
	BlockHeight int32 `json:"block_height,omitempty"`
	// the hash of the Block (inside the Blockchain) that the transaction is a part of
	BlockHash string `json:"block_hash,omitempty"`
	// UTC time of creation of the time the Block containing the transaction was created in RFC-3339 format
	Timestamp string `json:"timestamp,omitempty"`
	// The serial number within the Block of the transaction relative to other QEDIT transactions; indexing is 0-based
	IndexInBlock int32 `json:"index_in_block,omitempty"`
}

type AnalyticsTxType string

type AsyncApiService service

type AsyncTaskCreatedResponse struct {
	// The unique ID of the Task that was created in the Node to process the asynchronous request
	Id string `json:"id"`
}

type BalanceForAsset struct {
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id"`
	// The outstanding balance for the Asset Type
	Amount int32 `json:"amount"`
}

type BasicAuth struct {
	UserName string `json:"userName,omitempty"`
	Password string `json:"password,omitempty"`
}

type Block struct {
	BlockHash    string   `json:"block_hash"`
	Height       int32    `json:"height"`
	Transactions []string `json:"transactions"`
}

type ConfidentialAnalyticsOutput struct {
	IsConfidential                  bool                                     `json:"is_confidential"`
	OutputDescription               AnalyticsOutputDescription               `json:"output_description"`
	ConfidentialIssuanceDescription AnalyticsConfidentialIssuanceDescription `json:"confidential_issuance_description"`
}

type Configuration struct {
	BasePath      string            `json:"basePath,omitempty"`
	Host          string            `json:"host,omitempty"`
	Scheme        string            `json:"scheme,omitempty"`
	DefaultHeader map[string]string `json:"defaultHeader,omitempty"`
	UserAgent     string            `json:"userAgent,omitempty"`
	HTTPClient    *http.Client
}

type CreateRuleRequest struct {
	// The ID of the Wallet whose admin credentials should be used to create the new Rules
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet whose admin credentials should be used to create the new Rules
	Authorization string `json:"authorization"`
	// The list of Rules to add to the network
	RulesToAdd []Rule `json:"rules_to_add"`
}

type DeleteRuleRequest struct {
	// The ID of the Wallet whose admin credentials should be used to delete the Rules
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet whose admin credentials should be used to delete the Rules
	Authorization string `json:"authorization"`
	// The list of Rules to delete from the network
	RulesToDelete []Rule `json:"rules_to_delete"`
}

type DeleteWalletRequest struct {
	// The ID of the Wallet to delete
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet
	Authorization string `json:"authorization,omitempty"`
}

type EmptyContent struct {
}

type ErrorResponse struct {
	// The error code returned from the server
	ErrorCode int32 `json:"error_code"`
	// The error message returned from the server
	Message string `json:"message,omitempty"`
}

type ExportAuditorAccessWalletRequest struct {
	// The ID of the Wallet to export a viewing key for
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet
	Authorization string `json:"authorization"`
	// The Address of the Wallet that belongs to the intended recipient of the exported viewing key; used to encrypt the key in such a way that only the intended recipient can decrypt it
	RecipientPaymentAddress string `json:"recipient_payment_address"`
}

type ExportAuditorAccessWalletResponse struct {
	// The ID of the exported Wallet in the Node from which it was exported
	WalletId string `json:"wallet_id"`
	// The public key of the exported Wallet which uniquely identifies it across the network
	PublicKey string `json:"public_key"`
	// The encrypted viewing key
	AccessKey string `json:"access_key"`
}

type ExportWalletRequest struct {
	// The ID of the Wallet to export
	WalletId string `json:"wallet_id"`
}

type ExportWalletResponse struct {
	// The ID of the exported Wallet in the Node from which it was exported
	WalletId string `json:"wallet_id"`
	// The encrypted secret key of the Wallet
	EncryptedSk string `json:"encrypted_sk"`
	// The salt used in the encryption of the secret key
	Salt string `json:"salt"`
}

type GenerateWalletRequest struct {
	// The ID under which to create the Wallet; must be unique within the Node
	WalletId string `json:"wallet_id"`
	// The authorizarion password under which to encrypt the generated Wallet's secret key; will be required in order to perform actions using the Wallet
	Authorization string `json:"authorization"`
}

type GenericOpenAPIError struct {
	// contains filtered or unexported fields
}

type GetActivityRequest struct {
	WalletId        string `json:"wallet_id"`
	StartIndex      int32  `json:"start_index"`
	NumberOfResults int32  `json:"number_of_results"`
}

type GetActivityResponse struct {
	WalletId     string                  `json:"wallet_id"`
	Transactions []TransactionsForWallet `json:"transactions"`
}

type GetAllWalletsResponse struct {
	// The IDs of the Wallets currently active in this Node
	WalletIds []string `json:"wallet_ids,omitempty"`
}

type GetBlocksRequest struct {
	StartIndex      int32 `json:"start_index"`
	NumberOfResults int32 `json:"number_of_results"`
}

type GetBlocksResponse struct {
	Blocks []Block `json:"blocks"`
}

type GetNetworkActivityRequest struct {
	// An offset used to paginate through the activity history; indexing is 0-based
	StartIndex int32 `json:"start_index"`
	// Maximal number of results to fetch in this call
	NumberOfResults int32    `json:"number_of_results"`
	TxHashes        []string `json:"tx_hashes,omitempty"`
}

type GetNetworkActivityResponse struct {
	Transactions []AnalyticTransaction `json:"transactions,omitempty"`
}

type GetNewAddressRequest struct {
	// The ID of the Wallet for which to generate an Address
	WalletId string `json:"wallet_id"`
	// An optional 11-byte (22 hexadecimal characters) input which is used to generate different Addresses. A unique Address will be generated for each different diversifier used. If omitted, the Node selects a random diversifier.
	Diversifier string `json:"diversifier,omitempty"`
}

type GetNewAddressResponse struct {
	// The ID of the Wallet the Address belongs to
	WalletId string `json:"wallet_id"`
	// The generated Address of the Wallet
	RecipientAddress string `json:"recipient_address"`
}

type GetNotificationsRequest struct {
	// Fetch notifications that relate to this wallet ID only
	WalletId string             `json:"wallet_id,omitempty"`
	Types    []NotificationType `json:"types,omitempty"`
	// Fetch notifications reported at this timestamp or later/earlier. Later notifications will be fetched if the order is ascending, and earlier ones if the order is descending. The timestamp is expected to be in RFC-3339 format.
	StartingWithTime string `json:"starting_with_time,omitempty"`
	// Fetch notifications after this given ID (not including the notification with the given ID). This is meant to facilitate pagination. Later notifications will be fetched if ascending order is selected, and earlier ones if descending order is selected. Warning - do not assume anything about the implementation of after_id; the values of the ID are intended to be copy-pasted from retrieved notifications for pagination.
	AfterId int32     `json:"after_id,omitempty"`
	Order   OrderEnum `json:"order,omitempty"`
	// The maximal number of results to fetch
	MaxResults int32 `json:"max_results,omitempty"`
}

type GetNotificationsResponse struct {
	Notifications []Notification `json:"notifications,omitempty"`
}

type GetPublicKeyRequest struct {
	// The ID of the Wallet for which to retrieve the public key
	WalletId string `json:"wallet_id"`
}

type GetPublicKeyResponse struct {
	// The ID of the Wallet the pubic key belongs to
	WalletId string `json:"wallet_id"`
	// The public key of the Wallet
	PublicKey string `json:"public_key"`
}

type GetRulesResponse struct {
	// The Rules currently active in the network
	Rules []Rule `json:"rules,omitempty"`
}

type GetSyncStatusResponse struct {
	// Boolean signifying whether the QEDIT Node is in sync with the Blockchain; false if the Node is not synced; sync is defined as having less than a preconfigured difference between the current Blockchain height and the last block processed by the Node; the allowed difference defaults to 5, but can be configured when setting up the Node
	InSync bool `json:"in_sync,omitempty"`
	// The current block height of the Blockchain
	BlockchainBlockHeight int32 `json:"blockchain_block_height,omitempty"`
	// The height of the last block that was processed in the Node
	LastProcessedBlockHeight int32 `json:"last_processed_block_height,omitempty"`
}

type GetTaskStatusRequest struct {
	// The ID of the Task
	Id string `json:"id"`
}

type GetTaskStatusResponse struct {
	// Unique ID of the Task
	Id string `json:"id,omitempty"`
	// UTC time of creation of the Task in RFC-3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// UTC last time the Task was updated in RFC-3339 format
	UpdatedAt string    `json:"updated_at,omitempty"`
	Result    Result    `json:"result,omitempty"`
	State     TaskState `json:"state,omitempty"`
	// The Blockchain-generated hash of the Transaction; populated after the Blockchain Node accepted the Transaction
	TxHash string `json:"tx_hash,omitempty"`
	// The QEDIT-generated hash of the Transaction; generated after proof generation, but prior to Broadcast by the QEDIT Node
	QeditTxHash string   `json:"qedit_tx_hash,omitempty"`
	Type        TaskType `json:"type,omitempty"`
	Data        TaskData `json:"data,omitempty"`
	// In case of failure this field reports the reason for the failure
	Error string `json:"error,omitempty"`
}

type GetTasksRequest struct {
	// An offset used to paginate through the Task list; indexing is 0-based
	StartIndex int32 `json:"start_index"`
	// Maximal number of results to fetch in this call
	NumberOfResults int32 `json:"number_of_results"`
	// Types of Tasks to fetch; fetch all types if omitted
	Types []TaskType `json:"types,omitempty"`
	// List of results (statuses) to filter by; fetch in_progress tasks if omitted
	Results []Result  `json:"results,omitempty"`
	Order   OrderEnum `json:"order,omitempty"`
}

type GetTasksResponse struct {
	// The returned Tasks array, sorted in the requested order
	Tasks []GetTaskStatusResponse `json:"tasks,omitempty"`
}

type GetTransactionsRequest struct {
	WalletId        string `json:"wallet_id"`
	StartIndex      int32  `json:"start_index"`
	NumberOfResults int32  `json:"number_of_results"`
}

type GetTransactionsResponse struct {
	WalletId     string                  `json:"wallet_id"`
	Transactions []TransactionsForWallet `json:"transactions"`
}

type GetWalletActivityRequest struct {
	// The ID of the Wallet for which to retrieve activity history
	WalletId string `json:"wallet_id"`
	// An offset used to paginate through the activity history; indexing is 0-based
	StartIndex int32 `json:"start_index"`
	// Maximal number of results to fetch in this call
	NumberOfResults int32 `json:"number_of_results"`
}

type GetWalletActivityResponse struct {
	WalletId string `json:"wallet_id,omitempty"`
	// The list of retrieved transactions
	Transactions []AnalyticWalletTx `json:"transactions,omitempty"`
}

type GetWalletBalanceRequest struct {
	// The ID of the Wallet
	WalletId string `json:"wallet_id"`
}

type GetWalletBalanceResponse struct {
	// The ID of the Wallet
	WalletId string `json:"wallet_id"`
	// The balances of the various Asset Types held by the Wallet
	Assets []BalanceForAsset `json:"assets"`
}

type HealthApiService service

type HealthcheckResponse struct {
	// API version of the Node
	Version             string                  `json:"version,omitempty"`
	BlockchainConnector HealthcheckResponseItem `json:"blockchain_connector,omitempty"`
	MessageQueue        HealthcheckResponseItem `json:"message_queue,omitempty"`
	Database            HealthcheckResponseItem `json:"database,omitempty"`
	// Boolean signifying whether the endpoint is ready for calls
	Passing bool `json:"passing,omitempty"`
}

type HealthcheckResponseBlockchainConnector struct {
	Passing bool   `json:"passing,omitempty"`
	Error   string `json:"error,omitempty"`
}

type HealthcheckResponseItem struct {
	// Boolean signifying whether the component is healthy
	Passing bool `json:"passing,omitempty"`
	// Error string describing the component's problem; empty if the component is healthy
	Error string `json:"error,omitempty"`
}

type ImportAuditorAccessWalletRequest struct {
	// The ID under which to import the Wallet; can be different from the ID the Wallet was stored under in the exporting Node
	WalletId string `json:"wallet_id"`
	// The public key of the imported Wallet
	PublicKey string `json:"public_key"`
	// the encrypted viewing key of the imported Wallet
	AccessKey string `json:"access_key"`
}

type ImportWalletRequest struct {
	// The ID under which to import the Wallet; can be different from the ID the Wallet was stored under in the exporting Node
	WalletId string `json:"wallet_id"`
	// The encrypted secret key of the Wallet
	EncryptedSk string `json:"encrypted_sk"`
	// The authorization password used during Wallet generation that allows to decrypt the encrypted secret key
	Authorization string `json:"authorization"`
	// The salt used in the encryption of the secret key
	Salt string `json:"salt"`
}

type IssueAssetRequest struct {
	// The ID of the Wallet that has the required Issuance privileges
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet that has the Issuance privileges
	Authorization string `json:"authorization"`
	// The Address of the recipient of the issued Assets
	RecipientAddress string `json:"recipient_address"`
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id"`
	// the amount of Assets to issue
	Amount int32 `json:"amount"`
	// Boolean which should be true if the issuance should be confidential, and false of the Issuance should be public
	Confidential bool   `json:"confidential"`
	Memo         string `json:"memo"`
}

type NodeApiService service

type Notification struct {
	// The unique identifier of the notification. Can be used for pagination purposes.
	Id int32 `json:"id"`
	// Timestamp the notification was created at, in RFC-3339 format.
	CreatedAt string `json:"created_at"`
	// The ID of the wallet the notification relates to. May be null in cases there is no such specific wallet.
	WalletId string `json:"wallet_id,omitempty"`
	// The ID of the task the notification relates to. May be empty in cases there is no such specific task.
	TaskId           string                 `json:"task_id"`
	NotificationType NotificationType       `json:"notification_type"`
	Content          map[string]interface{} `json:"content,omitempty"`
}

type NotificationType string

type OrderEnum string

type PublicAnalyticsOutput struct {
	IsConfidential            bool                               `json:"is_confidential"`
	OutputDescription         AnalyticsOutputDescription         `json:"output_description"`
	PublicIssuanceDescription AnalyticsPublicIssuanceDescription `json:"public_issuance_description"`
}

type Result string

type Rule struct {
	// The public key of the Wallet that is being granted rights in this Rule
	PublicKey string `json:"public_key"`
	// Boolean signifying whether the Rule grants admin rights
	IsAdmin bool `json:"is_admin"`
	// A `Namespace` describes what Asset IDs can be issued in an Issuance Rule. It is a string in the same format as `AssetId`. Additionally, if it ends with a wildcard character `*`, then the namespace covers all asset IDs with the namespace as a prefix. Without a final wildcard, the namespace covers exactly one asset ID. Example: The namespace `currencies.dollar` covers only this exact asset type, while `currencies.*` covers all asset types that start with `currencies.`.
	Namespace string `json:"namespace"`
	// Boolean signifying whether the Rule grants confidentialy issuance rights; if true, then both public and confidential issuance right are granted; if false, then only public issuance rights are granted
	CanIssueConfidentially bool `json:"can_issue_confidentially"`
}

type TaskActionRequest struct {
	TaskId        string `json:"task_id"`
	Authorization string `json:"authorization"`
}

type TaskData struct {
	// The public key of the sender of the confirmation request
	SenderPublicKey string `json:"sender_public_key,omitempty"`
	// The public key for the confirmation request receiver
	RequireConfirmationFrom string `json:"require_confirmation_from,omitempty"`
	// The address the request was sent to
	RecipientAddress string `json:"recipient_address,omitempty"`
	AssetId          string `json:"asset_id,omitempty"`
	Amount           int32  `json:"amount,omitempty"`
	WalletId         string `json:"wallet_id,omitempty"`
}

type TaskState string

type TaskType string

type TransactionsForWallet struct {
	IsIncoming       bool   `json:"is_incoming"`
	AssetId          int32  `json:"asset_id"`
	Amount           int32  `json:"amount"`
	RecipientAddress string `json:"recipient_address"`
	Memo             string `json:"memo"`
	Id               string `json:"id"`
}

type TransferAssetRequest struct {
	// The ID of the Wallet to transfer from
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet to transfer from
	Authorization string `json:"authorization"`
	// The Address of the recipient of the funds
	RecipientAddress string `json:"recipient_address"`
	// The ID of an Asset Type. It must be a string of length 0 to 40 characters. Allowed characters are lower- and uppercase letters, digits, dot (.), and hyphen (-). It must not end with an hyphen. Asset IDs are case-sensitive.
	AssetId string `json:"asset_id"`
	// The amount of assets to transfer
	Amount int32 `json:"amount"`
	// An app-customizable field to store additional private data relating to the transfer; the memo is shared between the sender and the receiver, but is not divulged to other parties
	Memo string `json:"memo"`
	// A user may request confirmation from the receiving party. If a public key of the approver is included in this optional field, the transaction will only become valid after the received signs it. The receiver will be able to decide whether to accept or reject the transfer by calling the /node/approve_task or the /node/reject_task respectively.
	RequireConfirmationFrom string `json:"require_confirmation_from,omitempty"`
}

type UnlockWalletRequest struct {
	// The ID of the Wallet to unlock
	WalletId string `json:"wallet_id"`
	// The authorization password for the Wallet
	Authorization string `json:"authorization"`
	// The number of seconds to keep the Wallet unlocked
	Seconds int32 `json:"seconds"`
}

type WalletApiService service