bitbadgesjs-sdk 0.0.6 → 0.1.0

package/dist/utils/types/collections.js

@@ -1,122 +1,740 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertBitBadgesCollection = exports.convertUserBalanceStoreWithDetails = exports.convertCollectionApprovalWithDetails = exports.convertUserPermissionsWithDetails = exports.convertCollectionPermissionsWithDetails = exports.convertUserOutgoingApprovalPermissionWithDetails = exports.convertUserIncomingApprovalPermissionWithDetails = exports.convertCollectionApprovalPermissionWithDetails = exports.convertBadgeMetadataDetails = void 0;
+exports.getFullIsArchivedTimeline = exports.getFullStandardsTimeline = exports.getFullCustomDataTimeline = exports.getOffChainBalancesMetadataTimeline = exports.getFullBadgeMetadataTimeline = exports.getFullCollectionMetadataTimeline = exports.getFullManagerTimeline = exports.getIdxAtTimeForTimeline = exports.getValueAtTimeForTimeline = exports.getCurrentIdxForTimeline = exports.getCurrentValueForTimeline = exports.BitBadgesCollection = exports.UserBalanceStoreWithDetails = exports.CollectionApprovalWithDetails = exports.ApprovalCriteriaWithDetails = exports.UserPermissionsWithDetails = exports.CollectionPermissionsWithDetails = exports.UserOutgoingApprovalPermissionWithDetails = exports.UserIncomingApprovalPermissionWithDetails = exports.CollectionApprovalPermissionWithDetails = exports.BadgeMetadataDetails = void 0;
 const __1 = require("../..");
+const __2 = require("../..");
 const activity_1 = require("./activity");
 const db_1 = require("./db");
 const metadata_1 = require("./metadata");
 const users_1 = require("./users");
-const utils_1 = require("./utils");
-function convertBadgeMetadataDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        metadataId: item.metadataId ? convertFunction(item.metadataId) : undefined,
-        badgeIds: item.badgeIds.map((UintRange) => (0, __1.convertUintRange)(UintRange, convertFunction)),
-        metadata: (0, metadata_1.convertMetadata)(item.metadata, convertFunction),
-    });
+class BadgeMetadataDetails extends __1.BaseNumberTypeClass {
+    metadataId;
+    badgeIds;
+    metadata;
+    uri;
+    customData;
+    toUpdate;
+    constructor(data) {
+        super();
+        this.metadataId = data.metadataId;
+        this.badgeIds = data.badgeIds.map((range) => new __1.UintRange(range));
+        this.metadata = new metadata_1.Metadata(data.metadata);
+        this.uri = data.uri;
+        this.customData = data.customData;
+        this.toUpdate = data.toUpdate;
+    }
+    convert(convertFunction) {
+        return new BadgeMetadataDetails((0, __2.deepCopy)({
+            ...this,
+            metadataId: this.metadataId ? convertFunction(this.metadataId) : undefined,
+            badgeIds: this.badgeIds.map((UintRange) => UintRange.convert(convertFunction)),
+            metadata: this.metadata.convert(convertFunction),
+        }));
+    }
 }
-exports.convertBadgeMetadataDetails = convertBadgeMetadataDetails;
-function convertCollectionApprovalPermissionWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertCollectionApprovalPermission)(item, convertFunction),
-        toList: item.toList,
-        fromList: item.fromList,
-        initiatedByList: item.initiatedByList,
-    });
+exports.BadgeMetadataDetails = BadgeMetadataDetails;
+class CollectionApprovalPermissionWithDetails extends __1.CollectionApprovalPermission {
+    toList;
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new __1.AddressList(data.toList);
+        this.fromList = new __1.AddressList(data.fromList);
+        this.initiatedByList = new __1.AddressList(data.initiatedByList);
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalPermissionWithDetails((0, __2.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+        }));
+    }
 }
-exports.convertCollectionApprovalPermissionWithDetails = convertCollectionApprovalPermissionWithDetails;
-function convertUserIncomingApprovalPermissionWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertUserIncomingApprovalPermission)(item, convertFunction),
-        fromList: item.fromList,
-        initiatedByList: item.initiatedByList,
-    });
+exports.CollectionApprovalPermissionWithDetails = CollectionApprovalPermissionWithDetails;
+class UserIncomingApprovalPermissionWithDetails extends __1.UserIncomingApprovalPermission {
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.fromList = new __1.AddressList(data.fromList);
+        this.initiatedByList = new __1.AddressList(data.initiatedByList);
+    }
+    convert(convertFunction) {
+        return new UserIncomingApprovalPermissionWithDetails((0, __2.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+        }));
+    }
 }
-exports.convertUserIncomingApprovalPermissionWithDetails = convertUserIncomingApprovalPermissionWithDetails;
-function convertUserOutgoingApprovalPermissionWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertUserOutgoingApprovalPermission)(item, convertFunction),
-        toList: item.toList,
-        initiatedByList: item.initiatedByList,
-    });
+exports.UserIncomingApprovalPermissionWithDetails = UserIncomingApprovalPermissionWithDetails;
+class UserOutgoingApprovalPermissionWithDetails extends __1.UserOutgoingApprovalPermission {
+    toList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new __1.AddressList(data.toList);
+        this.initiatedByList = new __1.AddressList(data.initiatedByList);
+    }
+    convert(convertFunction) {
+        return new UserOutgoingApprovalPermissionWithDetails((0, __2.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+        }));
+    }
 }
-exports.convertUserOutgoingApprovalPermissionWithDetails = convertUserOutgoingApprovalPermissionWithDetails;
-function convertCollectionPermissionsWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertCollectionPermissions)(item, convertFunction),
-        canUpdateCollectionApprovals: item.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => {
-            return {
-                ...canUpdateCollectionApproval,
-                ...convertCollectionApprovalPermissionWithDetails(canUpdateCollectionApproval, convertFunction),
-            };
-        }),
-    });
+exports.UserOutgoingApprovalPermissionWithDetails = UserOutgoingApprovalPermissionWithDetails;
+class CollectionPermissionsWithDetails extends __1.BaseNumberTypeClass {
+    canUpdateCollectionApprovals;
+    canDeleteCollection;
+    canArchiveCollection;
+    canUpdateOffChainBalancesMetadata;
+    canUpdateStandards;
+    canUpdateCustomData;
+    canUpdateManager;
+    canUpdateCollectionMetadata;
+    canCreateMoreBadges;
+    canUpdateBadgeMetadata;
+    constructor(data) {
+        super();
+        this.canUpdateCollectionApprovals = data.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => new CollectionApprovalPermissionWithDetails(canUpdateCollectionApproval));
+        this.canDeleteCollection = data.canDeleteCollection.map((actionPermission) => new __1.ActionPermission(actionPermission));
+        this.canArchiveCollection = data.canArchiveCollection.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canUpdateOffChainBalancesMetadata = data.canUpdateOffChainBalancesMetadata.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canUpdateStandards = data.canUpdateStandards.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canUpdateCustomData = data.canUpdateCustomData.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canUpdateManager = data.canUpdateManager.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canUpdateCollectionMetadata = data.canUpdateCollectionMetadata.map((timedUpdatePermission) => new __1.TimedUpdatePermission(timedUpdatePermission));
+        this.canCreateMoreBadges = data.canCreateMoreBadges.map((balancesActionPermission) => new __1.BalancesActionPermission(balancesActionPermission));
+        this.canUpdateBadgeMetadata = data.canUpdateBadgeMetadata.map((timedUpdateWithBadgeIdsPermission) => new __1.TimedUpdateWithBadgeIdsPermission(timedUpdateWithBadgeIdsPermission));
+    }
+    convert(convertFunction) {
+        return new CollectionPermissionsWithDetails((0, __2.deepCopy)({
+            ...this,
+            canUpdateCollectionApprovals: this.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => canUpdateCollectionApproval.convert(convertFunction)),
+            canDeleteCollection: this.canDeleteCollection.map((actionPermission) => actionPermission.convert(convertFunction)),
+            canArchiveCollection: this.canArchiveCollection.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canUpdateOffChainBalancesMetadata: this.canUpdateOffChainBalancesMetadata.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canUpdateStandards: this.canUpdateStandards.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canUpdateCustomData: this.canUpdateCustomData.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canUpdateManager: this.canUpdateManager.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canUpdateCollectionMetadata: this.canUpdateCollectionMetadata.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
+            canCreateMoreBadges: this.canCreateMoreBadges.map((balancesActionPermission) => balancesActionPermission.convert(convertFunction)),
+            canUpdateBadgeMetadata: this.canUpdateBadgeMetadata.map((timedUpdateWithBadgeIdsPermission) => timedUpdateWithBadgeIdsPermission.convert(convertFunction)),
+        }));
+    }
+}
+exports.CollectionPermissionsWithDetails = CollectionPermissionsWithDetails;
+class UserPermissionsWithDetails extends __1.BaseNumberTypeClass {
+    canUpdateIncomingApprovals;
+    canUpdateOutgoingApprovals;
+    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
+    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
+    constructor(data) {
+        super();
+        this.canUpdateIncomingApprovals = data.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => new UserIncomingApprovalPermissionWithDetails(canUpdateUserIncomingApproval));
+        this.canUpdateOutgoingApprovals = data.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => new UserOutgoingApprovalPermissionWithDetails(canUpdateUserOutgoingApproval));
+        this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers = data.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((actionPermission) => new __1.ActionPermission(actionPermission));
+        this.canUpdateAutoApproveSelfInitiatedIncomingTransfers = data.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((actionPermission) => new __1.ActionPermission(actionPermission));
+    }
+    convert(convertFunction) {
+        return new UserPermissionsWithDetails((0, __2.deepCopy)({
+            ...this,
+            canUpdateIncomingApprovals: this.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => canUpdateUserIncomingApproval.convert(convertFunction)),
+            canUpdateOutgoingApprovals: this.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => canUpdateUserOutgoingApproval.convert(convertFunction)),
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((actionPermission) => actionPermission.convert(convertFunction)),
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: this.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((actionPermission) => actionPermission.convert(convertFunction)),
+        }));
+    }
+}
+exports.UserPermissionsWithDetails = UserPermissionsWithDetails;
+class ApprovalCriteriaWithDetails extends __1.BaseNumberTypeClass {
+    merkleChallenge;
+    mustOwnBadges;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireFromEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    overridesFromOutgoingApprovals;
+    overridesToIncomingApprovals;
+    constructor(data) {
+        super();
+        this.merkleChallenge = data.merkleChallenge;
+        this.mustOwnBadges = data.mustOwnBadges?.map((x) => new __1.MustOwnBadges(x));
+        this.predeterminedBalances = data.predeterminedBalances ? new __1.PredeterminedBalances(data.predeterminedBalances) : undefined;
+        this.approvalAmounts = data.approvalAmounts ? new __1.ApprovalAmounts(data.approvalAmounts) : undefined;
+        this.maxNumTransfers = data.maxNumTransfers ? new __1.MaxNumTransfers(data.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = data.requireToEqualsInitiatedBy;
+        this.requireFromEqualsInitiatedBy = data.requireFromEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = data.requireToDoesNotEqualInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = data.requireFromDoesNotEqualInitiatedBy;
+        this.overridesFromOutgoingApprovals = data.overridesFromOutgoingApprovals;
+        this.overridesToIncomingApprovals = data.overridesToIncomingApprovals;
+    }
+    convert(convertFunction) {
+        return new ApprovalCriteriaWithDetails((0, __2.deepCopy)({
+            ...this,
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+        }));
+    }
+    toProto() {
+        return __1.ApprovalCriteria.prototype.toProto.call(this);
+    }
+}
+exports.ApprovalCriteriaWithDetails = ApprovalCriteriaWithDetails;
+class CollectionApprovalWithDetails extends __1.BaseNumberTypeClass {
+    approvalCriteria;
+    details;
+    toList;
+    fromList;
+    initiatedByList;
+    toListId;
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    constructor(data) {
+        super();
+        this.approvalCriteria = data.approvalCriteria ? new ApprovalCriteriaWithDetails(data.approvalCriteria) : undefined;
+        this.details = data.details ? new db_1.ApprovalInfoDetails(data.details) : undefined;
+        this.toList = new __1.AddressList(data.toList);
+        this.fromList = new __1.AddressList(data.fromList);
+        this.initiatedByList = new __1.AddressList(data.initiatedByList);
+        this.toListId = data.toListId;
+        this.fromListId = data.fromListId;
+        this.initiatedByListId = data.initiatedByListId;
+        this.transferTimes = data.transferTimes.map((range) => new __1.UintRange(range));
+        this.badgeIds = data.badgeIds.map((range) => new __1.UintRange(range));
+        this.ownershipTimes = data.ownershipTimes.map((range) => new __1.UintRange(range));
+        this.approvalId = data.approvalId;
+        this.amountTrackerId = data.amountTrackerId;
+        this.challengeTrackerId = data.challengeTrackerId;
+        this.uri = data.uri;
+        this.customData = data.customData;
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalWithDetails((0, __2.deepCopy)({
+            ...this,
+            approvalCriteria: this.approvalCriteria?.convert(convertFunction),
+            details: this.details?.convert(convertFunction),
+            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
+        }));
+    }
+    toProto() {
+        return __1.CollectionApproval.prototype.toProto.call(this);
+    }
+}
+exports.CollectionApprovalWithDetails = CollectionApprovalWithDetails;
+class UserBalanceStoreWithDetails extends __1.BaseNumberTypeClass {
+    outgoingApprovals;
+    incomingApprovals;
+    userPermissions;
+    balances;
+    autoApproveSelfInitiatedOutgoingTransfers;
+    autoApproveSelfInitiatedIncomingTransfers;
+    constructor(data) {
+        super();
+        this.outgoingApprovals = data.outgoingApprovals.map((outgoingApproval) => new users_1.UserOutgoingApprovalWithDetails(outgoingApproval));
+        this.incomingApprovals = data.incomingApprovals.map((incomingApproval) => new users_1.UserIncomingApprovalWithDetails(incomingApproval));
+        this.userPermissions = new UserPermissionsWithDetails(data.userPermissions);
+        this.balances = data.balances.map((balance) => new __1.Balance(balance));
+        this.autoApproveSelfInitiatedOutgoingTransfers = data.autoApproveSelfInitiatedOutgoingTransfers;
+        this.autoApproveSelfInitiatedIncomingTransfers = data.autoApproveSelfInitiatedIncomingTransfers;
+    }
+    convert(convertFunction) {
+        return new UserBalanceStoreWithDetails((0, __2.deepCopy)({
+            ...this,
+            outgoingApprovals: this.outgoingApprovals.map((outgoingApproval) => outgoingApproval.convert(convertFunction)),
+            incomingApprovals: this.incomingApprovals.map((incomingApproval) => incomingApproval.convert(convertFunction)),
+            userPermissions: this.userPermissions.convert(convertFunction),
+            balances: this.balances.map((balance) => balance.convert(convertFunction)),
+        }));
+    }
 }
-exports.convertCollectionPermissionsWithDetails = convertCollectionPermissionsWithDetails;
-function convertUserPermissionsWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertUserPermissions)(item, convertFunction),
-        canUpdateIncomingApprovals: item.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => {
+exports.UserBalanceStoreWithDetails = UserBalanceStoreWithDetails;
+class BitBadgesCollection extends __1.BaseNumberTypeClass {
+    _docId;
+    _id;
+    collectionId;
+    collectionMetadataTimeline;
+    badgeMetadataTimeline;
+    balancesType;
+    offChainBalancesMetadataTimeline;
+    customDataTimeline;
+    managerTimeline;
+    standardsTimeline;
+    isArchivedTimeline;
+    createdBy;
+    createdBlock;
+    createdTimestamp;
+    updateHistory;
+    aliasAddress;
+    collectionApprovals;
+    collectionPermissions;
+    defaultBalances;
+    cachedCollectionMetadata;
+    cachedBadgeMetadata;
+    activity;
+    reviews;
+    owners;
+    merkleChallenges;
+    approvalTrackers;
+    nsfw;
+    reported;
+    views;
+    constructor(data) {
+        super();
+        this._docId = data._docId;
+        this._id = data._id;
+        this.collectionId = data.collectionId;
+        this.collectionMetadataTimeline = data.collectionMetadataTimeline.map((timelineItem) => new __1.CollectionMetadataTimeline(timelineItem));
+        this.badgeMetadataTimeline = data.badgeMetadataTimeline.map((timelineItem) => new __1.BadgeMetadataTimeline(timelineItem));
+        this.balancesType = data.balancesType;
+        this.offChainBalancesMetadataTimeline = data.offChainBalancesMetadataTimeline.map((timelineItem) => new __1.OffChainBalancesMetadataTimeline(timelineItem));
+        this.customDataTimeline = data.customDataTimeline.map((timelineItem) => new __1.CustomDataTimeline(timelineItem));
+        this.managerTimeline = data.managerTimeline.map((timelineItem) => new __1.ManagerTimeline(timelineItem));
+        this.standardsTimeline = data.standardsTimeline.map((timelineItem) => new __1.StandardsTimeline(timelineItem));
+        this.isArchivedTimeline = data.isArchivedTimeline.map((timelineItem) => new __1.IsArchivedTimeline(timelineItem));
+        this.createdBy = data.createdBy;
+        this.createdBlock = data.createdBlock;
+        this.createdTimestamp = data.createdTimestamp;
+        this.updateHistory = data.updateHistory.map((updateHistoryItem) => ({ ...updateHistoryItem }));
+        this.aliasAddress = data.aliasAddress;
+        this.collectionApprovals = data.collectionApprovals.map((collectionApproval) => new CollectionApprovalWithDetails(collectionApproval));
+        this.collectionPermissions = new CollectionPermissionsWithDetails(data.collectionPermissions);
+        this.defaultBalances = new UserBalanceStoreWithDetails(data.defaultBalances);
+        this.cachedCollectionMetadata = data.cachedCollectionMetadata ? new metadata_1.Metadata(data.cachedCollectionMetadata) : undefined;
+        this.cachedBadgeMetadata = data.cachedBadgeMetadata.map((metadata) => new BadgeMetadataDetails(metadata));
+        this.activity = data.activity.map((activityItem) => new activity_1.TransferActivityDoc(activityItem));
+        this.reviews = data.reviews.map((activityItem) => new activity_1.ReviewDoc(activityItem));
+        this.owners = data.owners.map((balance) => new db_1.BalanceDocWithDetails(balance));
+        this.merkleChallenges = data.merkleChallenges.map((merkleChallenge) => new db_1.MerkleChallengeDoc(merkleChallenge));
+        this.approvalTrackers = data.approvalTrackers.map((approvalTracker) => new db_1.ApprovalTrackerDoc(approvalTracker));
+        this.nsfw = data.nsfw;
+        this.reported = data.reported;
+        this.views = data.views;
+    }
+    convert(convertFunction) {
+        return new BitBadgesCollection((0, __2.deepCopy)({
+            ...this,
+            ...new db_1.CollectionDoc(this).convert(convertFunction),
+            collectionApprovals: this.collectionApprovals.map((collectionApproval) => collectionApproval.convert(convertFunction)),
+            defaultBalances: this.defaultBalances.convert(convertFunction),
+            collectionPermissions: this.collectionPermissions.convert(convertFunction),
+            cachedCollectionMetadata: this.cachedCollectionMetadata ? this.cachedCollectionMetadata.convert(convertFunction) : undefined,
+            cachedBadgeMetadata: this.cachedBadgeMetadata.map((metadata) => metadata.convert(convertFunction)),
+            activity: this.activity.map((activityItem) => activityItem.convert(convertFunction)),
+            reviews: this.reviews.map((activityItem) => activityItem.convert(convertFunction)),
+            owners: this.owners.map((balance) => balance.convert(convertFunction)),
+            merkleChallenges: this.merkleChallenges.map((merkleChallenge) => merkleChallenge.convert(convertFunction)),
+            approvalTrackers: this.approvalTrackers.map((approvalTracker) => approvalTracker.convert(convertFunction)),
+            _rev: undefined,
+            _deleted: undefined,
+            nsfw: this.nsfw ? { ...this.nsfw, badgeIds: this.nsfw.badgeIds.map((UintRange) => UintRange.convert(convertFunction)) } : undefined,
+            reported: this.reported ? { ...this.reported, badgeIds: this.reported.badgeIds.map((UintRange) => UintRange.convert(convertFunction)) } : undefined,
+        }));
+    }
+    getOwnerInfo(address, throwIfNotFound = true) {
+        const owner = this.owners.find((x) => x.cosmosAddress === address);
+        if (!owner && throwIfNotFound)
+            throw new Error(`Owner not found for address ${address}. Balance not fetched yet. Missing doc for '${address}' in owners.`);
+        return owner;
+    }
+    getOwnerBalances(address, throwIfNotFound = true) {
+        return this.getOwnerInfo(address, throwIfNotFound)?.balances;
+    }
+    getMaxBadgeId() {
+        const totalSupplyBalance = this.getOwnerBalances('Total')?.map((balance) => balance.convert(__1.BigIntify)) ?? [];
+        const defaultBalances = this.defaultBalances.balances.map((balance) => balance.convert(__1.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;
+    }
+    getTimelineValuesAtTime(time) {
+        const coll = this.convert(__1.BigIntify);
+        return {
+            manager: getValueAtTimeForTimeline(coll.managerTimeline, time)?.manager ?? "",
+            collectionMetadata: getValueAtTimeForTimeline(coll.collectionMetadataTimeline, time)?.collectionMetadata ?? {
+                uri: '',
+                customData: '',
+            },
+            badgeMetadata: getValueAtTimeForTimeline(coll.badgeMetadataTimeline, time)?.badgeMetadata ?? [],
+            offChainBalancesMetadata: getValueAtTimeForTimeline(coll.offChainBalancesMetadataTimeline, time)?.offChainBalancesMetadata ?? {
+                uri: '',
+                customData: '',
+            },
+            customData: getValueAtTimeForTimeline(coll.customDataTimeline, time)?.customData ?? "",
+            standards: getValueAtTimeForTimeline(coll.standardsTimeline, time)?.standards ?? [],
+            isArchived: getValueAtTimeForTimeline(coll.isArchivedTimeline, time)?.isArchived ?? false,
+        };
+    }
+    getManager(time) {
+        return this.getTimelineValuesAtTime(time).manager;
+    }
+    getCollectionMetadata() {
+        return this.cachedCollectionMetadata;
+    }
+    getBadgeMetadata(badgeId) {
+        return (0, __1.getMetadataForBadgeId)(badgeId, this.cachedBadgeMetadata);
+    }
+    getBadgeMetadataDetails(badgeId) {
+        return (0, __1.getMetadataDetailsForBadgeId)(badgeId, this.cachedBadgeMetadata);
+    }
+    getCollectionMetadataTimelineValue(time) {
+        return this.getTimelineValuesAtTime(time).collectionMetadata;
+    }
+    getBadgeMetadataTimelineValue(time) {
+        return this.getTimelineValuesAtTime(time).badgeMetadata;
+    }
+    getOffChainBalancesMetadata(time) {
+        return this.getTimelineValuesAtTime(time).offChainBalancesMetadata;
+    }
+    getCustomData(time) {
+        return this.getTimelineValuesAtTime(time).customData;
+    }
+    getStandards(time) {
+        return this.getTimelineValuesAtTime(time).standards;
+    }
+    getIsArchived(time) {
+        return this.getTimelineValuesAtTime(time).isArchived;
+    }
+    getDefaultUserBalance() {
+        return (0, __2.deepCopy)(new __1.UserBalanceStore({ ...this.defaultBalances }));
+    }
+    pruneMetadataToFetch(metadataToFetch) {
+        return (0, __1.pruneMetadataToFetch)(this.convert(__1.BigIntify), metadataToFetch);
+    }
+    getMaxMetadataId() {
+        return (0, __1.getMaxMetadataId)(this.convert(__1.BigIntify).getBadgeMetadataTimelineValue());
+    }
+    validatePermissionsUpdate(newPermissions) {
+        const result = (0, __1.validatePermissionsUpdate)(this.convert(__1.BigIntify).collectionPermissions, newPermissions.convert(__1.BigIntify));
+        return result;
+    }
+    validatePermissionUpdate(permissionName, newPermissions) {
+        const { validatePermissionUpdateFunction } = (0, __1.getPermissionVariablesFromName)(permissionName);
+        const oldPermissions = this.collectionPermissions[permissionName];
+        const result = validatePermissionUpdateFunction(oldPermissions, newPermissions);
+        return result;
+    }
+    validateCollectionApprovalsUpdate(newApprovals) {
+        const result = (0, __1.validateCollectionApprovalsUpdate)(this.convert(__1.BigIntify).collectionApprovals, newApprovals.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateCollectionApprovals);
+        return result;
+    }
+    validateBadgeMetadataUpdate(newBadgeMetadata) {
+        const result = (0, __1.validateBadgeMetadataUpdate)(this.convert(__1.BigIntify).badgeMetadataTimeline, newBadgeMetadata.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateBadgeMetadata);
+        return result;
+    }
+    validateOffChainBalancesMetadataUpdate(newOffChainBalancesMetadata) {
+        const result = (0, __1.validateOffChainBalancesMetadataUpdate)(this.convert(__1.BigIntify).offChainBalancesMetadataTimeline, newOffChainBalancesMetadata.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateOffChainBalancesMetadata);
+        return result;
+    }
+    validateCustomDataUpdate(newCustomData) {
+        const result = (0, __1.validateCustomDataUpdate)(this.convert(__1.BigIntify).customDataTimeline, newCustomData.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateCustomData);
+        return result;
+    }
+    validateStandardsUpdate(newStandards) {
+        const result = (0, __1.validateStandardsUpdate)(this.convert(__1.BigIntify).standardsTimeline, newStandards.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateStandards);
+        return result;
+    }
+    validateIsArchivedUpdate(newIsArchived) {
+        const result = (0, __1.validateIsArchivedUpdate)(this.convert(__1.BigIntify).isArchivedTimeline, newIsArchived.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canArchiveCollection);
+        return result;
+    }
+    validateManagerUpdate(newManager) {
+        const result = (0, __1.validateManagerUpdate)(this.convert(__1.BigIntify).managerTimeline, newManager.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateManager);
+        return result;
+    }
+    checkCanDeleteCollection(time) {
+        return (0, __1.checkIfActionPermissionPermits)(this.convert(__1.BigIntify).collectionPermissions.canDeleteCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanArchiveCollection(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canArchiveCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateManager(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateManager, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateOffChainBalancesMetadata(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateOffChainBalancesMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateStandards(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateStandards, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCustomData(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateCustomData, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionMetadata(timelineTimes, time) {
+        return (0, __1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canUpdateCollectionMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanCreateMoreBadges(balances, time) {
+        return (0, __1.checkIfBalancesActionPermissionPermits)(balances.map(x => x.convert(__1.BigIntify)), this.convert(__1.BigIntify).collectionPermissions.canCreateMoreBadges, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateBadgeMetadata(details, time) {
+        return (0, __1.checkIfTimedUpdateWithBadgeIdsPermissionPermits)(details.map(x => {
             return {
-                ...canUpdateUserIncomingApproval,
-                ...convertUserIncomingApprovalPermissionWithDetails(canUpdateUserIncomingApproval, convertFunction),
+                timelineTimes: x.timelineTimes.map(y => y.convert(__1.BigIntify)),
+                badgeIds: x.badgeIds.map(y => y.convert(__1.BigIntify))
             };
-        }),
-        canUpdateOutgoingApprovals: item.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => {
+        }), this.convert(__1.BigIntify).collectionPermissions.canUpdateBadgeMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionApprovals(details, time) {
+        return (0, __1.checkIfCollectionApprovalPermissionPermits)(details.map(x => {
             return {
-                ...canUpdateUserOutgoingApproval,
-                ...convertUserOutgoingApprovalPermissionWithDetails(canUpdateUserOutgoingApproval, convertFunction),
+                ...x,
+                timelineTimes: x.timelineTimes.map(y => y.convert(__1.BigIntify)),
+                badgeIds: x.badgeIds.map(y => y.convert(__1.BigIntify)),
+                ownershipTimes: x.ownershipTimes.map(y => y.convert(__1.BigIntify)),
+                transferTimes: x.transferTimes.map(y => y.convert(__1.BigIntify)),
             };
-        }),
-    });
+        }), this.convert(__1.BigIntify).collectionPermissions.canUpdateCollectionApprovals, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    static async FetchAndInitialize(api, options) {
+        const collection = await api.getCollections({ collectionsToFetch: [options] }).then((x) => x.collections[0]);
+        return new BitBadgesCollection(collection);
+    }
+    static async FetchAndInitializeBatch(api, collectionsToFetch) {
+        const collection = await api.getCollections({ collectionsToFetch: collectionsToFetch });
+        return collection.collections.map((x) => new BitBadgesCollection(x));
+    }
+    async fetchOwnerInfo(api, address, forceful) {
+        const currOwnerInfo = this.getOwnerInfo(address, false);
+        if (currOwnerInfo && !forceful)
+            return currOwnerInfo;
+        const newOwnerInfo = await api.getBadgeBalanceByAddress(this.collectionId, address);
+        if (currOwnerInfo) {
+            Object.assign(currOwnerInfo, newOwnerInfo);
+            return currOwnerInfo;
+        }
+        else {
+            this.owners.push(newOwnerInfo);
+        }
+        return newOwnerInfo;
+    }
+    isRedundantRequest(options) {
+        const cachedCollection = this.convert(__1.BigIntify);
+        const prunedMetadataToFetch = (0, __1.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 shouldFetchMerkleChallengeIds = (options.challengeTrackersToFetch ?? []).find(x => {
+            const match = cachedCollection.merkleChallenges.find(y => y.challengeId === x.challengeId && x.approverAddress === y.approverAddress && x.collectionId === y.collectionId && x.challengeLevel === y.challengeLevel);
+            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 || shouldFetchMerkleChallengeIds || shouldFetchAmountTrackerIds);
+    }
+    async fetchAndUpdate(api, options, forceful) {
+        if (!forceful) {
+            if (this.isRedundantRequest(options))
+                return;
+            if (options.metadataToFetch)
+                options.metadataToFetch = this.pruneMetadataToFetch(options.metadataToFetch);
+            options.viewsToFetch = (options.viewsToFetch || []).filter(x => this.viewHasMore(x.viewId));
+        }
+        const collection = await api.getCollections({ 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 = (0, __1.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) {
+        if (!this.viewHasMore(viewId))
+            return;
+        await this.fetchAndUpdate(api, {
+            viewsToFetch: [{
+                    viewType: viewType,
+                    viewId: viewId,
+                    bookmark: this.views[viewId]?.pagination?.bookmark || ''
+                }]
+        });
+    }
+    async fetchAllForView(api, viewType, viewId) {
+        while (this.viewHasMore(viewId)) {
+            await this.fetchNextForView(api, viewType, viewId);
+            await new Promise(r => setTimeout(r, 1000));
+        }
+    }
+    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 = (0, __1.getAliasDerivationKeysForBadge)(this.collectionId, badgeId);
+        return (0, __1.generateAlias)(moduleName, derivationKeys);
+    }
+    getUnhandledCollectionApprovals() {
+        return (0, __1.getUnhandledCollectionApprovals)(this.convert(__1.BigIntify).collectionApprovals, true);
+    }
+    getNonMintCollectionApprovals() {
+        return (0, __1.getNonMintApprovals)(this.convert(__1.BigIntify).collectionApprovals);
+    }
+    getMintCollectionApprovals() {
+        return (0, __1.getMintApprovals)(this.convert(__1.BigIntify).collectionApprovals);
+    }
+    async getRefreshStatus(api) {
+        return await api.getRefreshStatus(this.collectionId);
+    }
+    async refresh(api) {
+        return await api.refreshMetadata(this.collectionId);
+    }
+    async getBadgeActivity(api, badgeId, body) {
+        return await api.getBadgeActivity(this.collectionId, badgeId, body);
+    }
+    async getOwnersForBadge(api, badgeId, body) {
+        return await api.getOwnersForBadge(this.collectionId, badgeId, body);
+    }
+    async filterBadgesInCollection(api, bodyOptions) {
+        return await api.filterBadgesInCollection({ ...bodyOptions, collectionId: this.collectionId });
+    }
 }
-exports.convertUserPermissionsWithDetails = convertUserPermissionsWithDetails;
-function convertCollectionApprovalWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertCollectionApproval)(item, convertFunction),
-        details: item.details ? (0, db_1.convertApprovalInfoDetails)(item.details, convertFunction) : undefined,
-        approvalCriteria: item.approvalCriteria ? {
-            ...(0, __1.convertApprovalCriteria)(item.approvalCriteria, convertFunction),
-        } : undefined,
-    });
+exports.BitBadgesCollection = BitBadgesCollection;
+function getCurrentValueForTimeline(timeline) {
+    return getValueAtTimeForTimeline(timeline, BigInt(Date.now()));
+}
+exports.getCurrentValueForTimeline = getCurrentValueForTimeline;
+function getCurrentIdxForTimeline(timeline) {
+    return getIdxAtTimeForTimeline(timeline, BigInt(Date.now()));
 }
-exports.convertCollectionApprovalWithDetails = convertCollectionApprovalWithDetails;
-function convertUserBalanceStoreWithDetails(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, __1.convertUserBalanceStore)(item, convertFunction),
-        outgoingApprovals: item.outgoingApprovals.map((outgoingApproval) => (0, users_1.convertUserOutgoingApprovalWithDetails)(outgoingApproval, convertFunction)),
-        incomingApprovals: item.incomingApprovals.map((incomingApproval) => (0, users_1.convertUserIncomingApprovalWithDetails)(incomingApproval, convertFunction)),
-        userPermissions: convertUserPermissionsWithDetails(item.userPermissions, convertFunction),
+exports.getCurrentIdxForTimeline = getCurrentIdxForTimeline;
+function getValueAtTimeForTimeline(timeline, time) {
+    const timeToCheck = time ?? BigInt(Date.now());
+    for (const timelineItem of timeline) {
+        const timelineTimes = timelineItem.timelineTimes;
+        const [, found] = (0, __1.searchUintRangesForId)(BigInt(timeToCheck), timelineTimes);
+        if (found) {
+            return timelineItem;
+        }
+    }
+    return undefined;
+}
+exports.getValueAtTimeForTimeline = getValueAtTimeForTimeline;
+function getIdxAtTimeForTimeline(timeline, time) {
+    const timeToCheck = time ?? BigInt(Date.now());
+    for (const timelineItem of timeline) {
+        const timelineTimes = timelineItem.timelineTimes;
+        const [idx, found] = (0, __1.searchUintRangesForId)(BigInt(timeToCheck), timelineTimes);
+        if (found) {
+            return Number(idx);
+        }
+    }
+    return Number(-1);
+}
+exports.getIdxAtTimeForTimeline = getIdxAtTimeForTimeline;
+function getFullTimeline(timeline, fieldName, emptyValue, maxTime = 18446744073709551615n) {
+    let unhandledTimes = [new __1.UintRange({ start: BigInt(1n), end: maxTime })];
+    for (const timelineVal of timeline) {
+        const [remaining, _removed] = (0, __1.removeUintRangesFromUintRanges)(timelineVal.timelineTimes, unhandledTimes);
+        unhandledTimes = remaining;
+    }
+    if (unhandledTimes.length === 0) {
+        return timeline;
+    }
+    timeline.push({
+        [fieldName]: emptyValue,
+        timelineTimes: unhandledTimes,
     });
+    return timeline;
+}
+function getFullManagerTimeline(timeline) {
+    return getFullTimeline(timeline, "manager", "");
 }
-exports.convertUserBalanceStoreWithDetails = convertUserBalanceStoreWithDetails;
-function convertBitBadgesCollection(item, convertFunction) {
-    return (0, utils_1.deepCopy)({
-        ...item,
-        ...(0, db_1.convertCollectionDoc)({ ...item, _docId: item.collectionId.toString() }, convertFunction),
-        collectionApprovals: item.collectionApprovals.map((collectionApproval) => convertCollectionApprovalWithDetails(collectionApproval, convertFunction)),
-        defaultBalances: convertUserBalanceStoreWithDetails(item.defaultBalances, convertFunction),
-        collectionPermissions: convertCollectionPermissionsWithDetails(item.collectionPermissions, convertFunction),
-        cachedCollectionMetadata: item.cachedCollectionMetadata ? (0, metadata_1.convertMetadata)(item.cachedCollectionMetadata, convertFunction) : undefined,
-        cachedBadgeMetadata: item.cachedBadgeMetadata.map((metadata) => convertBadgeMetadataDetails(metadata, convertFunction)),
-        activity: item.activity.map((activityItem) => (0, activity_1.convertTransferActivityDoc)(activityItem, convertFunction)),
-        announcements: item.announcements.map((activityItem) => (0, activity_1.convertAnnouncementDoc)(activityItem, convertFunction)),
-        reviews: item.reviews.map((activityItem) => (0, activity_1.convertReviewDoc)(activityItem, convertFunction)),
-        owners: item.owners.map((balance) => (0, db_1.convertBalanceDocWithDetails)(balance, convertFunction)),
-        merkleChallenges: item.merkleChallenges.map((merkleChallenge) => (0, db_1.convertMerkleChallengeDoc)(merkleChallenge, convertFunction)),
-        approvalTrackers: item.approvalTrackers.map((approvalTracker) => (0, db_1.convertApprovalTrackerDoc)(approvalTracker, convertFunction)),
-        _rev: undefined,
-        _deleted: undefined,
-        nsfw: item.nsfw ? { ...item.nsfw, badgeIds: item.nsfw.badgeIds.map((UintRange) => (0, __1.convertUintRange)(UintRange, convertFunction)) } : undefined,
-        reported: item.reported ? { ...item.reported, badgeIds: item.reported.badgeIds.map((UintRange) => (0, __1.convertUintRange)(UintRange, convertFunction)) } : undefined,
+exports.getFullManagerTimeline = getFullManagerTimeline;
+function getFullCollectionMetadataTimeline(timeline) {
+    return getFullTimeline(timeline, "collectionMetadata", __1.DefaultPlaceholderMetadata);
+}
+exports.getFullCollectionMetadataTimeline = getFullCollectionMetadataTimeline;
+function getFullBadgeMetadataTimeline(timeline) {
+    return getFullTimeline(timeline, "badgeMetadata", []);
+}
+exports.getFullBadgeMetadataTimeline = getFullBadgeMetadataTimeline;
+function getOffChainBalancesMetadataTimeline(timeline) {
+    return getFullTimeline(timeline, "offChainBalancesMetadata", {
+        uri: '',
+        customData: '',
     });
 }
-exports.convertBitBadgesCollection = convertBitBadgesCollection;
+exports.getOffChainBalancesMetadataTimeline = getOffChainBalancesMetadataTimeline;
+function getFullCustomDataTimeline(timeline) {
+    return getFullTimeline(timeline, "customData", "");
+}
+exports.getFullCustomDataTimeline = getFullCustomDataTimeline;
+function getFullStandardsTimeline(timeline) {
+    return getFullTimeline(timeline, "standards", []);
+}
+exports.getFullStandardsTimeline = getFullStandardsTimeline;
+function getFullIsArchivedTimeline(timeline) {
+    return getFullTimeline(timeline, "isArchived", false);
+}
+exports.getFullIsArchivedTimeline = getFullIsArchivedTimeline;
 //# sourceMappingURL=collections.js.map