@chainstream-io/sdk 0.0.5 → 0.0.7

package/src/openapi/apis/DexApi.ts

@@ -8,9 +8,9 @@ import {canConsumeForm, isCodeInRange} from '../util';
 import {SecurityAuthentication} from '../auth/auth';
 
 
-import { DexMintInput } from '../models/DexMintInput';
+import { CreateTokenReply } from '../models/CreateTokenReply';
+import { DexCreateTokenInput } from '../models/DexCreateTokenInput';
 import { DexPage } from '../models/DexPage';
-import { MintReply } from '../models/MintReply';
 import { SwapInput } from '../models/SwapInput';
 import { SwapReply } from '../models/SwapReply';
 import { SwapRouteInput } from '../models/SwapRouteInput';
@@ -22,46 +22,48 @@ import { SwapRouteResponse } from '../models/SwapRouteResponse';
 export class DexApiRequestFactory extends BaseAPIRequestFactory {
 
     /**
-     * CONTROLLER.DEX.LIST.DESCRIPTION
-     * CONTROLLER.DEX.LIST.SUMMARY
-     * @param chains 
-     * @param limit DTO.DEX.QUERY.LIMIT
-     * @param dexProgram DTO.DEX.QUERY.DEX_PROGRAM
+     * CONTROLLER.DEX.CREATE.DESCRIPTION
+     * CONTROLLER.DEX.CREATE.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param dexCreateTokenInput Token creation parameters
      */
-    public async list(chains?: Array<string>, limit?: number, dexProgram?: string, _options?: Configuration): Promise<RequestContext> {
+    public async createToken(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexCreateTokenInput: DexCreateTokenInput, _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("DexApi", "createToken", "chain");
+        }
 
 
+        // verify required parameter 'dexCreateTokenInput' is not null or undefined
+        if (dexCreateTokenInput === null || dexCreateTokenInput === undefined) {
+            throw new RequiredError("DexApi", "createToken", "dexCreateTokenInput");
+        }
+
 
         // Path Params
-        const localVarPath = '/v1/dex';
+        const localVarPath = '/v1/dex/{chain}/create'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
 
         // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.POST);
         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 (chains !== undefined) {
-            const serializedParams = ObjectSerializer.serialize(chains, "Array<string>", "");
-            for (const serializedParam of serializedParams) {
-                requestContext.appendQueryParam("chains", serializedParam);
-            }
-        }
-
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
-        }
-
-        // Query Params
-        if (dexProgram !== undefined) {
-            requestContext.setQueryParam("dexProgram", ObjectSerializer.serialize(dexProgram, "string", ""));
-        }
 
+        // Body Params
+        const contentType = ObjectSerializer.getPreferredMediaType([
+            "application/json"
+        ]);
+        requestContext.setHeaderParam("Content-Type", contentType);
+        const serializedBody = ObjectSerializer.stringify(
+            ObjectSerializer.serialize(dexCreateTokenInput, "DexCreateTokenInput", ""),
+            contentType
+        );
+        requestContext.setBody(serializedBody);
 
         let authMethod: SecurityAuthentication | undefined;
         // Apply auth methods
@@ -79,48 +81,46 @@ export class DexApiRequestFactory extends BaseAPIRequestFactory {
     }
 
     /**
-     * CONTROLLER.DEX.MINT.DESCRIPTION
-     * CONTROLLER.DEX.MINT.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param dexMintInput Token creation parameters
+     * CONTROLLER.DEX.LIST.DESCRIPTION
+     * CONTROLLER.DEX.LIST.SUMMARY
+     * @param chains 
+     * @param limit DTO.DEX.QUERY.LIMIT
+     * @param dexProgram DTO.DEX.QUERY.DEX_PROGRAM
      */
-    public async mint(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexMintInput: DexMintInput, _options?: Configuration): Promise<RequestContext> {
+    public async list(chains?: Array<string>, limit?: number, dexProgram?: 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("DexApi", "mint", "chain");
-        }
-
 
-        // verify required parameter 'dexMintInput' is not null or undefined
-        if (dexMintInput === null || dexMintInput === undefined) {
-            throw new RequiredError("DexApi", "mint", "dexMintInput");
-        }
 
 
         // Path Params
-        const localVarPath = '/v1/dex/{chain}/mint'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        const localVarPath = '/v1/dex';
 
         // Make Request Context
-        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.POST);
+        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 (chains !== undefined) {
+            const serializedParams = ObjectSerializer.serialize(chains, "Array<string>", "");
+            for (const serializedParam of serializedParams) {
+                requestContext.appendQueryParam("chains", serializedParam);
+            }
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (dexProgram !== undefined) {
+            requestContext.setQueryParam("dexProgram", ObjectSerializer.serialize(dexProgram, "string", ""));
+        }
 
-        // Body Params
-        const contentType = ObjectSerializer.getPreferredMediaType([
-            "application/json"
-        ]);
-        requestContext.setHeaderParam("Content-Type", contentType);
-        const serializedBody = ObjectSerializer.stringify(
-            ObjectSerializer.serialize(dexMintInput, "DexMintInput", ""),
-            contentType
-        );
-        requestContext.setBody(serializedBody);
 
         let authMethod: SecurityAuthentication | undefined;
         // Apply auth methods
@@ -263,25 +263,25 @@ export class DexApiResponseProcessor {
      * 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 list
+     * @params response Response returned by the server for a request to createToken
      * @throws ApiException if the response code was not in [200, 299]
      */
-     public async listWithHttpInfo(response: ResponseContext): Promise<HttpInfo<DexPage >> {
+     public async createTokenWithHttpInfo(response: ResponseContext): Promise<HttpInfo<CreateTokenReply >> {
         const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
         if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: DexPage = ObjectSerializer.deserialize(
+            const body: CreateTokenReply = ObjectSerializer.deserialize(
                 ObjectSerializer.parse(await response.body.text(), contentType),
-                "DexPage", ""
-            ) as DexPage;
+                "CreateTokenReply", ""
+            ) as CreateTokenReply;
             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: DexPage = ObjectSerializer.deserialize(
+            const body: CreateTokenReply = ObjectSerializer.deserialize(
                 ObjectSerializer.parse(await response.body.text(), contentType),
-                "DexPage", ""
-            ) as DexPage;
+                "CreateTokenReply", ""
+            ) as CreateTokenReply;
             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);
@@ -291,25 +291,25 @@ export class DexApiResponseProcessor {
      * 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 mint
+     * @params response Response returned by the server for a request to list
      * @throws ApiException if the response code was not in [200, 299]
      */
-     public async mintWithHttpInfo(response: ResponseContext): Promise<HttpInfo<MintReply >> {
+     public async listWithHttpInfo(response: ResponseContext): Promise<HttpInfo<DexPage >> {
         const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
         if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: MintReply = ObjectSerializer.deserialize(
+            const body: DexPage = ObjectSerializer.deserialize(
                 ObjectSerializer.parse(await response.body.text(), contentType),
-                "MintReply", ""
-            ) as MintReply;
+                "DexPage", ""
+            ) as DexPage;
             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: MintReply = ObjectSerializer.deserialize(
+            const body: DexPage = ObjectSerializer.deserialize(
                 ObjectSerializer.parse(await response.body.text(), contentType),
-                "MintReply", ""
-            ) as MintReply;
+                "DexPage", ""
+            ) as DexPage;
             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);