@chainstream-io/sdk 0.0.1

package/src/openapi/apis/RedPacketApi.ts

@@ -0,0 +1,726 @@
+// 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';
+
+/**
+ * no description
+ */
+export class RedPacketApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * 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");
+        }
+
+
+        // verify required parameter 'claimRedPacketInput' is not null or undefined
+        if (claimRedPacketInput === null || claimRedPacketInput === undefined) {
+            throw new RequiredError("RedPacketApi", "claim", "claimRedPacketInput");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/redpacket/{chain}/claim'
+            .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())
+
+
+
+        // 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 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;
+    }
+
+    /**
+     * 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");
+        }
+
+
+        // verify required parameter 'createRedPacketInput' is not null or undefined
+        if (createRedPacketInput === null || createRedPacketInput === undefined) {
+            throw new RequiredError("RedPacketApi", "create", "createRedPacketInput");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/redpacket/{chain}/create'
+            .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())
+
+
+
+        // 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);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.RED_PACKET.GET.DESCRIPTION
+     * CONTROLLER.RED_PACKET.GET.SUMMARY
+     * @param id DTO.RED_PACKET.ID
+     */
+    public async get(id: string, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'id' is not null or undefined
+        if (id === null || id === undefined) {
+            throw new RequiredError("RedPacketApi", "get", "id");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/redpacket/{id}'
+            .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())
+
+
+
+        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;
+    }
+
+    /**
+     * 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;
+
+        // verify required parameter 'id' is not null or undefined
+        if (id === null || id === undefined) {
+            throw new RequiredError("RedPacketApi", "getClaims", "id");
+        }
+
+
+
+
+
+        // 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", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "string", ""));
+        }
+
+
+        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;
+    }
+
+    /**
+     * 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;
+
+        // verify required parameter 'address' is not null or undefined
+        if (address === null || address === undefined) {
+            throw new RequiredError("RedPacketApi", "getClaimsByAddress", "address");
+        }
+
+
+
+
+
+        // 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", ""));
+        }
+
+
+        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;
+    }
+
+    /**
+     * 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;
+
+
+
+
+
+
+        // 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", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "string", ""));
+        }
+
+        // Query Params
+        if (creator !== undefined) {
+            requestContext.setQueryParam("creator", ObjectSerializer.serialize(creator, "string", ""));
+        }
+
+        // Query Params
+        if (chain !== undefined) {
+            requestContext.setQueryParam("chain", ObjectSerializer.serialize(chain, "'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui'", ""));
+        }
+
+
+        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;
+    }
+
+    /**
+     * 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");
+        }
+
+
+
+
+
+        // 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", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "string", ""));
+        }
+
+
+        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;
+    }
+
+    /**
+     * 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");
+        }
+
+
+        // verify required parameter 'redPacketSendTxInput' is not null or undefined
+        if (redPacketSendTxInput === null || redPacketSendTxInput === undefined) {
+            throw new RequiredError("RedPacketApi", "redpacketSend", "redPacketSendTxInput");
+        }
+
+
+        // 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())
+
+
+
+        // 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);
+
+        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;
+    }
+
+}
+
+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);
+    }
+
+    /**
+     * 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]
+     */
+     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);
+    }
+
+}