bitbadgesjs-sdk 0.3.94 → 0.3.95

package/dist/esm/api-indexer/BitBadgesCollection.js

@@ -0,0 +1,1297 @@
+import { convertClassPropertiesAndMaintainNumberTypes, getConverterFunction } from '@/common/base';
+import { BigIntify } from '@/common/string-numbers';
+import { AddressList } from '@/core/addressLists';
+import { generateAlias, getAliasDerivationKeysForBadge } from '@/core/aliases';
+import { getMintApprovals, getNonMintApprovals, getUnhandledCollectionApprovals } from '@/core/approval-utils';
+import { CollectionApprovalWithDetails } from '@/core/approvals';
+import { BalanceArray } from '@/core/balances';
+import { BadgeMetadataTimeline, BadgeMetadataTimelineWithDetails, CollectionMetadataTimelineWithDetails, CustomDataTimeline, IsArchivedTimeline, ManagerTimeline, OffChainBalancesMetadataTimeline, StandardsTimeline } from '@/core/misc';
+import { getPermissionVariablesFromName } from '@/core/permission-utils';
+import { ActionPermission, BalancesActionPermission, CollectionApprovalPermissionWithDetails, CollectionPermissionsWithDetails, TimedUpdatePermission, TimedUpdateWithBadgeIdsPermission } from '@/core/permissions';
+import { UintRange, UintRangeArray } from '@/core/uintRanges';
+import { UserBalanceStoreWithDetails } from '@/core/userBalances';
+import { ReviewDoc, TransferActivityDoc } from './docs/activity';
+import { ApprovalTrackerDoc, BalanceDocWithDetails, CollectionDoc, MapDoc, MerkleChallengeDoc } from './docs/docs';
+import { BadgeMetadataDetails } from './metadata/badgeMetadata';
+import { GO_MAX_UINT_64 } from '@/common/math';
+import { getCurrentValueForTimeline } from '@/core/timelines';
+import { ClaimDetails } from './requests';
+import { FilterBadgesInCollectionSuccessResponse, GetBadgeActivitySuccessResponse, GetBadgeBalanceByAddressSuccessResponse, GetCollectionsSuccessResponse, GetOwnersForBadgeSuccessResponse, RefreshMetadataSuccessResponse, RefreshStatusSuccessResponse } from './requests/collections';
+import { BitBadgesApiRoutes } from './requests/routes';
+import { convertToCosmosAddress } from '..';
+import typia from 'typia';
+const NEW_COLLECTION_ID = 0n;
+export class BitBadgesCollection extends CollectionDoc {
+    collectionApprovals;
+    collectionPermissions;
+    defaultBalances;
+    collectionMetadataTimeline;
+    badgeMetadataTimeline;
+    activity;
+    reviews;
+    owners;
+    merkleChallenges;
+    approvalTrackers;
+    claims;
+    reservedMap;
+    nsfw;
+    reported;
+    views;
+    constructor(data) {
+        super(data);
+        this.collectionApprovals = data.collectionApprovals.map((collectionApproval) => new CollectionApprovalWithDetails(collectionApproval));
+        this.collectionPermissions = new CollectionPermissionsWithDetails(data.collectionPermissions);
+        this.defaultBalances = new UserBalanceStoreWithDetails(data.defaultBalances);
+        this.collectionMetadataTimeline = data.collectionMetadataTimeline.map((collectionMetadata) => new CollectionMetadataTimelineWithDetails(collectionMetadata));
+        this.badgeMetadataTimeline = data.badgeMetadataTimeline.map((badgeMetadata) => new BadgeMetadataTimelineWithDetails(badgeMetadata));
+        this.activity = data.activity.map((activityItem) => new TransferActivityDoc(activityItem));
+        this.reviews = data.reviews.map((activityItem) => new ReviewDoc(activityItem));
+        this.owners = data.owners.map((balance) => new BalanceDocWithDetails(balance));
+        this.merkleChallenges = data.merkleChallenges.map((merkleChallenge) => new MerkleChallengeDoc(merkleChallenge));
+        this.approvalTrackers = data.approvalTrackers.map((approvalTracker) => new ApprovalTrackerDoc(approvalTracker));
+        this.nsfw = data.nsfw ? { ...data.nsfw, badgeIds: UintRangeArray.From(data.nsfw.badgeIds) } : undefined;
+        this.reported = data.reported ? { ...data.reported, badgeIds: UintRangeArray.From(data.reported.badgeIds) } : undefined;
+        this.views = data.views;
+        this.claims = data.claims.map((x) => new ClaimDetails(x));
+        this.reservedMap = data.reservedMap ? new MapDoc(data.reservedMap) : undefined;
+    }
+    getNumberFieldNames() {
+        return [...super.getNumberFieldNames()];
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    clone() {
+        return super.clone();
+    }
+    getCollectionMetadata() {
+        return getCurrentValueForTimeline(this.collectionMetadataTimeline)?.collectionMetadata.metadata;
+    }
+    getCollectionMetadataDetails() {
+        return getCurrentValueForTimeline(this.collectionMetadataTimeline)?.collectionMetadata;
+    }
+    setCollectionMetadataForTimes(metadata, timelineTimesToSet) {
+        const converterFunction = getConverterFunction(this.collectionId);
+        const fullTimeline = timelineTimesToSet
+            ? this.collectionMetadataTimeline
+                .map((x) => x.clone())
+                .map((x) => {
+                const newTimes = x.timelineTimes.clone().remove(timelineTimesToSet);
+                return new CollectionMetadataTimelineWithDetails({
+                    ...x,
+                    timelineTimes: newTimes
+                });
+            })
+                .filter((x) => x.timelineTimes.length > 0)
+            : [];
+        fullTimeline.push(new CollectionMetadataTimelineWithDetails({
+            collectionMetadata: metadata,
+            timelineTimes: timelineTimesToSet ? UintRangeArray.From(timelineTimesToSet ?? []) : UintRangeArray.FullRanges()
+        }).convert(converterFunction));
+        return fullTimeline;
+    }
+    setBadgeMetadataForTimes(metadata, timelineTimesToSet) {
+        const converterFunction = getConverterFunction(this.collectionId);
+        const fullTimeline = timelineTimesToSet
+            ? this.badgeMetadataTimeline
+                .map((x) => x.clone())
+                .map((x) => {
+                const newTimes = x.timelineTimes.clone().remove(timelineTimesToSet);
+                return new BadgeMetadataTimelineWithDetails({
+                    ...x,
+                    timelineTimes: newTimes
+                });
+            })
+                .filter((x) => x.timelineTimes.length > 0)
+            : [];
+        fullTimeline.push(new BadgeMetadataTimelineWithDetails({
+            badgeMetadata: metadata,
+            timelineTimes: timelineTimesToSet ? UintRangeArray.From(timelineTimesToSet ?? []) : UintRangeArray.FullRanges()
+        }).convert(converterFunction));
+        return fullTimeline;
+    }
+    getCurrentBadgeMetadata() {
+        return getCurrentValueForTimeline(this.badgeMetadataTimeline)?.badgeMetadata.map((x) => x.clone()) ?? [];
+    }
+    getBadgeMetadata(badgeId) {
+        return BadgeMetadataDetails.getMetadataForBadgeId(badgeId, this.getCurrentBadgeMetadata());
+    }
+    getBadgeMetadataDetails(badgeId) {
+        return BadgeMetadataDetails.getMetadataDetailsForBadgeId(badgeId, this.getCurrentBadgeMetadata());
+    }
+    getBadgeIdRange() {
+        return UintRangeArray.From([{ start: 1n, end: this.getMaxBadgeId() }]);
+    }
+    getBalanceInfo(address, throwIfNotFound = true) {
+        const convertedAddress = address === 'Mint' || address === 'Total' ? address : convertToCosmosAddress(address);
+        const owner = this.owners.find((x) => x.cosmosAddress === convertedAddress);
+        if (!owner && throwIfNotFound)
+            throw new Error(`Owner not found for address ${address}. Balance not fetched yet. Missing doc for '${address}' in owners.`);
+        return owner;
+    }
+    getBadgeBalanceInfo(address) {
+        return this.getBalanceInfo(address, false);
+    }
+    mustGetBadgeBalanceInfo(address) {
+        return this.getBalanceInfo(address, true);
+    }
+    getBadgeBalances(address) {
+        return this.getBadgeBalanceInfo(address)?.balances;
+    }
+    mustGetBadgeBalances(address) {
+        return this.mustGetBadgeBalanceInfo(address).balances;
+    }
+    getMaxBadgeId() {
+        const totalSupplyBalance = this.getBadgeBalances('Total')?.map((balance) => balance.convert(BigIntify)) ?? [];
+        const defaultBalances = this.defaultBalances.balances.map((balance) => balance.convert(BigIntify));
+        let maxBadgeId = 0n;
+        for (const balance of [...totalSupplyBalance, ...defaultBalances]) {
+            for (const badgeIdRange of balance.badgeIds) {
+                if (badgeIdRange.end > maxBadgeId) {
+                    maxBadgeId = badgeIdRange.end;
+                }
+            }
+        }
+        return maxBadgeId;
+    }
+    pruneMetadataToFetch(metadataToFetch) {
+        return pruneMetadataToFetch(this.convert(BigIntify), metadataToFetch);
+    }
+    validatePermissionsUpdate(newPermissions) {
+        const result = CollectionPermissionsWithDetails.validateUpdate(this.collectionPermissions, newPermissions);
+        return result;
+    }
+    validatePermissionUpdate(permissionName, newPermissions) {
+        const { validatePermissionUpdateFunction } = getPermissionVariablesFromName(permissionName);
+        const oldPermissions = this.collectionPermissions[permissionName];
+        const result = validatePermissionUpdateFunction(oldPermissions, newPermissions);
+        return result;
+    }
+    validateCollectionApprovalsUpdate(newApprovals) {
+        const result = CollectionApprovalWithDetails.validateUpdate(this.collectionApprovals, newApprovals, this.collectionPermissions.canUpdateCollectionApprovals);
+        return result;
+    }
+    validateBadgeMetadataUpdate(newBadgeMetadata) {
+        const result = BadgeMetadataTimeline.validateUpdate(this.badgeMetadataTimeline, newBadgeMetadata, this.collectionPermissions.canUpdateBadgeMetadata);
+        return result;
+    }
+    validateOffChainBalancesMetadataUpdate(newOffChainBalancesMetadata) {
+        const result = OffChainBalancesMetadataTimeline.validateUpdate(this.offChainBalancesMetadataTimeline, newOffChainBalancesMetadata, this.collectionPermissions.canUpdateOffChainBalancesMetadata);
+        return result;
+    }
+    validateCustomDataUpdate(newCustomData) {
+        const result = CustomDataTimeline.validateUpdate(this.customDataTimeline, newCustomData, this.collectionPermissions.canUpdateCustomData);
+        return result;
+    }
+    validateStandardsUpdate(newStandards) {
+        const result = StandardsTimeline.validateUpdate(this.standardsTimeline, newStandards, this.collectionPermissions.canUpdateStandards);
+        return result;
+    }
+    validateIsArchivedUpdate(newIsArchived) {
+        const result = IsArchivedTimeline.validateUpdate(this.isArchivedTimeline, newIsArchived, this.collectionPermissions.canArchiveCollection);
+        return result;
+    }
+    validateManagerUpdate(newManager) {
+        const result = ManagerTimeline.validateUpdate(this.managerTimeline, newManager, this.collectionPermissions.canUpdateManager);
+        return result;
+    }
+    checkCanDeleteCollection(time) {
+        return ActionPermission.check(this.convert(BigIntify).collectionPermissions.canDeleteCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanArchiveCollection(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canArchiveCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateManager(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canUpdateManager, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateOffChainBalancesMetadata(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canUpdateOffChainBalancesMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateStandards(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canUpdateStandards, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCustomData(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canUpdateCustomData, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionMetadata(timelineTimes, time) {
+        return TimedUpdatePermission.check(UintRangeArray.From(timelineTimes.map((x) => new UintRange(x).convert(BigIntify))), this.convert(BigIntify).collectionPermissions.canUpdateCollectionMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanCreateMoreBadges(balances, time) {
+        return BalancesActionPermission.check(BalanceArray.From(balances)
+            .convert(BigIntify)
+            .map((x) => {
+            return { badgeIds: x.badgeIds, ownershipTimes: x.ownershipTimes };
+        }), this.convert(BigIntify).collectionPermissions.canCreateMoreBadges, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateBadgeMetadata(details, time) {
+        return TimedUpdateWithBadgeIdsPermission.check(details.map((x) => {
+            return {
+                ...x,
+                timelineTimes: UintRangeArray.From(x.timelineTimes).convert(BigIntify),
+                badgeIds: UintRangeArray.From(x.badgeIds).convert(BigIntify)
+            };
+        }), this.convert(BigIntify).collectionPermissions.canUpdateBadgeMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionApprovals(details, time) {
+        return CollectionApprovalPermissionWithDetails.check(details.map((x) => {
+            return {
+                ...x,
+                timelineTimes: UintRangeArray.From(x.timelineTimes).convert(BigIntify),
+                badgeIds: UintRangeArray.From(x.badgeIds).convert(BigIntify),
+                ownershipTimes: UintRangeArray.From(x.ownershipTimes).convert(BigIntify),
+                transferTimes: UintRangeArray.From(x.transferTimes).convert(BigIntify),
+                toList: new AddressList(x.toList),
+                fromList: new AddressList(x.fromList),
+                initiatedByList: new AddressList(x.initiatedByList),
+                approvalIdList: new AddressList(x.approvalIdList),
+                amountTrackerIdList: new AddressList(x.amountTrackerIdList),
+                challengeTrackerIdList: new AddressList(x.challengeTrackerIdList)
+            };
+        }), this.convert(BigIntify).collectionPermissions.canUpdateCollectionApprovals, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    static async FetchAndInitialize(api, options) {
+        const collection = await BitBadgesCollection.GetCollections(api, { collectionsToFetch: [options] }).then((x) => x.collections[0]);
+        return new BitBadgesCollection(collection);
+    }
+    static async GetCollections(api, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    const $ip0 = input => {
+                        const array = input;
+                        const top = input[0];
+                        if (0 === input.length)
+                            return true;
+                        const arrayPredicators = [
+                            [
+                                top => "object" === typeof top && null !== top && $io6(top),
+                                entire => entire.every(elem => "object" === typeof elem && null !== elem && $io6(elem))
+                            ],
+                            [
+                                top => "string" === typeof top || "number" === typeof top || "bigint" === typeof top,
+                                entire => entire.every(elem => "string" === typeof elem || "number" === typeof elem || "bigint" === typeof elem)
+                            ]
+                        ];
+                        const passed = arrayPredicators.filter(pred => pred[0](top));
+                        if (1 === passed.length)
+                            return passed[0][1](array);
+                        else if (1 < passed.length)
+                            for (const pred of passed)
+                                if (array.every(value => true === pred[0](value)))
+                                    return pred[1](array);
+                        return false;
+                    };
+                    const $io0 = input => Array.isArray(input.collectionsToFetch) && input.collectionsToFetch.every(elem => "object" === typeof elem && null !== elem && $io1(elem));
+                    const $io1 = input => (undefined === input.viewsToFetch || Array.isArray(input.viewsToFetch) && input.viewsToFetch.every(elem => "object" === typeof elem && null !== elem && $io2(elem))) && (undefined === input.fetchTotalAndMintBalances || "boolean" === typeof input.fetchTotalAndMintBalances) && (undefined === input.challengeTrackersToFetch || Array.isArray(input.challengeTrackersToFetch) && input.challengeTrackersToFetch.every(elem => "object" === typeof elem && null !== elem && $io3(elem))) && (undefined === input.approvalTrackersToFetch || Array.isArray(input.approvalTrackersToFetch) && input.approvalTrackersToFetch.every(elem => "object" === typeof elem && null !== elem && $io4(elem))) && (undefined === input.handleAllAndAppendDefaults || "boolean" === typeof input.handleAllAndAppendDefaults) && (undefined === input.fetchPrivateParams || "boolean" === typeof input.fetchPrivateParams) && (undefined === input.metadataToFetch || "object" === typeof input.metadataToFetch && null !== input.metadataToFetch && false === Array.isArray(input.metadataToFetch) && $io5(input.metadataToFetch)) && ("string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId);
+                    const $io2 = input => ("transferActivity" === input.viewType || "reviews" === input.viewType || "owners" === input.viewType || "amountTrackers" === input.viewType || "challengeTrackers" === input.viewType) && "string" === typeof input.viewId && "string" === typeof input.bookmark && (undefined === input.oldestFirst || "boolean" === typeof input.oldestFirst) && (undefined === input.cosmosAddress || "string" === typeof input.cosmosAddress);
+                    const $io3 = input => ("string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId) && "string" === typeof input.approvalId && "string" === typeof input.challengeTrackerId && ("" === input.approvalLevel || "collection" === input.approvalLevel || "incoming" === input.approvalLevel || "outgoing" === input.approvalLevel) && "string" === typeof input.approverAddress;
+                    const $io4 = input => ("string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId) && "string" === typeof input.approvalId && "string" === typeof input.amountTrackerId && "string" === typeof input.approvalLevel && "string" === typeof input.approverAddress && "string" === typeof input.trackerType && "string" === typeof input.approvedAddress;
+                    const $io5 = input => (undefined === input.doNotFetchCollectionMetadata || "boolean" === typeof input.doNotFetchCollectionMetadata) && (undefined === input.uris || Array.isArray(input.uris) && input.uris.every(elem => "string" === typeof elem)) && (undefined === input.badgeIds || Array.isArray(input.badgeIds) && ($ip0(input.badgeIds) || false));
+                    const $io6 = input => ("string" === typeof input.start || "number" === typeof input.start || "bigint" === typeof input.start) && ("string" === typeof input.end || "number" === typeof input.end || "bigint" === typeof input.end);
+                    return "object" === typeof input && null !== input && $io0(input);
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vp0 = (input, _path, _exceptionable = true) => {
+                            const array = input;
+                            const top = input[0];
+                            if (0 === input.length)
+                                return true;
+                            const arrayPredicators = [
+                                [
+                                    top => "object" === typeof top && null !== top && $vo6(top, _path, false && _exceptionable),
+                                    entire => entire.map((elem, _index8) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                        path: _path + "[" + _index8 + "]",
+                                        expected: "iUintRange<NumberType>",
+                                        value: elem
+                                    })) && $vo6(elem, _path + "[" + _index8 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                        path: _path + "[" + _index8 + "]",
+                                        expected: "iUintRange<NumberType>",
+                                        value: elem
+                                    })).every(flag => flag)
+                                ],
+                                [
+                                    top => "string" === typeof top || "number" === typeof top || "bigint" === typeof top,
+                                    entire => entire.map((elem, _index9) => "string" === typeof elem || "number" === typeof elem || "bigint" === typeof elem || $report(_exceptionable, {
+                                        path: _path + "[" + _index9 + "]",
+                                        expected: "(bigint | number | string)",
+                                        value: elem
+                                    })).every(flag => flag)
+                                ]
+                            ];
+                            const passed = arrayPredicators.filter(pred => pred[0](top));
+                            if (1 === passed.length)
+                                return passed[0][1](array);
+                            else if (1 < passed.length)
+                                for (const pred of passed)
+                                    if (array.every(value => true === pred[0](value)))
+                                        return pred[1](array);
+                            return $report(_exceptionable, {
+                                path: _path,
+                                expected: "(Array<iUintRange<NumberType>> | Array<NumberType>)",
+                                value: input
+                            });
+                        };
+                        const $vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.collectionsToFetch) || $report(_exceptionable, {
+                                path: _path + ".collectionsToFetch",
+                                expected: "Array<GetCollectionRequestBody>",
+                                value: input.collectionsToFetch
+                            })) && input.collectionsToFetch.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".collectionsToFetch[" + _index1 + "]",
+                                expected: "GetCollectionRequestBody",
+                                value: elem
+                            })) && $vo1(elem, _path + ".collectionsToFetch[" + _index1 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".collectionsToFetch[" + _index1 + "]",
+                                expected: "GetCollectionRequestBody",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".collectionsToFetch",
+                                expected: "Array<GetCollectionRequestBody>",
+                                value: input.collectionsToFetch
+                            })].every(flag => flag);
+                        const $vo1 = (input, _path, _exceptionable = true) => [undefined === input.viewsToFetch || (Array.isArray(input.viewsToFetch) || $report(_exceptionable, {
+                                path: _path + ".viewsToFetch",
+                                expected: "(Array<__type> | undefined)",
+                                value: input.viewsToFetch
+                            })) && input.viewsToFetch.map((elem, _index2) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".viewsToFetch[" + _index2 + "]",
+                                expected: "__type",
+                                value: elem
+                            })) && $vo2(elem, _path + ".viewsToFetch[" + _index2 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".viewsToFetch[" + _index2 + "]",
+                                expected: "__type",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".viewsToFetch",
+                                expected: "(Array<__type> | undefined)",
+                                value: input.viewsToFetch
+                            }), undefined === input.fetchTotalAndMintBalances || "boolean" === typeof input.fetchTotalAndMintBalances || $report(_exceptionable, {
+                                path: _path + ".fetchTotalAndMintBalances",
+                                expected: "(boolean | undefined)",
+                                value: input.fetchTotalAndMintBalances
+                            }), undefined === input.challengeTrackersToFetch || (Array.isArray(input.challengeTrackersToFetch) || $report(_exceptionable, {
+                                path: _path + ".challengeTrackersToFetch",
+                                expected: "(Array<iChallengeTrackerIdDetails<NumberType>> | undefined)",
+                                value: input.challengeTrackersToFetch
+                            })) && input.challengeTrackersToFetch.map((elem, _index3) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".challengeTrackersToFetch[" + _index3 + "]",
+                                expected: "iChallengeTrackerIdDetails<NumberType>",
+                                value: elem
+                            })) && $vo3(elem, _path + ".challengeTrackersToFetch[" + _index3 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".challengeTrackersToFetch[" + _index3 + "]",
+                                expected: "iChallengeTrackerIdDetails<NumberType>",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".challengeTrackersToFetch",
+                                expected: "(Array<iChallengeTrackerIdDetails<NumberType>> | undefined)",
+                                value: input.challengeTrackersToFetch
+                            }), undefined === input.approvalTrackersToFetch || (Array.isArray(input.approvalTrackersToFetch) || $report(_exceptionable, {
+                                path: _path + ".approvalTrackersToFetch",
+                                expected: "(Array<iAmountTrackerIdDetails<NumberType>> | undefined)",
+                                value: input.approvalTrackersToFetch
+                            })) && input.approvalTrackersToFetch.map((elem, _index4) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".approvalTrackersToFetch[" + _index4 + "]",
+                                expected: "iAmountTrackerIdDetails<NumberType>",
+                                value: elem
+                            })) && $vo4(elem, _path + ".approvalTrackersToFetch[" + _index4 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".approvalTrackersToFetch[" + _index4 + "]",
+                                expected: "iAmountTrackerIdDetails<NumberType>",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".approvalTrackersToFetch",
+                                expected: "(Array<iAmountTrackerIdDetails<NumberType>> | undefined)",
+                                value: input.approvalTrackersToFetch
+                            }), undefined === input.handleAllAndAppendDefaults || "boolean" === typeof input.handleAllAndAppendDefaults || $report(_exceptionable, {
+                                path: _path + ".handleAllAndAppendDefaults",
+                                expected: "(boolean | undefined)",
+                                value: input.handleAllAndAppendDefaults
+                            }), undefined === input.fetchPrivateParams || "boolean" === typeof input.fetchPrivateParams || $report(_exceptionable, {
+                                path: _path + ".fetchPrivateParams",
+                                expected: "(boolean | undefined)",
+                                value: input.fetchPrivateParams
+                            }), undefined === input.metadataToFetch || ("object" === typeof input.metadataToFetch && null !== input.metadataToFetch && false === Array.isArray(input.metadataToFetch) || $report(_exceptionable, {
+                                path: _path + ".metadataToFetch",
+                                expected: "(MetadataFetchOptions | undefined)",
+                                value: input.metadataToFetch
+                            })) && $vo5(input.metadataToFetch, _path + ".metadataToFetch", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".metadataToFetch",
+                                expected: "(MetadataFetchOptions | undefined)",
+                                value: input.metadataToFetch
+                            }), "string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId || $report(_exceptionable, {
+                                path: _path + ".collectionId",
+                                expected: "(bigint | number | string)",
+                                value: input.collectionId
+                            })].every(flag => flag);
+                        const $vo2 = (input, _path, _exceptionable = true) => ["transferActivity" === input.viewType || "reviews" === input.viewType || "owners" === input.viewType || "amountTrackers" === input.viewType || "challengeTrackers" === input.viewType || $report(_exceptionable, {
+                                path: _path + ".viewType",
+                                expected: "(\"amountTrackers\" | \"challengeTrackers\" | \"owners\" | \"reviews\" | \"transferActivity\")",
+                                value: input.viewType
+                            }), "string" === typeof input.viewId || $report(_exceptionable, {
+                                path: _path + ".viewId",
+                                expected: "string",
+                                value: input.viewId
+                            }), "string" === typeof input.bookmark || $report(_exceptionable, {
+                                path: _path + ".bookmark",
+                                expected: "string",
+                                value: input.bookmark
+                            }), undefined === input.oldestFirst || "boolean" === typeof input.oldestFirst || $report(_exceptionable, {
+                                path: _path + ".oldestFirst",
+                                expected: "(boolean | undefined)",
+                                value: input.oldestFirst
+                            }), undefined === input.cosmosAddress || "string" === typeof input.cosmosAddress || $report(_exceptionable, {
+                                path: _path + ".cosmosAddress",
+                                expected: "(string | undefined)",
+                                value: input.cosmosAddress
+                            })].every(flag => flag);
+                        const $vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId || $report(_exceptionable, {
+                                path: _path + ".collectionId",
+                                expected: "(bigint | number | string)",
+                                value: input.collectionId
+                            }), "string" === typeof input.approvalId || $report(_exceptionable, {
+                                path: _path + ".approvalId",
+                                expected: "string",
+                                value: input.approvalId
+                            }), "string" === typeof input.challengeTrackerId || $report(_exceptionable, {
+                                path: _path + ".challengeTrackerId",
+                                expected: "string",
+                                value: input.challengeTrackerId
+                            }), "" === input.approvalLevel || "collection" === input.approvalLevel || "incoming" === input.approvalLevel || "outgoing" === input.approvalLevel || $report(_exceptionable, {
+                                path: _path + ".approvalLevel",
+                                expected: "(\"\" | \"collection\" | \"incoming\" | \"outgoing\")",
+                                value: input.approvalLevel
+                            }), "string" === typeof input.approverAddress || $report(_exceptionable, {
+                                path: _path + ".approverAddress",
+                                expected: "string",
+                                value: input.approverAddress
+                            })].every(flag => flag);
+                        const $vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.collectionId || "number" === typeof input.collectionId || "bigint" === typeof input.collectionId || $report(_exceptionable, {
+                                path: _path + ".collectionId",
+                                expected: "(bigint | number | string)",
+                                value: input.collectionId
+                            }), "string" === typeof input.approvalId || $report(_exceptionable, {
+                                path: _path + ".approvalId",
+                                expected: "string",
+                                value: input.approvalId
+                            }), "string" === typeof input.amountTrackerId || $report(_exceptionable, {
+                                path: _path + ".amountTrackerId",
+                                expected: "string",
+                                value: input.amountTrackerId
+                            }), "string" === typeof input.approvalLevel || $report(_exceptionable, {
+                                path: _path + ".approvalLevel",
+                                expected: "string",
+                                value: input.approvalLevel
+                            }), "string" === typeof input.approverAddress || $report(_exceptionable, {
+                                path: _path + ".approverAddress",
+                                expected: "string",
+                                value: input.approverAddress
+                            }), "string" === typeof input.trackerType || $report(_exceptionable, {
+                                path: _path + ".trackerType",
+                                expected: "string",
+                                value: input.trackerType
+                            }), "string" === typeof input.approvedAddress || $report(_exceptionable, {
+                                path: _path + ".approvedAddress",
+                                expected: "string",
+                                value: input.approvedAddress
+                            })].every(flag => flag);
+                        const $vo5 = (input, _path, _exceptionable = true) => [undefined === input.doNotFetchCollectionMetadata || "boolean" === typeof input.doNotFetchCollectionMetadata || $report(_exceptionable, {
+                                path: _path + ".doNotFetchCollectionMetadata",
+                                expected: "(boolean | undefined)",
+                                value: input.doNotFetchCollectionMetadata
+                            }), undefined === input.uris || (Array.isArray(input.uris) || $report(_exceptionable, {
+                                path: _path + ".uris",
+                                expected: "(Array<string> | undefined)",
+                                value: input.uris
+                            })) && input.uris.map((elem, _index5) => "string" === typeof elem || $report(_exceptionable, {
+                                path: _path + ".uris[" + _index5 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".uris",
+                                expected: "(Array<string> | undefined)",
+                                value: input.uris
+                            }), undefined === input.badgeIds || (Array.isArray(input.badgeIds) || $report(_exceptionable, {
+                                path: _path + ".badgeIds",
+                                expected: "(Array<NumberType> | Array<iUintRange<NumberType>> | undefined)",
+                                value: input.badgeIds
+                            })) && ($vp0(input.badgeIds, _path + ".badgeIds", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".badgeIds",
+                                expected: "Array<iUintRange<NumberType>> | Array<NumberType>",
+                                value: input.badgeIds
+                            })) || $report(_exceptionable, {
+                                path: _path + ".badgeIds",
+                                expected: "(Array<NumberType> | Array<iUintRange<NumberType>> | undefined)",
+                                value: input.badgeIds
+                            })].every(flag => flag);
+                        const $vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.start || "number" === typeof input.start || "bigint" === typeof input.start || $report(_exceptionable, {
+                                path: _path + ".start",
+                                expected: "(bigint | number | string)",
+                                value: input.start
+                            }), "string" === typeof input.end || "number" === typeof input.end || "bigint" === typeof input.end || $report(_exceptionable, {
+                                path: _path + ".end",
+                                expected: "(bigint | number | string)",
+                                value: input.end
+                            })].every(flag => flag);
+                        return ("object" === typeof input && null !== input || $report(true, {
+                            path: _path + "",
+                            expected: "GetCollectionsPayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "GetCollectionsPayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.GetCollectionsRoute()}`, body);
+            return new GetCollectionsSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    static async GetBadgeBalanceByAddress(api, collectionId, cosmosAddress, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    const $io0 = input => undefined === input.fetchPrivateParams || "boolean" === typeof input.fetchPrivateParams;
+                    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vo0 = (input, _path, _exceptionable = true) => [undefined === input.fetchPrivateParams || "boolean" === typeof input.fetchPrivateParams || $report(_exceptionable, {
+                                path: _path + ".fetchPrivateParams",
+                                expected: "(boolean | undefined)",
+                                value: input.fetchPrivateParams
+                            })].every(flag => flag);
+                        return ("object" === typeof input && null !== input && false === Array.isArray(input) || $report(true, {
+                            path: _path + "",
+                            expected: "GetBadgeBalanceByAddressPayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "GetBadgeBalanceByAddressPayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.GetBadgeBalanceByAddressRoute(collectionId, cosmosAddress)}`, body);
+            return new GetBadgeBalanceByAddressSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    static async FetchAndInitializeBatch(api, collectionsToFetch) {
+        const collection = await BitBadgesCollection.GetCollections(api, { collectionsToFetch: collectionsToFetch });
+        return collection.collections.map((x) => new BitBadgesCollection(x));
+    }
+    async fetchBadgeBalances(api, address, forceful) {
+        const currOwnerInfo = this.getBadgeBalanceInfo(address);
+        if (currOwnerInfo && !forceful)
+            return currOwnerInfo;
+        const newOwnerInfo = await BitBadgesCollection.GetBadgeBalanceByAddress(api, this.collectionId, address);
+        this.owners = this.owners.filter((x) => x.cosmosAddress !== newOwnerInfo.cosmosAddress);
+        this.owners.push(newOwnerInfo);
+        return newOwnerInfo;
+    }
+    isRedundantRequest(options) {
+        options = this.prunePayload(options);
+        const cachedCollection = this.convert(BigIntify);
+        const prunedMetadataToFetch = pruneMetadataToFetch(cachedCollection, options.metadataToFetch);
+        const shouldFetchMetadata = (prunedMetadataToFetch.uris && prunedMetadataToFetch.uris.length > 0) || !prunedMetadataToFetch.doNotFetchCollectionMetadata;
+        const viewsToFetch = (options.viewsToFetch || []).filter((x) => this.viewHasMore(x.viewId));
+        const hasTotalAndMint = cachedCollection.owners.find((x) => x.cosmosAddress === 'Mint') && cachedCollection.owners.find((x) => x.cosmosAddress === 'Total');
+        const shouldFetchTotalAndMint = !hasTotalAndMint && options.fetchTotalAndMintBalances;
+        const shouldFetchMerklechallengeTrackerIds = (options.challengeTrackersToFetch ?? []).find((x) => {
+            const match = cachedCollection.merkleChallenges.find((y) => y.challengeTrackerId === x.challengeTrackerId &&
+                x.approverAddress === y.approverAddress &&
+                x.collectionId === y.collectionId &&
+                x.approvalLevel === y.approvalLevel);
+            return !match;
+        }) !== undefined;
+        const shouldFetchAmountTrackerIds = (options.approvalTrackersToFetch ?? []).find((x) => {
+            const match = cachedCollection.approvalTrackers.find((y) => y.amountTrackerId === x.amountTrackerId &&
+                x.approverAddress === y.approverAddress &&
+                x.collectionId === y.collectionId &&
+                y.approvedAddress === x.approvedAddress &&
+                y.trackerType === x.trackerType);
+            return !match;
+        }) !== undefined;
+        return !(shouldFetchMetadata ||
+            viewsToFetch.length > 0 ||
+            shouldFetchTotalAndMint ||
+            shouldFetchMerklechallengeTrackerIds ||
+            shouldFetchAmountTrackerIds ||
+            options.fetchPrivateParams);
+    }
+    prunePayload(options) {
+        const prunedMetadataToFetch = pruneMetadataToFetch(this.convert(BigIntify), options.metadataToFetch);
+        const prunedViewsToFetch = (options.viewsToFetch || []).filter((x) => this.viewHasMore(x.viewId));
+        const prunedChallengeTrackersToFetch = (options.challengeTrackersToFetch || []).filter((x) => {
+            return !this.merkleChallenges.find((y) => y.challengeTrackerId === x.challengeTrackerId &&
+                x.approverAddress === y.approverAddress &&
+                x.collectionId === y.collectionId &&
+                x.approvalLevel === y.approvalLevel);
+        });
+        const prunedApprovalTrackersToFetch = (options.approvalTrackersToFetch || []).filter((x) => {
+            return !this.approvalTrackers.find((y) => y.amountTrackerId === x.amountTrackerId &&
+                x.approverAddress === y.approverAddress &&
+                x.collectionId === y.collectionId &&
+                y.approvedAddress === x.approvedAddress &&
+                y.trackerType === x.trackerType);
+        });
+        const shouldFetchTotalAndMint = (!this.owners.find((x) => x.cosmosAddress === 'Mint') || !this.owners.find((x) => x.cosmosAddress === 'Total')) &&
+            options.fetchTotalAndMintBalances;
+        return {
+            collectionId: this.collectionId,
+            ...options,
+            metadataToFetch: prunedMetadataToFetch,
+            viewsToFetch: prunedViewsToFetch,
+            challengeTrackersToFetch: prunedChallengeTrackersToFetch,
+            approvalTrackersToFetch: prunedApprovalTrackersToFetch,
+            fetchTotalAndMintBalances: shouldFetchTotalAndMint
+        };
+    }
+    async fetchAndUpdate(api, options, forceful) {
+        if (!forceful) {
+            if (this.isRedundantRequest(options))
+                return;
+            options = this.prunePayload(options);
+        }
+        const collection = await BitBadgesCollection.GetCollections(api, {
+            collectionsToFetch: [{ collectionId: this.collectionId, ...options }]
+        }).then((x) => x.collections[0]);
+        this.updateWithNewResponse(collection, forceful);
+    }
+    updateWithNewResponse(newResponse, forceful) {
+        if (forceful) {
+            const newCollectionInfo = new BitBadgesCollection(newResponse);
+            Object.assign(this, newCollectionInfo);
+            return;
+        }
+        else {
+            const newCollectionInfo = updateCollectionWithResponse(this, newResponse);
+            Object.assign(this, newCollectionInfo);
+            return;
+        }
+    }
+    async fetchMetadata(api, options, forceful) {
+        if (!forceful) {
+            if (options.metadataToFetch)
+                options.metadataToFetch = this.pruneMetadataToFetch(options.metadataToFetch);
+        }
+        await this.fetchAndUpdate(api, options, forceful);
+    }
+    viewHasMore(viewId) {
+        return this.views[viewId]?.pagination?.hasMore ?? true;
+    }
+    getViewPagination(viewId) {
+        return this.views[viewId]?.pagination;
+    }
+    getViewBookmark(viewId) {
+        return this.views[viewId]?.pagination?.bookmark;
+    }
+    async fetchNextForView(api, viewType, viewId, oldestFirst, cosmosAddress) {
+        if (!this.viewHasMore(viewId))
+            return;
+        await this.fetchAndUpdate(api, {
+            viewsToFetch: [
+                {
+                    viewType: viewType,
+                    viewId: viewId,
+                    bookmark: this.views[viewId]?.pagination?.bookmark || '',
+                    oldestFirst: oldestFirst,
+                    cosmosAddress: cosmosAddress
+                }
+            ]
+        });
+    }
+    async fetchAllForView(api, viewType, viewId, oldestFirst, cosmosAddress) {
+        while (this.viewHasMore(viewId)) {
+            await this.fetchNextForView(api, viewType, viewId, oldestFirst, cosmosAddress);
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+    getView(viewType, viewId) {
+        switch (viewType) {
+            case 'transferActivity':
+                return this.getActivityView(viewId);
+            case 'reviews':
+                return this.getReviewsView(viewId);
+            case 'owners':
+                return this.getOwnersView(viewId);
+            case 'amountTrackers':
+                return this.getApprovalTrackersView(viewId);
+            case 'challengeTrackers':
+                return this.getMerkleChallengesView(viewId);
+            default:
+                throw new Error(`Unknown view type: ${viewType}`);
+        }
+    }
+    getActivityView(viewId) {
+        return (this.views[viewId]?.ids.map((x) => {
+            return this.activity.find((y) => y._docId === x);
+        }) ?? []);
+    }
+    getReviewsView(viewId) {
+        return (this.views[viewId]?.ids.map((x) => {
+            return this.reviews.find((y) => y._docId === x);
+        }) ?? []);
+    }
+    getOwnersView(viewId) {
+        return (this.views[viewId]?.ids.map((x) => {
+            return this.owners.find((y) => y._docId === x);
+        }) ?? []);
+    }
+    getMerkleChallengesView(viewId) {
+        return (this.views[viewId]?.ids.map((x) => {
+            return this.merkleChallenges.find((y) => y._docId === x);
+        }) ?? []);
+    }
+    getApprovalTrackersView(viewId) {
+        return (this.views[viewId]?.ids.map((x) => {
+            return this.approvalTrackers.find((y) => y._docId === x);
+        }) ?? []);
+    }
+    generateAliasForBadgeId(badgeId) {
+        const moduleName = 'badges';
+        const derivationKeys = getAliasDerivationKeysForBadge(this.collectionId, badgeId);
+        return generateAlias(moduleName, derivationKeys);
+    }
+    getUnhandledCollectionApprovals() {
+        return getUnhandledCollectionApprovals(this.convert(BigIntify).collectionApprovals, true);
+    }
+    getNonMintCollectionApprovals() {
+        return getNonMintApprovals(this.convert(BigIntify).collectionApprovals);
+    }
+    getMintCollectionApprovals() {
+        return getMintApprovals(this.convert(BigIntify).collectionApprovals);
+    }
+    static async GetRefreshStatus(api, collectionId) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.GetRefreshStatusRoute(collectionId)}`);
+            return new RefreshStatusSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getRefreshStatus(api) {
+        return await BitBadgesCollection.GetRefreshStatus(api, this.collectionId);
+    }
+    static async RefreshMetadata(api, collectionId, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    return "object" === typeof input && null !== input && true;
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vo0 = (input, _path, _exceptionable = true) => true;
+                        return ("object" === typeof input && null !== input && false === Array.isArray(input) || $report(true, {
+                            path: _path + "",
+                            expected: "RefreshMetadataPayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "RefreshMetadataPayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.RefreshMetadataRoute(collectionId)}`, body);
+            return new RefreshMetadataSuccessResponse(response.data);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async refresh(api) {
+        return await BitBadgesCollection.RefreshMetadata(api, this.collectionId);
+    }
+    static async GetBadgeActivity(api, collectionId, badgeId, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    const $io0 = input => (undefined === input.bookmark || "string" === typeof input.bookmark) && (undefined === input.cosmosAddress || "string" === typeof input.cosmosAddress);
+                    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vo0 = (input, _path, _exceptionable = true) => [undefined === input.bookmark || "string" === typeof input.bookmark || $report(_exceptionable, {
+                                path: _path + ".bookmark",
+                                expected: "(string | undefined)",
+                                value: input.bookmark
+                            }), undefined === input.cosmosAddress || "string" === typeof input.cosmosAddress || $report(_exceptionable, {
+                                path: _path + ".cosmosAddress",
+                                expected: "(string | undefined)",
+                                value: input.cosmosAddress
+                            })].every(flag => flag);
+                        return ("object" === typeof input && null !== input && false === Array.isArray(input) || $report(true, {
+                            path: _path + "",
+                            expected: "GetBadgeActivityPayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "GetBadgeActivityPayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            api.assertPositiveInteger(collectionId);
+            api.assertPositiveInteger(badgeId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.GetBadgeActivityRoute(collectionId, badgeId)}`, body);
+            return new GetBadgeActivitySuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getBadgeActivity(api, badgeId, body) {
+        return await BitBadgesCollection.GetBadgeActivity(api, this.collectionId, badgeId, body);
+    }
+    static async GetOwnersForBadge(api, collectionId, badgeId, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    const $io0 = input => undefined === input.bookmark || "string" === typeof input.bookmark;
+                    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vo0 = (input, _path, _exceptionable = true) => [undefined === input.bookmark || "string" === typeof input.bookmark || $report(_exceptionable, {
+                                path: _path + ".bookmark",
+                                expected: "(string | undefined)",
+                                value: input.bookmark
+                            })].every(flag => flag);
+                        return ("object" === typeof input && null !== input && false === Array.isArray(input) || $report(true, {
+                            path: _path + "",
+                            expected: "GetOwnersForBadgePayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "GetOwnersForBadgePayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            api.assertPositiveInteger(collectionId);
+            api.assertPositiveInteger(badgeId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.GetOwnersForBadgeRoute(collectionId, badgeId)}`, body);
+            return new GetOwnersForBadgeSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getOwnersForBadge(api, badgeId, body) {
+        return await BitBadgesCollection.GetOwnersForBadge(api, this.collectionId, badgeId, body);
+    }
+    static async FilterBadgesInCollection(api, collectionId, body) {
+        try {
+            const validateRes = (input => {
+                const errors = [];
+                const __is = input => {
+                    const $io0 = input => (undefined === input.badgeIds || Array.isArray(input.badgeIds) && input.badgeIds.every(elem => "object" === typeof elem && null !== elem && $io1(elem))) && (undefined === input.categories || Array.isArray(input.categories) && input.categories.every(elem => "string" === typeof elem)) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && (undefined === input.mostViewed || "daily" === input.mostViewed || "allTime" === input.mostViewed || "weekly" === input.mostViewed || "monthly" === input.mostViewed || "yearly" === input.mostViewed) && (undefined === input.bookmark || "string" === typeof input.bookmark) && (undefined === input.attributes || Array.isArray(input.attributes) && input.attributes.every(elem => "object" === typeof elem && null !== elem && $io2(elem)));
+                    const $io1 = input => ("string" === typeof input.start || "number" === typeof input.start || "bigint" === typeof input.start) && ("string" === typeof input.end || "number" === typeof input.end || "bigint" === typeof input.end);
+                    const $io2 = input => "string" === typeof input.name && ("string" === typeof input.value || "number" === typeof input.value || "boolean" === typeof input.value);
+                    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+                };
+                if (false === __is(input)) {
+                    const $report = typia.validate.report(errors);
+                    ((input, _path, _exceptionable = true) => {
+                        const $vo0 = (input, _path, _exceptionable = true) => [undefined === input.badgeIds || (Array.isArray(input.badgeIds) || $report(_exceptionable, {
+                                path: _path + ".badgeIds",
+                                expected: "(Array<iUintRange<NumberType>> | undefined)",
+                                value: input.badgeIds
+                            })) && input.badgeIds.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".badgeIds[" + _index1 + "]",
+                                expected: "iUintRange<NumberType>",
+                                value: elem
+                            })) && $vo1(elem, _path + ".badgeIds[" + _index1 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".badgeIds[" + _index1 + "]",
+                                expected: "iUintRange<NumberType>",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".badgeIds",
+                                expected: "(Array<iUintRange<NumberType>> | undefined)",
+                                value: input.badgeIds
+                            }), undefined === input.categories || (Array.isArray(input.categories) || $report(_exceptionable, {
+                                path: _path + ".categories",
+                                expected: "(Array<string> | undefined)",
+                                value: input.categories
+                            })) && input.categories.map((elem, _index2) => "string" === typeof elem || $report(_exceptionable, {
+                                path: _path + ".categories[" + _index2 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".categories",
+                                expected: "(Array<string> | undefined)",
+                                value: input.categories
+                            }), undefined === input.tags || (Array.isArray(input.tags) || $report(_exceptionable, {
+                                path: _path + ".tags",
+                                expected: "(Array<string> | undefined)",
+                                value: input.tags
+                            })) && input.tags.map((elem, _index3) => "string" === typeof elem || $report(_exceptionable, {
+                                path: _path + ".tags[" + _index3 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".tags",
+                                expected: "(Array<string> | undefined)",
+                                value: input.tags
+                            }), undefined === input.mostViewed || "daily" === input.mostViewed || "allTime" === input.mostViewed || "weekly" === input.mostViewed || "monthly" === input.mostViewed || "yearly" === input.mostViewed || $report(_exceptionable, {
+                                path: _path + ".mostViewed",
+                                expected: "(\"allTime\" | \"daily\" | \"monthly\" | \"weekly\" | \"yearly\" | undefined)",
+                                value: input.mostViewed
+                            }), undefined === input.bookmark || "string" === typeof input.bookmark || $report(_exceptionable, {
+                                path: _path + ".bookmark",
+                                expected: "(string | undefined)",
+                                value: input.bookmark
+                            }), undefined === input.attributes || (Array.isArray(input.attributes) || $report(_exceptionable, {
+                                path: _path + ".attributes",
+                                expected: "(Array<__type> | undefined)",
+                                value: input.attributes
+                            })) && input.attributes.map((elem, _index4) => ("object" === typeof elem && null !== elem || $report(_exceptionable, {
+                                path: _path + ".attributes[" + _index4 + "]",
+                                expected: "__type",
+                                value: elem
+                            })) && $vo2(elem, _path + ".attributes[" + _index4 + "]", true && _exceptionable) || $report(_exceptionable, {
+                                path: _path + ".attributes[" + _index4 + "]",
+                                expected: "__type",
+                                value: elem
+                            })).every(flag => flag) || $report(_exceptionable, {
+                                path: _path + ".attributes",
+                                expected: "(Array<__type> | undefined)",
+                                value: input.attributes
+                            })].every(flag => flag);
+                        const $vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.start || "number" === typeof input.start || "bigint" === typeof input.start || $report(_exceptionable, {
+                                path: _path + ".start",
+                                expected: "(bigint | number | string)",
+                                value: input.start
+                            }), "string" === typeof input.end || "number" === typeof input.end || "bigint" === typeof input.end || $report(_exceptionable, {
+                                path: _path + ".end",
+                                expected: "(bigint | number | string)",
+                                value: input.end
+                            })].every(flag => flag);
+                        const $vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || $report(_exceptionable, {
+                                path: _path + ".name",
+                                expected: "string",
+                                value: input.name
+                            }), "string" === typeof input.value || "number" === typeof input.value || "boolean" === typeof input.value || $report(_exceptionable, {
+                                path: _path + ".value",
+                                expected: "(boolean | number | string)",
+                                value: input.value
+                            })].every(flag => flag);
+                        return ("object" === typeof input && null !== input && false === Array.isArray(input) || $report(true, {
+                            path: _path + "",
+                            expected: "FilterBadgesInCollectionPayload",
+                            value: input
+                        })) && $vo0(input, _path + "", true) || $report(true, {
+                            path: _path + "",
+                            expected: "FilterBadgesInCollectionPayload",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                }
+                const success = 0 === errors.length;
+                return {
+                    success,
+                    errors,
+                    data: success ? input : undefined
+                };
+            })(body ?? {});
+            if (!validateRes.success) {
+                throw new Error('Invalid payload: ' + JSON.stringify(validateRes.errors));
+            }
+            const response = await api.axios.post(`${api.BACKEND_URL}${BitBadgesApiRoutes.FilterBadgesInCollectionRoute(collectionId)}`, body);
+            return new FilterBadgesInCollectionSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async filterBadgesInCollection(api, bodyOptions) {
+        return await BitBadgesCollection.FilterBadgesInCollection(api, this.collectionId, bodyOptions);
+    }
+}
+export function convertCollectionMap(item, convertFunction) {
+    return Object.fromEntries(Object.entries(item).map(([key, value]) => {
+        return [key, value ? value.convert(convertFunction) : undefined];
+    }));
+}
+const pruneMetadataToFetch = (cachedCollection, metadataFetchReq) => {
+    if (!cachedCollection)
+        throw new Error('Collection does not exist');
+    const metadataToFetch = {
+        doNotFetchCollectionMetadata: cachedCollection.getCollectionMetadata() !== undefined || metadataFetchReq?.doNotFetchCollectionMetadata || false,
+        uris: [],
+        badgeIds: []
+    };
+    const allBadgeIdsInMetadata = UintRangeArray.From(cachedCollection
+        .getCurrentBadgeMetadata()
+        .map((x) => x.badgeIds)
+        .flat()).convert(BigIntify);
+    allBadgeIdsInMetadata.sortAndMerge();
+    const allBadgeIdsNotInMetadata = allBadgeIdsInMetadata.toInverted({ start: 1n, end: GO_MAX_UINT_64 });
+    if (metadataFetchReq) {
+        const badgeMetadata = cachedCollection.getCurrentBadgeMetadata();
+        if (metadataFetchReq.uris) {
+            for (const uri of metadataFetchReq.uris) {
+                if (!uri)
+                    continue;
+                const currentBadgeMetadata = cachedCollection.getCurrentBadgeMetadata();
+                let hasMetadata = false;
+                for (const metadataDetails of currentBadgeMetadata) {
+                    if (metadataDetails.fetchedUri === uri && metadataDetails.metadata !== undefined) {
+                        hasMetadata = true;
+                        break;
+                    }
+                }
+                if (!hasMetadata) {
+                    metadataToFetch.uris.push(uri);
+                }
+            }
+        }
+        if (metadataFetchReq.badgeIds) {
+            for (const badgeId of metadataFetchReq.badgeIds) {
+                const badgeIdCastedAsUintRange = new UintRange(badgeId);
+                const badgeIdCastedAsNumber = badgeId;
+                let badgeIdsLeft;
+                if (typeof badgeIdCastedAsNumber === 'object' && badgeIdCastedAsUintRange.start && badgeIdCastedAsUintRange.end) {
+                    badgeIdsLeft = UintRangeArray.From([badgeIdCastedAsUintRange.convert(BigIntify)]);
+                }
+                else {
+                    badgeIdsLeft = UintRangeArray.From([{ start: BigInt(badgeIdCastedAsNumber), end: BigInt(badgeIdCastedAsNumber) }]);
+                }
+                badgeIdsLeft.remove(allBadgeIdsNotInMetadata);
+                badgeIdsLeft.sortAndMerge();
+                let infiniteLoopPreventer = 0;
+                while (badgeIdsLeft.length > 0) {
+                    const currBadgeUintRange = badgeIdsLeft[0];
+                    if (infiniteLoopPreventer++ > 1000)
+                        throw new Error('Infinite loop detected');
+                    const allMatchingBadgeUintRanges = UintRangeArray.From({ start: currBadgeUintRange.start, end: currBadgeUintRange.start });
+                    let handled = false;
+                    for (const metadataDetails of badgeMetadata) {
+                        if (metadataDetails.badgeIds.searchIfExists(BigInt(currBadgeUintRange.start))) {
+                            handled = true;
+                            if (metadataDetails.metadata == undefined) {
+                                if (metadataDetails.uri.includes('{id}')) {
+                                    metadataToFetch.uris.push(metadataDetails.uri.replace('{id}', currBadgeUintRange.start.toString()));
+                                    badgeIdsLeft.remove(allMatchingBadgeUintRanges);
+                                }
+                                else {
+                                    metadataToFetch.uris.push(metadataDetails.uri);
+                                    allMatchingBadgeUintRanges.push(...UintRangeArray.From(metadataDetails.badgeIds).convert(BigIntify));
+                                    allMatchingBadgeUintRanges.sortAndMerge();
+                                    badgeIdsLeft.remove(allMatchingBadgeUintRanges);
+                                }
+                            }
+                            else {
+                                allMatchingBadgeUintRanges.push(...UintRangeArray.From(metadataDetails.badgeIds).convert(BigIntify));
+                                allMatchingBadgeUintRanges.sortAndMerge();
+                                badgeIdsLeft.remove(allMatchingBadgeUintRanges);
+                            }
+                            break;
+                        }
+                    }
+                    if (!handled) {
+                        throw new Error('Badge ID not found in metadata');
+                    }
+                    badgeIdsLeft.sortAndMerge();
+                }
+            }
+        }
+    }
+    return {
+        ...metadataToFetch,
+        uris: metadataToFetch.uris ?? []
+    };
+};
+function updateCollectionWithResponse(oldCollection, newCollectionResponse) {
+    const convertFunction = getConverterFunction(newCollectionResponse.collectionId);
+    let cachedCollection = oldCollection ? oldCollection.convert(convertFunction) : undefined;
+    if (!cachedCollection)
+        return newCollectionResponse;
+    const newCollection = newCollectionResponse;
+    const newBadgeMetadata = newCollection.getCurrentBadgeMetadata() && newCollection.getCurrentBadgeMetadata().length > 0
+        ? BadgeMetadataDetails.batchUpdateBadgeMetadata(cachedCollection.getCurrentBadgeMetadata(), newCollection
+            .getCurrentBadgeMetadata()
+            .map((x) => x.convert(convertFunction))
+            .filter((x) => x.metadata))
+        : cachedCollection.getCurrentBadgeMetadata();
+    const newViews = cachedCollection?.views || {};
+    if (newCollection.views) {
+        for (const [key, val] of Object.entries(newCollection.views)) {
+            if (!val)
+                continue;
+            const oldVal = cachedCollection?.views[key];
+            const newVal = val;
+            newViews[key] = {
+                ids: [...(oldVal?.ids || []), ...(newVal?.ids || [])].filter((val, index, self) => self.findIndex((x) => x === val) === index),
+                pagination: newVal.pagination,
+                type: val.type
+            };
+        }
+    }
+    const reviews = cachedCollection.reviews || [];
+    for (const newReview of newCollection.reviews || []) {
+        const existingReview = reviews.findIndex((x) => x._docId === newReview._docId);
+        if (existingReview !== -1) {
+            reviews[existingReview] = newReview;
+        }
+        else {
+            reviews.push(newReview);
+        }
+    }
+    const activity = cachedCollection.activity || [];
+    for (const newActivity of newCollection.activity || []) {
+        const existingActivity = activity.findIndex((x) => x._docId === newActivity._docId);
+        if (existingActivity !== -1) {
+            activity[existingActivity] = newActivity;
+        }
+        else {
+            activity.push(newActivity);
+        }
+    }
+    const owners = cachedCollection.owners || [];
+    for (const newOwner of newCollection.owners || []) {
+        const existingOwner = owners.findIndex((x) => x._docId === newOwner._docId);
+        if (existingOwner !== -1) {
+            owners[existingOwner] = newOwner;
+        }
+        else {
+            owners.push(newOwner);
+        }
+    }
+    const merkleChallenges = cachedCollection.merkleChallenges || [];
+    for (const newMerkleChallenge of newCollection.merkleChallenges || []) {
+        const existingMerkleChallenge = merkleChallenges.findIndex((x) => x._docId === newMerkleChallenge._docId);
+        if (existingMerkleChallenge !== -1) {
+            merkleChallenges[existingMerkleChallenge] = newMerkleChallenge;
+        }
+        else {
+            merkleChallenges.push(newMerkleChallenge);
+        }
+    }
+    const approvalTrackers = cachedCollection.approvalTrackers || [];
+    for (const newApprovalTracker of newCollection.approvalTrackers || []) {
+        const existingApprovalTracker = approvalTrackers.findIndex((x) => x._docId === newApprovalTracker._docId);
+        if (existingApprovalTracker !== -1) {
+            approvalTrackers[existingApprovalTracker] = newApprovalTracker;
+        }
+        else {
+            approvalTrackers.push(newApprovalTracker);
+        }
+    }
+    const newCollectionMetadata = newCollection.getCollectionMetadata() || cachedCollection?.getCollectionMetadata();
+    const newCollectionMetadataTimeline = newCollection.collectionMetadataTimeline || cachedCollection?.collectionMetadataTimeline;
+    for (const timelineTime of newCollectionMetadataTimeline) {
+        if (timelineTime.timelineTimes.searchIfExists(BigInt(Date.now()))) {
+            timelineTime.collectionMetadata.metadata = newCollectionMetadata;
+        }
+    }
+    const newBadgeMetadataTimeline = newCollection.badgeMetadataTimeline || cachedCollection?.badgeMetadataTimeline;
+    for (const timelineTime of newBadgeMetadataTimeline) {
+        if (timelineTime.timelineTimes.searchIfExists(BigInt(Date.now()))) {
+            timelineTime.badgeMetadata = newBadgeMetadata;
+        }
+    }
+    cachedCollection = new BitBadgesCollection({
+        ...cachedCollection,
+        ...newCollection,
+        collectionMetadataTimeline: newCollectionMetadataTimeline,
+        badgeMetadataTimeline: newBadgeMetadataTimeline,
+        reviews,
+        activity,
+        owners,
+        merkleChallenges,
+        approvalTrackers,
+        views: newViews
+    });
+    if (cachedCollection.collectionId === NEW_COLLECTION_ID) {
+        for (const timelineItem of cachedCollection.collectionMetadataTimeline) {
+            delete timelineItem.collectionMetadata?.metadata?.fetchedAt;
+            delete timelineItem.collectionMetadata?.metadata?.fetchedAtBlock;
+        }
+        for (const metadataDetails of cachedCollection.badgeMetadataTimeline) {
+            for (const metadata of metadataDetails.badgeMetadata) {
+                delete metadata.metadata?.fetchedAt;
+                delete metadata.metadata?.fetchedAtBlock;
+            }
+        }
+    }
+    return cachedCollection;
+}
+//# sourceMappingURL=BitBadgesCollection.js.map