contract

type ActivityStatsResponse struct {
	Online float64 `json:"online_percent"`
	Active float64 `json:"active_percent"`
}

type AuthRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type AuthResponse struct {
	// example: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6Im15c3QiLCJleHAiOjE2MDEwNDA1NzB9.hnn9FosblyWtx1feSupx3MhZZdkbCuMTaiM6xl54VwQ
	Token string `json:"token"`

	// example: 2019-06-06T11:04:43.910035Z
	ExpiresAt string `json:"expires_at"`
}

type BalanceDTO struct {
	Balance       *big.Int `json:"balance"`
	BalanceTokens Tokens   `json:"balance_tokens"`
}

type BeneficiaryAddressRequest struct {
	Address string `json:"address"`
}

type BeneficiaryTxStatus struct {
	State beneficiary.SettleState `json:"state"`
	Error string                  `json:"error"`
	// example: 0x0000000000000000000000000000000000000001
	ChangeTo string `json:"change_to"`
}

type BuildInfoDTO struct {
	// example: <unknown>
	Commit string `json:"commit"`

	// example: <unknown>
	Branch string `json:"branch"`

	// example: dev-build
	BuildNumber string `json:"build_number"`
}

type ChainSummary struct {
	Chains       map[int64]string `json:"chains"`
	CurrentChain int64            `json:"current_chain"`
}

type ChangePasswordRequest struct {
	Username    string `json:"username"`
	OldPassword string `json:"old_password"`
	NewPassword string `json:"new_password"`
}

type CombinedFeesResponse struct {
	Current TransactorFees `json:"current"`
	Last    TransactorFees `json:"last"`

	ServerTime    time.Time `json:"server_time"`
	HermesPercent string    `json:"hermes_percent"`
}

type ConnectOptions struct {
	// kill switch option restricting communication only through VPN
	// required: false
	// example: true
	DisableKillSwitch bool `json:"kill_switch"`
	// DNS to use
	// required: false
	// default: auto
	// example: auto, provider, system, "1.1.1.1,8.8.8.8"
	DNS connection.DNSOption `json:"dns"`

	ProxyPort int `json:"proxy_port"`
}

type ConnectionCreateFilter struct {
	Providers               []string `json:"providers,omitempty"`
	CountryCode             string   `json:"country_code,omitempty"`
	IPType                  string   `json:"ip_type,omitempty"`
	IncludeMonitoringFailed bool     `json:"include_monitoring_failed,omitempty"`
	SortBy                  string   `json:"sort_by,omitempty"`
}

type ConnectionCreateRequest struct {
	// consumer identity
	// required: true
	// example: 0x0000000000000000000000000000000000000001
	ConsumerID string `json:"consumer_id"`

	// provider identity
	// required: true
	// example: 0x0000000000000000000000000000000000000002
	ProviderID string `json:"provider_id"`

	Filter ConnectionCreateFilter `json:"filter"`

	// hermes identity
	// example: 0x0000000000000000000000000000000000000003
	HermesID string `json:"hermes_id"`

	// service type. Possible values are "openvpn", "wireguard" and "noop"
	// required: false
	// default: openvpn
	// example: openvpn
	ServiceType string `json:"service_type"`

	// connect options
	// required: false
	ConnectOptions ConnectOptions `json:"connect_options,omitempty"`
}

type ConnectionDTO struct {
	ConnectionInfoDTO
	Statistics *ConnectionStatisticsDTO `json:"statistics,omitempty"`
}

type ConnectionInfoDTO struct {
	// example: Connected
	Status string `json:"status"`

	// example: 0x00
	ConsumerID string `json:"consumer_id,omitempty"`

	// example: 0x00
	HermesID string `json:"hermes_id,omitempty"`

	// example: {"id":1,"provider_id":"0x71ccbdee7f6afe85a5bc7106323518518cd23b94","service_type":"openvpn","location":{"country":"CA"}}
	Proposal *ProposalDTO `json:"proposal,omitempty"`

	// example: 4cfb0324-daf6-4ad8-448b-e61fe0a1f918
	SessionID string `json:"session_id,omitempty"`
}

type ConnectionStatisticsDTO struct {
	// example: 1024
	BytesSent uint64 `json:"bytes_sent"`

	// example: 1024
	BytesReceived uint64 `json:"bytes_received"`

	// Upload speed in bits per second
	// example: 1024
	ThroughputSent uint64 `json:"throughput_sent"`

	// Download speed in bits per second
	// example: 1024
	ThroughputReceived uint64 `json:"throughput_received"`

	// connection duration in seconds
	// example: 60
	Duration int `json:"duration"`

	// example: 500000
	TokensSpent *big.Int `json:"tokens_spent"`

	SpentTokens Tokens `json:"spent_tokens"`
}

type ConnectionTrafficDTO struct {
	// example: 1024
	BytesSent uint64 `json:"bytes_sent"`

	// example: 1024
	BytesReceived uint64 `json:"bytes_received"`
}

type CurrencyExchangeDTO struct {
	Amount   float64 `json:"amount"`
	Currency string  `json:"currency"`
}

type CurrentPriceResponse struct {
	ServiceType string `json:"service_type"`
	// deprecated
	PricePerHour       *big.Int `json:"price_per_hour"`
	PricePerHourTokens Tokens   `json:"price_per_hour_tokens"`
	// deprecated
	PricePerGiB       *big.Int `json:"price_per_gib"`
	PricePerGiBTokens Tokens   `json:"price_per_gib_tokens"`
}

type DecreaseStakeRequest struct {
	ID     string   `json:"id,omitempty"`
	Amount *big.Int `json:"amount,omitempty"`
}

type DownloadNodeUIRequest struct {
	Version string `json:"version"`
}

type EarningsDTO struct {
	Earnings      Tokens `json:"earnings"`
	EarningsTotal Tokens `json:"earnings_total"`
}

type EarningsPerServiceResponse struct {
	EarningsPublic          Tokens `json:"public_tokens"`
	EarningsVPN             Tokens `json:"data_transfer_tokens"`
	EarningsScraping        Tokens `json:"scraping_tokens"`
	EarningsDVPN            Tokens `json:"dvpn_tokens"`
	EarningsMonitoring      Tokens `json:"monitoring_tokens"`
	EarningsTotal           Tokens `json:"total_tokens"`
	TotalEarningsPublic     Tokens `json:"total_public_tokens"`
	TotalEarningsVPN        Tokens `json:"total_data_transfer_tokens"`
	TotalEarningsScraping   Tokens `json:"total_scraping_tokens"`
	TotalEarningsDVPN       Tokens `json:"total_dvpn_tokens"`
	TotalEarningsMonitoring Tokens `json:"total_monitoring_tokens"`
}

type EncryptedKeyJSON struct {
	Address string     `json:"address"`
	Crypto  cryptoJSON `json:"crypto"`
	Id      string     `json:"id"`
	Version int        `json:"version"`
}

type EntertainmentEstimateRequest struct {
	Amount float64
}

type EntertainmentEstimateResponse struct {
	VideoMinutes    uint64  `json:"video_minutes"`
	MusicMinutes    uint64  `json:"music_minutes"`
	BrowsingMinutes uint64  `json:"browsing_minutes"`
	TrafficMB       uint64  `json:"traffic_mb"`
	PriceGiB        float64 `json:"price_gib"`
	PriceMin        float64 `json:"price_min"`
}

type FeesDTO struct {
	Registration       *big.Int `json:"registration"`
	RegistrationTokens Tokens   `json:"registration_tokens"`
	Settlement         *big.Int `json:"settlement"`
	SettlementTokens   Tokens   `json:"settlement_tokens"`
	// deprecated - confusing name
	Hermes              uint16   `json:"hermes"`
	HermesPercent       string   `json:"hermes_percent"`
	DecreaseStake       *big.Int `json:"decreaseStake"`
	DecreaseStakeTokens Tokens   `json:"decrease_stake_tokens"`
}

type FilterPreset struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

type GatewaysResponse struct {
	Name         string              `json:"name"`
	OrderOptions PaymentOrderOptions `json:"order_options"`
	Currencies   []string            `json:"currencies"`
}

type HealthCheckDTO struct {
	// example: 25h53m33.540493171s
	Uptime string `json:"uptime"`

	// example: 10449
	Process int `json:"process"`

	// example: 0.0.6
	Version   string       `json:"version"`
	BuildInfo BuildInfoDTO `json:"build_info"`
}

type IPDTO struct {
	// public IP address
	// example: 127.0.0.1
	IP string `json:"ip"`
}

type IdentityBeneficiaryResponse struct {
	Beneficiary      string `json:"beneficiary"`
	IsChannelAddress bool   `json:"is_channel_address"`
}

type IdentityCreateRequest struct {
	Passphrase *string `json:"passphrase"`
}

type IdentityCurrentRequest struct {
	Address    *string `json:"id"`
	Passphrase *string `json:"passphrase"`
}

type IdentityDTO struct {
	// identity in Ethereum address format
	// required: true
	// example: 0x0000000000000000000000000000000000000001
	Address            string `json:"id"`
	RegistrationStatus string `json:"registration_status"`
	ChannelAddress     string `json:"channel_address"`

	// deprecated
	Balance       *big.Int `json:"balance"`
	Earnings      *big.Int `json:"earnings"`
	EarningsTotal *big.Int `json:"earnings_total"`

	BalanceTokens       Tokens `json:"balance_tokens"`
	EarningsTokens      Tokens `json:"earnings_tokens"`
	EarningsTotalTokens Tokens `json:"earnings_total_tokens"`

	Stake             *big.Int               `json:"stake"`
	HermesID          string                 `json:"hermes_id"`
	EarningsPerHermes map[string]EarningsDTO `json:"earnings_per_hermes"`
}

type IdentityExportRequest struct {
	Identity      string `json:"identity,omitempty"`
	NewPassphrase string `json:"newpassphrase,omitempty"`
}

type IdentityImportRequest struct {
	Data              []byte `json:"data"`
	CurrentPassphrase string `json:"current_passphrase,omitempty"`

	// Optional. Default values are OK.
	SetDefault    bool   `json:"set_default"`
	NewPassphrase string `json:"new_passphrase"`
}

type IdentityRefDTO struct {
	// identity in Ethereum address format
	// required: true
	// example: 0x0000000000000000000000000000000000000001
	Address string `json:"id"`
}

type IdentityRegisterRequest struct {
	// Token: referral token, if the user has one
	ReferralToken *string `json:"referral_token,omitempty"`
	// Beneficiary: beneficiary to set during registration. Optional.
	Beneficiary string `json:"beneficiary,omitempty"`
	// Fee: an agreed amount to pay for registration
	Fee *big.Int `json:"fee"`
}

type IdentityRegistrationResponse struct {
	Status string `json:"status"`
	// Returns true if identity is registered in payments smart contract
	Registered bool `json:"registered"`
}

type IdentityUnlockRequest struct {
	Passphrase *string `json:"passphrase"`
}

type LatestReleaseResponse struct {
	Version string `json:"version"`
}

type ListIdentitiesResponse struct {
	Identities []IdentityRefDTO `json:"identities"`
}

type ListProposalFilterPresetsResponse struct {
	Items []FilterPreset `json:"items"`
}

type ListProposalsCountiesResponse map[string]int

type ListProposalsResponse struct {
	Proposals []ProposalDTO `json:"proposals"`
}

type LocalVersionsResponse struct {
	Versions []versionmanager.LocalVersion `json:"versions"`
}

type LocationDTO struct {
	// IP address
	// example: 1.2.3.4
	IP string `json:"ip"`
	// Autonomous system number
	// example: 62179
	ASN int `json:"asn"`
	// Internet Service Provider name
	// example: Telia Lietuva, AB
	ISP string `json:"isp"`

	// Continent
	// example: EU
	Continent string `json:"continent"`
	// Node Country
	// example: LT
	Country string `json:"country"`
	// Node Region
	// example: Vilnius region
	Region string `json:"region"`
	// Node City
	// example: Vilnius
	City string `json:"city"`

	// IP type (data_center, residential, etc.)
	// example: residential
	IPType string `json:"ip_type"`
}

type MMNApiKeyRequest struct {
	ApiKey string `json:"api_key"`
}

type MMNGrantVerificationResponse struct {
	ApiKey                        string `json:"api_key"`
	WalletAddress                 string `json:"wallet_address"`
	IsEligibleForFreeRegistration bool   `json:"is_eligible_for_free_registration"`
}

type MMNLinkRedirectResponse struct {
	Link string `json:"link"`
}

type MigrationStatus = string

type MigrationStatusResponse struct {
	Status MigrationStatus `json:"status"`
}

type MonitoringAgentResponse struct {
	Statuses node.MonitoringAgentStatuses `json:"statuses"`
	Error    string                       `json:"error,omitempty"`
}

type MystnodesSSOGrantLoginRequest struct {
	AuthorizationGrant string `json:"authorization_grant"`
}

type MystnodesSSOGrantVerificationRequest struct {
	AuthorizationGrant    string `json:"authorizationGrant"`
	CodeVerifierBase64url string `json:"codeVerifierBase64url"`
}

type MystnodesSSOLinkResponse struct {
	Link string `json:"link"`
}

type NATTypeDTO struct {
	Type  nat.NATType `json:"type"`
	Error string      `json:"error,omitempty"`
}

type NodeStatusResponse struct {
	Status monitoring.Status `json:"status"`
}

type PageableDTO struct {
	// The current page of the items.
	Page int `json:"page"`
	// Number of items per page.
	PageSize int `json:"page_size"`
	// The total items.
	TotalItems int `json:"total_items"`
	// The last page of the items.
	TotalPages int `json:"total_pages"`
}

type PaginationQuery struct {
	// Number of items per page.
	// in: query
	// default: 50
	PageSize int `json:"page_size"`

	// Page to filter the items by.
	// in: query
	// default: 1
	Page int `json:"page"`
}

type PaymentChannelDTO struct {
	// Unique identifier of payment channel
	// example: 0x8fc5f7a1794dc39c6837df10613bddf1ec9810503a50306a8667f702457a739a
	ID string `json:"id"`

	// example: 0x0000000000000000000000000000000000000001
	OwnerID string `json:"owner_id"`

	// example: 0x42a537D649d6853C0a866470f2d084DA0f73b5E4
	HermesID string `json:"hermes_id"`

	// Current unsettled earnings
	// example: 19449034049997187
	Earnings *big.Int `json:"earnings"`

	// Earnings of all history
	// example: 19449034049997187
	EarningsTotal *big.Int `json:"earnings_total"`

	// Beneficiary - eth wallet address
	Beneficiary string `json:"beneficiary"`
}

type PaymentOrderOptions struct {
	Minimum   float64   `json:"minimum"`
	Suggested []float64 `json:"suggested"`
}

type PaymentOrderRequest struct {
	// example: 3.14
	MystAmount string `json:"myst_amount"`

	// example: 20
	AmountUSD string `json:"amount_usd"`

	// example: EUR
	PayCurrency string `json:"pay_currency"`

	// example: US
	Country string `json:"country"`

	// example: MO
	State string `json:"state"`

	// example: mysteriumvpn, mystnodes
	ProjectID string `json:"project_id"`

	// example: {}
	CallerData json.RawMessage `json:"gateway_caller_data"`
}

type PaymentOrderResponse struct {
	ID     string `json:"id"`
	Status string `json:"status"`

	Identity       string `json:"identity"`
	ChainID        int64  `json:"chain_id"`
	ChannelAddress string `json:"channel_address"`

	GatewayName string `json:"gateway_name"`

	ReceiveMYST string `json:"receive_myst"`
	PayAmount   string `json:"pay_amount"`
	PayCurrency string `json:"pay_currency"`
	Country     string `json:"country"`
	State       string `json:"state"`

	Currency      string `json:"currency"`
	ItemsSubTotal string `json:"items_sub_total"`
	TaxRate       string `json:"tax_rate"`
	TaxSubTotal   string `json:"tax_sub_total"`
	OrderTotal    string `json:"order_total"`

	PublicGatewayData json.RawMessage `json:"public_gateway_data"`
}

type Price struct {
	Currency      string `json:"currency"`
	PerHour       uint64 `json:"per_hour"`
	PerHourTokens Tokens `json:"per_hour_tokens"`
	PerGiB        uint64 `json:"per_gib"`
	PerGiBTokens  Tokens `json:"per_gib_tokens"`
}

type ProposalDTO struct {
	// Proposal format.
	Format string `json:"format"`

	// Compatibility level.
	Compatibility int `json:"compatibility"`

	// provider who offers service
	// example: 0x0000000000000000000000000000000000000001
	ProviderID string `json:"provider_id"`

	// type of service provider offers
	// example: openvpn
	ServiceType string `json:"service_type"`

	// Service location
	Location ServiceLocationDTO `json:"location"`

	// Service price
	Price Price `json:"price"`

	// AccessPolicies
	AccessPolicies *[]market.AccessPolicy `json:"access_policies,omitempty"`

	// Quality of the service.
	Quality Quality `json:"quality"`
}

type ProviderConsumersCountResponse struct {
	Count int `json:"count"`
}

type ProviderEarningsSeriesResponse struct {
	Data []ProviderSeriesItem `json:"data"`
}

type ProviderSeriesItem struct {
	Value     string `json:"value"`
	Timestamp int64  `json:"timestamp"`
}

type ProviderSession struct {
	ID               string `json:"id"`
	ConsumerCountry  string `json:"consumer_country"`
	ServiceType      string `json:"service_type"`
	DurationSeconds  int64  `json:"duration_seconds"`
	StartedAt        string `json:"started_at"`
	Earnings         Tokens `json:"earnings"`
	TransferredBytes int64  `json:"transferred_bytes"`
}

type ProviderSessionsCountResponse struct {
	Count int `json:"count"`
}

type ProviderSessionsResponse struct {
	Sessions []ProviderSession `json:"sessions"`
}

type ProviderSessionsSeriesResponse struct {
	Data []ProviderSeriesItem `json:"data"`
}

type ProviderTransferredDataResponse struct {
	Bytes int `json:"transferred_data_bytes"`
}

type ProviderTransferredDataSeriesResponse struct {
	Data []ProviderSeriesItem `json:"data"`
}

type Quality struct {
	Quality   float64 `json:"quality"`
	Latency   float64 `json:"latency"`
	Bandwidth float64 `json:"bandwidth"`
	Uptime    float64 `json:"uptime"`
}

type QualityInfoResponse struct {
	Quality float64 `json:"quality"`
}

type ReferralTokenResponse struct {
	Token string `json:"token"`
}

type RegistrationPaymentResponse struct {
	Paid bool `json:"paid"`
}

type RemoteVersionsResponse struct {
	Versions []versionmanager.RemoteVersion `json:"versions"`
}

type ServiceAccessPolicies struct {
	IDs []string `json:"ids"`
}

type ServiceInfoDTO struct {
	// example: 6ba7b810-9dad-11d1-80b4-00c04fd430c8
	ID string `json:"id,omitempty"`

	// provider identity
	// example: 0x0000000000000000000000000000000000000002
	ProviderID string `json:"provider_id,omitempty"`

	// service type. Possible values are "openvpn", "wireguard" and "noop"
	// example: openvpn
	Type string `json:"type"`

	// options with which service was started. Every service has a unique list of allowed options.
	// example: {"port": 1123, "protocol": "udp"}
	Options interface{} `json:"options,omitempty"`

	// example: Running
	Status string `json:"status"`

	Proposal *ProposalDTO `json:"proposal,omitempty"`

	ConnectionStatistics *ServiceStatisticsDTO `json:"connection_statistics,omitempty"`
}

type ServiceListResponse []ServiceInfoDTO

type ServiceLocationDTO struct {
	// example: EU
	Continent string `json:"continent,omitempty"`
	// example: NL
	Country string `json:"country,omitempty"`
	// example: Amsterdam
	City string `json:"city,omitempty"`

	// Autonomous System Number
	// example: 00001
	ASN int `json:"asn"`
	// example: Telia Lietuva, AB
	ISP string `json:"isp,omitempty"`
	// example: residential
	IPType string `json:"ip_type,omitempty"`
}

type ServiceStartRequest struct {
	// provider identity
	// required: true
	// example: 0x0000000000000000000000000000000000000002
	ProviderID string `json:"provider_id"`

	// service type. Possible values are "openvpn", "wireguard" and "noop"
	// required: true
	// example: openvpn
	Type string `json:"type"`

	// access list which determines which identities will be able to receive the service
	// required: false
	AccessPolicies *ServiceAccessPolicies `json:"access_policies,omitempty"`

	// service options. Every service has a unique list of allowed options.
	// required: false
	// example: {"port": 1123, "protocol": "udp"}
	Options interface{} `json:"options"`
}

type ServiceStatisticsDTO struct {
	Attempted  int `json:"attempted"`
	Successful int `json:"successful"`
}

type SessionDTO struct {
	// example: 4cfb0324-daf6-4ad8-448b-e61fe0a1f918
	ID string `json:"id"`

	// example: Consumed
	Direction string `json:"direction"`

	// example: 0x0000000000000000000000000000000000000001
	ConsumerID string `json:"consumer_id"`

	// example: 0x0000000000000000000000000000000000000001
	HermesID string `json:"hermes_id"`

	// example: 0x0000000000000000000000000000000000000001
	ProviderID string `json:"provider_id"`

	// example: openvpn
	ServiceType string `json:"service_type"`

	// example: NL
	ConsumerCountry string `json:"consumer_country"`

	// example: US
	ProviderCountry string `json:"provider_country"`

	// example: 2019-06-06T11:04:43.910035Z
	CreatedAt string `json:"created_at"`

	// duration in seconds
	// example: 120
	Duration uint64 `json:"duration"`

	// example: 1024
	BytesReceived uint64 `json:"bytes_received"`

	// example: 1024
	BytesSent uint64 `json:"bytes_sent"`

	// example: 500000
	Tokens *big.Int `json:"tokens"`

	// example: Completed
	Status string `json:"status"`

	// example: residential
	IPType string `json:"ip_type"`
}

type SessionListQuery struct {
	PaginationQuery
	SessionQuery
}

type SessionListResponse struct {
	Items []SessionDTO `json:"items"`
	PageableDTO
}

type SessionQuery struct {
	// Filter the sessions from this date. Formatted in RFC3339 e.g. 2020-07-01.
	// in: query
	DateFrom *strfmt.Date `json:"date_from"`

	// Filter the sessions until this date. Formatted in RFC3339 e.g. 2020-07-30.
	// in: query
	DateTo *strfmt.Date `json:"date_to"`

	// Direction to filter the sessions by. Possible values are "Provided", "Consumed".
	// in: query
	Direction *string `json:"direction"`

	// Consumer identity to filter the sessions by.
	// in: query
	ConsumerID *string `json:"consumer_id"`

	// Hermes ID to filter the sessions by.
	// in: query
	HermesID *string `json:"hermes_id"`

	// Provider identity to filter the sessions by.
	// in: query
	ProviderID *string `json:"provider_id"`

	// Service type to filter the sessions by.
	// in: query
	ServiceType *string `json:"service_type"`

	// Status to filter the sessions by. Possible values are "New", "Completed".
	// in: query
	Status *string `json:"status"`
}

type SessionStatsAggregatedResponse struct {
	Stats SessionStatsDTO `json:"stats"`
}

type SessionStatsDTO struct {
	Count            int      `json:"count"`
	CountConsumers   int      `json:"count_consumers"`
	SumBytesReceived uint64   `json:"sum_bytes_received"`
	SumBytesSent     uint64   `json:"sum_bytes_sent"`
	SumDuration      uint64   `json:"sum_duration"`
	SumTokens        *big.Int `json:"sum_tokens"`
}

type SessionStatsDailyResponse struct {
	Items map[string]SessionStatsDTO `json:"items"`
	Stats SessionStatsDTO            `json:"stats"`
}

type SettleRequest struct {
	HermesIDs  []common.Address `json:"hermes_ids"`
	ProviderID string           `json:"provider_id"`

	// Deprecated
	HermesID string `json:"hermes_id"`
}

type SettleWithBeneficiaryRequest struct {
	ProviderID  string `json:"provider_id"`
	HermesID    string `json:"hermes_id"`
	Beneficiary string `json:"beneficiary"`
}

type SettlementDTO struct {
	// example: 0x20c070a9be65355adbd2ba479e095e2e8ed7e692596548734984eab75d3fdfa5
	TxHash string `json:"tx_hash"`

	// example: 0x0000000000000000000000000000000000000001
	ProviderID string `json:"provider_id"`

	// example: 0x0000000000000000000000000000000000000001
	HermesID string `json:"hermes_id"`

	// example: 0x0000000000000000000000000000000000000001
	ChannelAddress string `json:"channel_address"`

	// example: 0x0000000000000000000000000000000000000001
	Beneficiary string `json:"beneficiary"`

	// example: 500000
	Amount *big.Int `json:"amount"`

	// example: 2019-06-06T11:04:43.910035Z
	SettledAt string `json:"settled_at"`

	// example: 500000
	Fees *big.Int `json:"fees"`

	// example: false
	IsWithdrawal bool `json:"is_withdrawal"`

	// example: https://example.com
	BlockExplorerURL string `json:"block_explorer_url"`

	// example: internal server error
	Error string `json:"error"`
}

type SettlementListQuery struct {
	PaginationQuery

	// Filter the settlements from this date. Formatted in RFC3339 e.g. 2020-07-01.
	// in: query
	DateFrom *strfmt.Date `json:"date_from"`

	// Filter the settlements until this date Formatted in RFC3339 e.g. 2020-07-30.
	// in: query
	DateTo *strfmt.Date `json:"date_to"`

	// Provider identity to filter the sessions by.
	// in: query
	ProviderID *string `json:"provider_id"`

	// Hermes ID to filter the sessions by.
	// in: query
	HermesID *string `json:"hermes_id"`

	// Settlement type to filter the sessions by. "settlement" or "withdrawal"
	// in: query
	Types []string `json:"types"`
}

type SettlementListResponse struct {
	Items           []SettlementDTO `json:"items"`
	WithdrawalTotal string          `json:"withdrawal_total"`
	PageableDTO
}

type SwitchNodeUIRequest struct {
	Version string `json:"version"`
}

type TermsRequest struct {
	// example: false
	AgreedProvider *bool `json:"agreed_provider,omitempty"`
	// example: false
	AgreedConsumer *bool `json:"agreed_consumer,omitempty"`
	// example: 0.0.27
	AgreedVersion string `json:"agreed_version,omitempty"`
}

type TermsResponse struct {
	// example: false
	AgreedProvider bool `json:"agreed_provider"`
	// example: false
	AgreedConsumer bool `json:"agreed_consumer"`
	// example: 0.0.27
	AgreedVersion string `json:"agreed_version"`
	// example: 0.0.27
	CurrentVersion string `json:"current_version"`
}

type TokenRewardAmount struct {
	Amount *big.Int `json:"amount"`
}

type Tokens struct {
	Wei   string `json:"wei"`
	Ether string `json:"ether"`
	Human string `json:"human"`
}

type TransactorFees struct {
	Registration  Tokens `json:"registration"`
	Settlement    Tokens `json:"settlement"`
	DecreaseStake Tokens `json:"decrease_stake"`

	ValidUntil time.Time `json:"valid_until"`
}

type UI struct {
	BundledVersion string `json:"bundled_version"`
	UsedVersion    string `json:"used_version"`
}

type WithdrawRequest struct {
	HermesID    string `json:"hermes_id"`
	ProviderID  string `json:"provider_id"`
	Beneficiary string `json:"beneficiary"`
	FromChainID int64  `json:"from_chain_id"`
	ToChainID   int64  `json:"to_chain_id"`
	Amount      string `json:"amount,omitempty"`
}