bitbadgesjs-sdk 0.3.14 → 0.3.16

package/dist/api-indexer/BitBadgesApi.js

@@ -19,149 +19,147 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
     async getStatus() {
         try {
             const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetStatusRoute()}`);
-            return new requests_1.GetStatusRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            return new requests_1.GetStatusSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getSearchResults(searchValue, requestBody) {
+    async getSearchResults(searchValue, body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSearchRoute(searchValue)}`, requestBody);
-            return new requests_1.GetSearchRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSearchRoute(searchValue)}`, body);
+            return new requests_1.GetSearchSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getCollections(requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetCollections(this, requestBody);
+    async getCollections(body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetCollections(this, body);
     }
-    async getOwnersForBadge(collectionId, badgeId, requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetOwnersForBadge(this, collectionId, badgeId, requestBody);
+    async getOwnersForBadge(collectionId, badgeId, body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetOwnersForBadge(this, collectionId, badgeId, body);
     }
-    async getBadgeBalanceByAddress(collectionId, address, requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeBalanceByAddress(this, collectionId, address, requestBody);
+    async getBadgeBalanceByAddress(collectionId, address, body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeBalanceByAddress(this, collectionId, address, body);
     }
-    async getBadgeActivity(collectionId, badgeId, requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeActivity(this, collectionId, badgeId, requestBody);
+    async getBadgeActivity(collectionId, badgeId, body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.GetBadgeActivity(this, collectionId, badgeId, body);
     }
-    async refreshMetadata(collectionId, requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.RefreshMetadata(this, collectionId, requestBody);
+    async refreshMetadata(collectionId, body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.RefreshMetadata(this, collectionId, body);
     }
-    async checkAndCompleteClaim(claimId, cosmosAddress, requestBody) {
+    async completeClaim(claimId, cosmosAddress, body) {
         try {
             if (!claimId) {
                 throw new Error('claimId is required');
             }
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CheckAndCompleteClaimRoute(claimId, cosmosAddress)}`, requestBody);
-            return new requests_1.CheckAndCompleteClaimRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CompleteClaimRoute(claimId, cosmosAddress)}`, body);
+            return new requests_1.CompleteClaimSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteReview(reviewId, requestBody) {
+    async deleteReview(reviewId, body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteReviewRoute(reviewId)}`, requestBody);
-            return new requests_1.DeleteReviewRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteReviewRoute(reviewId)}`, body);
+            return new requests_1.DeleteReviewSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async addReview(requestBody) {
+    async addReview(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddReviewRoute()}`, requestBody);
-            return new requests_1.AddReviewRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddReviewRoute()}`, body);
+            return new requests_1.AddReviewSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getAccounts(requestBody) {
-        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetAccounts(this, requestBody);
+    async getAccounts(body) {
+        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetAccounts(this, body);
     }
-    async updateAccountInfo(requestBody) {
+    async updateAccountInfo(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAccountInfoRoute()}`, requestBody);
-            return new requests_1.UpdateAccountInfoRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAccountInfoRoute()}`, body);
+            return new requests_1.UpdateAccountInfoSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async addBalancesToOffChainStorage(requestBody) {
+    async addBalancesToOffChainStorage(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddBalancesToOffChainStorageRoute()}`, requestBody);
-            return new requests_1.AddBalancesToOffChainStorageRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddBalancesToOffChainStorageRoute()}`, body);
+            return new requests_1.AddBalancesToOffChainStorageSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async addMetadataToIpfs(requestBody) {
+    async addToIpfs(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddMetadataToIpfsRoute()}`, requestBody);
-            return new requests_1.AddMetadataToIpfsRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddToIpfsRoute()}`, body);
+            return new requests_1.AddToIpfsSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async addApprovalDetailsToOffChainStorage(requestBody) {
+    async addApprovalDetailsToOffChainStorage(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddApprovalDetailsToOffChainStorageRoute()}`, requestBody);
-            return new requests_1.AddApprovalDetailsToOffChainStorageRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.AddApprovalDetailsToOffChainStorageRoute()}`, body);
+            return new requests_1.AddApprovalDetailsToOffChainStorageSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getSignInChallenge(requestBody) {
+    async getSignInChallenge(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSignInChallengeRoute()}`, requestBody);
-            return new requests_1.GetSignInChallengeRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSignInChallengeRoute()}`, body);
+            return new requests_1.GetSignInChallengeSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async verifySignIn(requestBody) {
+    async verifySignIn(body) {
         try {
-            const body = requestBody;
             const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.VerifySignInRoute()}`, body);
-            return new requests_1.VerifySignInRouteSuccessResponse(response.data);
+            return new requests_1.VerifySignInSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async checkIfSignedIn(requestBody) {
+    async checkIfSignedIn(body) {
         try {
-            const body = requestBody;
             const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CheckIfSignedInRoute()}`, body);
-            return new requests_1.CheckSignInStatusRequestSuccessResponse(response.data);
+            return new requests_1.CheckSignInStatusSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async signOut(requestBody) {
+    async signOut(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SignOutRoute()}`, requestBody);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SignOutRoute()}`, body);
             return new requests_1.SignOutSuccessResponse(response.data);
         }
         catch (error) {
@@ -169,141 +167,149 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
             return Promise.reject(error);
         }
     }
-    async getBrowseCollections(requestBody) {
+    async getBrowseCollections(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBrowseCollectionsRoute()}`, requestBody);
-            return new requests_1.GetBrowseCollectionsRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBrowseCollectionsRoute()}`, body);
+            return new requests_1.GetBrowseCollectionsSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async broadcastTx(requestBody) {
+    async broadcastTx(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.BroadcastTxRoute()}`, requestBody);
-            return new requests_1.BroadcastTxRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.BroadcastTxRoute()}`, body);
+            return new requests_1.BroadcastTxSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async simulateTx(requestBody) {
+    async simulateTx(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateTxRoute()}`, requestBody);
-            return new requests_1.SimulateTxRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SimulateTxRoute()}`, body);
+            return new requests_1.SimulateTxSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async fetchMetadataDirectly(requestBody) {
+    async fetchMetadataDirectly(body) {
         try {
-            const error = requestBody.uris.find((uri) => joi_1.default.string().uri().required().validate(uri).error);
+            const error = body.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()}`, requestBody);
-            return new requests_1.FetchMetadataDirectlyRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.FetchMetadataDirectlyRoute()}`, body);
+            return new requests_1.FetchMetadataDirectlySuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getTokensFromFaucet(requestBody) {
+    async getTokensFromFaucet(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetTokensFromFaucetRoute()}`, requestBody);
-            return new requests_1.GetTokensFromFaucetRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetTokensFromFaucetRoute()}`, body);
+            return new requests_1.GetTokensFromFaucetSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createAddressLists(requestBody) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.CreateAddressList(this, requestBody);
+    async createAddressLists(body) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.CreateAddressList(this, body);
     }
-    async updateAddressLists(requestBody) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.UpdateAddressList(this, requestBody);
+    async updateAddressLists(body) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.UpdateAddressList(this, body);
     }
-    async getAddressLists(requestBody) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.GetAddressLists(this, requestBody);
+    async getAddressLists(body) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.GetAddressLists(this, body);
     }
-    async deleteAddressLists(requestBody) {
-        return await BitBadgesAddressList_1.BitBadgesAddressList.DeleteAddressList(this, requestBody);
+    async deleteAddressLists(body) {
+        return await BitBadgesAddressList_1.BitBadgesAddressList.DeleteAddressList(this, body);
     }
-    async getAuthCode(requestBody) {
+    async getAuthCode(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthCodeRoute()}`, requestBody);
-            return new requests_1.GetBlockinAuthCodeRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthCodeRoute()}`, body);
+            return new requests_1.GetBlockinAuthCodeSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createAuthCode(requestBody) {
+    async getAuthCodesForAuthApp(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthCodeRoute()}`, requestBody);
-            return new requests_1.CreateBlockinAuthCodeRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthCodesForAuthAppRoute()}`, body);
+            return new requests_1.GetBlockinAuthCodesForAuthAppSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteAuthCode(requestBody) {
+    async createAuthCode(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthCodeRoute()}`, requestBody);
-            return new requests_1.DeleteBlockinAuthCodeRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthCodeRoute()}`, body);
+            return new requests_1.CreateBlockinAuthCodeSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async verifySignInGeneric(requestBody) {
+    async deleteAuthCode(body) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthCodeRoute()}`, body);
+            return new requests_1.DeleteBlockinAuthCodeSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async verifySignInGeneric(body) {
         try {
-            const body = requestBody;
             const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyRoute()}`, body);
-            return new requests_1.GenericBlockinVerifyRouteSuccessResponse(response.data);
+            return new requests_1.GenericBlockinVerifySuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async verifyAssetsGeneric(requestBody) {
+    async verifyAssetsGeneric(body) {
         try {
-            const body = requestBody;
             const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenericVerifyAssetsRoute()}`, body);
-            return new requests_1.GenericVerifyAssetsRouteSuccessResponse(response.data);
+            return new requests_1.GenericVerifyAssetsSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async sendClaimAlert(requestBody) {
+    async sendClaimAlert(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SendClaimAlertRoute()}`, requestBody);
-            return new requests_1.SendClaimAlertsRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.SendClaimAlertRoute()}`, body);
+            return new requests_1.SendClaimAlertsSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getFollowDetails(requestBody) {
-        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetFollowDetails(this, requestBody);
+    async getFollowDetails(body) {
+        return await BitBadgesUserInfo_1.BitBadgesUserInfo.GetFollowDetails(this, body);
     }
-    async getClaimAlerts(requestBody) {
+    async getClaimAlerts(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAlertsRoute()}`, requestBody);
-            return new requests_1.GetClaimAlertsForCollectionRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimAlertsRoute()}`, body);
+            return new requests_1.GetClaimAlertsForCollectionSuccessResponse(response.data).convert(this.ConvertFunction);
         }
         catch (error) {
             await this.handleApiError(error);
@@ -313,123 +319,163 @@ class BitBadgesAPI extends base_1.BaseBitBadgesApi {
     async getRefreshStatus(collectionId) {
         return await BitBadgesCollection_1.BitBadgesCollection.GetRefreshStatus(this, collectionId);
     }
-    async getMaps(requestBody) {
+    async getMaps(body) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetMapsRoute()}`, body);
+            return new maps_1.GetMapsSuccessResponse(response.data).convert(this.ConvertFunction);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async filterBadgesInCollection(body) {
+        return await BitBadgesCollection_1.BitBadgesCollection.FilterBadgesInCollection(this, body);
+    }
+    async generateAppleWalletPass(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetMapsRoute()}`, requestBody);
-            return new maps_1.GetMapsRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenerateAppleWalletPassRoute()}`, body);
+            return new requests_1.GenerateAppleWalletPassSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async filterBadgesInCollection(requestBody) {
-        return await BitBadgesCollection_1.BitBadgesCollection.FilterBadgesInCollection(this, requestBody);
+    async getClaims(body) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimsRoute()}`, body);
+            return new requests_1.GetClaimsSuccessResponse(response.data).convert(this.ConvertFunction);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getSecret(body) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSecretRoute()}`, body);
+            return new requests_1.GetSecretSuccessResponse(response.data).convert(this.ConvertFunction);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async createSecret(body) {
+        try {
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateSecretRoute()}`, body);
+            return new requests_1.CreateSecretSuccessResponse(response.data);
+        }
+        catch (error) {
+            await this.handleApiError(error);
+            return Promise.reject(error);
+        }
     }
-    async generateAppleWalletPass(requestBody) {
+    async deleteSecret(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GenerateAppleWalletPassRoute()}`, requestBody);
-            return new requests_1.GenerateAppleWalletPassRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteSecretRoute()}`, body);
+            return new requests_1.DeleteSecretSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getClaims(requestBody) {
+    async updateSecret(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetClaimsRoute()}`, requestBody);
-            return new requests_1.GetClaimsRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateSecretRoute()}`, body);
+            return new requests_1.UpdateSecretSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getExternalCallKey(requestBody) {
+    async getAuthApps(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetExternalCallKeyRoute()}`, requestBody);
-            return new requests_1.GetExternalCallRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthAppRoute()}`, body);
+            return new requests_1.GetAuthAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getSecret(requestBody) {
+    async createAuthApp(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetSecretRoute()}`, requestBody);
-            return new requests_1.GetSecretRouteSuccessResponse(response.data).convert(this.ConvertFunction);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthAppRoute()}`, body);
+            return new requests_1.CreateAuthAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createSecret(requestBody) {
+    async deleteAuthApp(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateSecretRoute()}`, requestBody);
-            return new requests_1.CreateSecretRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthAppRoute()}`, body);
+            return new requests_1.DeleteAuthAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteSecret(requestBody) {
+    async updateAuthApp(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteSecretRoute()}`, requestBody);
-            return new requests_1.DeleteSecretRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAuthAppRoute()}`, body);
+            return new requests_1.UpdateAuthAppSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async updateSecret(requestBody) {
+    async getPlugins(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateSecretRoute()}`, requestBody);
-            return new requests_1.UpdateSecretRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetPluginRoute()}`, body);
+            return new requests_1.GetPluginSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async getAuthApps(requestBody) {
+    async createPlugin(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetAuthAppRoute()}`, requestBody);
-            return new requests_1.GetAuthAppRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreatePluginRoute()}`, body);
+            return new requests_1.CreatePluginSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async createAuthApp(requestBody) {
+    async createClaim(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateAuthAppRoute()}`, requestBody);
-            return new requests_1.CreateAuthAppRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.CreateClaimRoute()}`, body);
+            return new requests_1.CreateClaimSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async deleteAuthApp(requestBody) {
+    async deleteClaim(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteAuthAppRoute()}`, requestBody);
-            return new requests_1.DeleteAuthAppRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.DeleteClaimRoute()}`, body);
+            return new requests_1.DeleteClaimSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);
             return Promise.reject(error);
         }
     }
-    async updateAuthApp(requestBody) {
+    async updateClaim(body) {
         try {
-            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateAuthAppRoute()}`, requestBody);
-            return new requests_1.UpdateAuthAppRouteSuccessResponse(response.data);
+            const response = await this.axios.post(`${this.BACKEND_URL}${routes_1.BitBadgesApiRoutes.UpdateClaimRoute()}`, body);
+            return new requests_1.UpdateClaimSuccessResponse(response.data);
         }
         catch (error) {
             await this.handleApiError(error);