bitbadgesjs-sdk 0.3.96 → 0.3.99

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

@@ -1,1297 +0,0 @@
-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