getgems 1.0.0

package/README.md

@@ -0,0 +1,68 @@
+# Getgems NFT Marketplace API Client
+
+**TypeScript SDK for interacting with the Getgems NFT Marketplace API.**
+
+This package provides a convenient interface for working with the **Getgems** marketplace, supporting the ability to retrieve collection stats, manage NFTs, and more.
+
+This npm package follows the structure and types as outlined in the official [Getgems API documentation](https://api.getgems.io/public-api/docs).
+
+## Installation
+
+To install the package, use npm:
+
+```bash
+npm install getgems
+````
+
+## Usage
+
+### Initialize the Client
+
+```typescript
+import { Getgems } from 'getgems';
+
+const client = new Getgems('your-api-key');
+```
+
+### Accessing APIs
+
+The client provides access to the following APIs:
+
+1. **ReadApi** – Retrieve Collection Floor Price, NFTs in Collection, and More
+2. **MintingApi** – Create New NFTs and Collections via a Simple API
+3. **cNFTApi** – For Large NFT Collections
+4. **GiftApi** – This is a Special API for Partners Only
+5. **StorageApi** – This is a Special API for Partners Only
+
+To access the methods of these APIs, use the following properties of the created client class: `readApi`, `mintingApi`, `cNftApi`, `giftApi`, `storageApi`.
+
+### Example:
+
+```typescript
+//Get collection attributes
+const collectionAttributes = await client.readApi.getCollectionAttributes('collectionAddress');
+
+//Create minting task
+const mintingStatus = await client.mintingApi.createMinting('collectionAddress', mintingRequestBody);
+
+//Add CNFT to collection
+const addCNFTToCollectionResponse = await client.cNftApi.addCNFTToCollection('collectionAddress', cNFTRequestBody);
+
+//Publicly unavailable. Get offchain gifts by specified owner address
+const nftItems = await client.giftApi.getOwnerOffchainGifts('ownerAddress', queryParams);
+
+//Publicly unavailable. Create box for storage
+const storageBoxId = await client.storageApi.createStorage();
+```
+
+The method names correspond to the `operationId` values specified in the `paths/{path}/{httpRequestMethod}/operationId` for each endpoint, as outlined in [JSON file of the official API documentation](https://api.getgems.io/public-api/docs.json)
+
+For full documentation of available methods for each API, please refer to the official [Getgems API Documentation](https://api.getgems.io/public-api/docs).
+
+## Data Structures
+
+If you require any of the Getgems API schema types (e.g., for forming request bodies), you can import them directly from `getgems/schemas`.
+
+```typescript
+import { DefaultErrorObject, NftItemFull } from 'getgems/schemas'
+```

package/dist/api-service/abstract-api.service.d.ts

@@ -0,0 +1,9 @@
+import { MakeApiRequest } from ".";
+export declare abstract class ApiService {
+    private readonly API_KEY;
+    private readonly API_BASE_URL;
+    constructor(API_KEY: string);
+    protected makeApiRequest<Response>({ method, path, body, queryParams }: MakeApiRequest): Promise<Response>;
+    private makeUrl;
+    private getQueryParams;
+}

package/dist/api-service/abstract-api.service.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiService = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class ApiService {
+    constructor(API_KEY) {
+        this.API_KEY = API_KEY;
+        this.API_BASE_URL = 'https://api.getgems.io/public-api';
+    }
+    makeApiRequest(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ method, path, body, queryParams }) {
+            try {
+                const res = yield (0, node_fetch_1.default)(this.makeUrl(path, queryParams), {
+                    method,
+                    body,
+                    headers: {
+                        accept: 'application/json',
+                        'Authorization': this.API_KEY
+                    }
+                }).then(res => res.json());
+                return res;
+            }
+            catch (err) {
+                throw new Error(`Method: ${method} | Path: ${path} | Make API reqeuest: ${err}`);
+            }
+        });
+    }
+    makeUrl(path, queryParams) {
+        let url = `${this.API_BASE_URL}${path}`;
+        if (queryParams) {
+            url += `?${this.getQueryParams(queryParams)}`;
+        }
+        return url;
+    }
+    getQueryParams(params) {
+        return new URLSearchParams(Object.fromEntries(Object.entries(params).filter(([_, val]) => val !== undefined))).toString();
+    }
+}
+exports.ApiService = ApiService;

package/dist/api-service/abstract-api.types.d.ts

@@ -0,0 +1,32 @@
+import { BodyInit } from "node-fetch";
+import { EHistoryType } from "../schemas";
+export declare enum EApiRequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH"
+}
+export interface MakeApiRequest {
+    method: EApiRequestMethod;
+    path: string;
+    body?: BodyInit;
+    queryParams?: ApiQueryParams;
+}
+export interface ApiQueryParams {
+    after?: AfterParameter;
+    limit?: LimitParameter;
+    minTime?: MinTimeParameter;
+    maxTime?: MaxTimeParameter;
+    types?: EHistoryType[];
+    reverse?: boolean;
+    kind?: ECollectionsTopKind;
+}
+export type LimitParameter = number;
+export type AfterParameter = string;
+export type MinTimeParameter = number;
+export type MaxTimeParameter = number;
+export declare enum ECollectionsTopKind {
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    All = "all"
+}

package/dist/api-service/abstract-api.types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECollectionsTopKind = exports.EApiRequestMethod = void 0;
+var EApiRequestMethod;
+(function (EApiRequestMethod) {
+    EApiRequestMethod["GET"] = "GET";
+    EApiRequestMethod["POST"] = "POST";
+    EApiRequestMethod["PATCH"] = "PATCH";
+})(EApiRequestMethod || (exports.EApiRequestMethod = EApiRequestMethod = {}));
+var ECollectionsTopKind;
+(function (ECollectionsTopKind) {
+    ECollectionsTopKind["Day"] = "day";
+    ECollectionsTopKind["Week"] = "week";
+    ECollectionsTopKind["Month"] = "month";
+    ECollectionsTopKind["All"] = "all";
+})(ECollectionsTopKind || (exports.ECollectionsTopKind = ECollectionsTopKind = {}));

package/dist/api-service/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiService } from './abstract-api.service';
+export { EApiRequestMethod, MakeApiRequest, ApiQueryParams, LimitParameter, AfterParameter, MinTimeParameter, MaxTimeParameter, ECollectionsTopKind } from './abstract-api.types';

package/dist/api-service/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECollectionsTopKind = exports.EApiRequestMethod = exports.ApiService = void 0;
+var abstract_api_service_1 = require("./abstract-api.service");
+Object.defineProperty(exports, "ApiService", { enumerable: true, get: function () { return abstract_api_service_1.ApiService; } });
+var abstract_api_types_1 = require("./abstract-api.types");
+Object.defineProperty(exports, "EApiRequestMethod", { enumerable: true, get: function () { return abstract_api_types_1.EApiRequestMethod; } });
+Object.defineProperty(exports, "ECollectionsTopKind", { enumerable: true, get: function () { return abstract_api_types_1.ECollectionsTopKind; } });

package/dist/cnft-api/cnft-api.service.d.ts

@@ -0,0 +1,11 @@
+import { ApiService } from "../api-service";
+import { MintingWalletBalanceResponse, FailedResponse, MintingMessageResponse, AddCNFTToCollectionResponse, CNFTRequest, OpenCNFTResult, UploadResponse } from "../schemas";
+export declare class CNFTApiService extends ApiService {
+    constructor(API_KEY: string);
+    mintingWalletBalance(collectionAddress: string): Promise<FailedResponse | MintingWalletBalanceResponse>;
+    mintingWalletRefund(collectionAddress: string, receiverAddress: string): Promise<FailedResponse | MintingMessageResponse>;
+    mintingDeactivateApi(collectionAddress: string): Promise<FailedResponse | MintingMessageResponse>;
+    addCNFTToCollection(collectionAddress: string, body: CNFTRequest): Promise<FailedResponse | AddCNFTToCollectionResponse>;
+    openCNFTMintInCollection(collectionAddress: string): Promise<FailedResponse | OpenCNFTResult>;
+    createCNFTUpload(collectionAddress: string, fileName: string): Promise<FailedResponse | UploadResponse>;
+}

package/dist/cnft-api/cnft-api.service.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CNFTApiService = void 0;
+const api_service_1 = require("../api-service");
+class CNFTApiService extends api_service_1.ApiService {
+    constructor(API_KEY) {
+        super(API_KEY);
+    }
+    mintingWalletBalance(collectionAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/wallet-balance`
+            });
+        });
+    }
+    mintingWalletRefund(collectionAddress, receiverAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/refund/${receiverAddress}`
+            });
+        });
+    }
+    mintingDeactivateApi(collectionAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/deactivate-api`
+            });
+        });
+    }
+    addCNFTToCollection(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/cnft/${collectionAddress}/add-nft`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    openCNFTMintInCollection(collectionAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/cnft/${collectionAddress}/open-minting`,
+            });
+        });
+    }
+    createCNFTUpload(collectionAddress, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/cnft/create-upload/${collectionAddress}/${fileName}`,
+            });
+        });
+    }
+}
+exports.CNFTApiService = CNFTApiService;

package/dist/cnft-api/index.d.ts

@@ -0,0 +1 @@
+export { CNFTApiService } from './cnft-api.service';

package/dist/cnft-api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CNFTApiService = void 0;
+var cnft_api_service_1 = require("./cnft-api.service");
+Object.defineProperty(exports, "CNFTApiService", { enumerable: true, get: function () { return cnft_api_service_1.CNFTApiService; } });

package/dist/gift-api/gift-api.service.d.ts

@@ -0,0 +1,16 @@
+import { AfterParameter, ApiService, LimitParameter } from "../api-service";
+import { ConfirmTransferRequest, ConfirmTransferResponse, FailedResponse, GiftTransferRequest, NftItemsFullResponse, RequestTransferResponse, TransferOffchainGiftRequest, TransferResponse } from "../schemas";
+export declare class GiftApiService extends ApiService {
+    constructor(API_KEY: string);
+    transferOffchainGift(address: string, body: TransferOffchainGiftRequest): Promise<FailedResponse | TransferResponse>;
+    getCollectionOwnerOffchainGifts(collectionAddress: string, ownerAddress: string, queryParams?: {
+        after?: AfterParameter;
+        limit?: LimitParameter;
+    }): Promise<FailedResponse | NftItemsFullResponse>;
+    getOwnerOffchainGifts(ownerAddress: string, queryParams?: {
+        after?: AfterParameter;
+        limit?: LimitParameter;
+    }): Promise<FailedResponse | NftItemsFullResponse>;
+    requestGiftTransfer(body: GiftTransferRequest): Promise<FailedResponse | RequestTransferResponse>;
+    confirmGiftTransfer(body: ConfirmTransferRequest): Promise<FailedResponse | ConfirmTransferResponse>;
+}

package/dist/gift-api/gift-api.service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiftApiService = void 0;
+const api_service_1 = require("../api-service");
+class GiftApiService extends api_service_1.ApiService {
+    constructor(API_KEY) {
+        super(API_KEY);
+    }
+    transferOffchainGift(address, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/v1/gifts/offchain/transfer/${address}`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    getCollectionOwnerOffchainGifts(collectionAddress, ownerAddress, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/v1/gifts/offchain/${collectionAddress}/owner/${ownerAddress}`,
+                queryParams
+            });
+        });
+    }
+    getOwnerOffchainGifts(ownerAddress, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/v1/gifts/offchain/owner/${ownerAddress}`,
+                queryParams
+            });
+        });
+    }
+    requestGiftTransfer(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/v1/gifts/request-transfer`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    confirmGiftTransfer(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/v1/gifts/confirm-transfer`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+}
+exports.GiftApiService = GiftApiService;

package/dist/gift-api/index.d.ts

@@ -0,0 +1 @@
+export { GiftApiService } from './gift-api.service';

package/dist/gift-api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiftApiService = void 0;
+var gift_api_service_1 = require("./gift-api.service");
+Object.defineProperty(exports, "GiftApiService", { enumerable: true, get: function () { return gift_api_service_1.GiftApiService; } });

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { ReadApiService } from "./read-api";
+import { MintingApiService } from "./minting-api";
+import { CNFTApiService } from "./cnft-api";
+import { GiftApiService } from "./gift-api";
+import { StorageApiService } from "./storage-api";
+declare class GetgemsService {
+    readApi: ReadApiService;
+    mintingApi: MintingApiService;
+    cNftApi: CNFTApiService;
+    giftApi: GiftApiService;
+    storageApi: StorageApiService;
+    constructor(apiKey: string);
+}
+export { GetgemsService as Getgems };

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Getgems = void 0;
+const read_api_1 = require("./read-api");
+const minting_api_1 = require("./minting-api");
+const cnft_api_1 = require("./cnft-api");
+const gift_api_1 = require("./gift-api");
+const storage_api_1 = require("./storage-api");
+class GetgemsService {
+    constructor(apiKey) {
+        this.readApi = new read_api_1.ReadApiService(apiKey);
+        this.mintingApi = new minting_api_1.MintingApiService(apiKey);
+        this.cNftApi = new cnft_api_1.CNFTApiService(apiKey);
+        this.giftApi = new gift_api_1.GiftApiService(apiKey);
+        this.storageApi = new storage_api_1.StorageApiService(apiKey);
+    }
+}
+exports.Getgems = GetgemsService;

package/dist/minting-api/index.d.ts

@@ -0,0 +1 @@
+export { MintingApiService } from './minting-api.service';

package/dist/minting-api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MintingApiService = void 0;
+var minting_api_service_1 = require("./minting-api.service");
+Object.defineProperty(exports, "MintingApiService", { enumerable: true, get: function () { return minting_api_service_1.MintingApiService; } });

package/dist/minting-api/minting-api.service.d.ts

@@ -0,0 +1,36 @@
+import { AfterParameter, ApiService, LimitParameter } from "../api-service";
+import { BatchMintingRequest, BatchMintingStatusResponse, CollectionUpdateRequest, CreateNewCollectionRequest, DefaultErrorObject, FailedResponse, MintingListResponse, MintingMessageResponse, MintingRequest, MintingStatusResponse, MintingWalletBalanceResponse, NftCollectionCreatingStatusResponse, NftItemResponse, NftItemsResponse, UpdateRequest, UpdateResponse, UploadResponse, V2BatchMintingRequest } from "../schemas";
+export declare class MintingApiService extends ApiService {
+    constructor(API_KEY: string);
+    createMinting(collectionAddress: string, body: MintingRequest): Promise<FailedResponse | MintingStatusResponse>;
+    createBatchMinting(collectionAddress: string, body: BatchMintingRequest): Promise<FailedResponse | BatchMintingStatusResponse>;
+    v2CreateBatchMinting(collectionAddress: string, body: V2BatchMintingRequest): Promise<FailedResponse | BatchMintingStatusResponse>;
+    v2GetBatchStatus(collectionAddress: string, body: {
+        requestIds: string[];
+    }): Promise<FailedResponse | BatchMintingStatusResponse>;
+    mintingWalletBalance(collectionAddress: string): Promise<FailedResponse | MintingWalletBalanceResponse>;
+    mintingWalletRefund(collectionAddress: string, receiverAddress: string): Promise<FailedResponse | MintingMessageResponse>;
+    mintingDeactivateApi(collectionAddress: string): Promise<FailedResponse | MintingMessageResponse>;
+    getStatus(collectionAddress: string, requestId: string): Promise<FailedResponse | MintingStatusResponse>;
+    getMintingList(collectionAddress: string, queryParams?: {
+        after?: AfterParameter;
+        limit?: LimitParameter;
+        reverse?: boolean;
+    }): Promise<FailedResponse | MintingListResponse>;
+    createUpload(collectionAddress: string, fileName: string): Promise<FailedResponse | UploadResponse>;
+    getNftByAddress(collectionAddress: string, nftAddress: string): Promise<FailedResponse | NftItemResponse>;
+    getNftsInCollection(collectionAddress: string, queryParams?: {
+        after?: AfterParameter;
+        limit?: LimitParameter;
+    }): Promise<FailedResponse | NftItemsResponse>;
+    getUserNftsInCollection(collectionAddress: string, userAddress: string, queryParams?: {
+        after?: AfterParameter;
+        limit?: LimitParameter;
+    }): Promise<FailedResponse | NftItemsResponse>;
+    getUpdateNftStatus(collectionAddress: string, nftAddress: string): Promise<UpdateResponse | FailedResponse>;
+    updateNft(collectionAddress: string, nftAddress: string, body: UpdateRequest): Promise<UpdateResponse | FailedResponse>;
+    newNftCollectionStatus(collectionAddress: string, requestId: string): Promise<DefaultErrorObject | FailedResponse | NftCollectionCreatingStatusResponse>;
+    createNewNftCollection(collectionAddress: string, body: CreateNewCollectionRequest): Promise<DefaultErrorObject | FailedResponse | NftCollectionCreatingStatusResponse>;
+    updateNftCollection(collectionAddress: string, body: CollectionUpdateRequest): Promise<UpdateResponse | FailedResponse>;
+    getUpdateNftCollectionStatus(collectionAddress: string, requestId: string): Promise<UpdateResponse | FailedResponse>;
+}

package/dist/minting-api/minting-api.service.js

@@ -0,0 +1,181 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MintingApiService = void 0;
+const api_service_1 = require("../api-service");
+class MintingApiService extends api_service_1.ApiService {
+    constructor(API_KEY) {
+        super(API_KEY);
+    }
+    createMinting(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    createBatchMinting(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/batch`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    v2CreateBatchMinting(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/v2/minting/${collectionAddress}/batch`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    v2GetBatchStatus(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/v2/minting/${collectionAddress}/batch-status`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    mintingWalletBalance(collectionAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/wallet-balance`
+            });
+        });
+    }
+    mintingWalletRefund(collectionAddress, receiverAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/refund/${receiverAddress}`
+            });
+        });
+    }
+    mintingDeactivateApi(collectionAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/deactivate-api`
+            });
+        });
+    }
+    getStatus(collectionAddress, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/${requestId}`
+            });
+        });
+    }
+    getMintingList(collectionAddress, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/list`,
+                queryParams
+            });
+        });
+    }
+    createUpload(collectionAddress, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/create-upload/${collectionAddress}/${fileName}`
+            });
+        });
+    }
+    getNftByAddress(collectionAddress, nftAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/nft/collection/by-address/${collectionAddress}/${nftAddress}`
+            });
+        });
+    }
+    getNftsInCollection(collectionAddress, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/nft/collection/items/${collectionAddress}`,
+                queryParams
+            });
+        });
+    }
+    getUserNftsInCollection(collectionAddress, userAddress, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/nft/collection/items/${collectionAddress}/${userAddress}`,
+                queryParams
+            });
+        });
+    }
+    getUpdateNftStatus(collectionAddress, nftAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/update/${nftAddress}`
+            });
+        });
+    }
+    updateNft(collectionAddress, nftAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/update/${nftAddress}`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    newNftCollectionStatus(collectionAddress, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/new-collection/${requestId}`
+            });
+        });
+    }
+    createNewNftCollection(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/new-collection`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    updateNftCollection(collectionAddress, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.POST,
+                path: `/minting/${collectionAddress}/update-collection`,
+                body: JSON.stringify(body)
+            });
+        });
+    }
+    getUpdateNftCollectionStatus(collectionAddress, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeApiRequest({
+                method: api_service_1.EApiRequestMethod.GET,
+                path: `/minting/${collectionAddress}/update-collection/${requestId}`
+            });
+        });
+    }
+}
+exports.MintingApiService = MintingApiService;

package/dist/read-api/index.d.ts

@@ -0,0 +1 @@
+export { ReadApiService } from './read-api.service';

package/dist/read-api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadApiService = void 0;
+var read_api_service_1 = require("./read-api.service");
+Object.defineProperty(exports, "ReadApiService", { enumerable: true, get: function () { return read_api_service_1.ReadApiService; } });