Struct Client 

pub struct Client { /* private fields */ }

Client for Dex Aggregator API

Dex Aggregator API ⚡️

Version: 1.0

Implementations

impl Client

pub fn new(baseurl: &str) -> Self

Create a new client.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

pub fn new_with_client(baseurl: &str, client: ClientWithMiddleware) -> Self

Construct a new client with an existing reqwest_middleware::ClientWithMiddleware, allowing more control over its configuration.

baseurl is the base URL provided to the internal reqwest_middleware::ClientWithMiddleware, and should include a scheme and hostname, as well as port and a path stem if applicable.

impl Client

pub fn get(&self) -> Get<'_>

CONTROLLER.JOB.GET.SUMMARY

CONTROLLER.JOB.GET.DESCRIPTION

Sends a `GET` request to `/jobs/{id}`

Arguments:
- `id`: CONTROLLER.JOB.GET.ID
```ignore
let response = client.get()
    .id(id)
    .send()
    .await;
```

pub fn streaming(&self) -> Streaming<'_>

CONTROLLER.JOB.STREAMING.SUMMARY

CONTROLLER.JOB.STREAMING.DESCRIPTION

Sends a `GET` request to `/jobs/{id}/streaming`

Arguments:
- `id`: CONTROLLER.JOB.GET.ID
```ignore
let response = client.streaming()
    .id(id)
    .send()
    .await;
```

pub fn get_supported_blockchains(&self) -> GetSupportedBlockchains<'_>

CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY

CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION

Sends a `GET` request to `/v1/blockchain`

```ignore
let response = client.get_supported_blockchains()
    .send()
    .await;
```

pub fn get_latest_block(&self) -> GetLatestBlock<'_>

CONTROLLER.GET_LATEST_BLOCK.SUMMARY

CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION

Sends a `GET` request to `/v1/blockchain/{chain}/latest_block`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
```ignore
let response = client.get_latest_block()
    .chain(chain)
    .send()
    .await;
```

pub fn list_dex(&self) -> ListDex<'_>

CONTROLLER.DEX.LIST.SUMMARY

CONTROLLER.DEX.LIST.DESCRIPTION

Sends a `GET` request to `/v1/dex`

Arguments:
- `chains`
- `dex_program`: DTO.DEX.QUERY.DEX_PROGRAM
- `limit`: DTO.DEX.QUERY.LIMIT
```ignore
let response = client.list_dex()
    .chains(chains)
    .dex_program(dex_program)
    .limit(limit)
    .send()
    .await;
```

pub fn create_token(&self) -> CreateToken<'_>

CONTROLLER.DEX.CREATE.SUMMARY

CONTROLLER.DEX.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/create`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: Token creation parameters
```ignore
let response = client.create_token()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn quote(&self) -> Quote<'_>

CONTROLLER.DEX.QUOTE.SUMMARY

CONTROLLER.DEX.QUOTE.DESCRIPTION

Sends a `GET` request to `/v1/dex/{chain}/quote`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `amount`: DTO.DEX.QUOTE.AMOUNT
- `dex`: DTO.DEX.QUOTE.DEX
- `exact_in`: DTO.DEX.QUOTE.EXACT_IN
- `input_mint`: DTO.DEX.QUOTE.INPUT_MINT
- `output_mint`: DTO.DEX.QUOTE.OUTPUT_MINT
- `slippage`: DTO.DEX.QUOTE.SLIPPAGE
```ignore
let response = client.quote()
    .chain(chain)
    .amount(amount)
    .dex(dex)
    .exact_in(exact_in)
    .input_mint(input_mint)
    .output_mint(output_mint)
    .slippage(slippage)
    .send()
    .await;
```

pub fn route(&self) -> Route<'_>

CONTROLLER.DEX.ROUTE.SUMMARY

CONTROLLER.DEX.ROUTE.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/route`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.route()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn swap(&self) -> Swap<'_>

CONTROLLER.DEX.SWAP.SUMMARY

CONTROLLER.DEX.SWAP.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/swap`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.swap()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn get_dexpool(&self) -> GetDexpool<'_>

CONTROLLER.DEXPOOL.GET.SUMMARY

CONTROLLER.DEXPOOL.GET.DESCRIPTION

Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pool_address`: GLOBAL.POOLADDRESS.DESCRIPTION
```ignore
let response = client.get_dexpool()
    .chain(chain)
    .pool_address(pool_address)
    .send()
    .await;
```

pub fn get_dexpool_snapshots(&self) -> GetDexpoolSnapshots<'_>

CONTROLLER.DEXPOOL.SNAPSHOTS.SUMMARY

CONTROLLER.DEXPOOL.SNAPSHOTS.DESCRIPTION

Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}/snapshots`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pool_address`: GLOBAL.POOLADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR
- `limit`: DTO.PAGE.LIMIT
- `time`: DTO.DEXPOOL.SNAPSHOT.TIME
```ignore
let response = client.get_dexpool_snapshots()
    .chain(chain)
    .pool_address(pool_address)
    .cursor(cursor)
    .limit(limit)
    .time(time)
    .send()
    .await;
```

pub fn presign(&self) -> Presign<'_>

CONTROLLER.IPFS.PRESIGN.SUMMARY

CONTROLLER.IPFS.PRESIGN.DESCRIPTION

Sends a `POST` request to `/v1/ipfs/presign`

```ignore
let response = client.presign()
    .send()
    .await;
```

pub fn register_address(&self) -> RegisterAddress<'_>

CONTROLLER.KYT.REGISTER_ADDRESS.SUMMARY

CONTROLLER.KYT.REGISTER_ADDRESS.DESCRIPTION

Sends a `POST` request to `/v1/kyt/address`

```ignore
let response = client.register_address()
    .body(body)
    .send()
    .await;
```

pub fn get_address_risk(&self) -> GetAddressRisk<'_>

CONTROLLER.KYT.GET_ADDRESS_RISK.SUMMARY

CONTROLLER.KYT.GET_ADDRESS_RISK.DESCRIPTION

Sends a `GET` request to `/v1/kyt/addresses/{address}/risk`

Arguments:
- `address`: CONTROLLER.KYT.PARAM.ADDRESS
```ignore
let response = client.get_address_risk()
    .address(address)
    .send()
    .await;
```

pub fn register_transfer(&self) -> RegisterTransfer<'_>

CONTROLLER.KYT.REGISTER_TRANSFER.SUMMARY

CONTROLLER.KYT.REGISTER_TRANSFER.DESCRIPTION

Sends a `POST` request to `/v1/kyt/transfer`

```ignore
let response = client.register_transfer()
    .body(body)
    .send()
    .await;
```

pub fn get_transfer_alerts(&self) -> GetTransferAlerts<'_>

CONTROLLER.KYT.GET_TRANSFER_ALERTS.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_ALERTS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/alerts`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_alerts()
    .transfer_id(transfer_id)
    .send()
    .await;
```

pub fn get_transfer_direct_exposure(&self) -> GetTransferDirectExposure<'_>

CONTROLLER.KYT.GET_TRANSFER_DIRECT_EXPOSURE.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_DIRECT_EXPOSURE.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/exposures/direct`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_direct_exposure()
    .transfer_id(transfer_id)
    .send()
    .await;
```

pub fn get_transfer_network_identifications( &self, ) -> GetTransferNetworkIdentifications<'_>

CONTROLLER.KYT.GET_TRANSFER_NETWORK_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_NETWORK_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/network-identifications`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_network_identifications()
    .transfer_id(transfer_id)
    .send()
    .await;
```

pub fn get_transfer_summary(&self) -> GetTransferSummary<'_>

CONTROLLER.KYT.GET_TRANSFER_SUMMARY.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/summary`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_summary()
    .transfer_id(transfer_id)
    .send()
    .await;
```

pub fn register_withdrawal(&self) -> RegisterWithdrawal<'_>

CONTROLLER.KYT.REGISTER_WITHDRAWAL.SUMMARY

CONTROLLER.KYT.REGISTER_WITHDRAWAL.DESCRIPTION

Sends a `POST` request to `/v1/kyt/withdrawal`

```ignore
let response = client.register_withdrawal()
    .body(body)
    .send()
    .await;
```

pub fn get_withdrawal_address_identifications( &self, ) -> GetWithdrawalAddressIdentifications<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_ADDRESS_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_ADDRESS_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/address-identifications`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_address_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_withdrawal_alerts(&self) -> GetWithdrawalAlerts<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_ALERTS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_ALERTS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/alerts`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_alerts()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_withdrawal_direct_exposure(&self) -> GetWithdrawalDirectExposure<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_DIRECT_EXPOSURE.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_DIRECT_EXPOSURE.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/exposures/direct`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_direct_exposure()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_withdrawal_fraud_assessment( &self, ) -> GetWithdrawalFraudAssessment<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_FRAUD_ASSESSMENT.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_FRAUD_ASSESSMENT.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/fraud-assessment`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_fraud_assessment()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_withdrawal_network_identifications( &self, ) -> GetWithdrawalNetworkIdentifications<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_NETWORK_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_NETWORK_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/network-identifications`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_network_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_withdrawal_summary(&self) -> GetWithdrawalSummary<'_>

CONTROLLER.KYT.GET_WITHDRAWAL_SUMMARY.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/summary`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_summary()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```

pub fn get_final_stretch_tokens(&self) -> GetFinalStretchTokens<'_>

CONTROLLER.RANKING.FINAL_STRETCH_TOKENS.SUMMARY

CONTROLLER.RANKING.FINAL_STRETCH_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/finalStretch`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_final_stretch_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```

pub fn get_hot_tokens(&self) -> GetHotTokens<'_>

CONTROLLER.RANKING.HOT_TOKENS.SUMMARY

CONTROLLER.RANKING.HOT_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/hotTokens/{duration}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `duration`: CONTROLLER.RANKING.HOT_TOKENS.DURATION.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_hot_tokens()
    .chain(chain)
    .duration(duration)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```

pub fn get_migrated_tokens(&self) -> GetMigratedTokens<'_>

CONTROLLER.RANKING.MIGRATED_TOKENS.SUMMARY

CONTROLLER.RANKING.MIGRATED_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/migrated`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_migrated_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```

pub fn get_new_tokens(&self) -> GetNewTokens<'_>

CONTROLLER.RANKING.NEW_TOKENS.SUMMARY

CONTROLLER.RANKING.NEW_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/newTokens`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_new_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```

pub fn get_stocks_tokens(&self) -> GetStocksTokens<'_>

CONTROLLER.RANKING.STOCKS_TOKENS.SUMMARY

CONTROLLER.RANKING.STOCKS_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/stocks`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_stocks_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```

pub fn get_redpackets(&self) -> GetRedpackets<'_>

CONTROLLER.RED_PACKET.GET_REDPACKETS.SUMMARY

CONTROLLER.RED_PACKET.GET_REDPACKETS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket`

Arguments:
- `chain`: DTO.RED_PACKET.CHAIN
- `creator`: DTO.RED_PACKET.CREATOR
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_redpackets()
    .chain(chain)
    .creator(creator)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn get_claims_by_address(&self) -> GetClaimsByAddress<'_>

CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.SUMMARY

CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/wallet/{address}/claims`

Arguments:
- `address`
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_claims_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn get_redpackets_by_address(&self) -> GetRedpacketsByAddress<'_>

CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.SUMMARY

CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/wallet/{address}/redpackets`

Arguments:
- `address`
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_redpackets_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn claim_redpacket(&self) -> ClaimRedpacket<'_>

CONTROLLER.RED_PACKET.CLAIM.SUMMARY

CONTROLLER.RED_PACKET.CLAIM.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/claim`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.claim_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn create_redpacket(&self) -> CreateRedpacket<'_>

CONTROLLER.RED_PACKET.CREATE.SUMMARY

CONTROLLER.RED_PACKET.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/create`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.create_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn redpacket_send(&self) -> RedpacketSend<'_>

CONTROLLER.RED_PACKET.SEND.SUMMARY

CONTROLLER.RED_PACKET.SEND.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/send`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.redpacket_send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn get_redpacket(&self) -> GetRedpacket<'_>

CONTROLLER.RED_PACKET.GET.SUMMARY

CONTROLLER.RED_PACKET.GET.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/{id}`

Arguments:
- `id`: DTO.RED_PACKET.ID
```ignore
let response = client.get_redpacket()
    .id(id)
    .send()
    .await;
```

pub fn get_claims(&self) -> GetClaims<'_>

CONTROLLER.RED_PACKET.GET_CLAIMS.SUMMARY

CONTROLLER.RED_PACKET.GET_CLAIMS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/{id}/claims`

Arguments:
- `id`: DTO.RED_PACKET.ID
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_claims()
    .id(id)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn moonshot_create_token(&self) -> MoonshotCreateToken<'_>

CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY

CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/moonshot/create`

Arguments:
- `body`: Token creation parameters
```ignore
let response = client.moonshot_create_token()
    .body(body)
    .send()
    .await;
```

pub fn moonshot_submit_create_token(&self) -> MoonshotSubmitCreateToken<'_>

CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY

CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/moonshot/submitCreateToken`

Arguments:
- `body`: Signed transaction and token details
```ignore
let response = client.moonshot_submit_create_token()
    .body(body)
    .send()
    .await;
```

pub fn pumpfun_create_token(&self) -> PumpfunCreateToken<'_>

CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY

CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/pumpfun/create`

Arguments:
- `body`: Required parameters for minting token
```ignore
let response = client.pumpfun_create_token()
    .body(body)
    .send()
    .await;
```

pub fn search(&self) -> Search<'_>

CONTROLLER.TOKEN.SEARCH.SUMMARY

CONTROLLER.TOKEN.SEARCH.DESCRIPTION

Sends a `GET` request to `/v1/token/search`

Arguments:
- `chains`: DTO.TOKEN.SEARCH.CHAINS
- `cursor`: DTO.PAGE.CURSOR
- `limit`: DTO.TOKEN.SEARCH.LIMIT
- `protocols`: DTO.TOKEN.SEARCH.PROTOCOLS
- `q`: DTO.TOKEN.SEARCH.QUERY
- `sort`: DTO.TOKEN.SEARCH.SORT_DIRECTION
- `sort_by`: DTO.TOKEN.SEARCH.SORT_BY
```ignore
let response = client.search()
    .chains(chains)
    .cursor(cursor)
    .limit(limit)
    .protocols(protocols)
    .q(q)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;
```

pub fn get_dev_tokens(&self) -> GetDevTokens<'_>

CONTROLLER.TOKEN.GET_DEV_TOKENS.SUMMARY

CONTROLLER.TOKEN.GET_DEV_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/dev/{devAddress}/tokens`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `dev_address`: Developer address
```ignore
let response = client.get_dev_tokens()
    .chain(chain)
    .dev_address(dev_address)
    .send()
    .await;
```

pub fn list_token(&self) -> ListToken<'_>

CONTROLLER.TOKEN.GET_TOKEN_LIST.SUMMARY

CONTROLLER.TOKEN.GET_TOKEN_LIST.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/list`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `max_h1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUY_VOLUME_IN_USD
- `max_h1_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUYERS
- `max_h1_buys`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUYS
- `max_h1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H1_PRICE_CHANGE_RATIO
- `max_h1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELL_VOLUME_IN_USD
- `max_h1_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELLERS
- `max_h1_sells`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELLS
- `max_h1_trades`: DTO.TOKEN.LIST.QUERY.MAX_H1_TRADES
- `max_h1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_VOLUME_IN_USD
- `max_h24_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUY_VOLUME_IN_USD
- `max_h24_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUYERS
- `max_h24_buys`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUYS
- `max_h24_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H24_PRICE_CHANGE_RATIO
- `max_h24_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELL_VOLUME_IN_USD
- `max_h24_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELLERS
- `max_h24_sells`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELLS
- `max_h24_trades`: DTO.TOKEN.LIST.QUERY.MAX_H24_TRADES
- `max_h24_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_VOLUME_IN_USD
- `max_h4_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUY_VOLUME_IN_USD
- `max_h4_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUYERS
- `max_h4_buys`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUYS
- `max_h4_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H4_PRICE_CHANGE_RATIO
- `max_h4_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELL_VOLUME_IN_USD
- `max_h4_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELLERS
- `max_h4_sells`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELLS
- `max_h4_trades`: DTO.TOKEN.LIST.QUERY.MAX_H4_TRADES
- `max_h4_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_VOLUME_IN_USD
- `max_m15_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUY_VOLUME_IN_USD
- `max_m15_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUYERS
- `max_m15_buys`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUYS
- `max_m15_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M15_PRICE_CHANGE_RATIO
- `max_m15_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELL_VOLUME_IN_USD
- `max_m15_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELLERS
- `max_m15_sells`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELLS
- `max_m15_trades`: DTO.TOKEN.LIST.QUERY.MAX_M15_TRADES
- `max_m15_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_VOLUME_IN_USD
- `max_m1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUY_VOLUME_IN_USD
- `max_m1_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUYERS
- `max_m1_buys`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUYS
- `max_m1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M1_PRICE_CHANGE_RATIO
- `max_m1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELL_VOLUME_IN_USD
- `max_m1_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELLERS
- `max_m1_sells`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELLS
- `max_m1_trades`: DTO.TOKEN.LIST.QUERY.MAX_M1_TRADES
- `max_m1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_VOLUME_IN_USD
- `max_m30_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUY_VOLUME_IN_USD
- `max_m30_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUYERS
- `max_m30_buys`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUYS
- `max_m30_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M30_PRICE_CHANGE_RATIO
- `max_m30_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELL_VOLUME_IN_USD
- `max_m30_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELLERS
- `max_m30_sells`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELLS
- `max_m30_trades`: DTO.TOKEN.LIST.QUERY.MAX_M30_TRADES
- `max_m30_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_VOLUME_IN_USD
- `max_m5_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUY_VOLUME_IN_USD
- `max_m5_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUYERS
- `max_m5_buys`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUYS
- `max_m5_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M5_PRICE_CHANGE_RATIO
- `max_m5_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELL_VOLUME_IN_USD
- `max_m5_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELLERS
- `max_m5_sells`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELLS
- `max_m5_trades`: DTO.TOKEN.LIST.QUERY.MAX_M5_TRADES
- `max_m5_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_VOLUME_IN_USD
- `min_h1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUY_VOLUME_IN_USD
- `min_h1_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUYERS
- `min_h1_buys`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUYS
- `min_h1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H1_PRICE_CHANGE_RATIO
- `min_h1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELL_VOLUME_IN_USD
- `min_h1_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELLERS
- `min_h1_sells`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELLS
- `min_h1_trades`: DTO.TOKEN.LIST.QUERY.MIN_H1_TRADES
- `min_h1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_VOLUME_IN_USD
- `min_h24_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUY_VOLUME_IN_USD
- `min_h24_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUYERS
- `min_h24_buys`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUYS
- `min_h24_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H24_PRICE_CHANGE_RATIO
- `min_h24_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELL_VOLUME_IN_USD
- `min_h24_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELLERS
- `min_h24_sells`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELLS
- `min_h24_trades`: DTO.TOKEN.LIST.QUERY.MIN_H24_TRADES
- `min_h24_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_VOLUME_IN_USD
- `min_h4_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUY_VOLUME_IN_USD
- `min_h4_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUYERS
- `min_h4_buys`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUYS
- `min_h4_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H4_PRICE_CHANGE_RATIO
- `min_h4_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELL_VOLUME_IN_USD
- `min_h4_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELLERS
- `min_h4_sells`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELLS
- `min_h4_trades`: DTO.TOKEN.LIST.QUERY.MIN_H4_TRADES
- `min_h4_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_VOLUME_IN_USD
- `min_m15_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUY_VOLUME_IN_USD
- `min_m15_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUYERS
- `min_m15_buys`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUYS
- `min_m15_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M15_PRICE_CHANGE_RATIO
- `min_m15_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELL_VOLUME_IN_USD
- `min_m15_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELLERS
- `min_m15_sells`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELLS
- `min_m15_trades`: DTO.TOKEN.LIST.QUERY.MIN_M15_TRADES
- `min_m15_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_VOLUME_IN_USD
- `min_m1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUY_VOLUME_IN_USD
- `min_m1_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUYERS
- `min_m1_buys`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUYS
- `min_m1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M1_PRICE_CHANGE_RATIO
- `min_m1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELL_VOLUME_IN_USD
- `min_m1_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELLERS
- `min_m1_sells`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELLS
- `min_m1_trades`: DTO.TOKEN.LIST.QUERY.MIN_M1_TRADES
- `min_m1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_VOLUME_IN_USD
- `min_m30_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUY_VOLUME_IN_USD
- `min_m30_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUYERS
- `min_m30_buys`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUYS
- `min_m30_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M30_PRICE_CHANGE_RATIO
- `min_m30_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELL_VOLUME_IN_USD
- `min_m30_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELLERS
- `min_m30_sells`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELLS
- `min_m30_trades`: DTO.TOKEN.LIST.QUERY.MIN_M30_TRADES
- `min_m30_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_VOLUME_IN_USD
- `min_m5_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUY_VOLUME_IN_USD
- `min_m5_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUYERS
- `min_m5_buys`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUYS
- `min_m5_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M5_PRICE_CHANGE_RATIO
- `min_m5_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELL_VOLUME_IN_USD
- `min_m5_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELLERS
- `min_m5_sells`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELLS
- `min_m5_trades`: DTO.TOKEN.LIST.QUERY.MIN_M5_TRADES
- `min_m5_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_VOLUME_IN_USD
- `sort`: DTO.TOKEN.SEARCH.SORT_DIRECTION
- `sort_by`: DTO.TOKEN.LIST.QUERY.SORT_BY
```ignore
let response = client.list_token()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_h1_buy_volume_in_usd(max_h1_buy_volume_in_usd)
    .max_h1_buyers(max_h1_buyers)
    .max_h1_buys(max_h1_buys)
    .max_h1_price_change_ratio(max_h1_price_change_ratio)
    .max_h1_sell_volume_in_usd(max_h1_sell_volume_in_usd)
    .max_h1_sellers(max_h1_sellers)
    .max_h1_sells(max_h1_sells)
    .max_h1_trades(max_h1_trades)
    .max_h1_volume_in_usd(max_h1_volume_in_usd)
    .max_h24_buy_volume_in_usd(max_h24_buy_volume_in_usd)
    .max_h24_buyers(max_h24_buyers)
    .max_h24_buys(max_h24_buys)
    .max_h24_price_change_ratio(max_h24_price_change_ratio)
    .max_h24_sell_volume_in_usd(max_h24_sell_volume_in_usd)
    .max_h24_sellers(max_h24_sellers)
    .max_h24_sells(max_h24_sells)
    .max_h24_trades(max_h24_trades)
    .max_h24_volume_in_usd(max_h24_volume_in_usd)
    .max_h4_buy_volume_in_usd(max_h4_buy_volume_in_usd)
    .max_h4_buyers(max_h4_buyers)
    .max_h4_buys(max_h4_buys)
    .max_h4_price_change_ratio(max_h4_price_change_ratio)
    .max_h4_sell_volume_in_usd(max_h4_sell_volume_in_usd)
    .max_h4_sellers(max_h4_sellers)
    .max_h4_sells(max_h4_sells)
    .max_h4_trades(max_h4_trades)
    .max_h4_volume_in_usd(max_h4_volume_in_usd)
    .max_m15_buy_volume_in_usd(max_m15_buy_volume_in_usd)
    .max_m15_buyers(max_m15_buyers)
    .max_m15_buys(max_m15_buys)
    .max_m15_price_change_ratio(max_m15_price_change_ratio)
    .max_m15_sell_volume_in_usd(max_m15_sell_volume_in_usd)
    .max_m15_sellers(max_m15_sellers)
    .max_m15_sells(max_m15_sells)
    .max_m15_trades(max_m15_trades)
    .max_m15_volume_in_usd(max_m15_volume_in_usd)
    .max_m1_buy_volume_in_usd(max_m1_buy_volume_in_usd)
    .max_m1_buyers(max_m1_buyers)
    .max_m1_buys(max_m1_buys)
    .max_m1_price_change_ratio(max_m1_price_change_ratio)
    .max_m1_sell_volume_in_usd(max_m1_sell_volume_in_usd)
    .max_m1_sellers(max_m1_sellers)
    .max_m1_sells(max_m1_sells)
    .max_m1_trades(max_m1_trades)
    .max_m1_volume_in_usd(max_m1_volume_in_usd)
    .max_m30_buy_volume_in_usd(max_m30_buy_volume_in_usd)
    .max_m30_buyers(max_m30_buyers)
    .max_m30_buys(max_m30_buys)
    .max_m30_price_change_ratio(max_m30_price_change_ratio)
    .max_m30_sell_volume_in_usd(max_m30_sell_volume_in_usd)
    .max_m30_sellers(max_m30_sellers)
    .max_m30_sells(max_m30_sells)
    .max_m30_trades(max_m30_trades)
    .max_m30_volume_in_usd(max_m30_volume_in_usd)
    .max_m5_buy_volume_in_usd(max_m5_buy_volume_in_usd)
    .max_m5_buyers(max_m5_buyers)
    .max_m5_buys(max_m5_buys)
    .max_m5_price_change_ratio(max_m5_price_change_ratio)
    .max_m5_sell_volume_in_usd(max_m5_sell_volume_in_usd)
    .max_m5_sellers(max_m5_sellers)
    .max_m5_sells(max_m5_sells)
    .max_m5_trades(max_m5_trades)
    .max_m5_volume_in_usd(max_m5_volume_in_usd)
    .min_h1_buy_volume_in_usd(min_h1_buy_volume_in_usd)
    .min_h1_buyers(min_h1_buyers)
    .min_h1_buys(min_h1_buys)
    .min_h1_price_change_ratio(min_h1_price_change_ratio)
    .min_h1_sell_volume_in_usd(min_h1_sell_volume_in_usd)
    .min_h1_sellers(min_h1_sellers)
    .min_h1_sells(min_h1_sells)
    .min_h1_trades(min_h1_trades)
    .min_h1_volume_in_usd(min_h1_volume_in_usd)
    .min_h24_buy_volume_in_usd(min_h24_buy_volume_in_usd)
    .min_h24_buyers(min_h24_buyers)
    .min_h24_buys(min_h24_buys)
    .min_h24_price_change_ratio(min_h24_price_change_ratio)
    .min_h24_sell_volume_in_usd(min_h24_sell_volume_in_usd)
    .min_h24_sellers(min_h24_sellers)
    .min_h24_sells(min_h24_sells)
    .min_h24_trades(min_h24_trades)
    .min_h24_volume_in_usd(min_h24_volume_in_usd)
    .min_h4_buy_volume_in_usd(min_h4_buy_volume_in_usd)
    .min_h4_buyers(min_h4_buyers)
    .min_h4_buys(min_h4_buys)
    .min_h4_price_change_ratio(min_h4_price_change_ratio)
    .min_h4_sell_volume_in_usd(min_h4_sell_volume_in_usd)
    .min_h4_sellers(min_h4_sellers)
    .min_h4_sells(min_h4_sells)
    .min_h4_trades(min_h4_trades)
    .min_h4_volume_in_usd(min_h4_volume_in_usd)
    .min_m15_buy_volume_in_usd(min_m15_buy_volume_in_usd)
    .min_m15_buyers(min_m15_buyers)
    .min_m15_buys(min_m15_buys)
    .min_m15_price_change_ratio(min_m15_price_change_ratio)
    .min_m15_sell_volume_in_usd(min_m15_sell_volume_in_usd)
    .min_m15_sellers(min_m15_sellers)
    .min_m15_sells(min_m15_sells)
    .min_m15_trades(min_m15_trades)
    .min_m15_volume_in_usd(min_m15_volume_in_usd)
    .min_m1_buy_volume_in_usd(min_m1_buy_volume_in_usd)
    .min_m1_buyers(min_m1_buyers)
    .min_m1_buys(min_m1_buys)
    .min_m1_price_change_ratio(min_m1_price_change_ratio)
    .min_m1_sell_volume_in_usd(min_m1_sell_volume_in_usd)
    .min_m1_sellers(min_m1_sellers)
    .min_m1_sells(min_m1_sells)
    .min_m1_trades(min_m1_trades)
    .min_m1_volume_in_usd(min_m1_volume_in_usd)
    .min_m30_buy_volume_in_usd(min_m30_buy_volume_in_usd)
    .min_m30_buyers(min_m30_buyers)
    .min_m30_buys(min_m30_buys)
    .min_m30_price_change_ratio(min_m30_price_change_ratio)
    .min_m30_sell_volume_in_usd(min_m30_sell_volume_in_usd)
    .min_m30_sellers(min_m30_sellers)
    .min_m30_sells(min_m30_sells)
    .min_m30_trades(min_m30_trades)
    .min_m30_volume_in_usd(min_m30_volume_in_usd)
    .min_m5_buy_volume_in_usd(min_m5_buy_volume_in_usd)
    .min_m5_buyers(min_m5_buyers)
    .min_m5_buys(min_m5_buys)
    .min_m5_price_change_ratio(min_m5_price_change_ratio)
    .min_m5_sell_volume_in_usd(min_m5_sell_volume_in_usd)
    .min_m5_sellers(min_m5_sellers)
    .min_m5_sells(min_m5_sells)
    .min_m5_trades(min_m5_trades)
    .min_m5_volume_in_usd(min_m5_volume_in_usd)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;
```

pub fn get_market_data_multi(&self) -> GetMarketDataMulti<'_>

CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/marketData/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_market_data_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```

pub fn get_metadata_multi(&self) -> GetMetadataMulti<'_>

CONTROLLER.TOKEN.GET_METADATA_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_METADATA_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/metadata/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_metadata_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```

pub fn get_tokens(&self) -> GetTokens<'_>

CONTROLLER.TOKEN.GET_TOKENS.SUMMARY

CONTROLLER.TOKEN.GET_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `filter_by`: DTO.TOKEN.REQUEST.FILTER_BY
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_tokens()
    .chain(chain)
    .filter_by(filter_by)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .token_addresses(token_addresses)
    .send()
    .await;
```

pub fn get_stats_multi(&self) -> GetStatsMulti<'_>

CONTROLLER.TOKEN.GET_STATS_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_STATS_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/stats/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_stats_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```

pub fn get_token(&self) -> GetToken<'_>

CONTROLLER.TOKEN.GET.SUMMARY

CONTROLLER.TOKEN.GET.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_token()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_candles(&self) -> GetCandles<'_>

CONTROLLER.TOKEN.GET_CANDLES.SUMMARY

CONTROLLER.TOKEN.GET_CANDLES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/candles`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `from`: DTO.CANDLE.FROM
- `limit`: DTO.CANDLE.LIMIT
- `resolution`: DTO.CANDLE.RESOLUTION
- `to`: DTO.CANDLE.TO
```ignore
let response = client.get_candles()
    .chain(chain)
    .token_address(token_address)
    .from(from)
    .limit(limit)
    .resolution(resolution)
    .to(to)
    .send()
    .await;
```

pub fn get_creation(&self) -> GetCreation<'_>

CONTROLLER.TOKEN.GET_CREATION.SUMMARY

CONTROLLER.TOKEN.GET_CREATION.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/creation`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_creation()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_holders(&self) -> GetHolders<'_>

CONTROLLER.TOKEN.GET_HOLDERS.SUMMARY

CONTROLLER.TOKEN.GET_HOLDERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_holders()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn get_holders_multi(&self) -> GetHoldersMulti<'_>

CONTROLLER.TOKEN.GET_HOLDERS_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_HOLDERS_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `wallet_addresses`: GLOBAL.WALLETADDRESSES.DESCRIPTION
```ignore
let response = client.get_holders_multi()
    .chain(chain)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```

pub fn get_token_liquidity_snapshots(&self) -> GetTokenLiquiditySnapshots<'_>

CONTROLLER.TOKEN.GET_LIQUIDITY_SNAPSHOTS.SUMMARY

CONTROLLER.TOKEN.GET_LIQUIDITY_SNAPSHOTS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/liquiditySnapshots`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR
- `limit`: DTO.PAGE.LIMIT
- `time`: DTO.TOKEN.LIQUIDITY_SNAPSHOT.TIME
```ignore
let response = client.get_token_liquidity_snapshots()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .limit(limit)
    .time(time)
    .send()
    .await;
```

pub fn get_market_data(&self) -> GetMarketData<'_>

CONTROLLER.TOKEN.GET_MARKET_CAP.SUMMARY

CONTROLLER.TOKEN.GET_MARKET_CAP.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/marketData`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_market_data()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_metadata(&self) -> GetMetadata<'_>

CONTROLLER.TOKEN.GET_METADATA.SUMMARY

CONTROLLER.TOKEN.GET_METADATA.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/metadata`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_metadata()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_mint_and_burn(&self) -> GetMintAndBurn<'_>

CONTROLLER.TOKEN.GET_MINT_AND_BURN.SUMMARY

CONTROLLER.TOKEN.GET_MINT_AND_BURN.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/mintAndBurn`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `type_`: DTO.TOKEN.MINT_AND_BURN.TYPE
```ignore
let response = client.get_mint_and_burn()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .type_(type_)
    .send()
    .await;
```

pub fn get_pools(&self) -> GetPools<'_>

CONTROLLER.TOKEN.GET_POOLS.SUMMARY

CONTROLLER.TOKEN.GET_POOLS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/pools`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `max_tvl_in_sol`: DTO.POOL.MAX_TVL_IN_SOL
- `max_tvl_in_usd`: DTO.POOL.MAX_TVL_IN_USD
- `min_tvl_in_sol`: DTO.POOL.MIN_TVL_IN_SOL
- `min_tvl_in_usd`: DTO.POOL.MIN_TVL_IN_USD
- `sort_by`: DTO.POOL.SORT_BY
- `sort_direction`: DTO.POOL.SORT_DIRECTION
```ignore
let response = client.get_pools()
    .chain(chain)
    .token_address(token_address)
    .max_tvl_in_sol(max_tvl_in_sol)
    .max_tvl_in_usd(max_tvl_in_usd)
    .min_tvl_in_sol(min_tvl_in_sol)
    .min_tvl_in_usd(min_tvl_in_usd)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .send()
    .await;
```

pub fn get_price_by_time(&self) -> GetPriceByTime<'_>

CONTROLLER.TOKEN.GET_PRICE_BY_TIME.SUMMARY

CONTROLLER.TOKEN.GET_PRICE_BY_TIME.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/price`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `timestamp`: DTO.TOKEN.PRICE.QUERY.TIMESTAMP
```ignore
let response = client.get_price_by_time()
    .chain(chain)
    .token_address(token_address)
    .timestamp(timestamp)
    .send()
    .await;
```

pub fn get_prices(&self) -> GetPrices<'_>

CONTROLLER.TOKEN.GET_PRICES.SUMMARY

CONTROLLER.TOKEN.GET_PRICES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/prices`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_prices()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```

pub fn get_security(&self) -> GetSecurity<'_>

CONTROLLER.TOKEN.GET_SECURITY.SUMMARY

CONTROLLER.TOKEN.GET_SECURITY.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/security`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_security()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_stats(&self) -> GetStats<'_>

CONTROLLER.TOKEN.GET_STATS.SUMMARY

CONTROLLER.TOKEN.GET_STATS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/stats`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_stats()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_top_holders(&self) -> GetTopHolders<'_>

CONTROLLER.TOKEN.GET_TOP_HOLDERS.SUMMARY

CONTROLLER.TOKEN.GET_TOP_HOLDERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/topHolders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_top_holders()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_token_traders(&self) -> GetTokenTraders<'_>

CONTROLLER.TOKEN.GET_TOKEN_TRADERS.SUMMARY

CONTROLLER.TOKEN.GET_TOKEN_TRADERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/traders/{tag}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `tag`: Token trader tag
```ignore
let response = client.get_token_traders()
    .chain(chain)
    .token_address(token_address)
    .tag(tag)
    .send()
    .await;
```

pub fn get_trades(&self) -> GetTrades<'_>

CONTROLLER.TRADE.GET.TOKEN.SUMMARY

CONTROLLER.TRADE.GET.TOKEN.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `after_block_height`: DTO.TRADE.QUERY.AFTER_BLOCK_HEIGHT
- `after_timestamp`: DTO.TRADE.QUERY.AFTER_TIMESTAMP
- `before_block_height`: DTO.TRADE.QUERY.BEFORE_BLOCK_HEIGHT
- `before_timestamp`: DTO.TRADE.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `pool_address`: DTO.TRADE.QUERY.POOL_ADDRESS
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
- `transactions_signature`: DTO.TRADE.QUERY.TRANSACTIONS_SIGNATURE
- `type_`: DTO.TRADE.QUERY.TRADES_TYPE
- `wallet_address`: DTO.TRADE.QUERY.WALLET_ADDRESS
```ignore
let response = client.get_trades()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .pool_address(pool_address)
    .token_address(token_address)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;
```

pub fn get_activities(&self) -> GetActivities<'_>

CONTROLLER.TRADE.GET.TOKEN_ACTIVITIES.SUMMARY

CONTROLLER.TRADE.GET.TOKEN_ACTIVITIES.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}/activities`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `after_block_height`: DTO.TRADE.QUERY.AFTER_BLOCK_HEIGHT
- `after_timestamp`: DTO.TRADE.QUERY.AFTER_TIMESTAMP
- `before_block_height`: DTO.TRADE.QUERY.BEFORE_BLOCK_HEIGHT
- `before_timestamp`: DTO.TRADE.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `pool_address`: DTO.TRADE.QUERY.POOL_ADDRESS
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
- `transactions_signature`: DTO.TRADE.QUERY.TRANSACTIONS_SIGNATURE
- `type_`: DTO.TRADE.QUERY.ACTIVITIES_TYPE
- `wallet_address`: DTO.TRADE.QUERY.WALLET_ADDRESS
```ignore
let response = client.get_activities()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .pool_address(pool_address)
    .token_address(token_address)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;
```

pub fn get_top_traders(&self) -> GetTopTraders<'_>

CONTROLLER.TRADE.GET.TOP_TRADERS.SUMMARY

CONTROLLER.TRADE.GET.TOP_TRADERS.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}/top-traders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.TRADE.QUERY.LIMIT
- `sort_by`: DTO.TRADE.QUERY.SORT_BY
- `sort_type`: DTO.TRADE.QUERY.SORT_TYPE
- `time_frame`: DTO.TRADE.QUERY.TIME_FRAME
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
```ignore
let response = client.get_top_traders()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .sort_by(sort_by)
    .sort_type(sort_type)
    .time_frame(time_frame)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_gas_limit(&self) -> GetGasLimit<'_>

CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.SUMMARY

CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.DESCRIPTION

Sends a `POST` request to `/v1/transaction/{chain}/estimate-gas-limit`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.BODY
```ignore
let response = client.get_gas_limit()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn get_gas_price(&self) -> GetGasPrice<'_>

CONTROLLER.TRANSACTION.GET_GAS_PRICE.SUMMARY

CONTROLLER.TRANSACTION.GET_GAS_PRICE.DESCRIPTION

Sends a `GET` request to `/v1/transaction/{chain}/gas-price`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
```ignore
let response = client.get_gas_price()
    .chain(chain)
    .send()
    .await;
```

pub fn send(&self) -> Send<'_>

CONTROLLER.TRANSACTION.SEND.SUMMARY

CONTROLLER.TRANSACTION.SEND.DESCRIPTION

Sends a `POST` request to `/v1/transaction/{chain}/send`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: CONTROLLER.TRANSACTION.SEND.BODY
```ignore
let response = client.send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```

pub fn get_pnl(&self) -> GetPnl<'_>

CONTROLLER.WALLET.GET_PNL.SUMMARY

CONTROLLER.WALLET.GET_PNL.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_balance(&self) -> GetBalance<'_>

CONTROLLER.WALLET.GET_BALANCES.SUMMARY

CONTROLLER.WALLET.GET_BALANCES.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/balance`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `token_address`: DTO.WALLET.BALANCE.QUERY.TOKEN_ADDRESS
```ignore
let response = client.get_balance()
    .chain(chain)
    .wallet_address(wallet_address)
    .token_address(token_address)
    .send()
    .await;
```

pub fn get_balance_updates(&self) -> GetBalanceUpdates<'_>

CONTROLLER.WALLET.GET_BALANCE_UPDATES.SUMMARY

CONTROLLER.WALLET.GET_BALANCE_UPDATES.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/balance-updates`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `change_type`: DTO.WALLET.BALANCE_UPDATE.QUERY.CHANGE_TYPE
- `cursor`: DTO.PAGE.CURSOR
- `limit`: DTO.PAGE.LIMIT
- `time_from`: DTO.WALLET.BALANCE_UPDATE.QUERY.TIME_FROM
- `time_to`: DTO.WALLET.BALANCE_UPDATE.QUERY.TIME_TO
- `token_address`: DTO.WALLET.BALANCE_UPDATE.QUERY.TOKEN_ADDRESS
- `type_`: DTO.WALLET.BALANCE_UPDATE.QUERY.TYPE
```ignore
let response = client.get_balance_updates()
    .chain(chain)
    .wallet_address(wallet_address)
    .change_type(change_type)
    .cursor(cursor)
    .limit(limit)
    .time_from(time_from)
    .time_to(time_to)
    .token_address(token_address)
    .type_(type_)
    .send()
    .await;
```

pub fn calculate_pnl(&self) -> CalculatePnl<'_>

CONTROLLER.WALLET.CALCULATE_PNL.SUMMARY

CONTROLLER.WALLET.CALCULATE_PNL.DESCRIPTION

Sends a `POST` request to `/v1/wallet/{chain}/{walletAddress}/calculate-pnl`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `body`
```ignore
let response = client.calculate_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .body(body)
    .send()
    .await;
```

pub fn get_pnl_stats(&self) -> GetPnlStats<'_>

CONTROLLER.WALLET.GET_PNL_STATS.SUMMARY

CONTROLLER.WALLET.GET_PNL_STATS.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/stats`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
```ignore
let response = client.get_pnl_stats()
    .chain(chain)
    .wallet_address(wallet_address)
    .send()
    .await;
```

pub fn watchlist_add(&self) -> WatchlistAdd<'_>

CONTROLLER.WATCHLIST.ADD.SUMMARY

CONTROLLER.WATCHLIST.ADD.DESCRIPTION

Sends a `POST` request to `/v1/watchlist/{chain}/{walletAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
```ignore
let response = client.watchlist_add()
    .chain(chain)
    .wallet_address(wallet_address)
    .send()
    .await;
```

pub fn list_endpoints(&self) -> ListEndpoints<'_>

CONTROLLER.ENDPOINT.LIST.SUMMARY

CONTROLLER.ENDPOINT.LIST.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint`

Arguments:
- `iterator`: DTO.ENDPOINT.ITERATOR
- `limit`: DTO.ENDPOINT.LIMIT
- `order`: DTO.ENDPOINT.ORDER
```ignore
let response = client.list_endpoints()
    .iterator(iterator)
    .limit(limit)
    .order(order)
    .send()
    .await;
```

pub fn create_endpoint(&self) -> CreateEndpoint<'_>

CONTROLLER.ENDPOINT.CREATE.SUMMARY

CONTROLLER.ENDPOINT.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/webhook/endpoint`

```ignore
let response = client.create_endpoint()
    .body(body)
    .send()
    .await;
```

pub fn update_endpoint(&self) -> UpdateEndpoint<'_>

CONTROLLER.ENDPOINT.UPDATE.SUMMARY

CONTROLLER.ENDPOINT.UPDATE.DESCRIPTION

Sends a `PATCH` request to `/v1/webhook/endpoint`

```ignore
let response = client.update_endpoint()
    .body(body)
    .send()
    .await;
```

pub fn get_endpoint(&self) -> GetEndpoint<'_>

CONTROLLER.ENDPOINT.GET.SUMMARY

CONTROLLER.ENDPOINT.GET.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint/{id}`

```ignore
let response = client.get_endpoint()
    .id(id)
    .send()
    .await;
```

pub fn delete_endpoint(&self) -> DeleteEndpoint<'_>

CONTROLLER.ENDPOINT.DELETE.SUMMARY

CONTROLLER.ENDPOINT.DELETE.DESCRIPTION

Sends a `DELETE` request to `/v1/webhook/endpoint/{id}`

```ignore
let response = client.delete_endpoint()
    .id(id)
    .send()
    .await;
```

pub fn get_endpoint_secret(&self) -> GetEndpointSecret<'_>

CONTROLLER.ENDPOINT.GET.SECRET.SUMMARY

CONTROLLER.ENDPOINT.GET.SECRET.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint/{id}/secret`

```ignore
let response = client.get_endpoint_secret()
    .id(id)
    .send()
    .await;
```

pub fn rotate_endpoint_secret(&self) -> RotateEndpointSecret<'_>

CONTROLLER.ENDPOINT.ROTATE.SUMMARY

CONTROLLER.ENDPOINT.ROTATE.DESCRIPTION

Sends a `POST` request to `/v1/webhook/endpoint/{id}/secret/rotate`

```ignore
let response = client.rotate_endpoint_secret()
    .id(id)
    .send()
    .await;
```

Trait Implementations

impl ClientHooks for &Client

async fn pre<E>( &self, request: &mut Request, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs prior to the execution of the request. This may be used to modify the request before it is transmitted.

async fn post<E>( &self, result: &Result<Response, Error>, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs after completion of the request.

async fn exec( &self, request: Request, info: &OperationInfo, ) -> Result<Response, Error>

Execute the request. Note that for almost any reasonable implementation this will include code equivalent to this:

impl ClientInfo<()> for Client

fn api_version() -> &'static str

Get the version of this API.

fn baseurl(&self) -> &str

Get the base URL to which requests are made.

fn client(&self) -> &ClientWithMiddleware

Get the internal reqwest_middleware::ClientWithMiddleware used to make requests.

fn inner(&self) -> &()

Get the inner value of type T if one is specified.

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.