@chainstream-io/sdk 0.0.12 → 0.1.5

package/src/openapi/apis/RedPacketApi.ts

@@ -1,726 +1,621 @@
-// 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 { ClaimRedPacketInput } from '../models/ClaimRedPacketInput';
-import { CreateRedPacketInput } from '../models/CreateRedPacketInput';
-import { CreateRedPacketReply } from '../models/CreateRedPacketReply';
-import { RedPacketClaimsPage } from '../models/RedPacketClaimsPage';
-import { RedPacketDTO } from '../models/RedPacketDTO';
-import { RedPacketReply } from '../models/RedPacketReply';
-import { RedPacketSendTxInput } from '../models/RedPacketSendTxInput';
-import { RedPacketSendTxResponse } from '../models/RedPacketSendTxResponse';
-import { RedPacketsPage } from '../models/RedPacketsPage';
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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.
+ */
+
+
+import * as runtime from '../runtime';
+import type {
+  ClaimRedPacketInput,
+  CreateRedPacketInput,
+  CreateRedPacketReply,
+  RedPacketClaimsPage,
+  RedPacketDTO,
+  RedPacketReply,
+  RedPacketSendTxInput,
+  RedPacketSendTxResponse,
+  RedPacketsPage,
+} from '../models/index';
+import {
+    ClaimRedPacketInputFromJSON,
+    ClaimRedPacketInputToJSON,
+    CreateRedPacketInputFromJSON,
+    CreateRedPacketInputToJSON,
+    CreateRedPacketReplyFromJSON,
+    CreateRedPacketReplyToJSON,
+    RedPacketClaimsPageFromJSON,
+    RedPacketClaimsPageToJSON,
+    RedPacketDTOFromJSON,
+    RedPacketDTOToJSON,
+    RedPacketReplyFromJSON,
+    RedPacketReplyToJSON,
+    RedPacketSendTxInputFromJSON,
+    RedPacketSendTxInputToJSON,
+    RedPacketSendTxResponseFromJSON,
+    RedPacketSendTxResponseToJSON,
+    RedPacketsPageFromJSON,
+    RedPacketsPageToJSON,
+} from '../models/index';
+
+export interface ClaimRedpacketRequest {
+    chain: ClaimRedpacketChainEnum;
+    claimRedPacketInput: ClaimRedPacketInput;
+}
+
+export interface CreateRedpacketRequest {
+    chain: CreateRedpacketChainEnum;
+    createRedPacketInput: CreateRedPacketInput;
+}
+
+export interface GetClaimsRequest {
+    id: string;
+    cursor?: string;
+    limit?: number;
+    direction?: string;
+}
+
+export interface GetClaimsByAddressRequest {
+    address: string;
+    cursor?: string;
+    limit?: number;
+    direction?: string;
+}
+
+export interface GetRedpacketRequest {
+    id: string;
+}
+
+export interface GetRedpacketsRequest {
+    cursor?: string;
+    limit?: number;
+    direction?: string;
+    creator?: string;
+    chain?: GetRedpacketsChainEnum;
+}
+
+export interface GetRedpacketsByAddressRequest {
+    address: string;
+    cursor?: string;
+    limit?: number;
+    direction?: string;
+}
+
+export interface RedpacketSendRequest {
+    chain: RedpacketSendChainEnum;
+    redPacketSendTxInput: RedPacketSendTxInput;
+}
 
 /**
- * no description
+ * 
  */
-export class RedPacketApiRequestFactory extends BaseAPIRequestFactory {
+export class RedPacketApi extends runtime.BaseAPI {
 
     /**
      * CONTROLLER.RED_PACKET.CLAIM.DESCRIPTION
      * CONTROLLER.RED_PACKET.CLAIM.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param claimRedPacketInput 
      */
-    public async claim(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', claimRedPacketInput: ClaimRedPacketInput, _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("RedPacketApi", "claim", "chain");
+    async claimRedpacketRaw(requestParameters: ClaimRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketReply>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling claimRedpacket().'
+            );
         }
 
-
-        // verify required parameter 'claimRedPacketInput' is not null or undefined
-        if (claimRedPacketInput === null || claimRedPacketInput === undefined) {
-            throw new RequiredError("RedPacketApi", "claim", "claimRedPacketInput");
+        if (requestParameters['claimRedPacketInput'] == null) {
+            throw new runtime.RequiredError(
+                'claimRedPacketInput',
+                'Required parameter "claimRedPacketInput" was null or undefined when calling claimRedpacket().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/redpacket/{chain}/claim'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        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())
+        headerParameters['Content-Type'] = 'application/json';
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
 
-        // Body Params
-        const contentType = ObjectSerializer.getPreferredMediaType([
-            "application/json"
-        ]);
-        requestContext.setHeaderParam("Content-Type", contentType);
-        const serializedBody = ObjectSerializer.stringify(
-            ObjectSerializer.serialize(claimRedPacketInput, "ClaimRedPacketInput", ""),
-            contentType
-        );
-        requestContext.setBody(serializedBody);
+        let urlPath = `/v1/redpacket/{chain}/claim`;
+        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: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClaimRedPacketInputToJSON(requestParameters['claimRedPacketInput']),
+        }, 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) => RedPacketReplyFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.RED_PACKET.CLAIM.DESCRIPTION
+     * CONTROLLER.RED_PACKET.CLAIM.SUMMARY
+     */
+    async claimRedpacket(requestParameters: ClaimRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketReply> {
+        const response = await this.claimRedpacketRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.RED_PACKET.CREATE.DESCRIPTION
      * CONTROLLER.RED_PACKET.CREATE.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param createRedPacketInput 
      */
-    public async create(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', createRedPacketInput: CreateRedPacketInput, _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("RedPacketApi", "create", "chain");
+    async createRedpacketRaw(requestParameters: CreateRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateRedPacketReply>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling createRedpacket().'
+            );
         }
 
-
-        // verify required parameter 'createRedPacketInput' is not null or undefined
-        if (createRedPacketInput === null || createRedPacketInput === undefined) {
-            throw new RequiredError("RedPacketApi", "create", "createRedPacketInput");
+        if (requestParameters['createRedPacketInput'] == null) {
+            throw new runtime.RequiredError(
+                'createRedPacketInput',
+                'Required parameter "createRedPacketInput" was null or undefined when calling createRedpacket().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/redpacket/{chain}/create'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        // Make Request Context
-        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())
+        headerParameters['Content-Type'] = 'application/json';
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-
-        // Body Params
-        const contentType = ObjectSerializer.getPreferredMediaType([
-            "application/json"
-        ]);
-        requestContext.setHeaderParam("Content-Type", contentType);
-        const serializedBody = ObjectSerializer.stringify(
-            ObjectSerializer.serialize(createRedPacketInput, "CreateRedPacketInput", ""),
-            contentType
-        );
-        requestContext.setBody(serializedBody);
-
-        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/redpacket/{chain}/create`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        return requestContext;
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateRedPacketInputToJSON(requestParameters['createRedPacketInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CreateRedPacketReplyFromJSON(jsonValue));
     }
 
     /**
-     * CONTROLLER.RED_PACKET.GET.DESCRIPTION
-     * CONTROLLER.RED_PACKET.GET.SUMMARY
-     * @param id DTO.RED_PACKET.ID
+     * CONTROLLER.RED_PACKET.CREATE.DESCRIPTION
+     * CONTROLLER.RED_PACKET.CREATE.SUMMARY
      */
-    public async get(id: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
+    async createRedpacket(requestParameters: CreateRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateRedPacketReply> {
+        const response = await this.createRedpacketRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // verify required parameter 'id' is not null or undefined
-        if (id === null || id === undefined) {
-            throw new RequiredError("RedPacketApi", "get", "id");
+    /**
+     * CONTROLLER.RED_PACKET.GET_CLAIMS.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET_CLAIMS.SUMMARY
+     */
+    async getClaimsRaw(requestParameters: GetClaimsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketClaimsPage>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling getClaims().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/redpacket/{id}'
-            .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
 
-        // 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'];
+        }
 
+        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/redpacket/{id}/claims`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RedPacketClaimsPageFromJSON(jsonValue));
     }
 
     /**
      * CONTROLLER.RED_PACKET.GET_CLAIMS.DESCRIPTION
      * CONTROLLER.RED_PACKET.GET_CLAIMS.SUMMARY
-     * @param id DTO.RED_PACKET.ID
-     * @param cursor DTO.RED_PACKET.CURSOR
-     * @param limit DTO.RED_PACKET.LIMIT
-     * @param direction DTO.RED_PACKET.DIRECTION
      */
-    public async getClaims(id: string, cursor?: string, limit?: number, direction?: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
+    async getClaims(requestParameters: GetClaimsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketClaimsPage> {
+        const response = await this.getClaimsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // verify required parameter 'id' is not null or undefined
-        if (id === null || id === undefined) {
-            throw new RequiredError("RedPacketApi", "getClaims", "id");
+    /**
+     * CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.SUMMARY
+     */
+    async getClaimsByAddressRaw(requestParameters: GetClaimsByAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketClaimsPage>> {
+        if (requestParameters['address'] == null) {
+            throw new runtime.RequiredError(
+                'address',
+                'Required parameter "address" was null or undefined when calling getClaimsByAddress().'
+            );
         }
 
+        const queryParameters: any = {};
 
-
-
-
-        // Path Params
-        const localVarPath = '/v1/redpacket/{id}/claims'
-            .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
-
-        // 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, "string", ""));
+        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/redpacket/wallet/{address}/claims`;
+        urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RedPacketClaimsPageFromJSON(jsonValue));
     }
 
     /**
      * CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.DESCRIPTION
      * CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.SUMMARY
-     * @param address 
-     * @param cursor DTO.RED_PACKET.CURSOR
-     * @param limit DTO.RED_PACKET.LIMIT
-     * @param direction DTO.RED_PACKET.DIRECTION
      */
-    public async getClaimsByAddress(address: string, cursor?: string, limit?: number, direction?: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
+    async getClaimsByAddress(requestParameters: GetClaimsByAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketClaimsPage> {
+        const response = await this.getClaimsByAddressRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 
-        // verify required parameter 'address' is not null or undefined
-        if (address === null || address === undefined) {
-            throw new RequiredError("RedPacketApi", "getClaimsByAddress", "address");
+    /**
+     * CONTROLLER.RED_PACKET.GET.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET.SUMMARY
+     */
+    async getRedpacketRaw(requestParameters: GetRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketDTO>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling getRedpacket().'
+            );
         }
 
+        const queryParameters: any = {};
 
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-
-        // Path Params
-        const localVarPath = '/v1/redpacket/wallet/{address}/claims'
-            .replace('{' + 'address' + '}', encodeURIComponent(String(address)));
-
-        // 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", ""));
-        }
-
-        // Query Params
-        if (limit !== undefined) {
-            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
-        }
-
-        // Query Params
-        if (direction !== undefined) {
-            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "string", ""));
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
 
+        let urlPath = `/v1/redpacket/{id}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
-        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) => RedPacketDTOFromJSON(jsonValue));
+    }
 
-        return requestContext;
+    /**
+     * CONTROLLER.RED_PACKET.GET.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET.SUMMARY
+     */
+    async getRedpacket(requestParameters: GetRedpacketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketDTO> {
+        const response = await this.getRedpacketRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.RED_PACKET.GET_REDPACKETS.DESCRIPTION
      * CONTROLLER.RED_PACKET.GET_REDPACKETS.SUMMARY
-     * @param cursor DTO.RED_PACKET.CURSOR
-     * @param limit DTO.RED_PACKET.LIMIT
-     * @param direction DTO.RED_PACKET.DIRECTION
-     * @param creator DTO.RED_PACKET.CREATOR
-     * @param chain DTO.RED_PACKET.CHAIN
      */
-    public async getRedpackets(cursor?: string, limit?: number, direction?: string, creator?: string, chain?: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-
-
-
+    async getRedpacketsRaw(requestParameters: GetRedpacketsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketsPage>> {
+        const queryParameters: any = {};
 
-
-        // Path Params
-        const localVarPath = '/v1/redpacket';
-
-        // 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, "string", ""));
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
         }
 
-        // Query Params
-        if (creator !== undefined) {
-            requestContext.setQueryParam("creator", ObjectSerializer.serialize(creator, "string", ""));
+        if (requestParameters['creator'] != null) {
+            queryParameters['creator'] = requestParameters['creator'];
         }
 
-        // Query Params
-        if (chain !== undefined) {
-            requestContext.setQueryParam("chain", ObjectSerializer.serialize(chain, "'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui'", ""));
+        if (requestParameters['chain'] != null) {
+            queryParameters['chain'] = requestParameters['chain'];
         }
 
+        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/redpacket`;
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RedPacketsPageFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.RED_PACKET.GET_REDPACKETS.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET_REDPACKETS.SUMMARY
+     */
+    async getRedpackets(requestParameters: GetRedpacketsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketsPage> {
+        const response = await this.getRedpacketsRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.DESCRIPTION
      * CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.SUMMARY
-     * @param address 
-     * @param cursor DTO.RED_PACKET.CURSOR
-     * @param limit DTO.RED_PACKET.LIMIT
-     * @param direction DTO.RED_PACKET.DIRECTION
      */
-    public async getRedpacketsByAddress(address: string, cursor?: string, limit?: number, direction?: string, _options?: Configuration): Promise<RequestContext> {
-        let _config = _options || this.configuration;
-
-        // verify required parameter 'address' is not null or undefined
-        if (address === null || address === undefined) {
-            throw new RequiredError("RedPacketApi", "getRedpacketsByAddress", "address");
+    async getRedpacketsByAddressRaw(requestParameters: GetRedpacketsByAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketsPage>> {
+        if (requestParameters['address'] == null) {
+            throw new runtime.RequiredError(
+                'address',
+                'Required parameter "address" was null or undefined when calling getRedpacketsByAddress().'
+            );
         }
 
+        const queryParameters: any = {};
 
-
-
-
-        // Path Params
-        const localVarPath = '/v1/redpacket/wallet/{address}/redpackets'
-            .replace('{' + 'address' + '}', encodeURIComponent(String(address)));
-
-        // 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, "string", ""));
+        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/redpacket/wallet/{address}/redpackets`;
+        urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RedPacketsPageFromJSON(jsonValue));
+    }
+
+    /**
+     * CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.SUMMARY
+     */
+    async getRedpacketsByAddress(requestParameters: GetRedpacketsByAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketsPage> {
+        const response = await this.getRedpacketsByAddressRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * CONTROLLER.RED_PACKET.SEND.DESCRIPTION
      * CONTROLLER.RED_PACKET.SEND.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param redPacketSendTxInput 
      */
-    public async redpacketSend(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', redPacketSendTxInput: RedPacketSendTxInput, _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("RedPacketApi", "redpacketSend", "chain");
+    async redpacketSendRaw(requestParameters: RedpacketSendRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedPacketSendTxResponse>> {
+        if (requestParameters['chain'] == null) {
+            throw new runtime.RequiredError(
+                'chain',
+                'Required parameter "chain" was null or undefined when calling redpacketSend().'
+            );
         }
 
-
-        // verify required parameter 'redPacketSendTxInput' is not null or undefined
-        if (redPacketSendTxInput === null || redPacketSendTxInput === undefined) {
-            throw new RequiredError("RedPacketApi", "redpacketSend", "redPacketSendTxInput");
+        if (requestParameters['redPacketSendTxInput'] == null) {
+            throw new runtime.RequiredError(
+                'redPacketSendTxInput',
+                'Required parameter "redPacketSendTxInput" was null or undefined when calling redpacketSend().'
+            );
         }
 
+        const queryParameters: any = {};
 
-        // Path Params
-        const localVarPath = '/v1/redpacket/{chain}/send'
-            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
-
-        // Make Request Context
-        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())
-
+        const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
 
-        // Body Params
-        const contentType = ObjectSerializer.getPreferredMediaType([
-            "application/json"
-        ]);
-        requestContext.setHeaderParam("Content-Type", contentType);
-        const serializedBody = ObjectSerializer.stringify(
-            ObjectSerializer.serialize(redPacketSendTxInput, "RedPacketSendTxInput", ""),
-            contentType
-        );
-        requestContext.setBody(serializedBody);
+        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/redpacket/{chain}/send`;
+        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
 
-        return requestContext;
-    }
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: RedPacketSendTxInputToJSON(requestParameters['redPacketSendTxInput']),
+        }, initOverrides);
 
-}
-
-export class RedPacketApiResponseProcessor {
-
-    /**
-     * 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 claim
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async claimWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketReply >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketReply = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketReply", ""
-            ) as RedPacketReply;
-            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: RedPacketReply = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketReply", ""
-            ) as RedPacketReply;
-            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 create
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async createWithHttpInfo(response: ResponseContext): Promise<HttpInfo<CreateRedPacketReply >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: CreateRedPacketReply = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "CreateRedPacketReply", ""
-            ) as CreateRedPacketReply;
-            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: CreateRedPacketReply = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "CreateRedPacketReply", ""
-            ) as CreateRedPacketReply;
-            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 get
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketDTO >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketDTO", ""
-            ) as RedPacketDTO;
-            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: RedPacketDTO = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketDTO", ""
-            ) as RedPacketDTO;
-            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 getClaims
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getClaimsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketClaimsPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketClaimsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketClaimsPage", ""
-            ) as RedPacketClaimsPage;
-            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: RedPacketClaimsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketClaimsPage", ""
-            ) as RedPacketClaimsPage;
-            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 getClaimsByAddress
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getClaimsByAddressWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketClaimsPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketClaimsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketClaimsPage", ""
-            ) as RedPacketClaimsPage;
-            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: RedPacketClaimsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketClaimsPage", ""
-            ) as RedPacketClaimsPage;
-            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 getRedpackets
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getRedpacketsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketsPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketsPage", ""
-            ) as RedPacketsPage;
-            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: RedPacketsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketsPage", ""
-            ) as RedPacketsPage;
-            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) => RedPacketSendTxResponseFromJSON(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 getRedpacketsByAddress
-     * @throws ApiException if the response code was not in [200, 299]
-     */
-     public async getRedpacketsByAddressWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketsPage >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketsPage", ""
-            ) as RedPacketsPage;
-            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: RedPacketsPage = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketsPage", ""
-            ) as RedPacketsPage;
-            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 redpacketSend
-     * @throws ApiException if the response code was not in [200, 299]
+     * CONTROLLER.RED_PACKET.SEND.DESCRIPTION
+     * CONTROLLER.RED_PACKET.SEND.SUMMARY
      */
-     public async redpacketSendWithHttpInfo(response: ResponseContext): Promise<HttpInfo<RedPacketSendTxResponse >> {
-        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
-        if (isCodeInRange("200", response.httpStatusCode)) {
-            const body: RedPacketSendTxResponse = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketSendTxResponse", ""
-            ) as RedPacketSendTxResponse;
-            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: RedPacketSendTxResponse = ObjectSerializer.deserialize(
-                ObjectSerializer.parse(await response.body.text(), contentType),
-                "RedPacketSendTxResponse", ""
-            ) as RedPacketSendTxResponse;
-            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 redpacketSend(requestParameters: RedpacketSendRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedPacketSendTxResponse> {
+        const response = await this.redpacketSendRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }
+
+/**
+ * @export
+ */
+export const ClaimRedpacketChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type ClaimRedpacketChainEnum = typeof ClaimRedpacketChainEnum[keyof typeof ClaimRedpacketChainEnum];
+/**
+ * @export
+ */
+export const CreateRedpacketChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type CreateRedpacketChainEnum = typeof CreateRedpacketChainEnum[keyof typeof CreateRedpacketChainEnum];
+/**
+ * @export
+ */
+export const GetRedpacketsChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type GetRedpacketsChainEnum = typeof GetRedpacketsChainEnum[keyof typeof GetRedpacketsChainEnum];
+/**
+ * @export
+ */
+export const RedpacketSendChainEnum = {
+    Sol: 'sol',
+    Base: 'base',
+    Bsc: 'bsc',
+    Polygon: 'polygon',
+    Arbitrum: 'arbitrum',
+    Optimism: 'optimism',
+    Avalanche: 'avalanche',
+    Ethereum: 'ethereum',
+    Zksync: 'zksync',
+    Sui: 'sui'
+} as const;
+export type RedpacketSendChainEnum = typeof RedpacketSendChainEnum[keyof typeof RedpacketSendChainEnum];