anchor-sdk 0.1.36

package/dist/generated/Api.js

@@ -0,0 +1,571 @@
+"use strict";
+/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = exports.HttpClient = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["JsonApi"] = "application/vnd.api+json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (exports.ContentType = ContentType = {}));
+class HttpClient {
+    constructor(apiConfig = {}) {
+        this.baseUrl = "https://anchordev.dipbit.xyz/";
+        this.securityData = null;
+        this.abortControllers = new Map();
+        this.customFetch = (...fetchParams) => fetch(...fetchParams);
+        this.baseApiParams = {
+            credentials: "same-origin",
+            headers: {},
+            redirect: "follow",
+            referrerPolicy: "no-referrer",
+        };
+        this.setSecurityData = (data) => {
+            this.securityData = data;
+        };
+        this.contentFormatters = {
+            [ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+                ? JSON.stringify(input)
+                : input,
+            [ContentType.JsonApi]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+                ? JSON.stringify(input)
+                : input,
+            [ContentType.Text]: (input) => input !== null && typeof input !== "string"
+                ? JSON.stringify(input)
+                : input,
+            [ContentType.FormData]: (input) => {
+                if (input instanceof FormData) {
+                    return input;
+                }
+                return Object.keys(input || {}).reduce((formData, key) => {
+                    const property = input[key];
+                    formData.append(key, property instanceof Blob
+                        ? property
+                        : typeof property === "object" && property !== null
+                            ? JSON.stringify(property)
+                            : `${property}`);
+                    return formData;
+                }, new FormData());
+            },
+            [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+        };
+        this.createAbortSignal = (cancelToken) => {
+            if (this.abortControllers.has(cancelToken)) {
+                const abortController = this.abortControllers.get(cancelToken);
+                if (abortController) {
+                    return abortController.signal;
+                }
+                return void 0;
+            }
+            const abortController = new AbortController();
+            this.abortControllers.set(cancelToken, abortController);
+            return abortController.signal;
+        };
+        this.abortRequest = (cancelToken) => {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                abortController.abort();
+                this.abortControllers.delete(cancelToken);
+            }
+        };
+        this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+            const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
+                this.securityWorker &&
+                (await this.securityWorker(this.securityData))) ||
+                {};
+            const requestParams = this.mergeRequestParams(params, secureParams);
+            const queryString = query && this.toQueryString(query);
+            const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+            const responseFormat = format || requestParams.format;
+            return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+                ...requestParams,
+                headers: {
+                    ...(requestParams.headers || {}),
+                    ...(type && type !== ContentType.FormData
+                        ? { "Content-Type": type }
+                        : {}),
+                },
+                signal: (cancelToken
+                    ? this.createAbortSignal(cancelToken)
+                    : requestParams.signal) || null,
+                body: typeof body === "undefined" || body === null
+                    ? null
+                    : payloadFormatter(body),
+            }).then(async (response) => {
+                const r = response;
+                r.data = null;
+                r.error = null;
+                const data = !responseFormat
+                    ? r
+                    : await response[responseFormat]()
+                        .then((data) => {
+                        if (r.ok) {
+                            r.data = data;
+                        }
+                        else {
+                            r.error = data;
+                        }
+                        return r;
+                    })
+                        .catch((e) => {
+                        r.error = e;
+                        return r;
+                    });
+                if (cancelToken) {
+                    this.abortControllers.delete(cancelToken);
+                }
+                if (!response.ok)
+                    throw data;
+                return data;
+            });
+        };
+        Object.assign(this, apiConfig);
+    }
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+            .map((key) => Array.isArray(query[key])
+            ? this.addArrayQueryParam(query, key)
+            : this.addQueryParam(query, key))
+            .join("&");
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+}
+exports.HttpClient = HttpClient;
+/**
+ * @title Anchor OpenApi
+ * @version V1.0
+ * @license Apache 2.0 (http://springdoc.org)
+ * @baseUrl https://anchordev.dipbit.xyz/
+ */
+class Api extends HttpClient {
+    constructor() {
+        super(...arguments);
+        this.v1 = {
+            /**
+             * @description get nft series by id
+             *
+             * @tags Anchor
+             * @name GetNftSeriesById
+             * @summary get nft series by id
+             * @request GET:/v1/series/{type}/{series}
+             */
+            getNftSeriesById: (type, series, query, params = {}) => this.request({
+                path: `/v1/series/${type}/${series}`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description get nft series
+             *
+             * @tags Anchor
+             * @name NftSeries
+             * @summary get nft series
+             * @request GET:/v1/series/{type}
+             */
+            nftSeries: (type, params = {}) => this.request({
+                path: `/v1/series/${type}`,
+                method: "GET",
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description anchor check
+             *
+             * @tags Anchor
+             * @name Check
+             * @summary anchor check
+             * @request POST:/v1/check/{type}
+             */
+            check: (type, params = {}) => this.request({
+                path: `/v1/check/${type}`,
+                method: "POST",
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description get check result
+             *
+             * @tags Anchor
+             * @name GetCheckResult
+             * @summary get check result
+             * @request GET:/v1/check/{type}
+             */
+            getCheckResult: (type, params = {}) => this.request({
+                path: `/v1/check/${type}`,
+                method: "GET",
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description list season config
+             *
+             * @tags Season
+             * @name ListSeasonConfig
+             * @summary list season config
+             * @request GET:/v1/seasons
+             */
+            listSeasonConfig: (params = {}) => this.request({
+                path: `/v1/seasons`,
+                method: "GET",
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description query user claimable or claimed Badges
+             *
+             * @tags Anchor
+             * @name BadgeAssets
+             * @summary query user claimable or claimed Badges
+             * @request GET:/v1/badges
+             */
+            badgeAssets: (query, params = {}) => this.request({
+                path: `/v1/badges`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description 前端监听到合约成功事件，调用加快后端事件处理
+             *
+             * @tags Transaction
+             * @name UserOpHashProcess
+             * @summary userOpHash process
+             * @request POST:/v1/transaction/process/userOpHash
+             */
+            userOpHashProcess: (data, params = {}) => this.request({
+                path: `/v1/transaction/process/userOpHash`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description 前端监听到合约成功事件，调用加快后端事件处理
+             *
+             * @tags Transaction
+             * @name TransactionHashProcess
+             * @summary speed up transaction
+             * @request POST:/v1/transaction/process/{txHash}
+             */
+            transactionHashProcess: (txHash, params = {}) => this.request({
+                path: `/v1/transaction/process/${txHash}`,
+                method: "POST",
+                format: "json",
+                ...params,
+            }),
+        };
+        this.v2 = {
+            /**
+             * @description Get badges that the user can claim
+             *
+             * @tags BadgeV2
+             * @name GetUserClaimableBadges
+             * @summary Get user claimable badges
+             * @request GET:/v2/badges/claimable
+             */
+            getUserClaimableBadges: (query, params = {}) => this.request({
+                path: `/v2/badges/claimable`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Get detailed information of a specific badge series
+             *
+             * @tags BadgeV2
+             * @name GetBadgeSeriesDetail
+             * @summary Get badge series detail
+             * @request GET:/v2/badges/series/{series}
+             */
+            getBadgeSeriesDetail: (series, query, params = {}) => this.request({
+                path: `/v2/badges/series/${series}`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Get user's claimed and claimable badge assets
+             *
+             * @tags BadgeV2
+             * @name GetUserBadgeAssets
+             * @summary Get user badge assets
+             * @request GET:/v2/badges/assets
+             */
+            getUserBadgeAssets: (query, params = {}) => this.request({
+                path: `/v2/badges/assets`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Get verifiers for badge conditions based on platform and type
+             *
+             * @tags BadgeV2
+             * @name GetBadgeVerifiers
+             * @summary Get badge verifiers
+             * @request GET:/v2/badges/verifiers
+             */
+            getBadgeVerifiers: (query, params = {}) => this.request({
+                path: `/v2/badges/verifiers`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Check which badges the user can claim
+             *
+             * @tags BadgeV2
+             * @name CheckUserClaimableBadges
+             * @summary Check user claimable badges
+             * @request POST:/v2/badges
+             */
+            checkUserClaimableBadges: (data, params = {}) => this.request({
+                path: `/v2/badges`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Query badge series with optional filtering conditions
+             *
+             * @tags BadgeV2
+             * @name GetBadgeSeries
+             * @summary Query badge series with conditions
+             * @request GET:/v2/badges/series
+             */
+            getBadgeSeries: (query, params = {}) => this.request({
+                path: `/v2/badges/series`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description anchor mint
+             *
+             * @tags AnchorV2
+             * @name Mint
+             * @summary anchor mint
+             * @request POST:/v2/mint/{type}
+             */
+            mint: (type, data, params = {}) => this.request({
+                path: `/v2/mint/${type}`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description anchor batch mint
+             *
+             * @tags AnchorV2
+             * @name BatchMint
+             * @summary anchor batch mint
+             * @request POST:/v2/batch/mint/{type}
+             */
+            batchMint: (type, data, params = {}) => this.request({
+                path: `/v2/batch/mint/${type}`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Get signatures required for claiming badges
+             *
+             * @tags BadgeV2
+             * @name GetBadgeClaimSignatures
+             * @summary Get badge claim signatures
+             * @request POST:/v2/badges/signatures
+             */
+            getBadgeClaimSignatures: (data, params = {}) => this.request({
+                path: `/v2/badges/signatures`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Check if a specific badge is claimable for the user
+             *
+             * @tags BadgeV2
+             * @name CheckSingleBadgeClaimable
+             * @summary Check single badge claimable status
+             * @request POST:/v2/badges/{badgeId}
+             */
+            checkSingleBadgeClaimable: (badgeId, data, params = {}) => this.request({
+                path: `/v2/badges/${badgeId}`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description Get detailed information of a specific badge
+             *
+             * @tags BadgeV2
+             * @name GetBadgeDetail
+             * @summary Get badge detail
+             * @request GET:/v2/badges/{badgeId}
+             */
+            getBadgeDetail: (badgeId, params = {}) => this.request({
+                path: `/v2/badges/${badgeId}`,
+                method: "GET",
+                format: "json",
+                ...params,
+            }),
+        };
+        this.s1 = {
+            /**
+             * @description grant badge
+             *
+             * @tags AnchorS2S
+             * @name GrantBadge
+             * @summary grant badge
+             * @request POST:/s1/badges
+             */
+            grantBadge: (data, params = {}) => this.request({
+                path: `/s1/badges`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description purchase mint with signature
+             *
+             * @tags AnchorS2S
+             * @name PurchaseMint
+             * @summary purchase mint with signature
+             * @request POST:/s1/purchase/{type}
+             */
+            purchaseMint: (type, data, params = {}) => this.request({
+                path: `/s1/purchase/${type}`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description assets of badge
+             *
+             * @tags AnchorS2S
+             * @name QueryAssets
+             * @summary assets of badge
+             * @request POST:/s1/assets/{type}
+             */
+            queryAssets: (type, data, params = {}) => this.request({
+                path: `/s1/assets/${type}`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description get nft series by id
+             *
+             * @tags AnchorS2S
+             * @name GetNftSeriesDetail
+             * @summary get nft series by id
+             * @request GET:/s1/series/{type}/{series}
+             */
+            getNftSeriesDetail: (type, series, query, params = {}) => this.request({
+                path: `/s1/series/${type}/${series}`,
+                method: "GET",
+                query: query,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description check by event
+             *
+             * @tags AnchorS2S
+             * @name CheckByEvent
+             * @summary check by event
+             * @request POST:/s1/check/event
+             */
+            checkByEvent: (data, params = {}) => this.request({
+                path: `/s1/check/event`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @description badges check
+             *
+             * @tags AnchorS2S
+             * @name BadgesCheck
+             * @summary badges check
+             * @request POST:/s1/badges/check
+             */
+            badgesCheck: (data, params = {}) => this.request({
+                path: `/s1/badges/check`,
+                method: "POST",
+                body: data,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+        };
+    }
+}
+exports.Api = Api;