client

type Abi struct {
	Type  AbiType     `json:"type"`
	Value interface{} `json:"value"`
}

type AbiConfig struct {
	// Workchain id that is used by default in DeploySet.
	Workchain null.Int32 `json:"workchain"` // optional
	// Message lifetime for contracts which ABI includes "expire" header.
	// Must be specified in milliseconds. Default is 40000 (40 sec).
	MessageExpirationTimeout null.Uint32 `json:"message_expiration_timeout"` // optional
	// Factor that increases the expiration timeout for each retry.
	// Default is 1.5.
	MessageExpirationTimeoutGrowFactor null.Float32 `json:"message_expiration_timeout_grow_factor"` // optional
}

type AbiContract struct {
	ABIVersion null.Uint32   `json:"ABI version"` // optional
	AbiVersion null.Uint32   `json:"abi_version"` // optional
	Version    *null.String  `json:"version"`     // optional
	Header     []string      `json:"header"`      // optional
	Functions  []AbiFunction `json:"functions"`   // optional
	Events     []AbiEvent    `json:"events"`      // optional
	Data       []AbiData     `json:"data"`        // optional
	Fields     []AbiParam    `json:"fields"`      // optional
}

type AbiData struct {
	Key        uint32     `json:"key"`
	Name       string     `json:"name"`
	Type       string     `json:"type"`
	Components []AbiParam `json:"components"` // optional
}

type AbiEvent struct {
	Name   string       `json:"name"`
	Inputs []AbiParam   `json:"inputs"`
	ID     *null.String `json:"id"` // optional
}

type AbiFunction struct {
	Name    string       `json:"name"`
	Inputs  []AbiParam   `json:"inputs"`
	Outputs []AbiParam   `json:"outputs"`
	ID      *null.String `json:"id"` // optional
}

type AbiHandle uint32

type AbiParam struct {
	Name       string     `json:"name"`
	Type       string     `json:"type"`
	Components []AbiParam `json:"components"` // optional
}

type AbiType string

type AccountAccountForExecutor struct {
	// Account BOC.
	// Encoded as base64.
	Boc string `json:"boc"`
	// Flag for running account with the unlimited balance.
	// Can be used to calculate transaction fees without balance check.
	UnlimitedBalance null.Bool `json:"unlimited_balance"` // optional
}

type AccountAddressType string

type AccountForExecutor struct {
	// Should be any of
	// NoneAccountForExecutor
	// UninitAccountForExecutor
	// AccountAccountForExecutor
	EnumTypeValue interface{}
}

type AccountIDAddressStringFormat struct{}

type AddressBuilderOp struct {
	// Address in a common `workchain:account` or base64 format.
	Address string `json:"address"`
}

type AddressStringFormat struct {
	// Should be any of
	// AccountIDAddressStringFormat
	// HexAddressStringFormat
	// Base64AddressStringFormat
	EnumTypeValue interface{}
}

type AesEncryptionAlgorithm struct {
	Value AesParamsEB `json:"value"`
}

type AesInfo struct {
	Mode CipherMode  `json:"mode"`
	Iv   null.String `json:"iv"` // optional
}

type AesParamsEB struct {
	Mode CipherMode  `json:"mode"`
	Key  string      `json:"key"`
	Iv   null.String `json:"iv"` // optional
}

type AggregationFn string

type AppDebotBrowser interface {
	ApproveRequest(ApproveParamsOfAppDebotBrowser) (ApproveResultOfAppDebotBrowser, error)
	InputRequest(InputParamsOfAppDebotBrowser) (InputResultOfAppDebotBrowser, error)
	GetSigningBoxRequest(GetSigningBoxParamsOfAppDebotBrowser) (GetSigningBoxResultOfAppDebotBrowser, error)
	InvokeDebotRequest(InvokeDebotParamsOfAppDebotBrowser) (InvokeDebotResultOfAppDebotBrowser, error)

	LogNotify(LogParamsOfAppDebotBrowser)
	SwitchNotify(SwitchParamsOfAppDebotBrowser)
	SwitchCompletedNotify(SwitchCompletedParamsOfAppDebotBrowser)
	ShowActionNotify(ShowActionParamsOfAppDebotBrowser)
	SendNotify(SendParamsOfAppDebotBrowser)
}

type AppEncryptionBox interface {
	GetInfoRequest(GetInfoParamsOfAppEncryptionBox) (GetInfoResultOfAppEncryptionBox, error)
	EncryptRequest(EncryptParamsOfAppEncryptionBox) (EncryptResultOfAppEncryptionBox, error)
	DecryptRequest(DecryptParamsOfAppEncryptionBox) (DecryptResultOfAppEncryptionBox, error)
}

type AppPasswordProvider interface {
	GetPasswordRequest(GetPasswordParamsOfAppPasswordProvider) (GetPasswordResultOfAppPasswordProvider, error)
}

type AppRequestResult struct {
	// Should be any of
	// ErrorAppRequestResult
	// OkAppRequestResult
	EnumTypeValue interface{}
}

type AppSigningBox interface {
	GetPublicKeyRequest(GetPublicKeyParamsOfAppSigningBox) (GetPublicKeyResultOfAppSigningBox, error)
	SignRequest(SignParamsOfAppSigningBox) (SignResultOfAppSigningBox, error)
}

type ApproveParamsOfAppDebotBrowser struct {
	// DeBot activity details.
	Activity DebotActivity `json:"activity"`
}

type ApproveResultOfAppDebotBrowser struct {
	// Indicates whether the DeBot is allowed to perform the specified operation.
	Approved bool `json:"approved"`
}

type Base64AddressStringFormat struct {
	URL    bool `json:"url"`
	Test   bool `json:"test"`
	Bounce bool `json:"bounce"`
}

type BindingConfig struct {
	Library null.String `json:"library"` // optional
	Version null.String `json:"version"` // optional
}

type BitStringBuilderOp struct {
	// Bit string content using bitstring notation. See `TON VM specification` 1.0.
	// Contains hexadecimal string representation:
	// - Can end with `_` tag.
	// - Can be prefixed with `x` or `X`.
	// - Can be prefixed with `x{` or `X{` and ended with `}`.
	//
	// Contains binary string represented as a sequence
	// of `0` and `1` prefixed with `n` or `N`.
	//
	// Examples:
	// `1AB`, `x1ab`, `X1AB`, `x{1abc}`, `X{1ABC}`
	// `2D9_`, `x2D9_`, `X2D9_`, `x{2D9_}`, `X{2D9_}`
	// `n00101101100`, `N00101101100`.
	Value string `json:"value"`
}

type BocCacheType struct {
	// Should be any of
	// PinnedBocCacheType
	// UnpinnedBocCacheType
	EnumTypeValue interface{}
}

type BocConfig struct {
	// Maximum BOC cache size in kilobytes.
	// Default is 10 MB.
	CacheMaxSize null.Uint32 `json:"cache_max_size"` // optional
}

type BocMonitoredMessage struct {
	Boc string `json:"boc"`
}

type BoxEncryptionAlgorithm struct {
	// Should be any of
	// ChaCha20BoxEncryptionAlgorithm
	// NaclBoxBoxEncryptionAlgorithm
	// NaclSecretBoxBoxEncryptionAlgorithm
	EnumTypeValue interface{}
}

type BuildInfoDependency struct {
	// Dependency name.
	// Usually it is a crate name.
	Name string `json:"name"`
	// Git commit hash of the related repository.
	GitCommit string `json:"git_commit"`
}

type BuilderOp struct {
	// Should be any of
	// IntegerBuilderOp
	// BitStringBuilderOp
	// CellBuilderOp
	// CellBocBuilderOp
	// AddressBuilderOp
	EnumTypeValue interface{}
}

type CallSet struct {
	// Function name that is being called. Or function id encoded as string in hex (starting with 0x).
	FunctionName string `json:"function_name"`
	// Function header.
	// If an application omits some header parameters required by the
	// contract's ABI, the library will set the default values for
	// them.
	Header *FunctionHeader `json:"header"` // optional
	// Function input parameters according to ABI.
	Input json.RawMessage `json:"input"` // optional
}

type CellBocBuilderOp struct {
	// Nested cell BOC encoded with `base64` or BOC cache key.
	Boc string `json:"boc"`
}

type CellBuilderOp struct {
	// Nested cell builder.
	Builder []BuilderOp `json:"builder"`
}

type ChaCha20BoxEncryptionAlgorithm struct {
	Value ChaCha20ParamsCB `json:"value"`
}

type ChaCha20EncryptionAlgorithm struct {
	Value ChaCha20ParamsEB `json:"value"`
}

type ChaCha20ParamsCB struct {
	// 96-bit nonce.
	// Must be encoded with `hex`.
	Nonce string `json:"nonce"`
}

type ChaCha20ParamsEB struct {
	// 256-bit key.
	// Must be encoded with `hex`.
	Key string `json:"key"`
	// 96-bit nonce.
	// Must be encoded with `hex`.
	Nonce string `json:"nonce"`
}

type CipherMode string

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

type Config struct {
	Binding *BindingConfig `json:"binding"` // optional
	Network *NetworkConfig `json:"network"` // optional
	Crypto  *CryptoConfig  `json:"crypto"`  // optional
	Abi     *AbiConfig     `json:"abi"`     // optional
	Boc     *BocConfig     `json:"boc"`     // optional
	Proofs  *ProofsConfig  `json:"proofs"`  // optional
	// For file based storage is a folder name where SDK will store its data. For browser based is a browser async storage key prefix. Default (recommended) value is "~/.tonclient" for native environments and ".tonclient" for web-browser.
	LocalStoragePath null.String `json:"local_storage_path"` // optional
}

type CryptoBoxHandle uint32

type CryptoBoxSecret struct {
	// Should be any of
	// RandomSeedPhraseCryptoBoxSecret
	// PredefinedSeedPhraseCryptoBoxSecret
	// EncryptedSecretCryptoBoxSecret
	EnumTypeValue interface{}
}

type CryptoConfig struct {
	// Mnemonic dictionary that will be used by default in crypto functions. If not specified, `English` dictionary will be used.
	MnemonicDictionary *MnemonicDictionary `json:"mnemonic_dictionary"` // optional
	// Mnemonic word count that will be used by default in crypto functions. If not specified the default value will be 12.
	MnemonicWordCount null.Uint8 `json:"mnemonic_word_count"` // optional
	// Derivation path that will be used by default in crypto functions. If not specified `m/44'/396'/0'/0/0` will be used.
	HdkeyDerivationPath null.String `json:"hdkey_derivation_path"` // optional
}

type DataLayout string

type DebotAction struct {
	// A short action description.
	// Should be used by Debot Browser as name of menu item.
	Description string `json:"description"`
	// Depends on action type.
	// Can be a debot function name or a print string (for Print Action).
	Name string `json:"name"`
	// Action type.
	ActionType uint8 `json:"action_type"`
	// ID of debot context to switch after action execution.
	To uint8 `json:"to"`
	// Action attributes.
	// In the form of "param=value,flag". attribute example: instant, args, fargs, sign.
	Attributes string `json:"attributes"`
	// Some internal action data.
	// Used by debot only.
	Misc string `json:"misc"`
}

type DebotActivity struct {
	// Should be any of
	// TransactionDebotActivity
	EnumTypeValue interface{}
}

type DebotHandle uint32

type DebotInfo struct {
	// DeBot short name.
	Name null.String `json:"name"` // optional
	// DeBot semantic version.
	Version null.String `json:"version"` // optional
	// The name of DeBot deployer.
	Publisher null.String `json:"publisher"` // optional
	// Short info about DeBot.
	Caption null.String `json:"caption"` // optional
	// The name of DeBot developer.
	Author null.String `json:"author"` // optional
	// TON address of author for questions and donations.
	Support null.String `json:"support"` // optional
	// String with the first messsage from DeBot.
	Hello null.String `json:"hello"` // optional
	// String with DeBot interface language (ISO-639).
	Language null.String `json:"language"` // optional
	// String with DeBot ABI.
	Dabi null.String `json:"dabi"` // optional
	// DeBot icon.
	Icon null.String `json:"icon"` // optional
	// Vector with IDs of DInterfaces used by DeBot.
	Interfaces []string `json:"interfaces"`
	// ABI version ("x.y") supported by DeBot.
	DabiVersion string `json:"dabiVersion"`
}

type DecodedMessageBody struct {
	// Type of the message body content.
	BodyType MessageBodyType `json:"body_type"`
	// Function or event name.
	Name string `json:"name"`
	// Parameters or result value.
	Value json.RawMessage `json:"value"` // optional
	// Function header.
	Header *FunctionHeader `json:"header"` // optional
}

type DecodedOutput struct {
	// Decoded bodies of the out messages.
	// If the message can't be decoded, then `None` will be stored in
	// the appropriate position.
	OutMessages []*DecodedMessageBody `json:"out_messages"`
	// Decoded body of the function output message.
	Output json.RawMessage `json:"output"` // optional
}

type DecryptParamsOfAppEncryptionBox struct {
	// Data, encoded in Base64.
	Data string `json:"data"`
}

type DecryptResultOfAppEncryptionBox struct {
	// Decrypted data, encoded in Base64.
	Data string `json:"data"`
}

type DeploySet struct {
	// Content of TVC file encoded in `base64`. For compatibility reason this field can contain an encoded  `StateInit`.
	Tvc null.String `json:"tvc"` // optional
	// Contract code BOC encoded with base64.
	Code null.String `json:"code"` // optional
	// State init BOC encoded with base64.
	StateInit null.String `json:"state_init"` // optional
	// Target workchain for destination address.
	// Default is `0`.
	WorkchainID null.Int32 `json:"workchain_id"` // optional
	// List of initial values for contract's public variables.
	InitialData json.RawMessage `json:"initial_data"` // optional
	// Optional public key that can be provided in deploy set in order to substitute one in TVM file or provided by Signer.
	// Public key resolving priority:
	// 1. Public key from deploy set.
	// 2. Public key, specified in TVM file.
	// 3. Public key, provided by Signer.
	InitialPubkey null.String `json:"initial_pubkey"` // optional
}

type DidSendProcessingEvent struct {
	ShardBlockID string `json:"shard_block_id"`
	MessageID    string `json:"message_id"`
	MessageDst   string `json:"message_dst"`
	Message      string `json:"message"`
}

type EncodedMessageSource struct {
	Message string `json:"message"`
	Abi     *Abi   `json:"abi"` // optional
}

type EncryptParamsOfAppEncryptionBox struct {
	// Data, encoded in Base64.
	Data string `json:"data"`
}

type EncryptResultOfAppEncryptionBox struct {
	// Encrypted data, encoded in Base64.
	Data string `json:"data"`
}

type EncryptedSecretCryptoBoxSecret struct {
	// It is an object, containing encrypted seed phrase or private key (now we support only seed phrase).
	EncryptedSecret string `json:"encrypted_secret"`
}

type EncryptionAlgorithm struct {
	// Should be any of
	// AesEncryptionAlgorithm
	// ChaCha20EncryptionAlgorithm
	// NaclBoxEncryptionAlgorithm
	// NaclSecretBoxEncryptionAlgorithm
	EnumTypeValue interface{}
}

type EncryptionBoxHandle uint32

type EncryptionBoxInfo struct {
	// Derivation path, for instance "m/44'/396'/0'/0/0".
	Hdpath null.String `json:"hdpath"` // optional
	// Cryptographic algorithm, used by this encryption box.
	Algorithm null.String `json:"algorithm"` // optional
	// Options, depends on algorithm and specific encryption box implementation.
	Options json.RawMessage `json:"options"` // optional
	// Public information, depends on algorithm.
	Public json.RawMessage `json:"public"` // optional
}

type EndpointsSet struct {
	// List of endpoints provided by server.
	Endpoints []string `json:"endpoints"`
}

type EnumOfTypesDescriptor struct {
	Type string `json:"type"`
}

type Error struct {
	Code    uint32          `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data"`
}

type ErrorAppRequestResult struct {
	// Error description.
	Text string `json:"text"`
}

type EventCallback func(event *ProcessingEvent)

type ExecutionOptions struct {
	// boc with config.
	BlockchainConfig null.String `json:"blockchain_config"` // optional
	// time that is used as transaction time.
	BlockTime null.Uint32 `json:"block_time"` // optional
	// block logical time.
	BlockLt *big.Int `json:"block_lt"` // optional
	// transaction logical time.
	TransactionLt *big.Int `json:"transaction_lt"` // optional
	// Overrides standard TVM behaviour. If set to `true` then CHKSIG always will return `true`.
	ChksigAlwaysSucceed null.Bool `json:"chksig_always_succeed"` // optional
	// Signature ID to be used in signature verifying instructions when CapSignatureWithId capability is enabled.
	SignatureID null.Int32 `json:"signature_id"` // optional
}

type ExternalSigner struct {
	PublicKey string `json:"public_key"`
}

type FetchFirstBlockFailedProcessingEvent struct {
	Error      Error  `json:"error"`
	MessageID  string `json:"message_id"`
	MessageDst string `json:"message_dst"`
}

type FetchNextBlockFailedProcessingEvent struct {
	ShardBlockID string `json:"shard_block_id"`
	MessageID    string `json:"message_id"`
	MessageDst   string `json:"message_dst"`
	Message      string `json:"message"`
	Error        Error  `json:"error"`
}

type FieldAggregation struct {
	// Dot separated path to the field.
	Field string `json:"field"`
	// Aggregation function that must be applied to field values.
	Fn AggregationFn `json:"fn"`
}

type FunctionHeader struct {
	// Message expiration timestamp (UNIX time) in seconds.
	// If not specified - calculated automatically from message_expiration_timeout(),
	// try_index and message_expiration_timeout_grow_factor() (if ABI includes `expire` header).
	Expire null.Uint32 `json:"expire"` // optional
	// Message creation time in milliseconds.
	// If not specified, `now` is used (if ABI includes `time` header).
	Time *big.Int `json:"time"` // optional
	// Public key is used by the contract to check the signature.
	// Encoded in `hex`. If not specified, method fails with exception (if ABI includes `pubkey` header)..
	Pubkey null.String `json:"pubkey"` // optional
}

type GetInfoParamsOfAppEncryptionBox struct{}

type GetInfoResultOfAppEncryptionBox struct {
	Info EncryptionBoxInfo `json:"info"`
}

type GetPasswordParamsOfAppPasswordProvider struct {
	// Temporary library pubkey, that is used on application side for password encryption, along with application temporary private key and nonce. Used for password decryption on library side.
	EncryptionPublicKey string `json:"encryption_public_key"`
}

type GetPasswordResultOfAppPasswordProvider struct {
	// Password, encrypted and encoded to base64. Crypto box uses this password to decrypt its secret (seed phrase).
	EncryptedPassword string `json:"encrypted_password"`
	// Hex encoded public key of a temporary key pair, used for password encryption on application side.
	// Used together with `encryption_public_key` to decode `encrypted_password`.
	AppEncryptionPubkey string `json:"app_encryption_pubkey"`
}

type GetPublicKeyParamsOfAppSigningBox struct{}

type GetPublicKeyResultOfAppSigningBox struct {
	// Signing box public key.
	PublicKey string `json:"public_key"`
}

type GetSigningBoxParamsOfAppDebotBrowser struct{}

type GetSigningBoxResultOfAppDebotBrowser struct {
	// Signing box for signing data requested by debot engine.
	// Signing box is owned and disposed by debot engine.
	SigningBox SigningBoxHandle `json:"signing_box"`
}

type HashAddressMonitoredMessage struct {
	// Hash of the message.
	Hash string `json:"hash"`
	// Destination address of the message.
	Address string `json:"address"`
}

type HexAddressStringFormat struct{}

type InputParamsOfAppDebotBrowser struct {
	// A prompt string that must be printed to user before input request.
	Prompt string `json:"prompt"`
}

type InputResultOfAppDebotBrowser struct {
	// String entered by user.
	Value string `json:"value"`
}

type IntegerBuilderOp struct {
	// Bit size of the value.
	Size uint32 `json:"size"`
	// Value: - `Number` containing integer number.
	// e.g. `123`, `-123`. - Decimal string. e.g. `"123"`, `"-123"`.
	// - `0x` prefixed hexadecimal string.
	// e.g `0x123`, `0X123`, `-0x123`.
	Value json.RawMessage `json:"value"`
}

type InvokeDebotParamsOfAppDebotBrowser struct {
	// Address of debot in blockchain.
	DebotAddr string `json:"debot_addr"`
	// Debot action to execute.
	Action DebotAction `json:"action"`
}

type InvokeDebotResultOfAppDebotBrowser struct{}

type KeyPair struct {
	// Public key - 64 symbols hex string.
	Public string `json:"public"`
	// Private key - u64 symbols hex string.
	Secret string `json:"secret"`
}

type KeysSigner struct {
	Keys KeyPair `json:"keys"`
}

type LogParamsOfAppDebotBrowser struct {
	// A string that must be printed to user.
	Msg string `json:"msg"`
}

type MessageBodyType string

type MessageExpiredProcessingEvent struct {
	MessageID  string `json:"message_id"`
	MessageDst string `json:"message_dst"`
	Message    string `json:"message"`
	Error      Error  `json:"error"`
}

type MessageMonitoringParams struct {
	// Monitored message identification. Can be provided as a message's BOC or (hash, address) pair. BOC is a preferable way because it helps to determine possible error reason (using TVM execution of the message).
	Message MonitoredMessage `json:"message"`
	// Block time Must be specified as a UNIX timestamp in seconds.
	WaitUntil uint32 `json:"wait_until"`
	// User defined data associated with this message. Helps to identify this message when user received `MessageMonitoringResult`.
	UserData json.RawMessage `json:"user_data"` // optional
}

type MessageMonitoringResult struct {
	// Hash of the message.
	Hash string `json:"hash"`
	// Processing status.
	Status MessageMonitoringStatus `json:"status"`
	// In case of `Finalized` the transaction is extracted from the block. In case of `Timeout` the transaction is emulated using the last known account state.
	Transaction *MessageMonitoringTransaction `json:"transaction"` // optional
	// In case of `Timeout` contains possible error reason.
	Error null.String `json:"error"` // optional
	// User defined data related to this message. This is the same value as passed before with `MessageMonitoringParams` or `SendMessageParams`.
	UserData json.RawMessage `json:"user_data"` // optional
}

type MessageMonitoringStatus string

type MessageMonitoringTransaction struct {
	// Hash of the transaction. Present if transaction was included into the blocks. When then transaction was emulated this field will be missing.
	Hash null.String `json:"hash"` // optional
	// Aborted field of the transaction.
	Aborted bool `json:"aborted"`
	// Optional information about the compute phase of the transaction.
	Compute *MessageMonitoringTransactionCompute `json:"compute"` // optional
}

type MessageMonitoringTransactionCompute struct {
	// Compute phase exit code.
	ExitCode int32 `json:"exit_code"`
}

type MessageNode struct {
	// Message id.
	ID string `json:"id"`
	// Source transaction id.
	// This field is missing for an external inbound messages.
	SrcTransactionID null.String `json:"src_transaction_id"` // optional
	// Destination transaction id.
	// This field is missing for an external outbound messages.
	DstTransactionID null.String `json:"dst_transaction_id"` // optional
	// Source address.
	Src null.String `json:"src"` // optional
	// Destination address.
	Dst null.String `json:"dst"` // optional
	// Transferred tokens value.
	Value null.String `json:"value"` // optional
	// Bounce flag.
	Bounce bool `json:"bounce"`
	// Decoded body.
	// Library tries to decode message body using provided `params.abi_registry`.
	// This field will be missing if none of the provided abi can be used to decode.
	DecodedBody *DecodedMessageBody `json:"decoded_body"` // optional
}

type MessageSendingParams struct {
	// BOC of the message, that must be sent to the blockchain.
	Boc string `json:"boc"`
	// Expiration time of the message. Must be specified as a UNIX timestamp in seconds.
	WaitUntil uint32 `json:"wait_until"`
	// User defined data associated with this message. Helps to identify this message when user received `MessageMonitoringResult`.
	UserData json.RawMessage `json:"user_data"` // optional
}

type MessageSource struct {
	// Should be any of
	// EncodedMessageSource
	// ParamsOfEncodeMessage
	EnumTypeValue interface{}
}

type MessageStateInitSource struct {
	Source MessageSource `json:"source"`
}

type MnemonicDictionary int

type MonitorFetchWaitMode string

type MonitoredMessage struct {
	// Should be any of
	// BocMonitoredMessage
	// HashAddressMonitoredMessage
	EnumTypeValue interface{}
}

type MonitoringQueueInfo struct {
	// Count of the unresolved messages.
	Unresolved uint32 `json:"unresolved"`
	// Count of resolved results.
	Resolved uint32 `json:"resolved"`
}

type Multiplexer interface {
	SetChannels(chan<- *RawResponse, <-chan struct{}) uint32
	DeleteByRequestID(uint32)
	GetChannels(requestID uint32, deleteAfterGet bool) (chan<- *RawResponse, <-chan struct{}, bool)
}

type NaclBoxBoxEncryptionAlgorithm struct {
	Value NaclBoxParamsCB `json:"value"`
}

type NaclBoxEncryptionAlgorithm struct {
	Value NaclBoxParamsEB `json:"value"`
}

type NaclBoxParamsCB struct {
	// 256-bit key.
	// Must be encoded with `hex`.
	TheirPublic string `json:"their_public"`
	// 96-bit nonce.
	// Must be encoded with `hex`.
	Nonce string `json:"nonce"`
}

type NaclBoxParamsEB struct {
	// 256-bit key.
	// Must be encoded with `hex`.
	TheirPublic string `json:"their_public"`
	// 256-bit key.
	// Must be encoded with `hex`.
	Secret string `json:"secret"`
	// 96-bit nonce.
	// Must be encoded with `hex`.
	Nonce string `json:"nonce"`
}

type NaclSecretBoxBoxEncryptionAlgorithm struct {
	Value NaclSecretBoxParamsCB `json:"value"`
}

type NaclSecretBoxEncryptionAlgorithm struct {
	Value NaclSecretBoxParamsEB `json:"value"`
}

type NaclSecretBoxParamsCB struct {
	// Nonce in `hex`.
	Nonce string `json:"nonce"`
}

type NaclSecretBoxParamsEB struct {
	// Secret key - unprefixed 0-padded to 64 symbols hex string.
	Key string `json:"key"`
	// Nonce in `hex`.
	Nonce string `json:"nonce"`
}

type NetworkConfig struct {
	// **This field is deprecated, but left for backward-compatibility.** Evernode endpoint.
	ServerAddress null.String `json:"server_address"` // optional
	// List of Evernode endpoints.
	// Any correct URL format can be specified, including IP addresses. This parameter is prevailing over `server_address`.
	// Check the full list of [supported network endpoints](https://docs.evercloud.dev/products/evercloud/networks-endpoints).
	Endpoints []string `json:"endpoints"` // optional
	// Deprecated.
	// You must use `network.max_reconnect_timeout` that allows to specify maximum network resolving timeout.
	NetworkRetriesCount null.Int8 `json:"network_retries_count"` // optional
	// Maximum time for sequential reconnections.
	// Must be specified in milliseconds. Default is 120000 (2 min).
	MaxReconnectTimeout null.Uint32 `json:"max_reconnect_timeout"` // optional
	// Deprecated.
	ReconnectTimeout null.Uint32 `json:"reconnect_timeout"` // optional
	// The number of automatic message processing retries that SDK performs in case of `Message Expired (507)` error - but only for those messages which local emulation was successful or failed with replay protection error.
	// Default is 5.
	MessageRetriesCount null.Int8 `json:"message_retries_count"` // optional
	// Timeout that is used to process message delivery for the contracts which ABI does not include "expire" header. If the message is not delivered within the specified timeout the appropriate error occurs.
	// Must be specified in milliseconds. Default is 40000 (40 sec).
	MessageProcessingTimeout null.Uint32 `json:"message_processing_timeout"` // optional
	// Maximum timeout that is used for query response.
	// Must be specified in milliseconds. Default is 40000 (40 sec).
	WaitForTimeout null.Uint32 `json:"wait_for_timeout"` // optional
	// **DEPRECATED**: This parameter was deprecated.
	OutOfSyncThreshold null.Uint32 `json:"out_of_sync_threshold"` // optional
	// Maximum number of randomly chosen endpoints the library uses to broadcast a message.
	// Default is 1.
	SendingEndpointCount null.Uint8 `json:"sending_endpoint_count"` // optional
	// Frequency of sync latency detection.
	// Library periodically checks the current endpoint for blockchain data synchronization latency.
	// If the latency (time-lag) is less then `NetworkConfig.max_latency`
	// then library selects another endpoint.
	//
	// Must be specified in milliseconds. Default is 60000 (1 min).
	LatencyDetectionInterval null.Uint32 `json:"latency_detection_interval"` // optional
	// Maximum value for the endpoint's blockchain data synchronization latency (time-lag). Library periodically checks the current endpoint for blockchain data synchronization latency. If the latency (time-lag) is less then `NetworkConfig.max_latency` then library selects another endpoint.
	// Must be specified in milliseconds. Default is 60000 (1 min).
	MaxLatency null.Uint32 `json:"max_latency"` // optional
	// Default timeout for http requests.
	// Is is used when no timeout specified for the request to limit the answer waiting time. If no answer received during the timeout requests ends with
	// error.
	//
	// Must be specified in milliseconds. Default is 60000 (1 min).
	QueryTimeout null.Uint32 `json:"query_timeout"` // optional
	// Queries protocol.
	// `HTTP` or `WS`.
	// Default is `HTTP`.
	QueriesProtocol *NetworkQueriesProtocol `json:"queries_protocol"` // optional
	// UNSTABLE.
	// First REMP status awaiting timeout. If no status received during the timeout than fallback transaction scenario is activated.
	//
	// Must be specified in milliseconds. Default is 1 (1 ms) in order to start fallback scenario
	// together with REMP statuses processing while REMP is not properly tuned yet.
	FirstRempStatusTimeout null.Uint32 `json:"first_remp_status_timeout"` // optional
	// UNSTABLE.
	// Subsequent REMP status awaiting timeout. If no status received during the timeout than fallback transaction scenario is activated.
	//
	// Must be specified in milliseconds. Default is 5000 (5 sec).
	NextRempStatusTimeout null.Uint32 `json:"next_remp_status_timeout"` // optional
	// Network signature ID which is used by VM in signature verifying instructions if capability `CapSignatureWithId` is enabled in blockchain configuration parameters.
	// This parameter should be set to `global_id` field from any blockchain block if network can
	// not be reachable at the moment of message encoding and the message is aimed to be sent into
	// network with `CapSignatureWithId` enabled. Otherwise signature ID is detected automatically
	// inside message encoding functions.
	SignatureID null.Int32 `json:"signature_id"` // optional
	// Access key to GraphQL API (Project secret).
	AccessKey null.String `json:"access_key"` // optional
}

type NetworkQueriesProtocol string

type NoneAccountForExecutor struct{}

type NoneSigner struct{}

type OkAppRequestResult struct {
	// Request processing result.
	Result json.RawMessage `json:"result"`
}

type OrderBy struct {
	Path      string        `json:"path"`
	Direction SortDirection `json:"direction"`
}

type ParamsOfAbiEncodeBoc struct {
	// Parameters to encode into BOC.
	Params []AbiParam `json:"params"`
	// Parameters and values as a JSON structure.
	Data json.RawMessage `json:"data"`
	// Cache type to put the result.
	// The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfAggregateCollection struct {
	// Collection name (accounts, blocks, transactions, messages, block_signatures).
	Collection string `json:"collection"`
	// Collection filter.
	Filter json.RawMessage `json:"filter"` // optional
	// Projection (result) string.
	Fields []FieldAggregation `json:"fields"` // optional
}

type ParamsOfAppDebotBrowser struct {
	// Should be any of
	// LogParamsOfAppDebotBrowser
	// SwitchParamsOfAppDebotBrowser
	// SwitchCompletedParamsOfAppDebotBrowser
	// ShowActionParamsOfAppDebotBrowser
	// InputParamsOfAppDebotBrowser
	// GetSigningBoxParamsOfAppDebotBrowser
	// InvokeDebotParamsOfAppDebotBrowser
	// SendParamsOfAppDebotBrowser
	// ApproveParamsOfAppDebotBrowser
	EnumTypeValue interface{}
}

type ParamsOfAppEncryptionBox struct {
	// Should be any of
	// GetInfoParamsOfAppEncryptionBox
	// EncryptParamsOfAppEncryptionBox
	// DecryptParamsOfAppEncryptionBox
	EnumTypeValue interface{}
}

type ParamsOfAppPasswordProvider struct {
	// Should be any of
	// GetPasswordParamsOfAppPasswordProvider
	EnumTypeValue interface{}
}

type ParamsOfAppRequest struct {
	// Request ID.
	// Should be used in `resolve_app_request` call.
	AppRequestID uint32 `json:"app_request_id"`
	// Request describing data.
	RequestData json.RawMessage `json:"request_data"`
}

type ParamsOfAppSigningBox struct {
	// Should be any of
	// GetPublicKeyParamsOfAppSigningBox
	// SignParamsOfAppSigningBox
	EnumTypeValue interface{}
}

type ParamsOfAttachSignature struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Public key encoded in `hex`.
	PublicKey string `json:"public_key"`
	// Unsigned message BOC encoded in `base64`.
	Message string `json:"message"`
	// Signature encoded in `hex`.
	Signature string `json:"signature"`
}

type ParamsOfAttachSignatureToMessageBody struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Public key.
	// Must be encoded with `hex`.
	PublicKey string `json:"public_key"`
	// Unsigned message body BOC.
	// Must be encoded with `base64`.
	Message string `json:"message"`
	// Signature.
	// Must be encoded with `hex`.
	Signature string `json:"signature"`
}

type ParamsOfBatchQuery struct {
	// List of query operations that must be performed per single fetch.
	Operations []ParamsOfQueryOperation `json:"operations"`
}

type ParamsOfBocCacheGet struct {
	// Reference to the cached BOC.
	BocRef string `json:"boc_ref"`
}

type ParamsOfBocCacheSet struct {
	// BOC encoded as base64 or BOC reference.
	Boc string `json:"boc"`
	// Cache type.
	CacheType BocCacheType `json:"cache_type"`
}

type ParamsOfBocCacheUnpin struct {
	// Pinned name.
	Pin string `json:"pin"`
	// Reference to the cached BOC.
	// If it is provided then only referenced BOC is unpinned.
	BocRef null.String `json:"boc_ref"` // optional
}

type ParamsOfCalcFunctionId struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Contract function name.
	FunctionName string `json:"function_name"`
	// If set to `true` output function ID will be returned which is used in contract response. Default is `false`.
	Output null.Bool `json:"output"` // optional
}

type ParamsOfCalcStorageFee struct {
	Account string `json:"account"`
	Period  uint32 `json:"period"`
}

type ParamsOfCancelMonitor struct {
	// Name of the monitoring queue.
	Queue string `json:"queue"`
}

type ParamsOfChaCha20 struct {
	// Source data to be encrypted or decrypted.
	// Must be encoded with `base64`.
	Data string `json:"data"`
	// 256-bit key.
	// Must be encoded with `hex`.
	Key string `json:"key"`
	// 96-bit nonce.
	// Must be encoded with `hex`.
	Nonce string `json:"nonce"`
}

type ParamsOfCompressZstd struct {
	// Uncompressed data.
	// Must be encoded as base64.
	Uncompressed string `json:"uncompressed"`
	// Compression level, from 1 to 21. Where: 1 - lowest compression level (fastest compression); 21 - highest compression level (slowest compression). If level is omitted, the default compression level is used (currently `3`).
	Level null.Int32 `json:"level"` // optional
}

type ParamsOfConvertAddress struct {
	// Account address in any TON format.
	Address string `json:"address"`
	// Specify the format to convert to.
	OutputFormat AddressStringFormat `json:"output_format"`
}

type ParamsOfConvertPublicKeyToTonSafeFormat struct {
	// Public key - 64 symbols hex string.
	PublicKey string `json:"public_key"`
}

type ParamsOfCreateBlockIterator struct {
	// Starting time to iterate from.
	// If the application specifies this parameter then the iteration
	// includes blocks with `gen_utime` >= `start_time`.
	// Otherwise the iteration starts from zero state.
	//
	// Must be specified in seconds.
	StartTime null.Uint32 `json:"start_time"` // optional
	// Optional end time to iterate for.
	// If the application specifies this parameter then the iteration
	// includes blocks with `gen_utime` < `end_time`.
	// Otherwise the iteration never stops.
	//
	// Must be specified in seconds.
	EndTime null.Uint32 `json:"end_time"` // optional
	// Shard prefix filter.
	// If the application specifies this parameter and it is not the empty array
	// then the iteration will include items related to accounts that belongs to
	// the specified shard prefixes.
	// Shard prefix must be represented as a string "workchain:prefix".
	// Where `workchain` is a signed integer and the `prefix` if a hexadecimal
	// representation if the 64-bit unsigned integer with tagged shard prefix.
	// For example: "0:3800000000000000".
	ShardFilter []string `json:"shard_filter"` // optional
	// Projection (result) string.
	// List of the fields that must be returned for iterated items.
	// This field is the same as the `result` parameter of
	// the `query_collection` function.
	// Note that iterated items can contains additional fields that are
	// not requested in the `result`.
	Result null.String `json:"result"` // optional
}

type ParamsOfCreateCryptoBox struct {
	// Salt used for secret encryption. For example, a mobile device can use device ID as salt.
	SecretEncryptionSalt string `json:"secret_encryption_salt"`
	// Cryptobox secret.
	Secret CryptoBoxSecret `json:"secret"`
}

type ParamsOfCreateEncryptionBox struct {
	// Encryption algorithm specifier including cipher parameters (key, IV, etc).
	Algorithm EncryptionAlgorithm `json:"algorithm"`
}

type ParamsOfCreateTransactionIterator struct {
	// Starting time to iterate from.
	// If the application specifies this parameter then the iteration
	// includes blocks with `gen_utime` >= `start_time`.
	// Otherwise the iteration starts from zero state.
	//
	// Must be specified in seconds.
	StartTime null.Uint32 `json:"start_time"` // optional
	// Optional end time to iterate for.
	// If the application specifies this parameter then the iteration
	// includes blocks with `gen_utime` < `end_time`.
	// Otherwise the iteration never stops.
	//
	// Must be specified in seconds.
	EndTime null.Uint32 `json:"end_time"` // optional
	// Shard prefix filters.
	// If the application specifies this parameter and it is not an empty array
	// then the iteration will include items related to accounts that belongs to
	// the specified shard prefixes.
	// Shard prefix must be represented as a string "workchain:prefix".
	// Where `workchain` is a signed integer and the `prefix` if a hexadecimal
	// representation if the 64-bit unsigned integer with tagged shard prefix.
	// For example: "0:3800000000000000".
	// Account address conforms to the shard filter if
	// it belongs to the filter workchain and the first bits of address match to
	// the shard prefix. Only transactions with suitable account addresses are iterated.
	ShardFilter []string `json:"shard_filter"` // optional
	// Account address filter.
	// Application can specify the list of accounts for which
	// it wants to iterate transactions.
	//
	// If this parameter is missing or an empty list then the library iterates
	// transactions for all accounts that pass the shard filter.
	//
	// Note that the library doesn't detect conflicts between the account filter and the shard filter
	// if both are specified.
	// So it is an application responsibility to specify the correct filter combination.
	AccountsFilter []string `json:"accounts_filter"` // optional
	// Projection (result) string.
	// List of the fields that must be returned for iterated items.
	// This field is the same as the `result` parameter of
	// the `query_collection` function.
	// Note that iterated items can contain additional fields that are
	// not requested in the `result`.
	Result null.String `json:"result"` // optional
	// Include `transfers` field in iterated transactions.
	// If this parameter is `true` then each transaction contains field
	// `transfers` with list of transfer. See more about this structure in function description.
	IncludeTransfers null.Bool `json:"include_transfers"` // optional
}

type ParamsOfDecodeAccountData struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Data BOC or BOC handle.
	Data string `json:"data"`
	// Flag allowing partial BOC decoding when ABI doesn't describe the full body BOC. Controls decoder behaviour when after decoding all described in ABI params there are some data left in BOC: `true` - return decoded values `false` - return error of incomplete BOC deserialization (default).
	AllowPartial null.Bool `json:"allow_partial"` // optional
}

type ParamsOfDecodeBoc struct {
	// Parameters to decode from BOC.
	Params []AbiParam `json:"params"`
	// Data BOC or BOC handle.
	Boc          string `json:"boc"`
	AllowPartial bool   `json:"allow_partial"`
}

type ParamsOfDecodeInitialData struct {
	// Contract ABI.
	// Initial data is decoded if this parameter is provided.
	Abi *Abi `json:"abi"` // optional
	// Data BOC or BOC handle.
	Data string `json:"data"`
	// Flag allowing partial BOC decoding when ABI doesn't describe the full body BOC. Controls decoder behaviour when after decoding all described in ABI params there are some data left in BOC: `true` - return decoded values `false` - return error of incomplete BOC deserialization (default).
	AllowPartial null.Bool `json:"allow_partial"` // optional
}

type ParamsOfDecodeMessage struct {
	// contract ABI.
	Abi Abi `json:"abi"`
	// Message BOC.
	Message string `json:"message"`
	// Flag allowing partial BOC decoding when ABI doesn't describe the full body BOC. Controls decoder behaviour when after decoding all described in ABI params there are some data left in BOC: `true` - return decoded values `false` - return error of incomplete BOC deserialization (default).
	AllowPartial null.Bool `json:"allow_partial"` // optional
	// Function name or function id if is known in advance.
	FunctionName null.String `json:"function_name"` // optional
	DataLayout   *DataLayout `json:"data_layout"`   // optional
}

type ParamsOfDecodeMessageBody struct {
	// Contract ABI used to decode.
	Abi Abi `json:"abi"`
	// Message body BOC encoded in `base64`.
	Body string `json:"body"`
	// True if the body belongs to the internal message.
	IsInternal bool `json:"is_internal"`
	// Flag allowing partial BOC decoding when ABI doesn't describe the full body BOC. Controls decoder behaviour when after decoding all described in ABI params there are some data left in BOC: `true` - return decoded values `false` - return error of incomplete BOC deserialization (default).
	AllowPartial null.Bool `json:"allow_partial"` // optional
	// Function name or function id if is known in advance.
	FunctionName null.String `json:"function_name"` // optional
	DataLayout   *DataLayout `json:"data_layout"`   // optional
}

type ParamsOfDecodeStateInit struct {
	// Contract StateInit image BOC encoded as base64 or BOC handle.
	StateInit string `json:"state_init"`
	// Cache type to put the result. The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfDecodeTvc struct {
	// Contract TVC BOC encoded as base64 or BOC handle.
	Tvc string `json:"tvc"`
}

type ParamsOfDecompressZstd struct {
	// Compressed data.
	// Must be encoded as base64.
	Compressed string `json:"compressed"`
}

type ParamsOfEncodeAccount struct {
	// Source of the account state init.
	StateInit StateInitSource `json:"state_init"`
	// Initial balance.
	Balance *big.Int `json:"balance"` // optional
	// Initial value for the `last_trans_lt`.
	LastTransLt *big.Int `json:"last_trans_lt"` // optional
	// Initial value for the `last_paid`.
	LastPaid null.Uint32 `json:"last_paid"` // optional
	// Cache type to put the result.
	// The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfEncodeBoc struct {
	// Cell builder operations.
	Builder []BuilderOp `json:"builder"`
	// Cache type to put the result. The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfEncodeExternalInMessage struct {
	// Source address.
	Src null.String `json:"src"` // optional
	// Destination address.
	Dst string `json:"dst"`
	// Bag of cells with state init (used in deploy messages).
	Init null.String `json:"init"` // optional
	// Bag of cells with the message body encoded as base64.
	Body null.String `json:"body"` // optional
	// Cache type to put the result.
	// The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfEncodeInitialData struct {
	// Contract ABI.
	Abi *Abi `json:"abi"` // optional
	// List of initial values for contract's static variables.
	// `abi` parameter should be provided to set initial data.
	InitialData json.RawMessage `json:"initial_data"` // optional
	// Initial account owner's public key to set into account data.
	InitialPubkey null.String `json:"initial_pubkey"` // optional
	// Cache type to put the result. The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfEncodeInternalMessage struct {
	// Contract ABI.
	// Can be None if both deploy_set and call_set are None.
	Abi *Abi `json:"abi"` // optional
	// Target address the message will be sent to.
	// Must be specified in case of non-deploy message.
	Address null.String `json:"address"` // optional
	// Source address of the message.
	SrcAddress null.String `json:"src_address"` // optional
	// Deploy parameters.
	// Must be specified in case of deploy message.
	DeploySet *DeploySet `json:"deploy_set"` // optional
	// Function call parameters.
	// Must be specified in case of non-deploy message.
	//
	// In case of deploy message it is optional and contains parameters
	// of the functions that will to be called upon deploy transaction.
	CallSet *CallSet `json:"call_set"` // optional
	// Value in nanotokens to be sent with message.
	Value string `json:"value"`
	// Flag of bounceable message.
	// Default is true.
	Bounce null.Bool `json:"bounce"` // optional
	// Enable Instant Hypercube Routing for the message.
	// Default is false.
	EnableIhr null.Bool `json:"enable_ihr"` // optional
}

type ParamsOfEncodeMessage struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Target address the message will be sent to.
	// Must be specified in case of non-deploy message.
	Address null.String `json:"address"` // optional
	// Deploy parameters.
	// Must be specified in case of deploy message.
	DeploySet *DeploySet `json:"deploy_set"` // optional
	// Function call parameters.
	// Must be specified in case of non-deploy message.
	//
	// In case of deploy message it is optional and contains parameters
	// of the functions that will to be called upon deploy transaction.
	CallSet *CallSet `json:"call_set"` // optional
	// Signing parameters.
	Signer Signer `json:"signer"`
	// Processing try index.
	// Used in message processing with retries (if contract's ABI includes "expire" header).
	//
	// Encoder uses the provided try index to calculate message
	// expiration time. The 1st message expiration time is specified in
	// Client config.
	//
	// Expiration timeouts will grow with every retry.
	// Retry grow factor is set in Client config:
	// <.....add config parameter with default value here>
	//
	// Default value is 0.
	ProcessingTryIndex null.Uint8 `json:"processing_try_index"` // optional
	// Signature ID to be used in data to sign preparing when CapSignatureWithId capability is enabled.
	SignatureID null.Int32 `json:"signature_id"` // optional
}

type ParamsOfEncodeMessageBody struct {
	// Contract ABI.
	Abi Abi `json:"abi"`
	// Function call parameters.
	// Must be specified in non deploy message.
	//
	// In case of deploy message contains parameters of constructor.
	CallSet CallSet `json:"call_set"`
	// True if internal message body must be encoded.
	IsInternal bool `json:"is_internal"`
	// Signing parameters.
	Signer Signer `json:"signer"`
	// Processing try index.
	// Used in message processing with retries.
	//
	// Encoder uses the provided try index to calculate message
	// expiration time.
	//
	// Expiration timeouts will grow with every retry.
	//
	// Default value is 0.
	ProcessingTryIndex null.Uint8 `json:"processing_try_index"` // optional
	// Destination address of the message.
	// Since ABI version 2.3 destination address of external inbound message is used in message
	// body signature calculation. Should be provided when signed external inbound message body is
	// created. Otherwise can be omitted.
	Address null.String `json:"address"` // optional
	// Signature ID to be used in data to sign preparing when CapSignatureWithId capability is enabled.
	SignatureID null.Int32 `json:"signature_id"` // optional
}

type ParamsOfEncodeStateInit struct {
	// Contract code BOC encoded as base64 or BOC handle.
	Code null.String `json:"code"` // optional
	// Contract data BOC encoded as base64 or BOC handle.
	Data null.String `json:"data"` // optional
	// Contract library BOC encoded as base64 or BOC handle.
	Library null.String `json:"library"` // optional
	// `special.tick` field.
	// Specifies the contract ability to handle tick transactions.
	Tick null.Bool `json:"tick"` // optional
	// `special.tock` field.
	// Specifies the contract ability to handle tock transactions.
	Tock null.Bool `json:"tock"` // optional
	// Is present and non-zero only in instances of large smart contracts.
	SplitDepth null.Uint32 `json:"split_depth"` // optional
	// Cache type to put the result. The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfEncryptionBoxDecrypt struct {
	// Encryption box handle.
	EncryptionBox EncryptionBoxHandle `json:"encryption_box"`
	// Data to be decrypted, encoded in Base64.
	Data string `json:"data"`
}

type ParamsOfEncryptionBoxEncrypt struct {
	// Encryption box handle.
	EncryptionBox EncryptionBoxHandle `json:"encryption_box"`
	// Data to be encrypted, encoded in Base64.
	Data string `json:"data"`
}

type ParamsOfEncryptionBoxGetInfo struct {
	// Encryption box handle.
	EncryptionBox EncryptionBoxHandle `json:"encryption_box"`
}

type ParamsOfExecute struct {
	// Debot handle which references an instance of debot engine.
	DebotHandle DebotHandle `json:"debot_handle"`
	// Debot Action that must be executed.
	Action DebotAction `json:"action"`
}

type ParamsOfFactorize struct {
	// Hexadecimal representation of u64 composite number.
	Composite string `json:"composite"`
}

type ParamsOfFetch struct {
	// Debot smart contract address.
	Address string `json:"address"`
}

type ParamsOfFetchNextMonitorResults struct {
	// Name of the monitoring queue.
	Queue string `json:"queue"`
	// Wait mode.
	// Default is `NO_WAIT`.
	WaitMode *MonitorFetchWaitMode `json:"wait_mode"` // optional
}

type ParamsOfFindLastShardBlock struct {
	// Account address.
	Address string `json:"address"`
}

type ParamsOfGenerateRandomBytes struct {
	// Size of random byte array.
	Length uint32 `json:"length"`
}

type ParamsOfGetAddressType struct {
	// Account address in any TON format.
	Address string `json:"address"`
}

type ParamsOfGetBlockchainConfig struct {
	// Key block BOC or zerostate BOC encoded as base64.
	BlockBoc string `json:"block_boc"`
}

type ParamsOfGetBocDepth struct {
	// BOC encoded as base64 or BOC handle.
	Boc string `json:"boc"`
}

type ParamsOfGetBocHash struct {
	// BOC encoded as base64 or BOC handle.
	Boc string `json:"boc"`
}

type ParamsOfGetCodeFromTvc struct {
	// Contract TVC image or image BOC handle.
	Tvc string `json:"tvc"`
}

type ParamsOfGetCodeSalt struct {
	// Contract code BOC encoded as base64 or code BOC handle.
	Code string `json:"code"`
	// Cache type to put the result. The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
}

type ParamsOfGetCompilerVersion struct {
	// Contract code BOC encoded as base64 or code BOC handle.
	Code string `json:"code"`
}

type ParamsOfGetEncryptionBoxFromCryptoBox struct {
	// Crypto Box Handle.
	Handle uint32 `json:"handle"`
	// HD key derivation path.
	// By default, Everscale HD path is used.
	Hdpath null.String `json:"hdpath"` // optional
	// Encryption algorithm.
	Algorithm BoxEncryptionAlgorithm `json:"algorithm"`
	// Store derived secret for encryption algorithm for this lifetime (in ms). The timer starts after each encryption box operation. Secrets will be deleted (overwritten with zeroes) after each encryption operation, if this value is not set.
	SecretLifetime null.Uint32 `json:"secret_lifetime"` // optional
}

type ParamsOfGetMonitorInfo struct {
	// Name of the monitoring queue.
	Queue string `json:"queue"`
}

type ParamsOfGetSignatureData struct {
	// Contract ABI used to decode.
	Abi Abi `json:"abi"`
	// Message BOC encoded in `base64`.
	Message string `json:"message"`
	// Signature ID to be used in unsigned data preparing when CapSignatureWithId capability is enabled.
	SignatureID null.Int32 `json:"signature_id"` // optional
}

type ParamsOfGetSigningBoxFromCryptoBox struct {
	// Crypto Box Handle.
	Handle uint32 `json:"handle"`
	// HD key derivation path.
	// By default, Everscale HD path is used.
	Hdpath null.String `json:"hdpath"` // optional
	// Store derived secret for this lifetime (in ms). The timer starts after each signing box operation. Secrets will be deleted immediately after each signing box operation, if this value is not set.
	SecretLifetime null.Uint32 `json:"secret_lifetime"` // optional
}

type ParamsOfHDKeyDeriveFromXPrv struct {
	// Serialized extended private key.
	XPrv string `json:"xprv"`
	// Child index (see BIP-0032).
	ChildIndex uint32 `json:"child_index"`
	// Indicates the derivation of hardened/not-hardened key (see BIP-0032).
	Hardened bool `json:"hardened"`
}

type ParamsOfHDKeyDeriveFromXPrvPath struct {
	// Serialized extended private key.
	XPrv string `json:"xprv"`
	// Derivation path, for instance "m/44'/396'/0'/0/0".
	Path string `json:"path"`
}

type ParamsOfHDKeyPublicFromXPrv struct {
	// Serialized extended private key.
	XPrv string `json:"xprv"`
}

type ParamsOfHDKeySecretFromXPrv struct {
	// Serialized extended private key.
	XPrv string `json:"xprv"`
}

type ParamsOfHDKeyXPrvFromMnemonic struct {
	// String with seed phrase.
	Phrase string `json:"phrase"`
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
	// Mnemonic word count.
	WordCount null.Uint8 `json:"word_count"` // optional
}

type ParamsOfHash struct {
	// Input data for hash calculation.
	// Encoded with `base64`.
	Data string `json:"data"`
}

type ParamsOfInit struct {
	// Debot smart contract address.
	Address string `json:"address"`
}

type ParamsOfIteratorNext struct {
	// Iterator handle.
	Iterator uint32 `json:"iterator"`
	// Maximum count of the returned items.
	// If value is missing or is less than 1 the library uses 1.
	Limit null.Uint32 `json:"limit"` // optional
	// Indicates that function must return the iterator state that can be used for resuming iteration.
	ReturnResumeState null.Bool `json:"return_resume_state"` // optional
}

type ParamsOfMnemonicDeriveSignKeys struct {
	// Phrase.
	Phrase string `json:"phrase"`
	// Derivation path, for instance "m/44'/396'/0'/0/0".
	Path null.String `json:"path"` // optional
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
	// Word count.
	WordCount null.Uint8 `json:"word_count"` // optional
}

type ParamsOfMnemonicFromEntropy struct {
	// Entropy bytes.
	// Hex encoded.
	Entropy string `json:"entropy"`
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
	// Mnemonic word count.
	WordCount null.Uint8 `json:"word_count"` // optional
}

type ParamsOfMnemonicFromRandom struct {
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
	// Mnemonic word count.
	WordCount null.Uint8 `json:"word_count"` // optional
}

type ParamsOfMnemonicVerify struct {
	// Phrase.
	Phrase string `json:"phrase"`
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
	// Word count.
	WordCount null.Uint8 `json:"word_count"` // optional
}

type ParamsOfMnemonicWords struct {
	// Dictionary identifier.
	Dictionary *MnemonicDictionary `json:"dictionary"` // optional
}

type ParamsOfModularPower struct {
	// `base` argument of calculation.
	Base string `json:"base"`
	// `exponent` argument of calculation.
	Exponent string `json:"exponent"`
	// `modulus` argument of calculation.
	Modulus string `json:"modulus"`
}

type ParamsOfMonitorMessages struct {
	// Name of the monitoring queue.
	Queue string `json:"queue"`
	// Messages to start monitoring for.
	Messages []MessageMonitoringParams `json:"messages"`
}

type ParamsOfNaclBox struct {
	// Data that must be encrypted encoded in `base64`.
	Decrypted string `json:"decrypted"`
	// Nonce, encoded in `hex`.
	Nonce string `json:"nonce"`
	// Receiver's public key - unprefixed 0-padded to 64 symbols hex string.
	TheirPublic string `json:"their_public"`
	// Sender's private key - unprefixed 0-padded to 64 symbols hex string.
	Secret string `json:"secret"`
}

type ParamsOfNaclBoxKeyPairFromSecret struct {
	// Secret key - unprefixed 0-padded to 64 symbols hex string.
	Secret string `json:"secret"`
}

type ParamsOfNaclBoxOpen struct {
	// Data that must be decrypted.
	// Encoded with `base64`.
	Encrypted string `json:"encrypted"`
	// Nonce.
	Nonce string `json:"nonce"`
	// Sender's public key - unprefixed 0-padded to 64 symbols hex string.
	TheirPublic string `json:"their_public"`
	// Receiver's private key - unprefixed 0-padded to 64 symbols hex string.
	Secret string `json:"secret"`
}

type ParamsOfNaclSecretBox struct {
	// Data that must be encrypted.
	// Encoded with `base64`.
	Decrypted string `json:"decrypted"`
	// Nonce in `hex`.
	Nonce string `json:"nonce"`
	// Secret key - unprefixed 0-padded to 64 symbols hex string.
	Key string `json:"key"`
}

type ParamsOfNaclSecretBoxOpen struct {
	// Data that must be decrypted.
	// Encoded with `base64`.
	Encrypted string `json:"encrypted"`
	// Nonce in `hex`.
	Nonce string `json:"nonce"`
	// Secret key - unprefixed 0-padded to 64 symbols hex string.
	Key string `json:"key"`
}

type ParamsOfNaclSign struct {
	// Data that must be signed encoded in `base64`.
	Unsigned string `json:"unsigned"`
	// Signer's secret key - unprefixed 0-padded to 128 symbols hex string (concatenation of 64 symbols secret and 64 symbols public keys). See `nacl_sign_keypair_from_secret_key`.
	Secret string `json:"secret"`
}

type ParamsOfNaclSignDetachedVerify struct {
	// Unsigned data that must be verified.
	// Encoded with `base64`.
	Unsigned string `json:"unsigned"`
	// Signature that must be verified.
	// Encoded with `hex`.
	Signature string `json:"signature"`
	// Signer's public key - unprefixed 0-padded to 64 symbols hex string.
	Public string `json:"public"`
}

type ParamsOfNaclSignKeyPairFromSecret struct {
	// Secret key - unprefixed 0-padded to 64 symbols hex string.
	Secret string `json:"secret"`
}

type ParamsOfNaclSignOpen struct {
	// Signed data that must be unsigned.
	// Encoded with `base64`.
	Signed string `json:"signed"`
	// Signer's public key - unprefixed 0-padded to 64 symbols hex string.
	Public string `json:"public"`
}

type ParamsOfParse struct {
	// BOC encoded as base64.
	Boc string `json:"boc"`
}

type ParamsOfParseShardstate struct {
	// BOC encoded as base64.
	Boc string `json:"boc"`
	// Shardstate identifier.
	ID string `json:"id"`
	// Workchain shardstate belongs to.
	WorkchainID int32 `json:"workchain_id"`
}

type ParamsOfProcessMessage struct {
	// Message encode parameters.
	MessageEncodeParams ParamsOfEncodeMessage `json:"message_encode_params"`
	// Flag for requesting events sending. Default is `false`.
	SendEvents null.Bool `json:"send_events"` // optional
}

type ParamsOfProofBlockData struct {
	// Single block's data, retrieved from TONOS API, that needs proof. Required fields are `id` and/or top-level `boc` (for block identification), others are optional.
	Block json.RawMessage `json:"block"`
}

type ParamsOfProofMessageData struct {
	// Single message's data as queried from DApp server, without modifications. The required fields are `id` and/or top-level `boc`, others are optional. In order to reduce network requests count, it is recommended to provide at least `boc` of message and non-null `src_transaction.id` or `dst_transaction.id`.
	Message json.RawMessage `json:"message"`
}

type ParamsOfProofTransactionData struct {
	// Single transaction's data as queried from DApp server, without modifications. The required fields are `id` and/or top-level `boc`, others are optional. In order to reduce network requests count, it is recommended to provide `block_id` and `boc` of transaction.
	Transaction json.RawMessage `json:"transaction"`
}

type ParamsOfQuery struct {
	// GraphQL query text.
	Query string `json:"query"`
	// Variables used in query.
	// Must be a map with named values that can be used in query.
	Variables json.RawMessage `json:"variables"` // optional
}

type ParamsOfQueryCollection struct {
	// Collection name (accounts, blocks, transactions, messages, block_signatures).
	Collection string `json:"collection"`
	// Collection filter.
	Filter json.RawMessage `json:"filter"` // optional
	// Projection (result) string.
	Result string `json:"result"`
	// Sorting order.
	Order []OrderBy `json:"order"` // optional
	// Number of documents to return.
	Limit null.Uint32 `json:"limit"` // optional
}

type ParamsOfQueryCounterparties struct {
	// Account address.
	Account string `json:"account"`
	// Projection (result) string.
	Result string `json:"result"`
	// Number of counterparties to return.
	First null.Uint32 `json:"first"` // optional
	// `cursor` field of the last received result.
	After null.String `json:"after"` // optional
}

type ParamsOfQueryOperation struct {
	// Should be any of
	// ParamsOfQueryCollection
	// ParamsOfWaitForCollection
	// ParamsOfAggregateCollection
	// ParamsOfQueryCounterparties
	EnumTypeValue interface{}
}

type ParamsOfQueryTransactionTree struct {
	// Input message id.
	InMsg string `json:"in_msg"`
	// List of contract ABIs that will be used to decode message bodies. Library will try to decode each returned message body using any ABI from the registry.
	AbiRegistry []Abi `json:"abi_registry"` // optional
	// Timeout used to limit waiting time for the missing messages and transaction.
	// If some of the following messages and transactions are missing yet
	// The maximum waiting time is regulated by this option.
	//
	// Default value is 60000 (1 min). If `timeout` is set to 0 then function will wait infinitely
	// until the whole transaction tree is executed.
	Timeout null.Uint32 `json:"timeout"` // optional
	// Maximum transaction count to wait.
	// If transaction tree contains more transaction then this parameter then only first `transaction_max_count` transaction are awaited and returned.
	//
	// Default value is 50. If `transaction_max_count` is set to 0 then no limitation on
	// transaction count is used and all transaction are returned.
	TransactionMaxCount null.Uint32 `json:"transaction_max_count"` // optional
}

type ParamsOfRemove struct {
	// Debot handle which references an instance of debot engine.
	DebotHandle DebotHandle `json:"debot_handle"`
}

type ParamsOfResolveAppRequest struct {
	// Request ID received from SDK.
	AppRequestID uint32 `json:"app_request_id"`
	// Result of request processing.
	Result AppRequestResult `json:"result"`
}

type ParamsOfResumeBlockIterator struct {
	// Iterator state from which to resume.
	// Same as value returned from `iterator_next`.
	ResumeState json.RawMessage `json:"resume_state"`
}

type ParamsOfResumeTransactionIterator struct {
	// Iterator state from which to resume.
	// Same as value returned from `iterator_next`.
	ResumeState json.RawMessage `json:"resume_state"`
	// Account address filter.
	// Application can specify the list of accounts for which
	// it wants to iterate transactions.
	//
	// If this parameter is missing or an empty list then the library iterates
	// transactions for all accounts that passes the shard filter.
	//
	// Note that the library doesn't detect conflicts between the account filter and the shard filter
	// if both are specified.
	// So it is the application's responsibility to specify the correct filter combination.
	AccountsFilter []string `json:"accounts_filter"` // optional
}

type ParamsOfRunExecutor struct {
	// Input message BOC.
	// Must be encoded as base64.
	Message string `json:"message"`
	// Account to run on executor.
	Account AccountForExecutor `json:"account"`
	// Execution options.
	ExecutionOptions *ExecutionOptions `json:"execution_options"` // optional
	// Contract ABI for decoding output messages.
	Abi *Abi `json:"abi"` // optional
	// Skip transaction check flag.
	SkipTransactionCheck null.Bool `json:"skip_transaction_check"` // optional
	// Cache type to put the result.
	// The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
	// Return updated account flag.
	// Empty string is returned if the flag is `false`.
	ReturnUpdatedAccount null.Bool `json:"return_updated_account"` // optional
}

type ParamsOfRunGet struct {
	// Account BOC in `base64`.
	Account string `json:"account"`
	// Function name.
	FunctionName string `json:"function_name"`
	// Input parameters.
	Input json.RawMessage `json:"input"` // optional
	// Execution options.
	ExecutionOptions *ExecutionOptions `json:"execution_options"` // optional
	// Convert lists based on nested tuples in the **result** into plain arrays.
	// Default is `false`. Input parameters may use any of lists representations
	// If you receive this error on Web: "Runtime error. Unreachable code should not be executed...",
	// set this flag to true.
	// This may happen, for example, when elector contract contains too many participants.
	TupleListAsArray null.Bool `json:"tuple_list_as_array"` // optional
}

type ParamsOfRunTvm struct {
	// Input message BOC.
	// Must be encoded as base64.
	Message string `json:"message"`
	// Account BOC.
	// Must be encoded as base64.
	Account string `json:"account"`
	// Execution options.
	ExecutionOptions *ExecutionOptions `json:"execution_options"` // optional
	// Contract ABI for decoding output messages.
	Abi *Abi `json:"abi"` // optional
	// Cache type to put the result.
	// The BOC itself returned if no cache type provided.
	BocCache *BocCacheType `json:"boc_cache"` // optional
	// Return updated account flag.
	// Empty string is returned if the flag is `false`.
	ReturnUpdatedAccount null.Bool `json:"return_updated_account"` // optional
}