kraken

type APIKeyInfo struct {
	APIKey       string    `json:"api_key"`       // the public API key
	APIKeyName   string    `json:"api_key_name"`  // user-assigned key name
	IBAN         string    `json:"iban"`          // the account IBAN
	Permissions  []string  `json:"permissions"`   // granted permissions
	IPAllowlist  []string  `json:"ip_allowlist"`  // allowed source IPs (empty = any)
	Nonce        string    `json:"nonce"`         // last nonce seen for the key
	NonceWindow  string    `json:"nonce_window"`  // configured nonce window (seconds)
	CreatedTime  time.Time `json:"created_time"`  // when the key was created
	ModifiedTime time.Time `json:"modified_time"` // when the key was last modified
	LastUsed     time.Time `json:"last_used"`     // when the key was last used
	QueryFrom    time.Time `json:"query_from"`    // start of the key's allowed query window
	QueryTo      time.Time `json:"query_to"`      // end of the key's allowed query window
	ValidUntil   time.Time `json:"valid_until"`   // key expiry (zero = no expiry)
}

type AccountTransferResult struct {
	TransferID string `json:"transfer_id"` // transfer id
	Status     string `json:"status"`      // pending or complete
}

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

type AddOrderBatchResult struct {
	Orders []BatchOrderResult `json:"orders"`
}

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

type AddOrderResult struct {
	Description OrderDescr `json:"descr"` // order description(s)
	TxID        []string   `json:"txid"`  // transaction id(s) of the placed order(s)
}

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

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

type AmendOrderResult struct {
	AmendID string `json:"amend_id"` // unique id of this amend transaction
}

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

type Asset struct {
	AssetClass      string          `json:"aclass"`           // asset class, usually "currency"
	AltName         string          `json:"altname"`          // alternate (common) name, e.g. "XBT"
	Decimals        int             `json:"decimals"`         // scaling decimal places for record keeping
	DisplayDecimals int             `json:"display_decimals"` // scaling decimal places for display
	CollateralValue decimal.Decimal `json:"collateral_value"` // valuation as margin collateral (if applicable)
	MarginRate      decimal.Decimal `json:"margin_rate"`      // margin rate (if applicable)
	Status          string          `json:"status"`           // asset status: enabled, deposit_only, withdrawal_only, funding_temporarily_disabled
}

type AssetPair struct {
	AltName            string          `json:"altname"`              // alternate pair name
	WSName             string          `json:"wsname"`               // WebSocket pair name (if available)
	AssetClassBase     string          `json:"aclass_base"`          // asset class of base component
	Base               string          `json:"base"`                 // asset id of base component
	AssetClassQuote    string          `json:"aclass_quote"`         // asset class of quote component
	Quote              string          `json:"quote"`                // asset id of quote component
	Lot                string          `json:"lot"`                  // volume lot size
	CostDecimals       int             `json:"cost_decimals"`        // scaling decimals for cost
	PairDecimals       int             `json:"pair_decimals"`        // scaling decimals for pair price
	LotDecimals        int             `json:"lot_decimals"`         // scaling decimals for volume
	LotMultiplier      int             `json:"lot_multiplier"`       // amount to multiply lot volume by to get currency volume
	LeverageBuy        []int           `json:"leverage_buy"`         // array of leverage amounts available when buying
	LeverageSell       []int           `json:"leverage_sell"`        // array of leverage amounts available when selling
	Fees               []FeeTier       `json:"fees"`                 // taker fee schedule [volume, percent]
	FeesMaker          []FeeTier       `json:"fees_maker"`           // maker fee schedule [volume, percent]
	FeeVolumeCurrency  string          `json:"fee_volume_currency"`  // volume discount currency
	MarginCall         int             `json:"margin_call"`          // margin call level
	MarginStop         int             `json:"margin_stop"`          // stop-out / liquidation margin level
	OrderMin           decimal.Decimal `json:"ordermin"`             // minimum order size (in base currency)
	CostMin            decimal.Decimal `json:"costmin"`              // minimum order cost (in quote currency)
	TickSize           decimal.Decimal `json:"tick_size"`            // minimum price increment
	Status             string          `json:"status"`               // online | cancel_only | post_only | limit_only | reduce_only
	LongPositionLimit  int             `json:"long_position_limit"`  // maximum long margin position size (in base currency)
	ShortPositionLimit int             `json:"short_position_limit"` // maximum short margin position size (in base currency)
	ExecutionVenue     string          `json:"execution_venue"`      // execution venue, e.g. "international"
}

type AssetPairsInfo string

type BatchOrder struct {
	OrderType     OrderType           // required: execution model
	Side          OrderSide           // required: buy or sell
	Volume        decimal.Decimal     // required: base-currency quantity
	Price         decimal.Decimal     // limit/trigger price (omitted if zero)
	Price2        decimal.Decimal     // secondary price (omitted if zero)
	OrderFlags    string              // comma-delimited order flags
	TimeInForce   TimeInForce         // time in force
	Trigger       TriggerSignal       // trigger price signal
	STPType       SelfTradePrevention // self-trade prevention
	ReduceOnly    bool                // reduce-only (margin)
	DisplayVolume decimal.Decimal     // iceberg display quantity (omitted if zero)
	UserRef       int                 // group identifier (omitted if zero)
	ClientOrderID string              // client order id
	StartTime     string              // scheduled start time
	ExpireTime    string              // GTD expiry
}

type BatchOrderResult struct {
	TxID        string     `json:"txid"`  // transaction id, if successful
	Description OrderDescr `json:"descr"` // order description
	Error       string     `json:"error"` // per-order error message, if any
}

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

type BookEntry struct {
	Price     decimal.Decimal
	Volume    decimal.Decimal
	Timestamp time.Time
}

type CancelAllOrdersAfterResult struct {
	CurrentTime time.Time `json:"currentTime"` // when the request was received (RFC3339)
	TriggerTime time.Time `json:"triggerTime"` // when orders will be cancelled (RFC3339)
}

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

type CancelAllOrdersResult struct {
	Count int `json:"count"` // number of orders cancelled
}

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

type CancelOrderBatchResult struct {
	Count int `json:"count"` // number of orders cancelled
}

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

type CancelOrderResult struct {
	Count   int  `json:"count"`   // number of orders cancelled
	Pending bool `json:"pending"` // whether cancellation is still pending
}

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

type Candle struct {
	Time   time.Time       // candle start time
	Open   decimal.Decimal // opening price
	High   decimal.Decimal // highest price
	Low    decimal.Decimal // lowest price
	Close  decimal.Decimal // closing price
	VWAP   decimal.Decimal // volume weighted average price
	Volume decimal.Decimal // traded volume
	Count  int64           // number of trades
}

type Client struct {
	*client.Client
}

type ClosedOrdersResult struct {
	Closed map[string]OrderInfo `json:"closed"`
	Count  int                  `json:"count"`
}

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

type CreditAssetDetail struct {
	Balance         decimal.Decimal `json:"balance"`          // asset balance
	CollateralValue decimal.Decimal `json:"collateral_value"` // collateral valuation factor
	HoldTrade       decimal.Decimal `json:"hold_trade"`       // balance held for open orders
}

type CreditLimitsMonitor struct {
	DebtToEquity            decimal.Decimal `json:"debt_to_equity"`             // debt-to-equity ratio
	EquityUSD               decimal.Decimal `json:"equity_usd"`                 // total equity (USD)
	TotalCollateralValueUSD decimal.Decimal `json:"total_collateral_value_usd"` // total collateral value (USD)
	TotalCreditUSD          decimal.Decimal `json:"total_credit_usd"`           // total credit line (USD)
	TotalCreditUsedUSD      decimal.Decimal `json:"total_credit_used_usd"`      // credit currently used (USD)
}

type CreditLines struct {
	AssetDetails  map[string]CreditAssetDetail `json:"asset_details"`  // per-asset collateral details
	LimitsMonitor CreditLimitsMonitor          `json:"limits_monitor"` // aggregate margin limits
}

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

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

type DeleteExportReportType string

type DeleteExportResult struct {
	Delete bool `json:"delete"` // whether deletion was successful
	Cancel bool `json:"cancel"` // whether cancellation was successful
}

type DepositAddress struct {
	Address    string    `json:"address"`  // deposit address
	ExpireTime time.Time `json:"expiretm"` // expiration time (zero if it does not expire)
	New        bool      `json:"new"`      // whether the address was newly generated
	Memo       string    `json:"memo"`     // memo for the deposit (some assets)
	Tag        string    `json:"tag"`      // destination tag (some assets)
}

type DepositMethod struct {
	Method     string          `json:"method"`      // name of the deposit method
	Limit      MethodLimit     `json:"limit"`       // deposit limit (false if none)
	Fee        decimal.Decimal `json:"fee"`         // deposit fee, if any
	GenAddress bool            `json:"gen-address"` // whether new addresses can be generated
	Minimum    decimal.Decimal `json:"minimum"`     // minimum deposit amount
}

type EarnAPREstimate struct {
	High decimal.Decimal `json:"high"`
	Low  decimal.Decimal `json:"low"`
}

type EarnAllocation struct {
	StrategyID      string              `json:"strategy_id"`      // strategy id
	NativeAsset     string              `json:"native_asset"`     // asset allocated
	AssetClass      string              `json:"asset_class"`      // asset class of the allocated asset
	IsUtilized      bool                `json:"is_utilized"`      // whether the allocation is currently utilized
	AmountAllocated EarnAmountAllocated `json:"amount_allocated"` // breakdown of allocated amounts
	TotalRewarded   EarnConvertedAmount `json:"total_rewarded"`   // total rewards earned
	Payout          EarnPayout          `json:"payout"`           // current payout period info
}

type EarnAllocationDetail struct {
	Native    decimal.Decimal `json:"native"`     // amount in the native asset
	Converted decimal.Decimal `json:"converted"`  // amount in the converted asset
	CreatedAt time.Time       `json:"created_at"` // when the allocation was created
	Expires   time.Time       `json:"expires"`    // when bonding/unbonding completes
}

type EarnAllocationState struct {
	Native          decimal.Decimal        `json:"native"`           // amount in native asset
	Converted       decimal.Decimal        `json:"converted"`        // amount in converted asset
	AllocationCount int                    `json:"allocation_count"` // number of individual allocations
	Allocations     []EarnAllocationDetail `json:"allocations"`      // individual allocation records
}

type EarnAllocationStatus struct {
	Pending bool `json:"pending"` // whether the operation is still being processed
}

type EarnAllocationsResult struct {
	ConvertedAsset      string           `json:"converted_asset"`       // asset the converted values are in
	ConvertedAssetClass string           `json:"converted_asset_class"` // class of the converted asset
	TotalAllocated      decimal.Decimal  `json:"total_allocated"`       // total allocated (converted asset)
	TotalRewarded       decimal.Decimal  `json:"total_rewarded"`        // total rewarded (converted asset)
	NextCursor          string           `json:"next_cursor"`           // pagination cursor
	Items               []EarnAllocation `json:"items"`                 // per-strategy allocations
}

type EarnAmountAllocated struct {
	Bonding   EarnAllocationState `json:"bonding"`    // amount currently bonding
	ExitQueue EarnAllocationState `json:"exit_queue"` // amount in the exit queue
	Pending   EarnConvertedAmount `json:"pending"`    // amount pending allocation
	Unbonding EarnAllocationState `json:"unbonding"`  // amount currently unbonding
	Total     EarnConvertedAmount `json:"total"`      // total allocated
}

type EarnConvertedAmount struct {
	Native    decimal.Decimal `json:"native"`    // amount in the native asset
	Converted decimal.Decimal `json:"converted"` // amount in the converted asset
}

type EarnLockType struct {
	Type                    string `json:"type"`                      // flex, bonded, timed, instant
	PayoutFrequency         int64  `json:"payout_frequency"`          // reward payout frequency (seconds)
	BondingPeriod           int64  `json:"bonding_period"`            // bonding period (seconds)
	BondingPeriodVariable   bool   `json:"bonding_period_variable"`   // whether the bonding period varies
	BondingRewards          bool   `json:"bonding_rewards"`           // whether rewards accrue while bonding
	ExitQueuePeriod         int64  `json:"exit_queue_period"`         // exit-queue period (seconds)
	UnbondingPeriod         int64  `json:"unbonding_period"`          // unbonding period (seconds)
	UnbondingPeriodVariable bool   `json:"unbonding_period_variable"` // whether the unbonding period varies
	UnbondingRewards        bool   `json:"unbonding_rewards"`         // whether rewards accrue while unbonding
}

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

type EarnPayout struct {
	AccumulatedReward EarnConvertedAmount `json:"accumulated_reward"` // reward accrued this period
	EstimatedReward   EarnConvertedAmount `json:"estimated_reward"`   // estimated reward for the period
	PeriodStart       time.Time           `json:"period_start"`       // start of the payout period
	PeriodEnd         time.Time           `json:"period_end"`         // end of the payout period
}

type EarnStrategiesResult struct {
	Items      []EarnStrategy `json:"items"`
	NextCursor string         `json:"next_cursor"`
}

type EarnStrategy struct {
	ID                        string          `json:"id"`                          // strategy id
	Asset                     string          `json:"asset"`                       // asset that can be allocated
	AssetClass                string          `json:"asset_class"`                 // asset class
	AllocationFee             decimal.Decimal `json:"allocation_fee"`              // fee charged on allocation
	DeallocationFee           decimal.Decimal `json:"deallocation_fee"`            // fee charged on deallocation
	AllocationRestrictionInfo []string        `json:"allocation_restriction_info"` // reasons allocation may be restricted
	APREstimate               EarnAPREstimate `json:"apr_estimate"`                // estimated APR range
	AutoCompound              EarnNamedType   `json:"auto_compound"`               // auto-compound behavior
	CanAllocate               bool            `json:"can_allocate"`                // whether allocation is currently allowed
	CanDeallocate             bool            `json:"can_deallocate"`              // whether deallocation is currently allowed
	LockType                  EarnLockType    `json:"lock_type"`                   // lock/bonding terms
	UserCap                   decimal.Decimal `json:"user_cap"`                    // maximum the user may allocate
	UserMinAllocation         decimal.Decimal `json:"user_min_allocation"`         // minimum the user may allocate
	YieldSource               EarnNamedType   `json:"yield_source"`                // source of the yield
}

type EditOrderResult struct {
	Status          string          `json:"status"`           // Ok or Err
	TxID            string          `json:"txid"`             // new transaction id
	OriginalTxID    string          `json:"originaltxid"`     // original transaction id
	OrdersCancelled int             `json:"orders_cancelled"` // number of orders cancelled (0 or 1)
	Description     OrderDescr      `json:"descr"`            // new order description
	NewUserRef      string          `json:"newuserref"`       // new user reference
	OldUserRef      string          `json:"olduserref"`       // original user reference
	Volume          decimal.Decimal `json:"volume"`           // updated volume
	Price           decimal.Decimal `json:"price"`            // updated price
	Price2          decimal.Decimal `json:"price2"`           // updated secondary price
	ErrorMessage    string          `json:"error_message"`    // error detail, if unsuccessful
}

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

type ExportReport struct {
	ID            string    `json:"id"`            // unique report identifier
	Description   string    `json:"descr"`         // report description/name
	Format        string    `json:"format"`        // file format (CSV/TSV)
	Report        string    `json:"report"`        // report type (trades/ledgers)
	SubType       string    `json:"subtype"`       // report subtype
	Status        string    `json:"status"`        // Queued, Processing, Processed
	Error         string    `json:"error"`         // error code if failed
	Flags         string    `json:"flags"`         // legacy flag field (deprecated)
	Fields        string    `json:"fields"`        // fields included
	CreatedTime   time.Time `json:"createdtm"`     // time the report was requested
	ExpireTime    time.Time `json:"expiretm"`      // expiration timestamp (deprecated)
	StartTime     time.Time `json:"starttm"`       // time processing began
	CompletedTime time.Time `json:"completedtm"`   // time processing finished
	DataStartTime time.Time `json:"datastarttm"`   // report data period start
	DataEndTime   time.Time `json:"dataendtm"`     // report data period end
	AssetClass    string    `json:"aclass"`        // asset class (deprecated)
	Asset         string    `json:"asset"`         // assets included
	Assets        string    `json:"assets"`        // assets included (current key)
	AssetClasses  []string  `json:"asset_classes"` // asset classes covered
	EndTime       time.Time `json:"endtm"`         // report end time
	Delete        bool      `json:"delete"`        // whether marked for deletion
}

type ExportReportRef struct {
	ID string `json:"id"` // unique report identifier
}

type ExtendedBalance struct {
	Balance   decimal.Decimal `json:"balance"`    // total balance of the asset
	HoldTrade decimal.Decimal `json:"hold_trade"` // balance held for open orders/positions
}

type FeeInfo struct {
	Fee        decimal.Decimal `json:"fee"`        // current fee (percent)
	MinFee     decimal.Decimal `json:"minfee"`     // minimum fee (percent, if not fixed)
	MaxFee     decimal.Decimal `json:"maxfee"`     // maximum fee (percent, if not fixed)
	NextFee    decimal.Decimal `json:"nextfee"`    // next-tier fee (percent, if not fixed)
	TierVolume decimal.Decimal `json:"tiervolume"` // volume level of current tier
	NextVolume decimal.Decimal `json:"nextvolume"` // volume level of next tier
}

type FeeTier struct {
	Volume  decimal.Decimal // 30-day volume threshold (quote currency)
	Percent decimal.Decimal // fee percentage at or above that volume
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type GroupedLevel struct {
	Price decimal.Decimal `json:"price"` // grouped price level
	Qty   decimal.Decimal `json:"qty"`   // aggregated quantity at the level
}

type GroupedOrderBook struct {
	Pair     string         `json:"pair"`     // canonical pair name
	Grouping int            `json:"grouping"` // tick grouping applied
	Asks     []GroupedLevel `json:"asks"`     // aggregated ask levels
	Bids     []GroupedLevel `json:"bids"`     // aggregated bid levels
}

type Interval int

type L3Entry struct {
	OrderID   string          `json:"order_id"`  // order identifier
	Price     decimal.Decimal `json:"price"`     // limit price
	Qty       decimal.Decimal `json:"qty"`       // remaining quantity
	Timestamp NanoTime        `json:"timestamp"` // order timestamp (UNIX nanoseconds)
}

type L3OrderBook struct {
	Pair string    `json:"pair"` // canonical pair name
	Asks []L3Entry `json:"asks"` // individual ask orders
	Bids []L3Entry `json:"bids"` // individual bid orders
}

type LedgerEntry struct {
	RefID      string          `json:"refid"`   // reference id
	Time       time.Time       `json:"time"`    // time of ledger entry
	Type       string          `json:"type"`    // deposit, withdrawal, trade, margin, rollover, ...
	SubType    string          `json:"subtype"` // additional info on the type
	AssetClass string          `json:"aclass"`  // asset class
	Asset      string          `json:"asset"`   // asset
	Amount     decimal.Decimal `json:"amount"`  // transaction amount (signed)
	Fee        decimal.Decimal `json:"fee"`     // transaction fee
	Balance    decimal.Decimal `json:"balance"` // resulting balance
}

type LedgersResult struct {
	Ledger map[string]LedgerEntry `json:"ledger"`
	Count  int                    `json:"count"`
}

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

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

type MethodLimit struct {
	HasLimit bool            // whether a limit applies
	Amount   decimal.Decimal // the limit amount, when HasLimit and a number was returned
}

type NanoTime time.Time

type OHLCResult struct {
	Pair    string    // Kraken pair name the candles belong to
	Candles []Candle  // committed candles, oldest first
	Last    time.Time // cursor: id of the last candle, pass to SetSince to poll
}

type OpenOrdersResult struct {
	Open map[string]OrderInfo `json:"open"`
}

type OrderAmend struct {
	AmendID      string          `json:"amend_id"`      // amendment identifier
	AmendType    string          `json:"amend_type"`    // original, user, or restated
	OrderQty     decimal.Decimal `json:"order_qty"`     // order quantity (base asset)
	DisplayQty   decimal.Decimal `json:"display_qty"`   // quantity shown in book for iceberg orders
	RemainingQty decimal.Decimal `json:"remaining_qty"` // remaining un-traded quantity
	LimitPrice   decimal.Decimal `json:"limit_price"`   // limit price restriction
	TriggerPrice decimal.Decimal `json:"trigger_price"` // trigger price on trigger order types
	Reason       string          `json:"reason"`        // reason for this amend
	PostOnly     bool            `json:"post_only"`     // whether restricted from taking liquidity
	Timestamp    NanoTime        `json:"timestamp"`     // amendment time (UNIX nanoseconds)
}

type OrderAmendsResult struct {
	Count  int          `json:"count"`  // total count incl. the original order
	Amends []OrderAmend `json:"amends"` // amendment records
}

type OrderBook struct {
	Asks []BookEntry `json:"asks"`
	Bids []BookEntry `json:"bids"`
}

type OrderBookResult struct {
	Pair string
	Asks []BookEntry
	Bids []BookEntry
}

type OrderDescr struct {
	Order string `json:"order"` // order description
	Close string `json:"close"` // conditional close order description, if any
}

type OrderDescription struct {
	Pair       string          `json:"pair"`      // asset pair
	Type       string          `json:"type"`      // buy or sell
	OrderType  string          `json:"ordertype"` // market, limit, stop-loss, take-profit, ...
	Price      decimal.Decimal `json:"price"`     // primary price
	Price2     decimal.Decimal `json:"price2"`    // secondary price
	Leverage   string          `json:"leverage"`  // amount of leverage (e.g. "none", "5:1")
	Order      string          `json:"order"`     // order description
	Close      string          `json:"close"`     // conditional close order description, if any
	AssetClass string          `json:"aclass"`    // asset class of the pair
}

type OrderInfo struct {
	RefID          string           `json:"refid"`         // referral order tx id that created this order (nullable)
	UserRef        int64            `json:"userref"`       // optional client identifier (nullable)
	ClientOrderID  string           `json:"cl_ord_id"`     // optional alphanumeric client identifier (nullable)
	Status         string           `json:"status"`        // pending, open, closed, canceled, expired
	Reason         string           `json:"reason"`        // reason order was closed/canceled (nullable)
	OpenTime       time.Time        `json:"opentm"`        // time order was placed
	StartTime      time.Time        `json:"starttm"`       // order start time (0 if not set)
	ExpireTime     time.Time        `json:"expiretm"`      // order end time (0 if not set)
	CloseTime      time.Time        `json:"closetm"`       // time order was closed (ClosedOrders/QueryOrders)
	Description    OrderDescription `json:"descr"`         // order description
	Volume         decimal.Decimal  `json:"vol"`           // order volume (base currency)
	VolumeExecuted decimal.Decimal  `json:"vol_exec"`      // volume executed (base currency)
	Cost           decimal.Decimal  `json:"cost"`          // total cost (quote currency)
	Fee            decimal.Decimal  `json:"fee"`           // total fee (quote currency)
	Price          decimal.Decimal  `json:"price"`         // average price (quote currency)
	StopPrice      decimal.Decimal  `json:"stopprice"`     // stop price (quote currency)
	LimitPrice     decimal.Decimal  `json:"limitprice"`    // triggered limit price (quote currency)
	Trigger        string           `json:"trigger"`       // price signal for stop/take-profit: last or index
	Margin         bool             `json:"margin"`        // whether order is funded on margin
	Misc           string           `json:"misc"`          // comma-delimited misc info (stopped, touched, ...)
	SenderSubID    string           `json:"sender_sub_id"` // underlying sub-account for STP (nullable)
	OrderFlags     string           `json:"oflags"`        // comma-delimited order flags (post, fcib, fciq, ...)
	TimeInForce    string           `json:"time_in_force"` // gtc, ioc, gtd, fok
	Trades         []string         `json:"trades"`        // related trade ids (if requested and available)
}

type OrderSide string

type OrderType string

type PositionInfo struct {
	OrderTxID      string          `json:"ordertxid"`  // order id responsible for the position
	AssetClass     string          `json:"class"`      // asset class of the position
	PositionStatus string          `json:"posstatus"`  // position status (open)
	Pair           string          `json:"pair"`       // asset pair
	Time           time.Time       `json:"time"`       // time the position was opened
	Type           string          `json:"type"`       // buy or sell (direction)
	OrderType      string          `json:"ordertype"`  // order type used to open
	Cost           decimal.Decimal `json:"cost"`       // opening cost (quote currency)
	Fee            decimal.Decimal `json:"fee"`        // opening fee (quote currency)
	Volume         decimal.Decimal `json:"vol"`        // opening size (base currency)
	VolumeClosed   decimal.Decimal `json:"vol_closed"` // quantity closed (base currency)
	Margin         decimal.Decimal `json:"margin"`     // initial margin consumed (quote currency)
	Value          decimal.Decimal `json:"value"`      // current value (if docalcs)
	Net            decimal.Decimal `json:"net"`        // unrealized P&L of remaining position (if docalcs)
	Terms          string          `json:"terms"`      // funding cost and term of position
	RolloverTime   time.Time       `json:"rollovertm"` // timestamp of next margin rollover fee
	Misc           string          `json:"misc"`       // comma-delimited additional info
	OrderFlags     string          `json:"oflags"`     // comma-delimited opening order flags
}

type PostTrade struct {
	TradeID           string          `json:"trade_id"`             // trade identifier
	Symbol            string          `json:"symbol"`               // currency pair symbol
	Description       string          `json:"description"`          // human-readable description
	Price             decimal.Decimal `json:"price"`                // execution price
	Quantity          decimal.Decimal `json:"quantity"`             // executed quantity
	BaseAsset         string          `json:"base_asset"`           // base asset
	BaseDTICode       string          `json:"base_dti_code"`        // base Digital Token Identifier
	BaseDTIShortName  string          `json:"base_dti_short_name"`  // base DTI short name
	BaseNotation      string          `json:"base_notation"`        // base quantity notation
	QuoteAsset        string          `json:"quote_asset"`          // quote asset
	QuoteDTICode      string          `json:"quote_dti_code"`       // quote Digital Token Identifier
	QuoteDTIShortName string          `json:"quote_dti_short_name"` // quote DTI short name
	QuoteNotation     string          `json:"quote_notation"`       // quote notation (e.g. MONE)
	TradeVenue        string          `json:"trade_venue"`          // execution venue (MIC)
	TradeTime         time.Time       `json:"trade_ts"`             // execution time
	PublicationVenue  string          `json:"publication_venue"`    // publication venue (MIC)
	PublicationTime   time.Time       `json:"publication_ts"`       // data publication time
}

type PostTradeData struct {
	Count    int         `json:"count"`   // number of trades returned
	LastTime time.Time   `json:"last_ts"` // timestamp of the last trade in the page
	Trades   []PostTrade `json:"trades"`  // executed trades
}

type PreTradeData struct {
	Symbol            string          `json:"symbol"`               // currency pair symbol
	Description       string          `json:"description"`          // human-readable description
	BaseAsset         string          `json:"base_asset"`           // base asset
	BaseDTICode       string          `json:"base_dti_code"`        // base Digital Token Identifier
	BaseDTIShortName  string          `json:"base_dti_short_name"`  // base DTI short name
	BaseNotation      string          `json:"base_notation"`        // base quantity notation
	QuoteAsset        string          `json:"quote_asset"`          // quote asset
	QuoteDTICode      string          `json:"quote_dti_code"`       // quote Digital Token Identifier
	QuoteDTIShortName string          `json:"quote_dti_short_name"` // quote DTI short name
	QuoteNotation     string          `json:"quote_notation"`       // quote notation (e.g. MONE)
	Venue             string          `json:"venue"`                // market identifier code (MIC)
	System            string          `json:"system"`               // trading system (e.g. CLOB)
	Asks              []PreTradeLevel `json:"asks"`                 // aggregated ask levels
	Bids              []PreTradeLevel `json:"bids"`                 // aggregated bid levels
}

type PreTradeLevel struct {
	Side            string          `json:"side"`           // BUY or SELL
	Price           decimal.Decimal `json:"price"`          // price level
	Qty             decimal.Decimal `json:"qty"`            // aggregated quantity
	Count           int             `json:"count"`          // number of orders aggregated
	SubmissionTime  time.Time       `json:"submission_ts"`  // order submission time
	PublicationTime time.Time       `json:"publication_ts"` // data publication time
}

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

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

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

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

type ReportType string

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

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

type SelfTradePrevention string

type ServerTime struct {
	UnixTime time.Time `json:"unixtime"` // server time as unix seconds
	RFC1123  string    `json:"rfc1123"`  // server time as an RFC 1123 string
}

type Spread struct {
	Time time.Time       // sample time
	Bid  decimal.Decimal // best bid price
	Ask  decimal.Decimal // best ask price
}

type SpreadResult struct {
	Pair    string    // Kraken pair name the spreads belong to
	Spreads []Spread  // recent spreads, oldest first
	Last    time.Time // cursor; pass to SetSince to poll for newer spreads
}

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

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

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

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

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

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

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

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

type SystemStatus struct {
	Status    string    `json:"status"`    // online | maintenance | cancel_only | post_only
	Timestamp time.Time `json:"timestamp"` // RFC3339 time the status was last updated
}

type Ticker struct {
	Ask       TickerLevel       `json:"a"` // ask [price, wholeLotVolume, lotVolume]
	Bid       TickerLevel       `json:"b"` // bid [price, wholeLotVolume, lotVolume]
	Last      TickerLastTrade   `json:"c"` // last trade closed [price, lotVolume]
	Volume    TickerWindow      `json:"v"` // volume [today, last24Hours]
	VWAP      TickerWindow      `json:"p"` // volume weighted average price [today, last24Hours]
	Trades    TickerCountWindow `json:"t"` // number of trades [today, last24Hours]
	Low       TickerWindow      `json:"l"` // low [today, last24Hours]
	High      TickerWindow      `json:"h"` // high [today, last24Hours]
	OpenPrice decimal.Decimal   `json:"o"` // today's opening price
}

type TickerCountWindow struct {
	Today       int64
	Last24Hours int64
}

type TickerLastTrade struct {
	Price     decimal.Decimal
	LotVolume decimal.Decimal
}

type TickerLevel struct {
	Price          decimal.Decimal
	WholeLotVolume decimal.Decimal
	LotVolume      decimal.Decimal
}

type TickerWindow struct {
	Today       decimal.Decimal
	Last24Hours decimal.Decimal
}

type TimeInForce string

type Trade struct {
	Price     decimal.Decimal // execution price
	Volume    decimal.Decimal // executed volume (base currency)
	Time      time.Time       // execution time
	Side      string          // "b" buy, "s" sell
	OrderType string          // "l" limit, "m" market
	Misc      string          // miscellaneous info
	TradeID   int64           // unique trade id
}