bitbadgesjs-sdk 0.3.17 → 0.3.19

package/dist/api-indexer/BitBadgesApi.js

@@ -26,9 +26,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getSearchResults(searchValue, body) {
+    async getSearchResults(searchValue, payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSearchRoute(searchValue)}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SearchRoute(searchValue)}`, payload);
             return new requests_1.GetSearchSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -36,27 +36,27 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getCollections(body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetCollections(this, body);
+    async getCollections(payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetCollections(this, payload);
     }
-    async getOwnersForBadge(collectionId, badgeId, body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetOwnersForBadge(this, collectionId, badgeId, body);
+    async getOwnersForBadge(collectionId, badgeId, payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetOwnersForBadge(this, collectionId, badgeId, payload);
     }
-    async getBadgeBalanceByAddress(collectionId, address, body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeBalanceByAddress(this, collectionId, address, body);
+    async getBadgeBalanceByAddress(collectionId, address, payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeBalanceByAddress(this, collectionId, address, payload);
     }
-    async getBadgeActivity(collectionId, badgeId, body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeActivity(this, collectionId, badgeId, body);
+    async getBadgeActivity(collectionId, badgeId, payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeActivity(this, collectionId, badgeId, payload);
     }
-    async refreshMetadata(collectionId, body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.RefreshMetadata(this, collectionId, body);
+    async refreshMetadata(collectionId, payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.RefreshMetadata(this, collectionId, payload);
     }
-    async completeClaim(claimId, cosmosAddress, body) {
+    async completeClaim(claimId, cosmosAddress, payload) {
         try {
             if (!claimId) {
                 throw new Error('claimId is required');
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CompleteClaimRoute(claimId, cosmosAddress)}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CompleteClaimRoute(claimId, cosmosAddress)}`, payload);
             return new requests_1.CompleteClaimSuccessResponse(response.data);
         }
         catch (error) {
@@ -64,12 +64,12 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async simulateClaim(claimId, cosmosAddress, body) {
+    async simulateClaim(claimId, cosmosAddress, payload) {
         try {
             if (!claimId) {
                 throw new Error('claimId is required');
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateClaimRoute(claimId, cosmosAddress)}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateClaimRoute(claimId, cosmosAddress)}`, payload);
             return new requests_1.SimulateClaimSuccessResponse(response.data);
         }
         catch (error) {
@@ -77,25 +77,25 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getReservedCodes(claimId, cosmosAddress, body) {
+    async getReservedClaimCodes(claimId, cosmosAddress, payload) {
         try {
             if (!claimId) {
                 throw new Error('claimId is required');
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetReservedCodesRoute(claimId, cosmosAddress)}`, body);
-            return new requests_1.GetReservedCodesSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetReservedClaimCodesRoute(claimId, cosmosAddress)}`, payload);
+            return new requests_1.GetReservedClaimCodesSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getClaimAttemptStatus(txId) {
+    async getClaimAttemptStatus(claimAttemptId) {
         try {
-            if (!txId) {
-                throw new Error('txId is required');
+            if (!claimAttemptId) {
+                throw new Error('claimAttemptId is required');
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAttemptStatusRoute(txId)}`);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAttemptStatusRoute(claimAttemptId)}`);
             return new requests_1.GetClaimAttemptStatusSuccessResponse(response.data);
         }
         catch (error) {
@@ -103,9 +103,11 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async deleteReview(reviewId, body) {
+    async deleteReview(reviewId, payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteReviewRoute(reviewId)}`, body);
+            const response = await this.axios.delete(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteReviewRoute(reviewId)}`, {
+                data: payload
+            });
             return new requests_1.DeleteReviewSuccessResponse(response.data);
         }
         catch (error) {
@@ -113,9 +115,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async addReview(body) {
+    async addReview(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddReviewRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddReviewRoute()}`, payload);
             return new requests_1.AddReviewSuccessResponse(response.data);
         }
         catch (error) {
@@ -123,12 +125,12 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getAccounts(body) {
-        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetAccounts(this, body);
+    async getAccounts(payload) {
+        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetAccounts(this, payload);
     }
-    async updateAccountInfo(body) {
+    async updateAccountInfo(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAccountInfoRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAccountInfoRoute()}`, payload);
             return new requests_1.UpdateAccountInfoSuccessResponse(response.data);
         }
         catch (error) {
@@ -136,9 +138,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async addBalancesToOffChainStorage(body) {
+    async addBalancesToOffChainStorage(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddBalancesToOffChainStorageRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddBalancesToOffChainStorageRoute()}`, payload);
             return new requests_1.AddBalancesToOffChainStorageSuccessResponse(response.data);
         }
         catch (error) {
@@ -146,9 +148,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async addToIpfs(body) {
+    async addToIpfs(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddToIpfsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddToIpfsRoute()}`, payload);
             return new requests_1.AddToIpfsSuccessResponse(response.data);
         }
         catch (error) {
@@ -156,9 +158,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async addApprovalDetailsToOffChainStorage(body) {
+    async addApprovalDetailsToOffChainStorage(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddApprovalDetailsToOffChainStorageRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddApprovalDetailsToOffChainStorageRoute()}`, payload);
             return new requests_1.AddApprovalDetailsToOffChainStorageSuccessResponse(response.data);
         }
         catch (error) {
@@ -166,9 +168,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getSignInChallenge(body) {
+    async getSignInChallenge(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSignInChallengeRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSignInChallengeRoute()}`, payload);
             return new requests_1.GetSignInChallengeSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -176,9 +178,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async verifySignIn(body) {
+    async verifySignIn(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.VerifySignInRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.VerifySignInRoute()}`, payload);
             return new requests_1.VerifySignInSuccessResponse(response.data);
         }
         catch (error) {
@@ -186,9 +188,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async checkIfSignedIn(body) {
+    async checkIfSignedIn(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CheckIfSignedInRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CheckIfSignedInRoute()}`, payload);
             return new requests_1.CheckSignInStatusSuccessResponse(response.data);
         }
         catch (error) {
@@ -196,9 +198,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async signOut(body) {
+    async signOut(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SignOutRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SignOutRoute()}`, payload);
             return new requests_1.SignOutSuccessResponse(response.data);
         }
         catch (error) {
@@ -206,9 +208,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getBrowseCollections(body) {
+    async getBrowseCollections(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBrowseCollectionsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBrowseCollectionsRoute()}`, payload);
             return new requests_1.GetBrowseCollectionsSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -216,9 +218,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async broadcastTx(body) {
+    async broadcastTx(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.BroadcastTxRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.BroadcastTxRoute()}`, payload);
             return new requests_1.BroadcastTxSuccessResponse(response.data);
         }
         catch (error) {
@@ -226,9 +228,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async simulateTx(body) {
+    async simulateTx(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateTxRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateTxRoute()}`, payload);
             return new requests_1.SimulateTxSuccessResponse(response.data);
         }
         catch (error) {
@@ -236,13 +238,13 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async fetchMetadataDirectly(body) {
+    async fetchMetadataDirectly(payload) {
         try {
-            const error = body.uris.find((uri) => joi_1.default.string().uri().required().validate(uri).error);
+            const error = payload.uris.find((uri) => joi_1.default.string().uri().required().validate(uri).error);
             if (error) {
                 throw `Invalid URIs`;
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.FetchMetadataDirectlyRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.FetchMetadataDirectlyRoute()}`, payload);
             return new requests_1.FetchMetadataDirectlySuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -250,9 +252,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getTokensFromFaucet(body) {
+    async getTokensFromFaucet(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetTokensFromFaucetRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetTokensFromFaucetRoute()}`, payload);
             return new requests_1.GetTokensFromFaucetSuccessResponse(response.data);
         }
         catch (error) {
@@ -260,61 +262,61 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async createAddressLists(body) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.CreateAddressList(this, body);
+    async createAddressLists(payload) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.CreateAddressList(this, payload);
     }
-    async updateAddressLists(body) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.UpdateAddressList(this, body);
+    async updateAddressLists(payload) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.UpdateAddressList(this, payload);
     }
-    async getAddressLists(body) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.GetAddressLists(this, body);
+    async getAddressLists(payload) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.GetAddressLists(this, payload);
     }
-    async deleteAddressLists(body) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.DeleteAddressList(this, body);
+    async deleteAddressLists(payload) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.DeleteAddressList(this, payload);
     }
-    async getAuthCode(body) {
+    async getAndVerifySIWBBRequest(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthCodeRoute()}`, body);
-            return new requests_1.GetBlockinAuthCodeSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSIWBBRequestRoute()}`, payload);
+            return new requests_1.GetAndVerifySIWBBRequestSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getAuthCodesForAuthApp(body) {
+    async getSIWBBRequestsForDeveloperApp(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthCodesForAuthAppRoute()}`, body);
-            return new requests_1.GetBlockinAuthCodesForAuthAppSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSIWBBRequestsForDeveloperAppRoute()}`, payload);
+            return new requests_1.GetAndVerifySIWBBRequestsForDeveloperAppSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createAuthCode(body) {
+    async createSIWBBRequest(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthCodeRoute()}`, body);
-            return new requests_1.CreateBlockinAuthCodeSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSIWBBRequestRoute()}`, payload);
+            return new requests_1.CreateSIWBBRequestSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteAuthCode(body) {
+    async deleteSIWBBRequest(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthCodeRoute()}`, body);
-            return new requests_1.DeleteBlockinAuthCodeSuccessResponse(response.data);
+            const response = await this.axios.delete(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSIWBBRequestRoute()}`, { data: payload });
+            return new requests_1.DeleteSIWBBRequestSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async verifySignInGeneric(body) {
+    async verifySIWBBRequest(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyRoute()}`, payload);
             return new requests_1.GenericBlockinVerifySuccessResponse(response.data);
         }
         catch (error) {
@@ -322,9 +324,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async verifyAssetsGeneric(body) {
+    async verifyOwnershipRequirements(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyAssetsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyAssetsRoute()}`, payload);
             return new requests_1.GenericVerifyAssetsSuccessResponse(response.data);
         }
         catch (error) {
@@ -332,9 +334,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async sendClaimAlert(body) {
+    async sendClaimAlert(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SendClaimAlertRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SendClaimAlertRoute()}`, payload);
             return new requests_1.SendClaimAlertsSuccessResponse(response.data);
         }
         catch (error) {
@@ -342,12 +344,12 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getFollowDetails(body) {
-        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetFollowDetails(this, body);
+    async getFollowDetails(payload) {
+        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetFollowDetails(this, payload);
     }
-    async getClaimAlerts(body) {
+    async getClaimAlerts(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAlertsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAlertsRoute()}`, payload);
             return new requests_1.GetClaimAlertsForCollectionSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -358,9 +360,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
     async getRefreshStatus(collectionId) {
         return await BitBadgesCollection_1.BitBadgesCollection.GetRefreshStatus(this, collectionId);
     }
-    async getMaps(body) {
+    async getMaps(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetMapsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetMapsRoute()}`, payload);
             return new maps_1.GetMapsSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -368,12 +370,12 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async filterBadgesInCollection(body) {
-        return await BitBadgesCollection_1.BitBadgesCollection.FilterBadgesInCollection(this, body);
+    async filterBadgesInCollection(collectionId, payload) {
+        return await BitBadgesCollection_1.BitBadgesCollection.FilterBadgesInCollection(this, collectionId, payload);
     }
-    async generateAppleWalletPass(body) {
+    async generateAppleWalletPass(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenerateAppleWalletPassRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenerateAppleWalletPassRoute()}`, payload);
             return new requests_1.GenerateAppleWalletPassSuccessResponse(response.data);
         }
         catch (error) {
@@ -381,9 +383,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getClaims(body) {
+    async getClaims(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimsRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDClaimsRoute()}`, payload);
             return new requests_1.GetClaimsSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -391,9 +393,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getSecret(body) {
+    async getSecret(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSecretRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSecretRoute()}`, payload);
             return new requests_1.GetSecretSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
@@ -401,9 +403,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async createSecret(body) {
+    async createSecret(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateSecretRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSecretRoute()}`, payload);
             return new requests_1.CreateSecretSuccessResponse(response.data);
         }
         catch (error) {
@@ -411,9 +413,11 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async deleteSecret(body) {
+    async deleteSecret(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteSecretRoute()}`, body);
+            const response = await this.axios.delete(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSecretRoute()}`, {
+                data: payload
+            });
             return new requests_1.DeleteSecretSuccessResponse(response.data);
         }
         catch (error) {
@@ -421,9 +425,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async updateSecret(body) {
+    async updateSecret(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateSecretRoute()}`, body);
+            const response = await this.axios.put(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDSecretRoute()}`, payload);
             return new requests_1.UpdateSecretSuccessResponse(response.data);
         }
         catch (error) {
@@ -431,59 +435,59 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getAuthApps(body) {
+    async getDeveloperApps(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthAppRoute()}`, body);
-            return new requests_1.GetAuthAppSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDDeveloperAppRoute()}`, payload);
+            return new requests_1.GetDeveloperAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createAuthApp(body) {
+    async createDeveloperApp(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthAppRoute()}`, body);
-            return new requests_1.CreateAuthAppSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDDeveloperAppRoute()}`, payload);
+            return new requests_1.CreateDeveloperAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteAuthApp(body) {
+    async deleteDeveloperApp(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthAppRoute()}`, body);
-            return new requests_1.DeleteAuthAppSuccessResponse(response.data);
+            const response = await this.axios.delete(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDDeveloperAppRoute()}`, { data: payload });
+            return new requests_1.DeleteDeveloperAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async updateAuthApp(body) {
+    async updateDeveloperApp(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAuthAppRoute()}`, body);
-            return new requests_1.UpdateAuthAppSuccessResponse(response.data);
+            const response = await this.axios.put(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDDeveloperAppRoute()}`, payload);
+            return new requests_1.UpdateDeveloperAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getPlugins(body) {
+    async getPlugins(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetPluginRoute()}`, body);
-            return new requests_1.GetPluginSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDPluginRoute()}`, payload);
+            return new requests_1.GetPluginSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createPlugin(body) {
+    async createPlugin(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreatePluginRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDPluginRoute()}`, payload);
             return new requests_1.CreatePluginSuccessResponse(response.data);
         }
         catch (error) {
@@ -491,9 +495,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async createClaim(body) {
+    async createClaim(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateClaimRoute()}`, body);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDClaimsRoute()}`, payload);
             return new requests_1.CreateClaimSuccessResponse(response.data);
         }
         catch (error) {
@@ -501,9 +505,11 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async deleteClaim(body) {
+    async deleteClaim(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteClaimRoute()}`, body);
+            const response = await this.axios.delete(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDClaimsRoute()}`, {
+                data: payload
+            });
             return new requests_1.DeleteClaimSuccessResponse(response.data);
         }
         catch (error) {
@@ -511,9 +517,9 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async updateClaim(body) {
+    async updateClaim(payload) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateClaimRoute()}`, body);
+            const response = await this.axios.put(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CRUDClaimsRoute()}`, payload);
             return new requests_1.UpdateClaimSuccessResponse(response.data);
         }
         catch (error) {
@@ -521,6 +527,47 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
+    async getActiveAuthorizations(payload) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetActiveAuthorizationsRoute()}`, payload);
+            return new requests_1.GetActiveAuthorizationsSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getOauthAuthorizationCode(payload) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.OauthAuthorizeRoute()}`, payload);
+            console.log(response.data);
+            return new requests_1.OauthAuthorizeSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getOauthAccessToken(payload) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.OauthTokenRoute()}`, payload);
+            return new requests_1.OauthTokenSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async revokeOauthAuthorization(payload) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.OauthRevokeRoute()}`, payload);
+            return new requests_1.OauthRevokeSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
     async updateUserSeenActivity() {
         return await this.updateAccountInfo({ seenActivity: Date.now() });
     }