@chainstream-io/sdk 0.0.12 → 0.1.5

package/src/openapi/apis/TokenApi.ts

@@ -1,2697 +1,2569 @@
-// TODO: better import syntax?
-import {BaseAPIRequestFactory, RequiredError, COLLECTION_FORMATS} from './baseapi';
-import {Configuration} from '../configuration';
-import {RequestContext, HttpMethod, ResponseContext, HttpFile, HttpInfo} from '../http/http';
-import {ObjectSerializer} from '../models/ObjectSerializer';
-import {ApiException} from './exception';
-import {canConsumeForm, isCodeInRange} from '../util';
-import {SecurityAuthentication} from '../auth/auth';
-
-
-import { Candle } from '../models/Candle';
-import { DexPoolDTO } from '../models/DexPoolDTO';
-import { FilterCondition } from '../models/FilterCondition';
-import { Resolution } from '../models/Resolution';
-import { Token } from '../models/Token';
-import { TokenCreationDTO } from '../models/TokenCreationDTO';
-import { TokenCreationPage } from '../models/TokenCreationPage';
-import { TokenHolder } from '../models/TokenHolder';
-import { TokenHolderPage } from '../models/TokenHolderPage';
-import { TokenListPage } from '../models/TokenListPage';
-import { TokenMarketData } from '../models/TokenMarketData';
-import { TokenMetadata } from '../models/TokenMetadata';
-import { TokenPage } from '../models/TokenPage';
-import { TokenPriceDTO } from '../models/TokenPriceDTO';
-import { TokenPricePage } from '../models/TokenPricePage';
-import { TokenStat } from '../models/TokenStat';
-
+/* tslint:disable */
+/* eslint-disable */
 /**
- * no description
+ * Dex Aggregator API
+ * Dex Aggregator API ⚡️
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: ai@sx.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
  */
-export class TokenApiRequestFactory extends BaseAPIRequestFactory {
 
-    /**
-     * CONTROLLER.TOKEN.GET_CANDLES.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_CANDLES.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param resolution DTO.CANDLE.RESOLUTION
-     * @param _from DTO.CANDLE.FROM
-     * @param to DTO.CANDLE.TO
-     * @param limit DTO.CANDLE.LIMIT
-     */
-    public async getCandles(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, resolution: Resolution, _from?: number, to?: number, limit?: number, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
 
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getCandles", "chain");
-        }
+import * as runtime from '../runtime';
+import type {
+  Candle,
+  DexPoolDTO,
+  FilterCondition,
+  Resolution,
+  Token,
+  TokenCreationDTO,
+  TokenCreationPage,
+  TokenHolder,
+  TokenHolderPage,
+  TokenListPage,
+  TokenMarketData,
+  TokenMetadata,
+  TokenPage,
+  TokenPriceDTO,
+  TokenPricePage,
+  TokenStat,
+} from '../models/index';
+import {
+    CandleFromJSON,
+    CandleToJSON,
+    DexPoolDTOFromJSON,
+    DexPoolDTOToJSON,
+    FilterConditionFromJSON,
+    FilterConditionToJSON,
+    ResolutionFromJSON,
+    ResolutionToJSON,
+    TokenFromJSON,
+    TokenToJSON,
+    TokenCreationDTOFromJSON,
+    TokenCreationDTOToJSON,
+    TokenCreationPageFromJSON,
+    TokenCreationPageToJSON,
+    TokenHolderFromJSON,
+    TokenHolderToJSON,
+    TokenHolderPageFromJSON,
+    TokenHolderPageToJSON,
+    TokenListPageFromJSON,
+    TokenListPageToJSON,
+    TokenMarketDataFromJSON,
+    TokenMarketDataToJSON,
+    TokenMetadataFromJSON,
+    TokenMetadataToJSON,
+    TokenPageFromJSON,
+    TokenPageToJSON,
+    TokenPriceDTOFromJSON,
+    TokenPriceDTOToJSON,
+    TokenPricePageFromJSON,
+    TokenPricePageToJSON,
+    TokenStatFromJSON,
+    TokenStatToJSON,
+} from '../models/index';
+
+export interface GetCandlesRequest {
+    chain: GetCandlesChainEnum;
+    tokenAddress: string;
+    resolution: Resolution;
+    from?: number;
+    to?: number;
+    limit?: number;
+}
 
+export interface GetCreationRequest {
+    chain: GetCreationChainEnum;
+    tokenAddress: string;
+}
 
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getCandles", "tokenAddress");
-        }
+export interface GetHoldersRequest {
+    chain: GetHoldersChainEnum;
+    tokenAddress: string;
+    cursor?: string;
+    limit?: number;
+    direction?: GetHoldersDirectionEnum;
+}
 
+export interface GetHoldersMultiRequest {
+    chain: GetHoldersMultiChainEnum;
+    tokenAddress: string;
+    walletAddresses: string;
+}
 
-        // verify required parameter 'resolution' is not null or undefined
-        if (resolution === null || resolution === undefined) {
-            throw new RequiredError("TokenApi", "getCandles", "resolution");
-        }
+export interface GetMarketDataRequest {
+    chain: GetMarketDataChainEnum;
+    tokenAddress: string;
+}
 
+export interface GetMarketDataMultiRequest {
+    chain: GetMarketDataMultiChainEnum;
+    tokenAddresses: string;
+}
 
+export interface GetMetadataRequest {
+    chain: GetMetadataChainEnum;
+    tokenAddress: string;
+}
 
+export interface GetMetadataMultiRequest {
+    chain: GetMetadataMultiChainEnum;
+    tokenAddresses: string;
+}
 
+export interface GetMintAndBurnRequest {
+    chain: GetMintAndBurnChainEnum;
+    tokenAddress: string;
+    cursor?: string;
+    limit?: number;
+    direction?: GetMintAndBurnDirectionEnum;
+    type?: GetMintAndBurnTypeEnum;
+}
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/candles'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+export interface GetPoolsRequest {
+    chain: GetPoolsChainEnum;
+    tokenAddress: string;
+}
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+export interface GetPriceByTimeRequest {
+    chain: GetPriceByTimeChainEnum;
+    tokenAddress: string;
+    timestamp: number;
+}
 
+export interface GetPricesRequest {
+    chain: GetPricesChainEnum;
+    tokenAddress: string;
+    cursor?: string;
+    limit?: number;
+    direction?: GetPricesDirectionEnum;
+}
 
-        // Query Params
-        if (resolution !== undefined) {
-            requestContext.setQueryParam("resolution", ObjectSerializer.serialize(resolution, "string", ""));
-        }
+export interface GetSecurityRequest {
+    chain: GetSecurityChainEnum;
+    tokenAddress: string;
+}
 
-        // Query Params
-        if (_from !== undefined) {
-            requestContext.setQueryParam("from", ObjectSerializer.serialize(_from, "number", ""));
-        }
+export interface GetStatsRequest {
+    chain: GetStatsChainEnum;
+    tokenAddress: string;
+}
 
-        // Query Params
-        if (to !== undefined) {
-            requestContext.setQueryParam("to", ObjectSerializer.serialize(to, "number", ""));
-        }
+export interface GetStatsMultiRequest {
+    chain: GetStatsMultiChainEnum;
+    tokenAddresses: string;
+}
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
-        }
+export interface GetTokenRequest {
+    chain: GetTokenChainEnum;
+    tokenAddress: string;
+}
 
+export interface GetTokensRequest {
+    chain: GetTokensChainEnum;
+    tokenAddresses: string;
+    sortBy?: GetTokensSortByEnum;
+    sortDirection?: GetTokensSortDirectionEnum;
+    filterBy?: Array<FilterCondition>;
+}
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+export interface GetTopHoldersRequest {
+    chain: GetTopHoldersChainEnum;
+    tokenAddress: string;
+}
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+export interface ListTokenRequest {
+    chain: ListTokenChainEnum;
+    cursor?: string;
+    limit?: number;
+    direction?: ListTokenDirectionEnum;
+    sort?: ListTokenSortEnum;
+    sortBy?: ListTokenSortByEnum;
+    minH24VolumeInUsd?: string;
+    maxH24VolumeInUsd?: string;
+    minH24PriceChangeRatio?: string;
+    maxH24PriceChangeRatio?: string;
+    minH24Buys?: string;
+    maxH24Buys?: string;
+    minH24Sells?: string;
+    maxH24Sells?: string;
+    minH24Trades?: string;
+    maxH24Trades?: string;
+    minH24Buyers?: string;
+    maxH24Buyers?: string;
+    minH24Sellers?: string;
+    maxH24Sellers?: string;
+    minH24BuyVolumeInUsd?: string;
+    maxH24BuyVolumeInUsd?: string;
+    minH24SellVolumeInUsd?: string;
+    maxH24SellVolumeInUsd?: string;
+    minH4VolumeInUsd?: string;
+    maxH4VolumeInUsd?: string;
+    minH4PriceChangeRatio?: string;
+    maxH4PriceChangeRatio?: string;
+    minH4Buys?: string;
+    maxH4Buys?: string;
+    minH4Sells?: string;
+    maxH4Sells?: string;
+    minH4Trades?: string;
+    maxH4Trades?: string;
+    minH4Buyers?: string;
+    maxH4Buyers?: string;
+    minH4Sellers?: string;
+    maxH4Sellers?: string;
+    minH4BuyVolumeInUsd?: string;
+    maxH4BuyVolumeInUsd?: string;
+    minH4SellVolumeInUsd?: string;
+    maxH4SellVolumeInUsd?: string;
+    minH1VolumeInUsd?: string;
+    maxH1VolumeInUsd?: string;
+    minH1PriceChangeRatio?: string;
+    maxH1PriceChangeRatio?: string;
+    minH1Buys?: string;
+    maxH1Buys?: string;
+    minH1Sells?: string;
+    maxH1Sells?: string;
+    minH1Trades?: string;
+    maxH1Trades?: string;
+    minH1Buyers?: string;
+    maxH1Buyers?: string;
+    minH1Sellers?: string;
+    maxH1Sellers?: string;
+    minH1BuyVolumeInUsd?: string;
+    maxH1BuyVolumeInUsd?: string;
+    minH1SellVolumeInUsd?: string;
+    maxH1SellVolumeInUsd?: string;
+    minM30VolumeInUsd?: string;
+    maxM30VolumeInUsd?: string;
+    minM30PriceChangeRatio?: string;
+    maxM30PriceChangeRatio?: string;
+    minM30Buys?: string;
+    maxM30Buys?: string;
+    minM30Sells?: string;
+    maxM30Sells?: string;
+    minM30Trades?: string;
+    maxM30Trades?: string;
+    minM30Buyers?: string;
+    maxM30Buyers?: string;
+    minM30Sellers?: string;
+    maxM30Sellers?: string;
+    minM30BuyVolumeInUsd?: string;
+    maxM30BuyVolumeInUsd?: string;
+    minM30SellVolumeInUsd?: string;
+    maxM30SellVolumeInUsd?: string;
+    minM15VolumeInUsd?: string;
+    maxM15VolumeInUsd?: string;
+    minM15PriceChangeRatio?: string;
+    maxM15PriceChangeRatio?: string;
+    minM15Buys?: string;
+    maxM15Buys?: string;
+    minM15Sells?: string;
+    maxM15Sells?: string;
+    minM15Trades?: string;
+    maxM15Trades?: string;
+    minM15Buyers?: string;
+    maxM15Buyers?: string;
+    minM15Sellers?: string;
+    maxM15Sellers?: string;
+    minM15BuyVolumeInUsd?: string;
+    maxM15BuyVolumeInUsd?: string;
+    minM15SellVolumeInUsd?: string;
+    maxM15SellVolumeInUsd?: string;
+    minM5VolumeInUsd?: string;
+    maxM5VolumeInUsd?: string;
+    minM5PriceChangeRatio?: string;
+    maxM5PriceChangeRatio?: string;
+    minM5Buys?: string;
+    maxM5Buys?: string;
+    minM5Sells?: string;
+    maxM5Sells?: string;
+    minM5Trades?: string;
+    maxM5Trades?: string;
+    minM5Buyers?: string;
+    maxM5Buyers?: string;
+    minM5Sellers?: string;
+    maxM5Sellers?: string;
+    minM5BuyVolumeInUsd?: string;
+    maxM5BuyVolumeInUsd?: string;
+    minM5SellVolumeInUsd?: string;
+    maxM5SellVolumeInUsd?: string;
+    minM1VolumeInUsd?: string;
+    maxM1VolumeInUsd?: string;
+    minM1PriceChangeRatio?: string;
+    maxM1PriceChangeRatio?: string;
+    minM1Buys?: string;
+    maxM1Buys?: string;
+    minM1Sells?: string;
+    maxM1Sells?: string;
+    minM1Trades?: string;
+    maxM1Trades?: string;
+    minM1Buyers?: string;
+    maxM1Buyers?: string;
+    minM1Sellers?: string;
+    maxM1Sellers?: string;
+    minM1BuyVolumeInUsd?: string;
+    maxM1BuyVolumeInUsd?: string;
+    minM1SellVolumeInUsd?: string;
+    maxM1SellVolumeInUsd?: string;
+}
 
-        return requestContext;
-    }
+export interface SearchRequest {
+    chains?: Array<string>;
+    q?: string;
+    limit?: number;
+    sort?: SearchSortEnum;
+    protocols?: Array<string>;
+    cursor?: string;
+    sortBy?: SearchSortByEnum;
+}
+
+/**
+ * 
+ */
+export class TokenApi extends runtime.BaseAPI {
 
     /**
-     * CONTROLLER.TOKEN.GET_CREATION.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_CREATION.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_CANDLES.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_CANDLES.SUMMARY
      */
-    public async getCreation(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
+    async getCandlesRaw(requestParameters: GetCandlesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Candle>>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getCandles().'
+            );
+        }
 
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getCreation", "chain");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getCandles().'
+            );
         }
 
+        if (requestParameters['resolution'] == null) {
+            throw new runtime.RequiredError(
+                'resolution',
+                'Required parameter "resolution" was null or undefined when calling getCandles().'
+            );
+        }
 
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getCreation", "tokenAddress");
+        const queryParameters: any = {};
+
+        if (requestParameters['resolution'] != null) {
+            queryParameters['resolution'] = requestParameters['resolution'];
         }
 
+        if (requestParameters['from'] != null) {
+            queryParameters['from'] = requestParameters['from'];
+        }
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/creation'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        if (requestParameters['to'] != null) {
+            queryParameters['to'] = requestParameters['to'];
+        }
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/candles`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        return requestContext;
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CandleFromJSON));
     }
 
     /**
-     * CONTROLLER.TOKEN.GET_HOLDERS.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_HOLDERS.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
-     * @param limit DTO.PAGE.LIMIT
-     * @param direction DTO.PAGE.DIRECTION
+     * CONTROLLER.TOKEN.GET_CANDLES.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_CANDLES.SUMMARY
      */
-    public async getHolders(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, cursor?: string, limit?: number, direction?: 'next' | 'prev', _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
+    async getCandles(requestParameters: GetCandlesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Candle>> {
+        const response = await this.getCandlesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getHolders", "chain");
+    /**
+     * CONTROLLER.TOKEN.GET_CREATION.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_CREATION.SUMMARY
+     */
+    async getCreationRaw(requestParameters: GetCreationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenCreationDTO>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getCreation().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getHolders", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getCreation().'
+            );
         }
 
+        const queryParameters: any = {};
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/holders'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/creation`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenCreationDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.TOKEN.GET_CREATION.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_CREATION.SUMMARY
+     */
+    async getCreation(requestParameters: GetCreationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenCreationDTO> {
+        const response = await this.getCreationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // Query Params
-        if (cursor !== undefined) {
-            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+    /**
+     * CONTROLLER.TOKEN.GET_HOLDERS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_HOLDERS.SUMMARY
+     */
+    async getHoldersRaw(requestParameters: GetHoldersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenHolderPage>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getHolders().'
+            );
         }
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getHolders().'
+            );
         }
 
-        // Query Params
-        if (direction !== undefined) {
-            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        const queryParameters: any = {};
+
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        return requestContext;
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/holders`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenHolderPageFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.TOKEN.GET_HOLDERS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_HOLDERS.SUMMARY
+     */
+    async getHolders(requestParameters: GetHoldersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenHolderPage> {
+        const response = await this.getHoldersRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_HOLDERS_MULTI.DESCRIPTION
      * CONTROLLER.TOKEN.GET_HOLDERS_MULTI.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param walletAddresses GLOBAL.WALLETADDRESSES.DESCRIPTION
      */
-    public async getHoldersMulti(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, walletAddresses: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getHoldersMulti", "chain");
+    async getHoldersMultiRaw(requestParameters: GetHoldersMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<TokenHolder>>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getHoldersMulti().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getHoldersMulti", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getHoldersMulti().'
+            );
         }
 
-
-        // verify required parameter 'walletAddresses' is not null or undefined
-        if (walletAddresses === null || walletAddresses === undefined) {
-            throw new RequiredError("TokenApi", "getHoldersMulti", "walletAddresses");
+        if (requestParameters['walletAddresses'] == null) {
+            throw new runtime.RequiredError(
+                'walletAddresses',
+                'Required parameter "walletAddresses" was null or undefined when calling getHoldersMulti().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/holders/multi'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        if (requestParameters['walletAddresses'] != null) {
+            queryParameters['walletAddresses'] = requestParameters['walletAddresses'];
+        }
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        // Query Params
-        if (walletAddresses !== undefined) {
-            requestContext.setQueryParam("walletAddresses", ObjectSerializer.serialize(walletAddresses, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/holders/multi`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TokenHolderFromJSON));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_HOLDERS_MULTI.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_HOLDERS_MULTI.SUMMARY
+     */
+    async getHoldersMulti(requestParameters: GetHoldersMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<TokenHolder>> {
+        const response = await this.getHoldersMultiRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_MARKET_CAP.DESCRIPTION
      * CONTROLLER.TOKEN.GET_MARKET_CAP.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
      */
-    public async getMarketData(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getMarketData", "chain");
+    async getMarketDataRaw(requestParameters: GetMarketDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenMarketData>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getMarketData().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getMarketData", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getMarketData().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/marketData'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/marketData`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenMarketDataFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_MARKET_CAP.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_MARKET_CAP.SUMMARY
+     */
+    async getMarketData(requestParameters: GetMarketDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenMarketData> {
+        const response = await this.getMarketDataRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.DESCRIPTION
      * CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddresses GLOBAL.TOKENADDRESSES.DESCRIPTION
      */
-    public async getMarketDataMulti(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddresses: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getMarketDataMulti", "chain");
+    async getMarketDataMultiRaw(requestParameters: GetMarketDataMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: TokenMarketData; }>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getMarketDataMulti().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddresses' is not null or undefined
-        if (tokenAddresses === null || tokenAddresses === undefined) {
-            throw new RequiredError("TokenApi", "getMarketDataMulti", "tokenAddresses");
+        if (requestParameters['tokenAddresses'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddresses',
+                'Required parameter "tokenAddresses" was null or undefined when calling getMarketDataMulti().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/marketData/multi'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        if (requestParameters['tokenAddresses'] != null) {
+            queryParameters['tokenAddresses'] = requestParameters['tokenAddresses'];
+        }
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        // Query Params
-        if (tokenAddresses !== undefined) {
-            requestContext.setQueryParam("tokenAddresses", ObjectSerializer.serialize(tokenAddresses, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/token/{chain}/marketData/multi`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => runtime.mapValues(jsonValue, TokenMarketDataFromJSON));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.SUMMARY
+     */
+    async getMarketDataMulti(requestParameters: GetMarketDataMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: TokenMarketData; }> {
+        const response = await this.getMarketDataMultiRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_METADATA.DESCRIPTION
      * CONTROLLER.TOKEN.GET_METADATA.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
      */
-    public async getMetadata(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getMetadata", "chain");
+    async getMetadataRaw(requestParameters: GetMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenMetadata>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getMetadata().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getMetadata", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getMetadata().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/metadata'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/metadata`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenMetadataFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_METADATA.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_METADATA.SUMMARY
+     */
+    async getMetadata(requestParameters: GetMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenMetadata> {
+        const response = await this.getMetadataRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_METADATA_MULTI.DESCRIPTION
      * CONTROLLER.TOKEN.GET_METADATA_MULTI.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddresses GLOBAL.TOKENADDRESSES.DESCRIPTION
      */
-    public async getMetadataMulti(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddresses: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getMetadataMulti", "chain");
+    async getMetadataMultiRaw(requestParameters: GetMetadataMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: TokenMetadata; }>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getMetadataMulti().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddresses' is not null or undefined
-        if (tokenAddresses === null || tokenAddresses === undefined) {
-            throw new RequiredError("TokenApi", "getMetadataMulti", "tokenAddresses");
+        if (requestParameters['tokenAddresses'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddresses',
+                'Required parameter "tokenAddresses" was null or undefined when calling getMetadataMulti().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/metadata/multi'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        if (requestParameters['tokenAddresses'] != null) {
+            queryParameters['tokenAddresses'] = requestParameters['tokenAddresses'];
+        }
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        // Query Params
-        if (tokenAddresses !== undefined) {
-            requestContext.setQueryParam("tokenAddresses", ObjectSerializer.serialize(tokenAddresses, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/token/{chain}/metadata/multi`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => runtime.mapValues(jsonValue, TokenMetadataFromJSON));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_METADATA_MULTI.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_METADATA_MULTI.SUMMARY
+     */
+    async getMetadataMulti(requestParameters: GetMetadataMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: TokenMetadata; }> {
+        const response = await this.getMetadataMultiRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_MINT_AND_BURN.DESCRIPTION
      * CONTROLLER.TOKEN.GET_MINT_AND_BURN.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param type DTO.TOKEN.MINT_AND_BURN.TYPE
-     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
-     * @param limit DTO.PAGE.LIMIT
-     * @param direction DTO.PAGE.DIRECTION
      */
-    public async getMintAndBurn(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, type: 'all' | 'mint' | 'burn', cursor?: string, limit?: number, direction?: 'next' | 'prev', _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getMintAndBurn", "chain");
+    async getMintAndBurnRaw(requestParameters: GetMintAndBurnRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenCreationPage>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getMintAndBurn().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getMintAndBurn", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getMintAndBurn().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // verify required parameter 'type' is not null or undefined
-        if (type === null || type === undefined) {
-            throw new RequiredError("TokenApi", "getMintAndBurn", "type");
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
-
-
-
-
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/mintAndBurn'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
-
-        // Query Params
-        if (cursor !== undefined) {
-            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
         }
 
-        // Query Params
-        if (direction !== undefined) {
-            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
         }
 
-        // Query Params
-        if (type !== undefined) {
-            requestContext.setQueryParam("type", ObjectSerializer.serialize(type, "'all' | 'mint' | 'burn'", ""));
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/mintAndBurn`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        return requestContext;
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenCreationPageFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.TOKEN.GET_MINT_AND_BURN.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_MINT_AND_BURN.SUMMARY
+     */
+    async getMintAndBurn(requestParameters: GetMintAndBurnRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenCreationPage> {
+        const response = await this.getMintAndBurnRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_POOLS.DESCRIPTION
      * CONTROLLER.TOKEN.GET_POOLS.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
      */
-    public async getPools(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getPools", "chain");
+    async getPoolsRaw(requestParameters: GetPoolsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<DexPoolDTO>>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getPools().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getPools", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getPools().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/pools'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/pools`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(DexPoolDTOFromJSON));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_POOLS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_POOLS.SUMMARY
+     */
+    async getPools(requestParameters: GetPoolsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<DexPoolDTO>> {
+        const response = await this.getPoolsRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_PRICE_BY_TIME.DESCRIPTION
      * CONTROLLER.TOKEN.GET_PRICE_BY_TIME.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param timestamp DTO.TOKEN.PRICE.QUERY.TIMESTAMP
      */
-    public async getPriceByTime(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, timestamp: number, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getPriceByTime", "chain");
+    async getPriceByTimeRaw(requestParameters: GetPriceByTimeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenPriceDTO>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getPriceByTime().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getPriceByTime", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getPriceByTime().'
+            );
         }
 
-
-        // verify required parameter 'timestamp' is not null or undefined
-        if (timestamp === null || timestamp === undefined) {
-            throw new RequiredError("TokenApi", "getPriceByTime", "timestamp");
+        if (requestParameters['timestamp'] == null) {
+            throw new runtime.RequiredError(
+                'timestamp',
+                'Required parameter "timestamp" was null or undefined when calling getPriceByTime().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/price'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
+        if (requestParameters['timestamp'] != null) {
+            queryParameters['timestamp'] = requestParameters['timestamp'];
+        }
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        // Query Params
-        if (timestamp !== undefined) {
-            requestContext.setQueryParam("timestamp", ObjectSerializer.serialize(timestamp, "number", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/price`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenPriceDTOFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_PRICE_BY_TIME.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_PRICE_BY_TIME.SUMMARY
+     */
+    async getPriceByTime(requestParameters: GetPriceByTimeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenPriceDTO> {
+        const response = await this.getPriceByTimeRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_PRICES.DESCRIPTION
      * CONTROLLER.TOKEN.GET_PRICES.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
-     * @param limit DTO.PAGE.LIMIT
-     * @param direction DTO.PAGE.DIRECTION
      */
-    public async getPrices(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, cursor?: string, limit?: number, direction?: 'next' | 'prev', _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getPrices", "chain");
+    async getPricesRaw(requestParameters: GetPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenPricePage>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getPrices().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getPrices", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getPrices().'
+            );
         }
 
+        const queryParameters: any = {};
 
-
-
-
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/prices'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
-
-        // Query Params
-        if (cursor !== undefined) {
-            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        // Query Params
-        if (direction !== undefined) {
-            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
         }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        return requestContext;
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/prices`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenPricePageFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.TOKEN.GET_PRICES.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_PRICES.SUMMARY
+     */
+    async getPrices(requestParameters: GetPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenPricePage> {
+        const response = await this.getPricesRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.GET_SECURITY.DESCRIPTION
      * CONTROLLER.TOKEN.GET_SECURITY.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
      */
-    public async getSecurity(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getSecurity", "chain");
+    async getSecurityRaw(requestParameters: GetSecurityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<object>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getSecurity().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getSecurity", "tokenAddress");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getSecurity().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/security'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/security`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        return requestContext;
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse<any>(response);
     }
 
     /**
-     * CONTROLLER.TOKEN.GET_STATS.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_STATS.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_SECURITY.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_SECURITY.SUMMARY
      */
-    public async getStats(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getStats", "chain");
-        }
-
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getStats", "tokenAddress");
-        }
-
-
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/stats'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
-
-
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
-
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
-
-        return requestContext;
+    async getSecurity(requestParameters: GetSecurityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<object> {
+        const response = await this.getSecurityRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * CONTROLLER.TOKEN.GET_STATS_MULTI.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_STATS_MULTI.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddresses GLOBAL.TOKENADDRESSES.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS.SUMMARY
      */
-    public async getStatsMulti(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddresses: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getStatsMulti", "chain");
+    async getStatsRaw(requestParameters: GetStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenStat>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getStats().'
+            );
         }
 
-
-        // verify required parameter 'tokenAddresses' is not null or undefined
-        if (tokenAddresses === null || tokenAddresses === undefined) {
-            throw new RequiredError("TokenApi", "getStatsMulti", "tokenAddresses");
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getStats().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/stats/multi'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-
-        // Query Params
-        if (tokenAddresses !== undefined) {
-            requestContext.setQueryParam("tokenAddresses", ObjectSerializer.serialize(tokenAddresses, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/stats`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
-
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        return requestContext;
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenStatFromJSON(jsonValue));
     }
 
     /**
-     * CONTROLLER.TOKEN.GET.DESCRIPTION
-     * CONTROLLER.TOKEN.GET.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS.SUMMARY
      */
-    public async getToken(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getToken", "chain");
-        }
-
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getToken", "tokenAddress");
-        }
-
-
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
-
-
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
-
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
-
-        return requestContext;
+    async getStats(requestParameters: GetStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenStat> {
+        const response = await this.getStatsRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * CONTROLLER.TOKEN.GET_TOKEN_LIST.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_TOKEN_LIST.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
-     * @param limit DTO.PAGE.LIMIT
-     * @param direction DTO.PAGE.DIRECTION
-     * @param sort DTO.TOKEN.SEARCH.SORT_DIRECTION
-     * @param sortBy DTO.TOKEN.LIST.QUERY.SORT_BY
-     * @param minH24VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H24_VOLUME_IN_USD
-     * @param maxH24VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H24_VOLUME_IN_USD
-     * @param minH24PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_H24_PRICE_CHANGE_RATIO
-     * @param maxH24PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_H24_PRICE_CHANGE_RATIO
-     * @param minH24Buys DTO.TOKEN.LIST.QUERY.MIN_H24_BUYS
-     * @param maxH24Buys DTO.TOKEN.LIST.QUERY.MAX_H24_BUYS
-     * @param minH24Sells DTO.TOKEN.LIST.QUERY.MIN_H24_SELLS
-     * @param maxH24Sells DTO.TOKEN.LIST.QUERY.MAX_H24_SELLS
-     * @param minH24Trades DTO.TOKEN.LIST.QUERY.MIN_H24_TRADES
-     * @param maxH24Trades DTO.TOKEN.LIST.QUERY.MAX_H24_TRADES
-     * @param minH24Buyers DTO.TOKEN.LIST.QUERY.MIN_H24_BUYERS
-     * @param maxH24Buyers DTO.TOKEN.LIST.QUERY.MAX_H24_BUYERS
-     * @param minH24Sellers DTO.TOKEN.LIST.QUERY.MIN_H24_SELLERS
-     * @param maxH24Sellers DTO.TOKEN.LIST.QUERY.MAX_H24_SELLERS
-     * @param minH24BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H24_BUY_VOLUME_IN_USD
-     * @param maxH24BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H24_BUY_VOLUME_IN_USD
-     * @param minH24SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H24_SELL_VOLUME_IN_USD
-     * @param maxH24SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H24_SELL_VOLUME_IN_USD
-     * @param minH4VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H4_VOLUME_IN_USD
-     * @param maxH4VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H4_VOLUME_IN_USD
-     * @param minH4PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_H4_PRICE_CHANGE_RATIO
-     * @param maxH4PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_H4_PRICE_CHANGE_RATIO
-     * @param minH4Buys DTO.TOKEN.LIST.QUERY.MIN_H4_BUYS
-     * @param maxH4Buys DTO.TOKEN.LIST.QUERY.MAX_H4_BUYS
-     * @param minH4Sells DTO.TOKEN.LIST.QUERY.MIN_H4_SELLS
-     * @param maxH4Sells DTO.TOKEN.LIST.QUERY.MAX_H4_SELLS
-     * @param minH4Trades DTO.TOKEN.LIST.QUERY.MIN_H4_TRADES
-     * @param maxH4Trades DTO.TOKEN.LIST.QUERY.MAX_H4_TRADES
-     * @param minH4Buyers DTO.TOKEN.LIST.QUERY.MIN_H4_BUYERS
-     * @param maxH4Buyers DTO.TOKEN.LIST.QUERY.MAX_H4_BUYERS
-     * @param minH4Sellers DTO.TOKEN.LIST.QUERY.MIN_H4_SELLERS
-     * @param maxH4Sellers DTO.TOKEN.LIST.QUERY.MAX_H4_SELLERS
-     * @param minH4BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H4_BUY_VOLUME_IN_USD
-     * @param maxH4BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H4_BUY_VOLUME_IN_USD
-     * @param minH4SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H4_SELL_VOLUME_IN_USD
-     * @param maxH4SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H4_SELL_VOLUME_IN_USD
-     * @param minH1VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H1_VOLUME_IN_USD
-     * @param maxH1VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H1_VOLUME_IN_USD
-     * @param minH1PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_H1_PRICE_CHANGE_RATIO
-     * @param maxH1PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_H1_PRICE_CHANGE_RATIO
-     * @param minH1Buys DTO.TOKEN.LIST.QUERY.MIN_H1_BUYS
-     * @param maxH1Buys DTO.TOKEN.LIST.QUERY.MAX_H1_BUYS
-     * @param minH1Sells DTO.TOKEN.LIST.QUERY.MIN_H1_SELLS
-     * @param maxH1Sells DTO.TOKEN.LIST.QUERY.MAX_H1_SELLS
-     * @param minH1Trades DTO.TOKEN.LIST.QUERY.MIN_H1_TRADES
-     * @param maxH1Trades DTO.TOKEN.LIST.QUERY.MAX_H1_TRADES
-     * @param minH1Buyers DTO.TOKEN.LIST.QUERY.MIN_H1_BUYERS
-     * @param maxH1Buyers DTO.TOKEN.LIST.QUERY.MAX_H1_BUYERS
-     * @param minH1Sellers DTO.TOKEN.LIST.QUERY.MIN_H1_SELLERS
-     * @param maxH1Sellers DTO.TOKEN.LIST.QUERY.MAX_H1_SELLERS
-     * @param minH1BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H1_BUY_VOLUME_IN_USD
-     * @param maxH1BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H1_BUY_VOLUME_IN_USD
-     * @param minH1SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_H1_SELL_VOLUME_IN_USD
-     * @param maxH1SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_H1_SELL_VOLUME_IN_USD
-     * @param minM30VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M30_VOLUME_IN_USD
-     * @param maxM30VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M30_VOLUME_IN_USD
-     * @param minM30PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_M30_PRICE_CHANGE_RATIO
-     * @param maxM30PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_M30_PRICE_CHANGE_RATIO
-     * @param minM30Buys DTO.TOKEN.LIST.QUERY.MIN_M30_BUYS
-     * @param maxM30Buys DTO.TOKEN.LIST.QUERY.MAX_M30_BUYS
-     * @param minM30Sells DTO.TOKEN.LIST.QUERY.MIN_M30_SELLS
-     * @param maxM30Sells DTO.TOKEN.LIST.QUERY.MAX_M30_SELLS
-     * @param minM30Trades DTO.TOKEN.LIST.QUERY.MIN_M30_TRADES
-     * @param maxM30Trades DTO.TOKEN.LIST.QUERY.MAX_M30_TRADES
-     * @param minM30Buyers DTO.TOKEN.LIST.QUERY.MIN_M30_BUYERS
-     * @param maxM30Buyers DTO.TOKEN.LIST.QUERY.MAX_M30_BUYERS
-     * @param minM30Sellers DTO.TOKEN.LIST.QUERY.MIN_M30_SELLERS
-     * @param maxM30Sellers DTO.TOKEN.LIST.QUERY.MAX_M30_SELLERS
-     * @param minM30BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M30_BUY_VOLUME_IN_USD
-     * @param maxM30BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M30_BUY_VOLUME_IN_USD
-     * @param minM30SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M30_SELL_VOLUME_IN_USD
-     * @param maxM30SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M30_SELL_VOLUME_IN_USD
-     * @param minM15VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M15_VOLUME_IN_USD
-     * @param maxM15VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M15_VOLUME_IN_USD
-     * @param minM15PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_M15_PRICE_CHANGE_RATIO
-     * @param maxM15PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_M15_PRICE_CHANGE_RATIO
-     * @param minM15Buys DTO.TOKEN.LIST.QUERY.MIN_M15_BUYS
-     * @param maxM15Buys DTO.TOKEN.LIST.QUERY.MAX_M15_BUYS
-     * @param minM15Sells DTO.TOKEN.LIST.QUERY.MIN_M15_SELLS
-     * @param maxM15Sells DTO.TOKEN.LIST.QUERY.MAX_M15_SELLS
-     * @param minM15Trades DTO.TOKEN.LIST.QUERY.MIN_M15_TRADES
-     * @param maxM15Trades DTO.TOKEN.LIST.QUERY.MAX_M15_TRADES
-     * @param minM15Buyers DTO.TOKEN.LIST.QUERY.MIN_M15_BUYERS
-     * @param maxM15Buyers DTO.TOKEN.LIST.QUERY.MAX_M15_BUYERS
-     * @param minM15Sellers DTO.TOKEN.LIST.QUERY.MIN_M15_SELLERS
-     * @param maxM15Sellers DTO.TOKEN.LIST.QUERY.MAX_M15_SELLERS
-     * @param minM15BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M15_BUY_VOLUME_IN_USD
-     * @param maxM15BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M15_BUY_VOLUME_IN_USD
-     * @param minM15SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M15_SELL_VOLUME_IN_USD
-     * @param maxM15SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M15_SELL_VOLUME_IN_USD
-     * @param minM5VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M5_VOLUME_IN_USD
-     * @param maxM5VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M5_VOLUME_IN_USD
-     * @param minM5PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_M5_PRICE_CHANGE_RATIO
-     * @param maxM5PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_M5_PRICE_CHANGE_RATIO
-     * @param minM5Buys DTO.TOKEN.LIST.QUERY.MIN_M5_BUYS
-     * @param maxM5Buys DTO.TOKEN.LIST.QUERY.MAX_M5_BUYS
-     * @param minM5Sells DTO.TOKEN.LIST.QUERY.MIN_M5_SELLS
-     * @param maxM5Sells DTO.TOKEN.LIST.QUERY.MAX_M5_SELLS
-     * @param minM5Trades DTO.TOKEN.LIST.QUERY.MIN_M5_TRADES
-     * @param maxM5Trades DTO.TOKEN.LIST.QUERY.MAX_M5_TRADES
-     * @param minM5Buyers DTO.TOKEN.LIST.QUERY.MIN_M5_BUYERS
-     * @param maxM5Buyers DTO.TOKEN.LIST.QUERY.MAX_M5_BUYERS
-     * @param minM5Sellers DTO.TOKEN.LIST.QUERY.MIN_M5_SELLERS
-     * @param maxM5Sellers DTO.TOKEN.LIST.QUERY.MAX_M5_SELLERS
-     * @param minM5BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M5_BUY_VOLUME_IN_USD
-     * @param maxM5BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M5_BUY_VOLUME_IN_USD
-     * @param minM5SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M5_SELL_VOLUME_IN_USD
-     * @param maxM5SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M5_SELL_VOLUME_IN_USD
-     * @param minM1VolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M1_VOLUME_IN_USD
-     * @param maxM1VolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M1_VOLUME_IN_USD
-     * @param minM1PriceChangeRatio DTO.TOKEN.LIST.QUERY.MIN_M1_PRICE_CHANGE_RATIO
-     * @param maxM1PriceChangeRatio DTO.TOKEN.LIST.QUERY.MAX_M1_PRICE_CHANGE_RATIO
-     * @param minM1Buys DTO.TOKEN.LIST.QUERY.MIN_M1_BUYS
-     * @param maxM1Buys DTO.TOKEN.LIST.QUERY.MAX_M1_BUYS
-     * @param minM1Sells DTO.TOKEN.LIST.QUERY.MIN_M1_SELLS
-     * @param maxM1Sells DTO.TOKEN.LIST.QUERY.MAX_M1_SELLS
-     * @param minM1Trades DTO.TOKEN.LIST.QUERY.MIN_M1_TRADES
-     * @param maxM1Trades DTO.TOKEN.LIST.QUERY.MAX_M1_TRADES
-     * @param minM1Buyers DTO.TOKEN.LIST.QUERY.MIN_M1_BUYERS
-     * @param maxM1Buyers DTO.TOKEN.LIST.QUERY.MAX_M1_BUYERS
-     * @param minM1Sellers DTO.TOKEN.LIST.QUERY.MIN_M1_SELLERS
-     * @param maxM1Sellers DTO.TOKEN.LIST.QUERY.MAX_M1_SELLERS
-     * @param minM1BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M1_BUY_VOLUME_IN_USD
-     * @param maxM1BuyVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M1_BUY_VOLUME_IN_USD
-     * @param minM1SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MIN_M1_SELL_VOLUME_IN_USD
-     * @param maxM1SellVolumeInUsd DTO.TOKEN.LIST.QUERY.MAX_M1_SELL_VOLUME_IN_USD
+     * CONTROLLER.TOKEN.GET_STATS_MULTI.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS_MULTI.SUMMARY
      */
-    public async getTokenList(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', cursor?: string, limit?: number, direction?: 'next' | 'prev', sort?: 'asc' | 'desc', sortBy?: 'h24VolumeInUsd' | 'h24PriceChangeRatio' | 'h24Buys' | 'h24Sells' | 'h24Trades' | 'h24Buyers' | 'h24Sellers' | 'h24BuyVolumeInUsd' | 'h24SellVolumeInUsd' | 'h4VolumeInUsd' | 'h4PriceChangeRatio' | 'h4Buys' | 'h4Sells' | 'h4Trades' | 'h4Buyers' | 'h4Sellers' | 'h4BuyVolumeInUsd' | 'h4SellVolumeInUsd' | 'h1VolumeInUsd' | 'h1PriceChangeRatio' | 'h1Buys' | 'h1Sells' | 'h1Trades' | 'h1Buyers' | 'h1Sellers' | 'h1BuyVolumeInUsd' | 'h1SellVolumeInUsd' | 'm30VolumeInUsd' | 'm30PriceChangeRatio' | 'm30Buys' | 'm30Sells' | 'm30Trades' | 'm30Buyers' | 'm30Sellers' | 'm30BuyVolumeInUsd' | 'm30SellVolumeInUsd' | 'm15VolumeInUsd' | 'm15PriceChangeRatio' | 'm15Buys' | 'm15Sells' | 'm15Trades' | 'm15Buyers' | 'm15Sellers' | 'm15BuyVolumeInUsd' | 'm15SellVolumeInUsd' | 'm5VolumeInUsd' | 'm5PriceChangeRatio' | 'm5Buys' | 'm5Sells' | 'm5Trades' | 'm5Buyers' | 'm5Sellers' | 'm5BuyVolumeInUsd' | 'm5SellVolumeInUsd' | 'm1VolumeInUsd' | 'm1PriceChangeRatio' | 'm1Buys' | 'm1Sells' | 'm1Trades' | 'm1Buyers' | 'm1Sellers' | 'm1BuyVolumeInUsd' | 'm1SellVolumeInUsd', minH24VolumeInUsd?: string, maxH24VolumeInUsd?: string, minH24PriceChangeRatio?: string, maxH24PriceChangeRatio?: string, minH24Buys?: string, maxH24Buys?: string, minH24Sells?: string, maxH24Sells?: string, minH24Trades?: string, maxH24Trades?: string, minH24Buyers?: string, maxH24Buyers?: string, minH24Sellers?: string, maxH24Sellers?: string, minH24BuyVolumeInUsd?: string, maxH24BuyVolumeInUsd?: string, minH24SellVolumeInUsd?: string, maxH24SellVolumeInUsd?: string, minH4VolumeInUsd?: string, maxH4VolumeInUsd?: string, minH4PriceChangeRatio?: string, maxH4PriceChangeRatio?: string, minH4Buys?: string, maxH4Buys?: string, minH4Sells?: string, maxH4Sells?: string, minH4Trades?: string, maxH4Trades?: string, minH4Buyers?: string, maxH4Buyers?: string, minH4Sellers?: string, maxH4Sellers?: string, minH4BuyVolumeInUsd?: string, maxH4BuyVolumeInUsd?: string, minH4SellVolumeInUsd?: string, maxH4SellVolumeInUsd?: string, minH1VolumeInUsd?: string, maxH1VolumeInUsd?: string, minH1PriceChangeRatio?: string, maxH1PriceChangeRatio?: string, minH1Buys?: string, maxH1Buys?: string, minH1Sells?: string, maxH1Sells?: string, minH1Trades?: string, maxH1Trades?: string, minH1Buyers?: string, maxH1Buyers?: string, minH1Sellers?: string, maxH1Sellers?: string, minH1BuyVolumeInUsd?: string, maxH1BuyVolumeInUsd?: string, minH1SellVolumeInUsd?: string, maxH1SellVolumeInUsd?: string, minM30VolumeInUsd?: string, maxM30VolumeInUsd?: string, minM30PriceChangeRatio?: string, maxM30PriceChangeRatio?: string, minM30Buys?: string, maxM30Buys?: string, minM30Sells?: string, maxM30Sells?: string, minM30Trades?: string, maxM30Trades?: string, minM30Buyers?: string, maxM30Buyers?: string, minM30Sellers?: string, maxM30Sellers?: string, minM30BuyVolumeInUsd?: string, maxM30BuyVolumeInUsd?: string, minM30SellVolumeInUsd?: string, maxM30SellVolumeInUsd?: string, minM15VolumeInUsd?: string, maxM15VolumeInUsd?: string, minM15PriceChangeRatio?: string, maxM15PriceChangeRatio?: string, minM15Buys?: string, maxM15Buys?: string, minM15Sells?: string, maxM15Sells?: string, minM15Trades?: string, maxM15Trades?: string, minM15Buyers?: string, maxM15Buyers?: string, minM15Sellers?: string, maxM15Sellers?: string, minM15BuyVolumeInUsd?: string, maxM15BuyVolumeInUsd?: string, minM15SellVolumeInUsd?: string, maxM15SellVolumeInUsd?: string, minM5VolumeInUsd?: string, maxM5VolumeInUsd?: string, minM5PriceChangeRatio?: string, maxM5PriceChangeRatio?: string, minM5Buys?: string, maxM5Buys?: string, minM5Sells?: string, maxM5Sells?: string, minM5Trades?: string, maxM5Trades?: string, minM5Buyers?: string, maxM5Buyers?: string, minM5Sellers?: string, maxM5Sellers?: string, minM5BuyVolumeInUsd?: string, maxM5BuyVolumeInUsd?: string, minM5SellVolumeInUsd?: string, maxM5SellVolumeInUsd?: string, minM1VolumeInUsd?: string, maxM1VolumeInUsd?: string, minM1PriceChangeRatio?: string, maxM1PriceChangeRatio?: string, minM1Buys?: string, maxM1Buys?: string, minM1Sells?: string, maxM1Sells?: string, minM1Trades?: string, maxM1Trades?: string, minM1Buyers?: string, maxM1Buyers?: string, minM1Sellers?: string, maxM1Sellers?: string, minM1BuyVolumeInUsd?: string, maxM1BuyVolumeInUsd?: string, minM1SellVolumeInUsd?: string, maxM1SellVolumeInUsd?: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getTokenList", "chain");
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+    async getStatsMultiRaw(requestParameters: GetStatsMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: TokenStat; }>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getStatsMulti().'
+            );
+        }
 
+        if (requestParameters['tokenAddresses'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddresses',
+                'Required parameter "tokenAddresses" was null or undefined when calling getStatsMulti().'
+            );
+        }
 
+        const queryParameters: any = {};
 
+        if (requestParameters['tokenAddresses'] != null) {
+            queryParameters['tokenAddresses'] = requestParameters['tokenAddresses'];
+        }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/stats/multi`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
+        return new runtime.JSONApiResponse(response, (jsonValue) => runtime.mapValues(jsonValue, TokenStatFromJSON));
+    }
 
+    /**
+     * CONTROLLER.TOKEN.GET_STATS_MULTI.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_STATS_MULTI.SUMMARY
+     */
+    async getStatsMulti(requestParameters: GetStatsMultiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: TokenStat; }> {
+        const response = await this.getStatsMultiRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
+    /**
+     * CONTROLLER.TOKEN.GET.DESCRIPTION
+     * CONTROLLER.TOKEN.GET.SUMMARY
+     */
+    async getTokenRaw(requestParameters: GetTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Token>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getToken().'
+            );
+        }
 
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getToken().'
+            );
+        }
 
+        const queryParameters: any = {};
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/{tokenAddress}`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenFromJSON(jsonValue));
+    }
 
+    /**
+     * CONTROLLER.TOKEN.GET.DESCRIPTION
+     * CONTROLLER.TOKEN.GET.SUMMARY
+     */
+    async getToken(requestParameters: GetTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Token> {
+        const response = await this.getTokenRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
+    /**
+     * CONTROLLER.TOKEN.GET_TOKENS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOKENS.SUMMARY
+     */
+    async getTokensRaw(requestParameters: GetTokensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Token>>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getTokens().'
+            );
+        }
 
+        if (requestParameters['tokenAddresses'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddresses',
+                'Required parameter "tokenAddresses" was null or undefined when calling getTokens().'
+            );
+        }
 
+        const queryParameters: any = {};
 
+        if (requestParameters['tokenAddresses'] != null) {
+            queryParameters['tokenAddresses'] = requestParameters['tokenAddresses'];
+        }
 
+        if (requestParameters['sortBy'] != null) {
+            queryParameters['sortBy'] = requestParameters['sortBy'];
+        }
 
+        if (requestParameters['sortDirection'] != null) {
+            queryParameters['sortDirection'] = requestParameters['sortDirection'];
+        }
 
+        if (requestParameters['filterBy'] != null) {
+            queryParameters['filterBy'] = requestParameters['filterBy'];
+        }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/multi`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/list'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TokenFromJSON));
+    }
 
+    /**
+     * CONTROLLER.TOKEN.GET_TOKENS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOKENS.SUMMARY
+     */
+    async getTokens(requestParameters: GetTokensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Token>> {
+        const response = await this.getTokensRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // Query Params
-        if (cursor !== undefined) {
-            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+    /**
+     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.SUMMARY
+     */
+    async getTopHoldersRaw(requestParameters: GetTopHoldersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenHolderPage>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling getTopHolders().'
+            );
         }
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        if (requestParameters['tokenAddress'] == null) {
+            throw new runtime.RequiredError(
+                'tokenAddress',
+                'Required parameter "tokenAddress" was null or undefined when calling getTopHolders().'
+            );
         }
 
-        // Query Params
-        if (direction !== undefined) {
-            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
-        }
+        const queryParameters: any = {};
 
-        // Query Params
-        if (sort !== undefined) {
-            requestContext.setQueryParam("sort", ObjectSerializer.serialize(sort, "'asc' | 'desc'", ""));
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Query Params
-        if (sortBy !== undefined) {
-            requestContext.setQueryParam("sortBy", ObjectSerializer.serialize(sortBy, "'h24VolumeInUsd' | 'h24PriceChangeRatio' | 'h24Buys' | 'h24Sells' | 'h24Trades' | 'h24Buyers' | 'h24Sellers' | 'h24BuyVolumeInUsd' | 'h24SellVolumeInUsd' | 'h4VolumeInUsd' | 'h4PriceChangeRatio' | 'h4Buys' | 'h4Sells' | 'h4Trades' | 'h4Buyers' | 'h4Sellers' | 'h4BuyVolumeInUsd' | 'h4SellVolumeInUsd' | 'h1VolumeInUsd' | 'h1PriceChangeRatio' | 'h1Buys' | 'h1Sells' | 'h1Trades' | 'h1Buyers' | 'h1Sellers' | 'h1BuyVolumeInUsd' | 'h1SellVolumeInUsd' | 'm30VolumeInUsd' | 'm30PriceChangeRatio' | 'm30Buys' | 'm30Sells' | 'm30Trades' | 'm30Buyers' | 'm30Sellers' | 'm30BuyVolumeInUsd' | 'm30SellVolumeInUsd' | 'm15VolumeInUsd' | 'm15PriceChangeRatio' | 'm15Buys' | 'm15Sells' | 'm15Trades' | 'm15Buyers' | 'm15Sellers' | 'm15BuyVolumeInUsd' | 'm15SellVolumeInUsd' | 'm5VolumeInUsd' | 'm5PriceChangeRatio' | 'm5Buys' | 'm5Sells' | 'm5Trades' | 'm5Buyers' | 'm5Sellers' | 'm5BuyVolumeInUsd' | 'm5SellVolumeInUsd' | 'm1VolumeInUsd' | 'm1PriceChangeRatio' | 'm1Buys' | 'm1Sells' | 'm1Trades' | 'm1Buyers' | 'm1Sellers' | 'm1BuyVolumeInUsd' | 'm1SellVolumeInUsd'", ""));
-        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        // Query Params
-        if (minH24VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h24_volume_in_usd", ObjectSerializer.serialize(minH24VolumeInUsd, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        // Query Params
-        if (maxH24VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h24_volume_in_usd", ObjectSerializer.serialize(maxH24VolumeInUsd, "string", ""));
-        }
+        let urlPath = `/v1/token/{chain}/{tokenAddress}/topHolders`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+        urlPath = urlPath.replace(`{${"tokenAddress"}}`, encodeURIComponent(String(requestParameters['tokenAddress'])));
 
-        // Query Params
-        if (minH24PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_h24_price_change_ratio", ObjectSerializer.serialize(minH24PriceChangeRatio, "string", ""));
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        // Query Params
-        if (maxH24PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_h24_price_change_ratio", ObjectSerializer.serialize(maxH24PriceChangeRatio, "string", ""));
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenHolderPageFromJSON(jsonValue));
+    }
 
-        // Query Params
-        if (minH24Buys !== undefined) {
-            requestContext.setQueryParam("min_h24_buys", ObjectSerializer.serialize(minH24Buys, "string", ""));
-        }
+    /**
+     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.SUMMARY
+     */
+    async getTopHolders(requestParameters: GetTopHoldersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenHolderPage> {
+        const response = await this.getTopHoldersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // Query Params
-        if (maxH24Buys !== undefined) {
-            requestContext.setQueryParam("max_h24_buys", ObjectSerializer.serialize(maxH24Buys, "string", ""));
+    /**
+     * CONTROLLER.TOKEN.GET_TOKEN_LIST.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOKEN_LIST.SUMMARY
+     */
+    async listTokenRaw(requestParameters: ListTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenListPage>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling listToken().'
+            );
         }
 
-        // Query Params
-        if (minH24Sells !== undefined) {
-            requestContext.setQueryParam("min_h24_sells", ObjectSerializer.serialize(minH24Sells, "string", ""));
-        }
+        const queryParameters: any = {};
 
-        // Query Params
-        if (maxH24Sells !== undefined) {
-            requestContext.setQueryParam("max_h24_sells", ObjectSerializer.serialize(maxH24Sells, "string", ""));
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
-        // Query Params
-        if (minH24Trades !== undefined) {
-            requestContext.setQueryParam("min_h24_trades", ObjectSerializer.serialize(minH24Trades, "string", ""));
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        // Query Params
-        if (maxH24Trades !== undefined) {
-            requestContext.setQueryParam("max_h24_trades", ObjectSerializer.serialize(maxH24Trades, "string", ""));
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
         }
 
-        // Query Params
-        if (minH24Buyers !== undefined) {
-            requestContext.setQueryParam("min_h24_buyers", ObjectSerializer.serialize(minH24Buyers, "string", ""));
+        if (requestParameters['sort'] != null) {
+            queryParameters['sort'] = requestParameters['sort'];
         }
 
-        // Query Params
-        if (maxH24Buyers !== undefined) {
-            requestContext.setQueryParam("max_h24_buyers", ObjectSerializer.serialize(maxH24Buyers, "string", ""));
+        if (requestParameters['sortBy'] != null) {
+            queryParameters['sortBy'] = requestParameters['sortBy'];
         }
 
-        // Query Params
-        if (minH24Sellers !== undefined) {
-            requestContext.setQueryParam("min_h24_sellers", ObjectSerializer.serialize(minH24Sellers, "string", ""));
+        if (requestParameters['minH24VolumeInUsd'] != null) {
+            queryParameters['min_h24_volume_in_usd'] = requestParameters['minH24VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH24Sellers !== undefined) {
-            requestContext.setQueryParam("max_h24_sellers", ObjectSerializer.serialize(maxH24Sellers, "string", ""));
+        if (requestParameters['maxH24VolumeInUsd'] != null) {
+            queryParameters['max_h24_volume_in_usd'] = requestParameters['maxH24VolumeInUsd'];
         }
 
-        // Query Params
-        if (minH24BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h24_buy_volume_in_usd", ObjectSerializer.serialize(minH24BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minH24PriceChangeRatio'] != null) {
+            queryParameters['min_h24_price_change_ratio'] = requestParameters['minH24PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxH24BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h24_buy_volume_in_usd", ObjectSerializer.serialize(maxH24BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxH24PriceChangeRatio'] != null) {
+            queryParameters['max_h24_price_change_ratio'] = requestParameters['maxH24PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minH24SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h24_sell_volume_in_usd", ObjectSerializer.serialize(minH24SellVolumeInUsd, "string", ""));
+        if (requestParameters['minH24Buys'] != null) {
+            queryParameters['min_h24_buys'] = requestParameters['minH24Buys'];
         }
 
-        // Query Params
-        if (maxH24SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h24_sell_volume_in_usd", ObjectSerializer.serialize(maxH24SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxH24Buys'] != null) {
+            queryParameters['max_h24_buys'] = requestParameters['maxH24Buys'];
         }
 
-        // Query Params
-        if (minH4VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h4_volume_in_usd", ObjectSerializer.serialize(minH4VolumeInUsd, "string", ""));
+        if (requestParameters['minH24Sells'] != null) {
+            queryParameters['min_h24_sells'] = requestParameters['minH24Sells'];
         }
 
-        // Query Params
-        if (maxH4VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h4_volume_in_usd", ObjectSerializer.serialize(maxH4VolumeInUsd, "string", ""));
+        if (requestParameters['maxH24Sells'] != null) {
+            queryParameters['max_h24_sells'] = requestParameters['maxH24Sells'];
         }
 
-        // Query Params
-        if (minH4PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_h4_price_change_ratio", ObjectSerializer.serialize(minH4PriceChangeRatio, "string", ""));
+        if (requestParameters['minH24Trades'] != null) {
+            queryParameters['min_h24_trades'] = requestParameters['minH24Trades'];
         }
 
-        // Query Params
-        if (maxH4PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_h4_price_change_ratio", ObjectSerializer.serialize(maxH4PriceChangeRatio, "string", ""));
+        if (requestParameters['maxH24Trades'] != null) {
+            queryParameters['max_h24_trades'] = requestParameters['maxH24Trades'];
         }
 
-        // Query Params
-        if (minH4Buys !== undefined) {
-            requestContext.setQueryParam("min_h4_buys", ObjectSerializer.serialize(minH4Buys, "string", ""));
+        if (requestParameters['minH24Buyers'] != null) {
+            queryParameters['min_h24_buyers'] = requestParameters['minH24Buyers'];
         }
 
-        // Query Params
-        if (maxH4Buys !== undefined) {
-            requestContext.setQueryParam("max_h4_buys", ObjectSerializer.serialize(maxH4Buys, "string", ""));
+        if (requestParameters['maxH24Buyers'] != null) {
+            queryParameters['max_h24_buyers'] = requestParameters['maxH24Buyers'];
         }
 
-        // Query Params
-        if (minH4Sells !== undefined) {
-            requestContext.setQueryParam("min_h4_sells", ObjectSerializer.serialize(minH4Sells, "string", ""));
+        if (requestParameters['minH24Sellers'] != null) {
+            queryParameters['min_h24_sellers'] = requestParameters['minH24Sellers'];
         }
 
-        // Query Params
-        if (maxH4Sells !== undefined) {
-            requestContext.setQueryParam("max_h4_sells", ObjectSerializer.serialize(maxH4Sells, "string", ""));
+        if (requestParameters['maxH24Sellers'] != null) {
+            queryParameters['max_h24_sellers'] = requestParameters['maxH24Sellers'];
         }
 
-        // Query Params
-        if (minH4Trades !== undefined) {
-            requestContext.setQueryParam("min_h4_trades", ObjectSerializer.serialize(minH4Trades, "string", ""));
+        if (requestParameters['minH24BuyVolumeInUsd'] != null) {
+            queryParameters['min_h24_buy_volume_in_usd'] = requestParameters['minH24BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH4Trades !== undefined) {
-            requestContext.setQueryParam("max_h4_trades", ObjectSerializer.serialize(maxH4Trades, "string", ""));
+        if (requestParameters['maxH24BuyVolumeInUsd'] != null) {
+            queryParameters['max_h24_buy_volume_in_usd'] = requestParameters['maxH24BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minH4Buyers !== undefined) {
-            requestContext.setQueryParam("min_h4_buyers", ObjectSerializer.serialize(minH4Buyers, "string", ""));
+        if (requestParameters['minH24SellVolumeInUsd'] != null) {
+            queryParameters['min_h24_sell_volume_in_usd'] = requestParameters['minH24SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH4Buyers !== undefined) {
-            requestContext.setQueryParam("max_h4_buyers", ObjectSerializer.serialize(maxH4Buyers, "string", ""));
+        if (requestParameters['maxH24SellVolumeInUsd'] != null) {
+            queryParameters['max_h24_sell_volume_in_usd'] = requestParameters['maxH24SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minH4Sellers !== undefined) {
-            requestContext.setQueryParam("min_h4_sellers", ObjectSerializer.serialize(minH4Sellers, "string", ""));
+        if (requestParameters['minH4VolumeInUsd'] != null) {
+            queryParameters['min_h4_volume_in_usd'] = requestParameters['minH4VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH4Sellers !== undefined) {
-            requestContext.setQueryParam("max_h4_sellers", ObjectSerializer.serialize(maxH4Sellers, "string", ""));
+        if (requestParameters['maxH4VolumeInUsd'] != null) {
+            queryParameters['max_h4_volume_in_usd'] = requestParameters['maxH4VolumeInUsd'];
         }
 
-        // Query Params
-        if (minH4BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h4_buy_volume_in_usd", ObjectSerializer.serialize(minH4BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minH4PriceChangeRatio'] != null) {
+            queryParameters['min_h4_price_change_ratio'] = requestParameters['minH4PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxH4BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h4_buy_volume_in_usd", ObjectSerializer.serialize(maxH4BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxH4PriceChangeRatio'] != null) {
+            queryParameters['max_h4_price_change_ratio'] = requestParameters['maxH4PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minH4SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h4_sell_volume_in_usd", ObjectSerializer.serialize(minH4SellVolumeInUsd, "string", ""));
+        if (requestParameters['minH4Buys'] != null) {
+            queryParameters['min_h4_buys'] = requestParameters['minH4Buys'];
         }
 
-        // Query Params
-        if (maxH4SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h4_sell_volume_in_usd", ObjectSerializer.serialize(maxH4SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxH4Buys'] != null) {
+            queryParameters['max_h4_buys'] = requestParameters['maxH4Buys'];
         }
 
-        // Query Params
-        if (minH1VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h1_volume_in_usd", ObjectSerializer.serialize(minH1VolumeInUsd, "string", ""));
+        if (requestParameters['minH4Sells'] != null) {
+            queryParameters['min_h4_sells'] = requestParameters['minH4Sells'];
         }
 
-        // Query Params
-        if (maxH1VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h1_volume_in_usd", ObjectSerializer.serialize(maxH1VolumeInUsd, "string", ""));
+        if (requestParameters['maxH4Sells'] != null) {
+            queryParameters['max_h4_sells'] = requestParameters['maxH4Sells'];
         }
 
-        // Query Params
-        if (minH1PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_h1_price_change_ratio", ObjectSerializer.serialize(minH1PriceChangeRatio, "string", ""));
+        if (requestParameters['minH4Trades'] != null) {
+            queryParameters['min_h4_trades'] = requestParameters['minH4Trades'];
         }
 
-        // Query Params
-        if (maxH1PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_h1_price_change_ratio", ObjectSerializer.serialize(maxH1PriceChangeRatio, "string", ""));
+        if (requestParameters['maxH4Trades'] != null) {
+            queryParameters['max_h4_trades'] = requestParameters['maxH4Trades'];
         }
 
-        // Query Params
-        if (minH1Buys !== undefined) {
-            requestContext.setQueryParam("min_h1_buys", ObjectSerializer.serialize(minH1Buys, "string", ""));
+        if (requestParameters['minH4Buyers'] != null) {
+            queryParameters['min_h4_buyers'] = requestParameters['minH4Buyers'];
         }
 
-        // Query Params
-        if (maxH1Buys !== undefined) {
-            requestContext.setQueryParam("max_h1_buys", ObjectSerializer.serialize(maxH1Buys, "string", ""));
+        if (requestParameters['maxH4Buyers'] != null) {
+            queryParameters['max_h4_buyers'] = requestParameters['maxH4Buyers'];
         }
 
-        // Query Params
-        if (minH1Sells !== undefined) {
-            requestContext.setQueryParam("min_h1_sells", ObjectSerializer.serialize(minH1Sells, "string", ""));
+        if (requestParameters['minH4Sellers'] != null) {
+            queryParameters['min_h4_sellers'] = requestParameters['minH4Sellers'];
         }
 
-        // Query Params
-        if (maxH1Sells !== undefined) {
-            requestContext.setQueryParam("max_h1_sells", ObjectSerializer.serialize(maxH1Sells, "string", ""));
+        if (requestParameters['maxH4Sellers'] != null) {
+            queryParameters['max_h4_sellers'] = requestParameters['maxH4Sellers'];
         }
 
-        // Query Params
-        if (minH1Trades !== undefined) {
-            requestContext.setQueryParam("min_h1_trades", ObjectSerializer.serialize(minH1Trades, "string", ""));
+        if (requestParameters['minH4BuyVolumeInUsd'] != null) {
+            queryParameters['min_h4_buy_volume_in_usd'] = requestParameters['minH4BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH1Trades !== undefined) {
-            requestContext.setQueryParam("max_h1_trades", ObjectSerializer.serialize(maxH1Trades, "string", ""));
+        if (requestParameters['maxH4BuyVolumeInUsd'] != null) {
+            queryParameters['max_h4_buy_volume_in_usd'] = requestParameters['maxH4BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minH1Buyers !== undefined) {
-            requestContext.setQueryParam("min_h1_buyers", ObjectSerializer.serialize(minH1Buyers, "string", ""));
+        if (requestParameters['minH4SellVolumeInUsd'] != null) {
+            queryParameters['min_h4_sell_volume_in_usd'] = requestParameters['minH4SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH1Buyers !== undefined) {
-            requestContext.setQueryParam("max_h1_buyers", ObjectSerializer.serialize(maxH1Buyers, "string", ""));
+        if (requestParameters['maxH4SellVolumeInUsd'] != null) {
+            queryParameters['max_h4_sell_volume_in_usd'] = requestParameters['maxH4SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minH1Sellers !== undefined) {
-            requestContext.setQueryParam("min_h1_sellers", ObjectSerializer.serialize(minH1Sellers, "string", ""));
+        if (requestParameters['minH1VolumeInUsd'] != null) {
+            queryParameters['min_h1_volume_in_usd'] = requestParameters['minH1VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxH1Sellers !== undefined) {
-            requestContext.setQueryParam("max_h1_sellers", ObjectSerializer.serialize(maxH1Sellers, "string", ""));
+        if (requestParameters['maxH1VolumeInUsd'] != null) {
+            queryParameters['max_h1_volume_in_usd'] = requestParameters['maxH1VolumeInUsd'];
         }
 
-        // Query Params
-        if (minH1BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h1_buy_volume_in_usd", ObjectSerializer.serialize(minH1BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minH1PriceChangeRatio'] != null) {
+            queryParameters['min_h1_price_change_ratio'] = requestParameters['minH1PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxH1BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h1_buy_volume_in_usd", ObjectSerializer.serialize(maxH1BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxH1PriceChangeRatio'] != null) {
+            queryParameters['max_h1_price_change_ratio'] = requestParameters['maxH1PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minH1SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_h1_sell_volume_in_usd", ObjectSerializer.serialize(minH1SellVolumeInUsd, "string", ""));
+        if (requestParameters['minH1Buys'] != null) {
+            queryParameters['min_h1_buys'] = requestParameters['minH1Buys'];
         }
 
-        // Query Params
-        if (maxH1SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_h1_sell_volume_in_usd", ObjectSerializer.serialize(maxH1SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxH1Buys'] != null) {
+            queryParameters['max_h1_buys'] = requestParameters['maxH1Buys'];
         }
 
-        // Query Params
-        if (minM30VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m30_volume_in_usd", ObjectSerializer.serialize(minM30VolumeInUsd, "string", ""));
+        if (requestParameters['minH1Sells'] != null) {
+            queryParameters['min_h1_sells'] = requestParameters['minH1Sells'];
         }
 
-        // Query Params
-        if (maxM30VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m30_volume_in_usd", ObjectSerializer.serialize(maxM30VolumeInUsd, "string", ""));
+        if (requestParameters['maxH1Sells'] != null) {
+            queryParameters['max_h1_sells'] = requestParameters['maxH1Sells'];
         }
 
-        // Query Params
-        if (minM30PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_m30_price_change_ratio", ObjectSerializer.serialize(minM30PriceChangeRatio, "string", ""));
+        if (requestParameters['minH1Trades'] != null) {
+            queryParameters['min_h1_trades'] = requestParameters['minH1Trades'];
         }
 
-        // Query Params
-        if (maxM30PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_m30_price_change_ratio", ObjectSerializer.serialize(maxM30PriceChangeRatio, "string", ""));
+        if (requestParameters['maxH1Trades'] != null) {
+            queryParameters['max_h1_trades'] = requestParameters['maxH1Trades'];
         }
 
-        // Query Params
-        if (minM30Buys !== undefined) {
-            requestContext.setQueryParam("min_m30_buys", ObjectSerializer.serialize(minM30Buys, "string", ""));
+        if (requestParameters['minH1Buyers'] != null) {
+            queryParameters['min_h1_buyers'] = requestParameters['minH1Buyers'];
         }
 
-        // Query Params
-        if (maxM30Buys !== undefined) {
-            requestContext.setQueryParam("max_m30_buys", ObjectSerializer.serialize(maxM30Buys, "string", ""));
+        if (requestParameters['maxH1Buyers'] != null) {
+            queryParameters['max_h1_buyers'] = requestParameters['maxH1Buyers'];
         }
 
-        // Query Params
-        if (minM30Sells !== undefined) {
-            requestContext.setQueryParam("min_m30_sells", ObjectSerializer.serialize(minM30Sells, "string", ""));
+        if (requestParameters['minH1Sellers'] != null) {
+            queryParameters['min_h1_sellers'] = requestParameters['minH1Sellers'];
         }
 
-        // Query Params
-        if (maxM30Sells !== undefined) {
-            requestContext.setQueryParam("max_m30_sells", ObjectSerializer.serialize(maxM30Sells, "string", ""));
+        if (requestParameters['maxH1Sellers'] != null) {
+            queryParameters['max_h1_sellers'] = requestParameters['maxH1Sellers'];
         }
 
-        // Query Params
-        if (minM30Trades !== undefined) {
-            requestContext.setQueryParam("min_m30_trades", ObjectSerializer.serialize(minM30Trades, "string", ""));
+        if (requestParameters['minH1BuyVolumeInUsd'] != null) {
+            queryParameters['min_h1_buy_volume_in_usd'] = requestParameters['minH1BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM30Trades !== undefined) {
-            requestContext.setQueryParam("max_m30_trades", ObjectSerializer.serialize(maxM30Trades, "string", ""));
+        if (requestParameters['maxH1BuyVolumeInUsd'] != null) {
+            queryParameters['max_h1_buy_volume_in_usd'] = requestParameters['maxH1BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM30Buyers !== undefined) {
-            requestContext.setQueryParam("min_m30_buyers", ObjectSerializer.serialize(minM30Buyers, "string", ""));
+        if (requestParameters['minH1SellVolumeInUsd'] != null) {
+            queryParameters['min_h1_sell_volume_in_usd'] = requestParameters['minH1SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM30Buyers !== undefined) {
-            requestContext.setQueryParam("max_m30_buyers", ObjectSerializer.serialize(maxM30Buyers, "string", ""));
+        if (requestParameters['maxH1SellVolumeInUsd'] != null) {
+            queryParameters['max_h1_sell_volume_in_usd'] = requestParameters['maxH1SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM30Sellers !== undefined) {
-            requestContext.setQueryParam("min_m30_sellers", ObjectSerializer.serialize(minM30Sellers, "string", ""));
+        if (requestParameters['minM30VolumeInUsd'] != null) {
+            queryParameters['min_m30_volume_in_usd'] = requestParameters['minM30VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM30Sellers !== undefined) {
-            requestContext.setQueryParam("max_m30_sellers", ObjectSerializer.serialize(maxM30Sellers, "string", ""));
+        if (requestParameters['maxM30VolumeInUsd'] != null) {
+            queryParameters['max_m30_volume_in_usd'] = requestParameters['maxM30VolumeInUsd'];
         }
 
-        // Query Params
-        if (minM30BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m30_buy_volume_in_usd", ObjectSerializer.serialize(minM30BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minM30PriceChangeRatio'] != null) {
+            queryParameters['min_m30_price_change_ratio'] = requestParameters['minM30PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxM30BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m30_buy_volume_in_usd", ObjectSerializer.serialize(maxM30BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxM30PriceChangeRatio'] != null) {
+            queryParameters['max_m30_price_change_ratio'] = requestParameters['maxM30PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minM30SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m30_sell_volume_in_usd", ObjectSerializer.serialize(minM30SellVolumeInUsd, "string", ""));
+        if (requestParameters['minM30Buys'] != null) {
+            queryParameters['min_m30_buys'] = requestParameters['minM30Buys'];
         }
 
-        // Query Params
-        if (maxM30SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m30_sell_volume_in_usd", ObjectSerializer.serialize(maxM30SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxM30Buys'] != null) {
+            queryParameters['max_m30_buys'] = requestParameters['maxM30Buys'];
         }
 
-        // Query Params
-        if (minM15VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m15_volume_in_usd", ObjectSerializer.serialize(minM15VolumeInUsd, "string", ""));
+        if (requestParameters['minM30Sells'] != null) {
+            queryParameters['min_m30_sells'] = requestParameters['minM30Sells'];
         }
 
-        // Query Params
-        if (maxM15VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m15_volume_in_usd", ObjectSerializer.serialize(maxM15VolumeInUsd, "string", ""));
+        if (requestParameters['maxM30Sells'] != null) {
+            queryParameters['max_m30_sells'] = requestParameters['maxM30Sells'];
         }
 
-        // Query Params
-        if (minM15PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_m15_price_change_ratio", ObjectSerializer.serialize(minM15PriceChangeRatio, "string", ""));
+        if (requestParameters['minM30Trades'] != null) {
+            queryParameters['min_m30_trades'] = requestParameters['minM30Trades'];
         }
 
-        // Query Params
-        if (maxM15PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_m15_price_change_ratio", ObjectSerializer.serialize(maxM15PriceChangeRatio, "string", ""));
+        if (requestParameters['maxM30Trades'] != null) {
+            queryParameters['max_m30_trades'] = requestParameters['maxM30Trades'];
         }
 
-        // Query Params
-        if (minM15Buys !== undefined) {
-            requestContext.setQueryParam("min_m15_buys", ObjectSerializer.serialize(minM15Buys, "string", ""));
+        if (requestParameters['minM30Buyers'] != null) {
+            queryParameters['min_m30_buyers'] = requestParameters['minM30Buyers'];
         }
 
-        // Query Params
-        if (maxM15Buys !== undefined) {
-            requestContext.setQueryParam("max_m15_buys", ObjectSerializer.serialize(maxM15Buys, "string", ""));
+        if (requestParameters['maxM30Buyers'] != null) {
+            queryParameters['max_m30_buyers'] = requestParameters['maxM30Buyers'];
         }
 
-        // Query Params
-        if (minM15Sells !== undefined) {
-            requestContext.setQueryParam("min_m15_sells", ObjectSerializer.serialize(minM15Sells, "string", ""));
+        if (requestParameters['minM30Sellers'] != null) {
+            queryParameters['min_m30_sellers'] = requestParameters['minM30Sellers'];
         }
 
-        // Query Params
-        if (maxM15Sells !== undefined) {
-            requestContext.setQueryParam("max_m15_sells", ObjectSerializer.serialize(maxM15Sells, "string", ""));
+        if (requestParameters['maxM30Sellers'] != null) {
+            queryParameters['max_m30_sellers'] = requestParameters['maxM30Sellers'];
         }
 
-        // Query Params
-        if (minM15Trades !== undefined) {
-            requestContext.setQueryParam("min_m15_trades", ObjectSerializer.serialize(minM15Trades, "string", ""));
+        if (requestParameters['minM30BuyVolumeInUsd'] != null) {
+            queryParameters['min_m30_buy_volume_in_usd'] = requestParameters['minM30BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM15Trades !== undefined) {
-            requestContext.setQueryParam("max_m15_trades", ObjectSerializer.serialize(maxM15Trades, "string", ""));
+        if (requestParameters['maxM30BuyVolumeInUsd'] != null) {
+            queryParameters['max_m30_buy_volume_in_usd'] = requestParameters['maxM30BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM15Buyers !== undefined) {
-            requestContext.setQueryParam("min_m15_buyers", ObjectSerializer.serialize(minM15Buyers, "string", ""));
+        if (requestParameters['minM30SellVolumeInUsd'] != null) {
+            queryParameters['min_m30_sell_volume_in_usd'] = requestParameters['minM30SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM15Buyers !== undefined) {
-            requestContext.setQueryParam("max_m15_buyers", ObjectSerializer.serialize(maxM15Buyers, "string", ""));
+        if (requestParameters['maxM30SellVolumeInUsd'] != null) {
+            queryParameters['max_m30_sell_volume_in_usd'] = requestParameters['maxM30SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM15Sellers !== undefined) {
-            requestContext.setQueryParam("min_m15_sellers", ObjectSerializer.serialize(minM15Sellers, "string", ""));
+        if (requestParameters['minM15VolumeInUsd'] != null) {
+            queryParameters['min_m15_volume_in_usd'] = requestParameters['minM15VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM15Sellers !== undefined) {
-            requestContext.setQueryParam("max_m15_sellers", ObjectSerializer.serialize(maxM15Sellers, "string", ""));
+        if (requestParameters['maxM15VolumeInUsd'] != null) {
+            queryParameters['max_m15_volume_in_usd'] = requestParameters['maxM15VolumeInUsd'];
         }
 
-        // Query Params
-        if (minM15BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m15_buy_volume_in_usd", ObjectSerializer.serialize(minM15BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minM15PriceChangeRatio'] != null) {
+            queryParameters['min_m15_price_change_ratio'] = requestParameters['minM15PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxM15BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m15_buy_volume_in_usd", ObjectSerializer.serialize(maxM15BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxM15PriceChangeRatio'] != null) {
+            queryParameters['max_m15_price_change_ratio'] = requestParameters['maxM15PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minM15SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m15_sell_volume_in_usd", ObjectSerializer.serialize(minM15SellVolumeInUsd, "string", ""));
+        if (requestParameters['minM15Buys'] != null) {
+            queryParameters['min_m15_buys'] = requestParameters['minM15Buys'];
         }
 
-        // Query Params
-        if (maxM15SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m15_sell_volume_in_usd", ObjectSerializer.serialize(maxM15SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxM15Buys'] != null) {
+            queryParameters['max_m15_buys'] = requestParameters['maxM15Buys'];
         }
 
-        // Query Params
-        if (minM5VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m5_volume_in_usd", ObjectSerializer.serialize(minM5VolumeInUsd, "string", ""));
+        if (requestParameters['minM15Sells'] != null) {
+            queryParameters['min_m15_sells'] = requestParameters['minM15Sells'];
         }
 
-        // Query Params
-        if (maxM5VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m5_volume_in_usd", ObjectSerializer.serialize(maxM5VolumeInUsd, "string", ""));
+        if (requestParameters['maxM15Sells'] != null) {
+            queryParameters['max_m15_sells'] = requestParameters['maxM15Sells'];
         }
 
-        // Query Params
-        if (minM5PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_m5_price_change_ratio", ObjectSerializer.serialize(minM5PriceChangeRatio, "string", ""));
+        if (requestParameters['minM15Trades'] != null) {
+            queryParameters['min_m15_trades'] = requestParameters['minM15Trades'];
         }
 
-        // Query Params
-        if (maxM5PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_m5_price_change_ratio", ObjectSerializer.serialize(maxM5PriceChangeRatio, "string", ""));
+        if (requestParameters['maxM15Trades'] != null) {
+            queryParameters['max_m15_trades'] = requestParameters['maxM15Trades'];
         }
 
-        // Query Params
-        if (minM5Buys !== undefined) {
-            requestContext.setQueryParam("min_m5_buys", ObjectSerializer.serialize(minM5Buys, "string", ""));
+        if (requestParameters['minM15Buyers'] != null) {
+            queryParameters['min_m15_buyers'] = requestParameters['minM15Buyers'];
         }
 
-        // Query Params
-        if (maxM5Buys !== undefined) {
-            requestContext.setQueryParam("max_m5_buys", ObjectSerializer.serialize(maxM5Buys, "string", ""));
+        if (requestParameters['maxM15Buyers'] != null) {
+            queryParameters['max_m15_buyers'] = requestParameters['maxM15Buyers'];
         }
 
-        // Query Params
-        if (minM5Sells !== undefined) {
-            requestContext.setQueryParam("min_m5_sells", ObjectSerializer.serialize(minM5Sells, "string", ""));
+        if (requestParameters['minM15Sellers'] != null) {
+            queryParameters['min_m15_sellers'] = requestParameters['minM15Sellers'];
         }
 
-        // Query Params
-        if (maxM5Sells !== undefined) {
-            requestContext.setQueryParam("max_m5_sells", ObjectSerializer.serialize(maxM5Sells, "string", ""));
+        if (requestParameters['maxM15Sellers'] != null) {
+            queryParameters['max_m15_sellers'] = requestParameters['maxM15Sellers'];
         }
 
-        // Query Params
-        if (minM5Trades !== undefined) {
-            requestContext.setQueryParam("min_m5_trades", ObjectSerializer.serialize(minM5Trades, "string", ""));
+        if (requestParameters['minM15BuyVolumeInUsd'] != null) {
+            queryParameters['min_m15_buy_volume_in_usd'] = requestParameters['minM15BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM5Trades !== undefined) {
-            requestContext.setQueryParam("max_m5_trades", ObjectSerializer.serialize(maxM5Trades, "string", ""));
+        if (requestParameters['maxM15BuyVolumeInUsd'] != null) {
+            queryParameters['max_m15_buy_volume_in_usd'] = requestParameters['maxM15BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM5Buyers !== undefined) {
-            requestContext.setQueryParam("min_m5_buyers", ObjectSerializer.serialize(minM5Buyers, "string", ""));
+        if (requestParameters['minM15SellVolumeInUsd'] != null) {
+            queryParameters['min_m15_sell_volume_in_usd'] = requestParameters['minM15SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM5Buyers !== undefined) {
-            requestContext.setQueryParam("max_m5_buyers", ObjectSerializer.serialize(maxM5Buyers, "string", ""));
+        if (requestParameters['maxM15SellVolumeInUsd'] != null) {
+            queryParameters['max_m15_sell_volume_in_usd'] = requestParameters['maxM15SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM5Sellers !== undefined) {
-            requestContext.setQueryParam("min_m5_sellers", ObjectSerializer.serialize(minM5Sellers, "string", ""));
+        if (requestParameters['minM5VolumeInUsd'] != null) {
+            queryParameters['min_m5_volume_in_usd'] = requestParameters['minM5VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM5Sellers !== undefined) {
-            requestContext.setQueryParam("max_m5_sellers", ObjectSerializer.serialize(maxM5Sellers, "string", ""));
+        if (requestParameters['maxM5VolumeInUsd'] != null) {
+            queryParameters['max_m5_volume_in_usd'] = requestParameters['maxM5VolumeInUsd'];
         }
 
-        // Query Params
-        if (minM5BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m5_buy_volume_in_usd", ObjectSerializer.serialize(minM5BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minM5PriceChangeRatio'] != null) {
+            queryParameters['min_m5_price_change_ratio'] = requestParameters['minM5PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxM5BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m5_buy_volume_in_usd", ObjectSerializer.serialize(maxM5BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxM5PriceChangeRatio'] != null) {
+            queryParameters['max_m5_price_change_ratio'] = requestParameters['maxM5PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minM5SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m5_sell_volume_in_usd", ObjectSerializer.serialize(minM5SellVolumeInUsd, "string", ""));
+        if (requestParameters['minM5Buys'] != null) {
+            queryParameters['min_m5_buys'] = requestParameters['minM5Buys'];
         }
 
-        // Query Params
-        if (maxM5SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m5_sell_volume_in_usd", ObjectSerializer.serialize(maxM5SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxM5Buys'] != null) {
+            queryParameters['max_m5_buys'] = requestParameters['maxM5Buys'];
         }
 
-        // Query Params
-        if (minM1VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m1_volume_in_usd", ObjectSerializer.serialize(minM1VolumeInUsd, "string", ""));
+        if (requestParameters['minM5Sells'] != null) {
+            queryParameters['min_m5_sells'] = requestParameters['minM5Sells'];
         }
 
-        // Query Params
-        if (maxM1VolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m1_volume_in_usd", ObjectSerializer.serialize(maxM1VolumeInUsd, "string", ""));
+        if (requestParameters['maxM5Sells'] != null) {
+            queryParameters['max_m5_sells'] = requestParameters['maxM5Sells'];
         }
 
-        // Query Params
-        if (minM1PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("min_m1_price_change_ratio", ObjectSerializer.serialize(minM1PriceChangeRatio, "string", ""));
+        if (requestParameters['minM5Trades'] != null) {
+            queryParameters['min_m5_trades'] = requestParameters['minM5Trades'];
         }
 
-        // Query Params
-        if (maxM1PriceChangeRatio !== undefined) {
-            requestContext.setQueryParam("max_m1_price_change_ratio", ObjectSerializer.serialize(maxM1PriceChangeRatio, "string", ""));
+        if (requestParameters['maxM5Trades'] != null) {
+            queryParameters['max_m5_trades'] = requestParameters['maxM5Trades'];
         }
 
-        // Query Params
-        if (minM1Buys !== undefined) {
-            requestContext.setQueryParam("min_m1_buys", ObjectSerializer.serialize(minM1Buys, "string", ""));
+        if (requestParameters['minM5Buyers'] != null) {
+            queryParameters['min_m5_buyers'] = requestParameters['minM5Buyers'];
         }
 
-        // Query Params
-        if (maxM1Buys !== undefined) {
-            requestContext.setQueryParam("max_m1_buys", ObjectSerializer.serialize(maxM1Buys, "string", ""));
+        if (requestParameters['maxM5Buyers'] != null) {
+            queryParameters['max_m5_buyers'] = requestParameters['maxM5Buyers'];
         }
 
-        // Query Params
-        if (minM1Sells !== undefined) {
-            requestContext.setQueryParam("min_m1_sells", ObjectSerializer.serialize(minM1Sells, "string", ""));
+        if (requestParameters['minM5Sellers'] != null) {
+            queryParameters['min_m5_sellers'] = requestParameters['minM5Sellers'];
         }
 
-        // Query Params
-        if (maxM1Sells !== undefined) {
-            requestContext.setQueryParam("max_m1_sells", ObjectSerializer.serialize(maxM1Sells, "string", ""));
+        if (requestParameters['maxM5Sellers'] != null) {
+            queryParameters['max_m5_sellers'] = requestParameters['maxM5Sellers'];
         }
 
-        // Query Params
-        if (minM1Trades !== undefined) {
-            requestContext.setQueryParam("min_m1_trades", ObjectSerializer.serialize(minM1Trades, "string", ""));
+        if (requestParameters['minM5BuyVolumeInUsd'] != null) {
+            queryParameters['min_m5_buy_volume_in_usd'] = requestParameters['minM5BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM1Trades !== undefined) {
-            requestContext.setQueryParam("max_m1_trades", ObjectSerializer.serialize(maxM1Trades, "string", ""));
+        if (requestParameters['maxM5BuyVolumeInUsd'] != null) {
+            queryParameters['max_m5_buy_volume_in_usd'] = requestParameters['maxM5BuyVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM1Buyers !== undefined) {
-            requestContext.setQueryParam("min_m1_buyers", ObjectSerializer.serialize(minM1Buyers, "string", ""));
+        if (requestParameters['minM5SellVolumeInUsd'] != null) {
+            queryParameters['min_m5_sell_volume_in_usd'] = requestParameters['minM5SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM1Buyers !== undefined) {
-            requestContext.setQueryParam("max_m1_buyers", ObjectSerializer.serialize(maxM1Buyers, "string", ""));
+        if (requestParameters['maxM5SellVolumeInUsd'] != null) {
+            queryParameters['max_m5_sell_volume_in_usd'] = requestParameters['maxM5SellVolumeInUsd'];
         }
 
-        // Query Params
-        if (minM1Sellers !== undefined) {
-            requestContext.setQueryParam("min_m1_sellers", ObjectSerializer.serialize(minM1Sellers, "string", ""));
+        if (requestParameters['minM1VolumeInUsd'] != null) {
+            queryParameters['min_m1_volume_in_usd'] = requestParameters['minM1VolumeInUsd'];
         }
 
-        // Query Params
-        if (maxM1Sellers !== undefined) {
-            requestContext.setQueryParam("max_m1_sellers", ObjectSerializer.serialize(maxM1Sellers, "string", ""));
+        if (requestParameters['maxM1VolumeInUsd'] != null) {
+            queryParameters['max_m1_volume_in_usd'] = requestParameters['maxM1VolumeInUsd'];
         }
 
-        // Query Params
-        if (minM1BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m1_buy_volume_in_usd", ObjectSerializer.serialize(minM1BuyVolumeInUsd, "string", ""));
+        if (requestParameters['minM1PriceChangeRatio'] != null) {
+            queryParameters['min_m1_price_change_ratio'] = requestParameters['minM1PriceChangeRatio'];
         }
 
-        // Query Params
-        if (maxM1BuyVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m1_buy_volume_in_usd", ObjectSerializer.serialize(maxM1BuyVolumeInUsd, "string", ""));
+        if (requestParameters['maxM1PriceChangeRatio'] != null) {
+            queryParameters['max_m1_price_change_ratio'] = requestParameters['maxM1PriceChangeRatio'];
         }
 
-        // Query Params
-        if (minM1SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("min_m1_sell_volume_in_usd", ObjectSerializer.serialize(minM1SellVolumeInUsd, "string", ""));
+        if (requestParameters['minM1Buys'] != null) {
+            queryParameters['min_m1_buys'] = requestParameters['minM1Buys'];
         }
 
-        // Query Params
-        if (maxM1SellVolumeInUsd !== undefined) {
-            requestContext.setQueryParam("max_m1_sell_volume_in_usd", ObjectSerializer.serialize(maxM1SellVolumeInUsd, "string", ""));
+        if (requestParameters['maxM1Buys'] != null) {
+            queryParameters['max_m1_buys'] = requestParameters['maxM1Buys'];
         }
 
-
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+        if (requestParameters['minM1Sells'] != null) {
+            queryParameters['min_m1_sells'] = requestParameters['minM1Sells'];
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
+        if (requestParameters['maxM1Sells'] != null) {
+            queryParameters['max_m1_sells'] = requestParameters['maxM1Sells'];
         }
 
-        return requestContext;
-    }
-
-    /**
-     * CONTROLLER.TOKEN.GET_TOKENS.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_TOKENS.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddresses GLOBAL.TOKENADDRESSES.DESCRIPTION
-     * @param sortBy DTO.TOKEN.REQUEST.SORT_BY
-     * @param sortDirection DTO.TOKEN.REQUEST.SORT_DIRECTION
-     * @param filterBy DTO.TOKEN.REQUEST.FILTER_BY
-     */
-    public async getTokens(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddresses: string, sortBy?: 'marketData.priceInUsd' | 'stats.priceChangeRatioInUsd1m' | 'stats.priceChangeRatioInUsd5m' | 'stats.priceChangeRatioInUsd1h' | 'stats.priceChangeRatioInUsd4h' | 'stats.priceChangeRatioInUsd24h' | 'marketData.marketCapInUsd' | 'marketData.tvlInUsd' | 'marketData.top10TotalHoldings' | 'marketData.top10HoldingsRatio' | 'marketData.top100TotalHoldings' | 'marketData.top100HoldingsRatio' | 'marketData.holders' | 'marketData.creatorHoldings' | 'marketData.creatorHoldingsRatio' | 'stats.buys1m' | 'stats.buys5m' | 'stats.buys15m' | 'stats.buys30m' | 'stats.buys1h' | 'stats.buys4h' | 'stats.buys24h' | 'stats.sells1m' | 'stats.sells5m' | 'stats.sells15m' | 'stats.sells30m' | 'stats.sells1h' | 'stats.sells4h' | 'stats.sells24h' | 'stats.trades1m' | 'stats.trades5m' | 'stats.trades1h' | 'stats.trades4h' | 'stats.trades24h' | 'stats.traders1m' | 'stats.traders5m' | 'stats.traders1h' | 'stats.traders4h' | 'stats.traders24h' | 'stats.volumesInUsd1m' | 'stats.volumesInUsd5m' | 'stats.volumesInUsd1h' | 'stats.volumesInUsd4h' | 'stats.volumesInUsd24h' | 'tokenCreatedAt', sortDirection?: 'ASC' | 'DESC', filterBy?: Array<FilterCondition>, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getTokens", "chain");
+        if (requestParameters['minM1Trades'] != null) {
+            queryParameters['min_m1_trades'] = requestParameters['minM1Trades'];
         }
 
-
-        // verify required parameter 'tokenAddresses' is not null or undefined
-        if (tokenAddresses === null || tokenAddresses === undefined) {
-            throw new RequiredError("TokenApi", "getTokens", "tokenAddresses");
+        if (requestParameters['maxM1Trades'] != null) {
+            queryParameters['max_m1_trades'] = requestParameters['maxM1Trades'];
         }
 
-
-
-
-
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/multi'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
-
-        // Query Params
-        if (tokenAddresses !== undefined) {
-            requestContext.setQueryParam("tokenAddresses", ObjectSerializer.serialize(tokenAddresses, "string", ""));
+        if (requestParameters['minM1Buyers'] != null) {
+            queryParameters['min_m1_buyers'] = requestParameters['minM1Buyers'];
         }
 
-        // Query Params
-        if (sortBy !== undefined) {
-            requestContext.setQueryParam("sortBy", ObjectSerializer.serialize(sortBy, "'marketData.priceInUsd' | 'stats.priceChangeRatioInUsd1m' | 'stats.priceChangeRatioInUsd5m' | 'stats.priceChangeRatioInUsd1h' | 'stats.priceChangeRatioInUsd4h' | 'stats.priceChangeRatioInUsd24h' | 'marketData.marketCapInUsd' | 'marketData.tvlInUsd' | 'marketData.top10TotalHoldings' | 'marketData.top10HoldingsRatio' | 'marketData.top100TotalHoldings' | 'marketData.top100HoldingsRatio' | 'marketData.holders' | 'marketData.creatorHoldings' | 'marketData.creatorHoldingsRatio' | 'stats.buys1m' | 'stats.buys5m' | 'stats.buys15m' | 'stats.buys30m' | 'stats.buys1h' | 'stats.buys4h' | 'stats.buys24h' | 'stats.sells1m' | 'stats.sells5m' | 'stats.sells15m' | 'stats.sells30m' | 'stats.sells1h' | 'stats.sells4h' | 'stats.sells24h' | 'stats.trades1m' | 'stats.trades5m' | 'stats.trades1h' | 'stats.trades4h' | 'stats.trades24h' | 'stats.traders1m' | 'stats.traders5m' | 'stats.traders1h' | 'stats.traders4h' | 'stats.traders24h' | 'stats.volumesInUsd1m' | 'stats.volumesInUsd5m' | 'stats.volumesInUsd1h' | 'stats.volumesInUsd4h' | 'stats.volumesInUsd24h' | 'tokenCreatedAt'", ""));
+        if (requestParameters['maxM1Buyers'] != null) {
+            queryParameters['max_m1_buyers'] = requestParameters['maxM1Buyers'];
         }
 
-        // Query Params
-        if (sortDirection !== undefined) {
-            requestContext.setQueryParam("sortDirection", ObjectSerializer.serialize(sortDirection, "'ASC' | 'DESC'", ""));
+        if (requestParameters['minM1Sellers'] != null) {
+            queryParameters['min_m1_sellers'] = requestParameters['minM1Sellers'];
         }
 
-        // Query Params
-        if (filterBy !== undefined) {
-            const serializedParams = ObjectSerializer.serialize(filterBy, "Array<FilterCondition>", "");
-            for (const serializedParam of serializedParams) {
-                requestContext.appendQueryParam("filterBy", serializedParam);
-            }
+        if (requestParameters['maxM1Sellers'] != null) {
+            queryParameters['max_m1_sellers'] = requestParameters['maxM1Sellers'];
         }
 
-
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
+        if (requestParameters['minM1BuyVolumeInUsd'] != null) {
+            queryParameters['min_m1_buy_volume_in_usd'] = requestParameters['minM1BuyVolumeInUsd'];
         }
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
+        if (requestParameters['maxM1BuyVolumeInUsd'] != null) {
+            queryParameters['max_m1_buy_volume_in_usd'] = requestParameters['maxM1BuyVolumeInUsd'];
         }
 
-        return requestContext;
-    }
-
-    /**
-     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.DESCRIPTION
-     * CONTROLLER.TOKEN.GET_TOP_HOLDERS.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
-     */
-    public async getTopHolders(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'chain' is not null or undefined
-        if (chain === null || chain === undefined) {
-            throw new RequiredError("TokenApi", "getTopHolders", "chain");
+        if (requestParameters['minM1SellVolumeInUsd'] != null) {
+            queryParameters['min_m1_sell_volume_in_usd'] = requestParameters['minM1SellVolumeInUsd'];
         }
 
-
-        // verify required parameter 'tokenAddress' is not null or undefined
-        if (tokenAddress === null || tokenAddress === undefined) {
-            throw new RequiredError("TokenApi", "getTopHolders", "tokenAddress");
+        if (requestParameters['maxM1SellVolumeInUsd'] != null) {
+            queryParameters['max_m1_sell_volume_in_usd'] = requestParameters['maxM1SellVolumeInUsd'];
         }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Path Params
-        const localVarPath = '/v1/token/{chain}/{tokenAddress}/topHolders'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
-            .replace('{' + 'tokenAddress' + '}', encodeURIComponent(String(tokenAddress)));
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
+        let urlPath = `/v1/token/{chain}/list`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenListPageFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.TOKEN.GET_TOKEN_LIST.DESCRIPTION
+     * CONTROLLER.TOKEN.GET_TOKEN_LIST.SUMMARY
+     */
+    async listToken(requestParameters: ListTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenListPage> {
+        const response = await this.listTokenRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.TOKEN.SEARCH.DESCRIPTION
      * CONTROLLER.TOKEN.SEARCH.SUMMARY
-     * @param chains DTO.TOKEN.SEARCH.CHAINS
-     * @param q DTO.TOKEN.SEARCH.QUERY
-     * @param limit DTO.TOKEN.SEARCH.LIMIT
-     * @param sort DTO.TOKEN.SEARCH.SORT_DIRECTION
-     * @param protocols DTO.TOKEN.SEARCH.PROTOCOLS
-     * @param cursor DTO.PAGE.CURSOR
-     * @param sortBy DTO.TOKEN.SEARCH.SORT_BY
      */
-    public async search(chains?: Array<string>, q?: string, limit?: number, sort?: 'asc' | 'desc', protocols?: Array<string>, cursor?: string, sortBy?: 'marketCapInUsd' | 'liquidityInUsd' | 'priceInUsd' | 'holderCount' | 'h24VolumeInUsd' | 'h24Transactions' | 'tokenCreatedAt', _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-
-
-
-
-
-
-
-        // Path Params
-        const localVarPath = '/v1/token/search';
-
-        // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
-        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
-        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
-        requestContext.setHeaderParam("x-req-id", randomId.toString())
-
+    async searchRaw(requestParameters: SearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenPage>> {
+        const queryParameters: any = {};
 
-        // Query Params
-        if (chains !== undefined) {
-            const serializedParams = ObjectSerializer.serialize(chains, "Array<string>", "");
-            for (const serializedParam of serializedParams) {
-                requestContext.appendQueryParam("chains", serializedParam);
-            }
+        if (requestParameters['chains'] != null) {
+            queryParameters['chains'] = requestParameters['chains'];
         }
 
-        // Query Params
-        if (q !== undefined) {
-            requestContext.setQueryParam("q", ObjectSerializer.serialize(q, "string", ""));
+        if (requestParameters['q'] != null) {
+            queryParameters['q'] = requestParameters['q'];
         }
 
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        // Query Params
-        if (sort !== undefined) {
-            requestContext.setQueryParam("sort", ObjectSerializer.serialize(sort, "'asc' | 'desc'", ""));
+        if (requestParameters['sort'] != null) {
+            queryParameters['sort'] = requestParameters['sort'];
         }
 
-        // Query Params
-        if (protocols !== undefined) {
-            const serializedParams = ObjectSerializer.serialize(protocols, "Array<string>", "");
-            for (const serializedParam of serializedParams) {
-                requestContext.appendQueryParam("protocols", serializedParam);
-            }
+        if (requestParameters['protocols'] != null) {
+            queryParameters['protocols'] = requestParameters['protocols'];
         }
 
-        // Query Params
-        if (cursor !== undefined) {
-            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
-        // Query Params
-        if (sortBy !== undefined) {
-            requestContext.setQueryParam("sortBy", ObjectSerializer.serialize(sortBy, "'marketCapInUsd' | 'liquidityInUsd' | 'priceInUsd' | 'holderCount' | 'h24VolumeInUsd' | 'h24Transactions' | 'tokenCreatedAt'", ""));
+        if (requestParameters['sortBy'] != null) {
+            queryParameters['sortBy'] = requestParameters['sortBy'];
         }
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        let authMethod: SecurityAuthentication | undefined;
-        // Apply auth methods
-        authMethod = _config.authMethods["bearer"]
-        if (authMethod?.applySecurityAuthentication) {
-            await authMethod?.applySecurityAuthentication(requestContext);
-        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
-        if (defaultAuth?.applySecurityAuthentication) {
-            await defaultAuth?.applySecurityAuthentication(requestContext);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
-        return requestContext;
-    }
-
-}
-
-export class TokenApiResponseProcessor {
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getCandles
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getCandlesWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<Candle> >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: Array<Candle> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<Candle>", ""
-            ) as Array<Candle>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: Array<Candle> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<Candle>", ""
-            ) as Array<Candle>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getCreation
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getCreationWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenCreationDTO >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenCreationDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenCreationDTO", ""
-            ) as TokenCreationDTO;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenCreationDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenCreationDTO", ""
-            ) as TokenCreationDTO;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getHolders
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getHoldersWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenHolderPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenHolderPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenHolderPage", ""
-            ) as TokenHolderPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenHolderPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenHolderPage", ""
-            ) as TokenHolderPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getHoldersMulti
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getHoldersMultiWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<TokenHolder> >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: Array<TokenHolder> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<TokenHolder>", ""
-            ) as Array<TokenHolder>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: Array<TokenHolder> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<TokenHolder>", ""
-            ) as Array<TokenHolder>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getMarketData
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getMarketDataWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenMarketData >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenMarketData = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenMarketData", ""
-            ) as TokenMarketData;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenMarketData = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenMarketData", ""
-            ) as TokenMarketData;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getMarketDataMulti
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getMarketDataMultiWithHttpInfo(response: ResponseContext): Promise<HttpInfo<{ [key: string]: TokenMarketData; } >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: { [key: string]: TokenMarketData; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenMarketData; }", ""
-            ) as { [key: string]: TokenMarketData; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: { [key: string]: TokenMarketData; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenMarketData; }", ""
-            ) as { [key: string]: TokenMarketData; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getMetadata
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getMetadataWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenMetadata >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenMetadata = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenMetadata", ""
-            ) as TokenMetadata;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenMetadata = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenMetadata", ""
-            ) as TokenMetadata;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getMetadataMulti
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getMetadataMultiWithHttpInfo(response: ResponseContext): Promise<HttpInfo<{ [key: string]: TokenMetadata; } >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: { [key: string]: TokenMetadata; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenMetadata; }", ""
-            ) as { [key: string]: TokenMetadata; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: { [key: string]: TokenMetadata; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenMetadata; }", ""
-            ) as { [key: string]: TokenMetadata; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getMintAndBurn
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getMintAndBurnWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenCreationPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenCreationPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenCreationPage", ""
-            ) as TokenCreationPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenCreationPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenCreationPage", ""
-            ) as TokenCreationPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getPools
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getPoolsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<DexPoolDTO> >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: Array<DexPoolDTO> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<DexPoolDTO>", ""
-            ) as Array<DexPoolDTO>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: Array<DexPoolDTO> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<DexPoolDTO>", ""
-            ) as Array<DexPoolDTO>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getPriceByTime
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getPriceByTimeWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenPriceDTO >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenPriceDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPriceDTO", ""
-            ) as TokenPriceDTO;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenPriceDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPriceDTO", ""
-            ) as TokenPriceDTO;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getPrices
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getPricesWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenPricePage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenPricePage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPricePage", ""
-            ) as TokenPricePage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenPricePage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPricePage", ""
-            ) as TokenPricePage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getSecurity
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getSecurityWithHttpInfo(response: ResponseContext): Promise<HttpInfo<any >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: any = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "any", ""
-            ) as any;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: any = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "any", ""
-            ) as any;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getStats
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getStatsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenStat >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenStat = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenStat", ""
-            ) as TokenStat;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenStat = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenStat", ""
-            ) as TokenStat;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getStatsMulti
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getStatsMultiWithHttpInfo(response: ResponseContext): Promise<HttpInfo<{ [key: string]: TokenStat; } >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: { [key: string]: TokenStat; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenStat; }", ""
-            ) as { [key: string]: TokenStat; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: { [key: string]: TokenStat; } = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "{ [key: string]: TokenStat; }", ""
-            ) as { [key: string]: TokenStat; };
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getToken
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getTokenWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Token >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: Token = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Token", ""
-            ) as Token;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: Token = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Token", ""
-            ) as Token;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
-
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getTokenList
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getTokenListWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenListPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenListPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenListPage", ""
-            ) as TokenListPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenListPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenListPage", ""
-            ) as TokenListPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
+        let urlPath = `/v1/token/search`;
 
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getTokens
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getTokensWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<Token> >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: Array<Token> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<Token>", ""
-            ) as Array<Token>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: Array<Token> = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "Array<Token>", ""
-            ) as Array<Token>;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
-    }
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-    /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to getTopHolders
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getTopHoldersWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenHolderPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenHolderPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenHolderPage", ""
-            ) as TokenHolderPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenHolderPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenHolderPage", ""
-            ) as TokenHolderPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenPageFromJSON(jsonValue));
     }
 
     /**
-     * Unwraps the actual response sent by the server from the response context and deserializes the response content
-     * to the expected objects
-     *
-     * @params response Response returned by the server for a request to search
-     * @throws ApiException if the response code was not in [200, 299]
+     * CONTROLLER.TOKEN.SEARCH.DESCRIPTION
+     * CONTROLLER.TOKEN.SEARCH.SUMMARY
      */
-     public async searchWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TokenPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: TokenPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPage", ""
-            ) as TokenPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-
-        // Work around for missing responses in specification, e.g. for petstore.yaml
-        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-            const body: TokenPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "TokenPage", ""
-            ) as TokenPage;
-            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
-        }
-        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    async search(requestParameters: SearchRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenPage> {
+        const response = await this.searchRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }
+
+/**
+ * @export
+ */
+export const GetCandlesChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetCandlesChainEnum = typeof GetCandlesChainEnum[keyof typeof GetCandlesChainEnum];
+/**
+ * @export
+ */
+export const GetCreationChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetCreationChainEnum = typeof GetCreationChainEnum[keyof typeof GetCreationChainEnum];
+/**
+ * @export
+ */
+export const GetHoldersChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetHoldersChainEnum = typeof GetHoldersChainEnum[keyof typeof GetHoldersChainEnum];
+/**
+ * @export
+ */
+export const GetHoldersDirectionEnum = {
+    Next: 'next',
+    Prev: 'prev'
+} as const;
+export type GetHoldersDirectionEnum = typeof GetHoldersDirectionEnum[keyof typeof GetHoldersDirectionEnum];
+/**
+ * @export
+ */
+export const GetHoldersMultiChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetHoldersMultiChainEnum = typeof GetHoldersMultiChainEnum[keyof typeof GetHoldersMultiChainEnum];
+/**
+ * @export
+ */
+export const GetMarketDataChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetMarketDataChainEnum = typeof GetMarketDataChainEnum[keyof typeof GetMarketDataChainEnum];
+/**
+ * @export
+ */
+export const GetMarketDataMultiChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetMarketDataMultiChainEnum = typeof GetMarketDataMultiChainEnum[keyof typeof GetMarketDataMultiChainEnum];
+/**
+ * @export
+ */
+export const GetMetadataChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetMetadataChainEnum = typeof GetMetadataChainEnum[keyof typeof GetMetadataChainEnum];
+/**
+ * @export
+ */
+export const GetMetadataMultiChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetMetadataMultiChainEnum = typeof GetMetadataMultiChainEnum[keyof typeof GetMetadataMultiChainEnum];
+/**
+ * @export
+ */
+export const GetMintAndBurnChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetMintAndBurnChainEnum = typeof GetMintAndBurnChainEnum[keyof typeof GetMintAndBurnChainEnum];
+/**
+ * @export
+ */
+export const GetMintAndBurnDirectionEnum = {
+    Next: 'next',
+    Prev: 'prev'
+} as const;
+export type GetMintAndBurnDirectionEnum = typeof GetMintAndBurnDirectionEnum[keyof typeof GetMintAndBurnDirectionEnum];
+/**
+ * @export
+ */
+export const GetMintAndBurnTypeEnum = {
+    All: 'all',
+    Mint: 'mint',
+    Burn: 'burn'
+} as const;
+export type GetMintAndBurnTypeEnum = typeof GetMintAndBurnTypeEnum[keyof typeof GetMintAndBurnTypeEnum];
+/**
+ * @export
+ */
+export const GetPoolsChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetPoolsChainEnum = typeof GetPoolsChainEnum[keyof typeof GetPoolsChainEnum];
+/**
+ * @export
+ */
+export const GetPriceByTimeChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetPriceByTimeChainEnum = typeof GetPriceByTimeChainEnum[keyof typeof GetPriceByTimeChainEnum];
+/**
+ * @export
+ */
+export const GetPricesChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetPricesChainEnum = typeof GetPricesChainEnum[keyof typeof GetPricesChainEnum];
+/**
+ * @export
+ */
+export const GetPricesDirectionEnum = {
+    Next: 'next',
+    Prev: 'prev'
+} as const;
+export type GetPricesDirectionEnum = typeof GetPricesDirectionEnum[keyof typeof GetPricesDirectionEnum];
+/**
+ * @export
+ */
+export const GetSecurityChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetSecurityChainEnum = typeof GetSecurityChainEnum[keyof typeof GetSecurityChainEnum];
+/**
+ * @export
+ */
+export const GetStatsChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetStatsChainEnum = typeof GetStatsChainEnum[keyof typeof GetStatsChainEnum];
+/**
+ * @export
+ */
+export const GetStatsMultiChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetStatsMultiChainEnum = typeof GetStatsMultiChainEnum[keyof typeof GetStatsMultiChainEnum];
+/**
+ * @export
+ */
+export const GetTokenChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetTokenChainEnum = typeof GetTokenChainEnum[keyof typeof GetTokenChainEnum];
+/**
+ * @export
+ */
+export const GetTokensChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetTokensChainEnum = typeof GetTokensChainEnum[keyof typeof GetTokensChainEnum];
+/**
+ * @export
+ */
+export const GetTokensSortByEnum = {
+    MarketDataPriceInUsd: 'marketData.priceInUsd',
+    StatsPriceChangeRatioInUsd1m: 'stats.priceChangeRatioInUsd1m',
+    StatsPriceChangeRatioInUsd5m: 'stats.priceChangeRatioInUsd5m',
+    StatsPriceChangeRatioInUsd1h: 'stats.priceChangeRatioInUsd1h',
+    StatsPriceChangeRatioInUsd4h: 'stats.priceChangeRatioInUsd4h',
+    StatsPriceChangeRatioInUsd24h: 'stats.priceChangeRatioInUsd24h',
+    MarketDataMarketCapInUsd: 'marketData.marketCapInUsd',
+    MarketDataTvlInUsd: 'marketData.tvlInUsd',
+    MarketDataTop10TotalHoldings: 'marketData.top10TotalHoldings',
+    MarketDataTop10HoldingsRatio: 'marketData.top10HoldingsRatio',
+    MarketDataTop100TotalHoldings: 'marketData.top100TotalHoldings',
+    MarketDataTop100HoldingsRatio: 'marketData.top100HoldingsRatio',
+    MarketDataHolders: 'marketData.holders',
+    MarketDataCreatorHoldings: 'marketData.creatorHoldings',
+    MarketDataCreatorHoldingsRatio: 'marketData.creatorHoldingsRatio',
+    StatsBuys1m: 'stats.buys1m',
+    StatsBuys5m: 'stats.buys5m',
+    StatsBuys15m: 'stats.buys15m',
+    StatsBuys30m: 'stats.buys30m',
+    StatsBuys1h: 'stats.buys1h',
+    StatsBuys4h: 'stats.buys4h',
+    StatsBuys24h: 'stats.buys24h',
+    StatsSells1m: 'stats.sells1m',
+    StatsSells5m: 'stats.sells5m',
+    StatsSells15m: 'stats.sells15m',
+    StatsSells30m: 'stats.sells30m',
+    StatsSells1h: 'stats.sells1h',
+    StatsSells4h: 'stats.sells4h',
+    StatsSells24h: 'stats.sells24h',
+    StatsTrades1m: 'stats.trades1m',
+    StatsTrades5m: 'stats.trades5m',
+    StatsTrades1h: 'stats.trades1h',
+    StatsTrades4h: 'stats.trades4h',
+    StatsTrades24h: 'stats.trades24h',
+    StatsTraders1m: 'stats.traders1m',
+    StatsTraders5m: 'stats.traders5m',
+    StatsTraders1h: 'stats.traders1h',
+    StatsTraders4h: 'stats.traders4h',
+    StatsTraders24h: 'stats.traders24h',
+    StatsVolumesInUsd1m: 'stats.volumesInUsd1m',
+    StatsVolumesInUsd5m: 'stats.volumesInUsd5m',
+    StatsVolumesInUsd1h: 'stats.volumesInUsd1h',
+    StatsVolumesInUsd4h: 'stats.volumesInUsd4h',
+    StatsVolumesInUsd24h: 'stats.volumesInUsd24h',
+    TokenCreatedAt: 'tokenCreatedAt'
+} as const;
+export type GetTokensSortByEnum = typeof GetTokensSortByEnum[keyof typeof GetTokensSortByEnum];
+/**
+ * @export
+ */
+export const GetTokensSortDirectionEnum = {
+    Asc: 'ASC',
+    Desc: 'DESC'
+} as const;
+export type GetTokensSortDirectionEnum = typeof GetTokensSortDirectionEnum[keyof typeof GetTokensSortDirectionEnum];
+/**
+ * @export
+ */
+export const GetTopHoldersChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetTopHoldersChainEnum = typeof GetTopHoldersChainEnum[keyof typeof GetTopHoldersChainEnum];
+/**
+ * @export
+ */
+export const ListTokenChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type ListTokenChainEnum = typeof ListTokenChainEnum[keyof typeof ListTokenChainEnum];
+/**
+ * @export
+ */
+export const ListTokenDirectionEnum = {
+    Next: 'next',
+    Prev: 'prev'
+} as const;
+export type ListTokenDirectionEnum = typeof ListTokenDirectionEnum[keyof typeof ListTokenDirectionEnum];
+/**
+ * @export
+ */
+export const ListTokenSortEnum = {
+    Asc: 'asc',
+    Desc: 'desc'
+} as const;
+export type ListTokenSortEnum = typeof ListTokenSortEnum[keyof typeof ListTokenSortEnum];
+/**
+ * @export
+ */
+export const ListTokenSortByEnum = {
+    H24VolumeInUsd: 'h24VolumeInUsd',
+    H24PriceChangeRatio: 'h24PriceChangeRatio',
+    H24Buys: 'h24Buys',
+    H24Sells: 'h24Sells',
+    H24Trades: 'h24Trades',
+    H24Buyers: 'h24Buyers',
+    H24Sellers: 'h24Sellers',
+    H24BuyVolumeInUsd: 'h24BuyVolumeInUsd',
+    H24SellVolumeInUsd: 'h24SellVolumeInUsd',
+    H4VolumeInUsd: 'h4VolumeInUsd',
+    H4PriceChangeRatio: 'h4PriceChangeRatio',
+    H4Buys: 'h4Buys',
+    H4Sells: 'h4Sells',
+    H4Trades: 'h4Trades',
+    H4Buyers: 'h4Buyers',
+    H4Sellers: 'h4Sellers',
+    H4BuyVolumeInUsd: 'h4BuyVolumeInUsd',
+    H4SellVolumeInUsd: 'h4SellVolumeInUsd',
+    H1VolumeInUsd: 'h1VolumeInUsd',
+    H1PriceChangeRatio: 'h1PriceChangeRatio',
+    H1Buys: 'h1Buys',
+    H1Sells: 'h1Sells',
+    H1Trades: 'h1Trades',
+    H1Buyers: 'h1Buyers',
+    H1Sellers: 'h1Sellers',
+    H1BuyVolumeInUsd: 'h1BuyVolumeInUsd',
+    H1SellVolumeInUsd: 'h1SellVolumeInUsd',
+    M30VolumeInUsd: 'm30VolumeInUsd',
+    M30PriceChangeRatio: 'm30PriceChangeRatio',
+    M30Buys: 'm30Buys',
+    M30Sells: 'm30Sells',
+    M30Trades: 'm30Trades',
+    M30Buyers: 'm30Buyers',
+    M30Sellers: 'm30Sellers',
+    M30BuyVolumeInUsd: 'm30BuyVolumeInUsd',
+    M30SellVolumeInUsd: 'm30SellVolumeInUsd',
+    M15VolumeInUsd: 'm15VolumeInUsd',
+    M15PriceChangeRatio: 'm15PriceChangeRatio',
+    M15Buys: 'm15Buys',
+    M15Sells: 'm15Sells',
+    M15Trades: 'm15Trades',
+    M15Buyers: 'm15Buyers',
+    M15Sellers: 'm15Sellers',
+    M15BuyVolumeInUsd: 'm15BuyVolumeInUsd',
+    M15SellVolumeInUsd: 'm15SellVolumeInUsd',
+    M5VolumeInUsd: 'm5VolumeInUsd',
+    M5PriceChangeRatio: 'm5PriceChangeRatio',
+    M5Buys: 'm5Buys',
+    M5Sells: 'm5Sells',
+    M5Trades: 'm5Trades',
+    M5Buyers: 'm5Buyers',
+    M5Sellers: 'm5Sellers',
+    M5BuyVolumeInUsd: 'm5BuyVolumeInUsd',
+    M5SellVolumeInUsd: 'm5SellVolumeInUsd',
+    M1VolumeInUsd: 'm1VolumeInUsd',
+    M1PriceChangeRatio: 'm1PriceChangeRatio',
+    M1Buys: 'm1Buys',
+    M1Sells: 'm1Sells',
+    M1Trades: 'm1Trades',
+    M1Buyers: 'm1Buyers',
+    M1Sellers: 'm1Sellers',
+    M1BuyVolumeInUsd: 'm1BuyVolumeInUsd',
+    M1SellVolumeInUsd: 'm1SellVolumeInUsd'
+} as const;
+export type ListTokenSortByEnum = typeof ListTokenSortByEnum[keyof typeof ListTokenSortByEnum];
+/**
+ * @export
+ */
+export const SearchSortEnum = {
+    Asc: 'asc',
+    Desc: 'desc'
+} as const;
+export type SearchSortEnum = typeof SearchSortEnum[keyof typeof SearchSortEnum];
+/**
+ * @export
+ */
+export const SearchSortByEnum = {
+    MarketCapInUsd: 'marketCapInUsd',
+    LiquidityInUsd: 'liquidityInUsd',
+    PriceInUsd: 'priceInUsd',
+    HolderCount: 'holderCount',
+    H24VolumeInUsd: 'h24VolumeInUsd',
+    H24Transactions: 'h24Transactions',
+    TokenCreatedAt: 'tokenCreatedAt'
+} as const;
+export type SearchSortByEnum = typeof SearchSortByEnum[keyof typeof SearchSortByEnum];