bitbadgesjs-sdk 0.3.96 → 0.3.99

package/dist/esm/core/misc.js

@@ -1,1123 +0,0 @@
-import { BaseNumberTypeClass, CustomTypeClass, deepCopyPrimitives } from '@/common/base';
-import * as badges from '@/proto/badges';
-import { BigIntify, Stringify } from '../common/string-numbers';
-import { AddressList } from './addressLists';
-import { CosmosCoin } from './coin';
-import { GetFirstMatchOnly, getOverlapsAndNonOverlaps } from './overlaps';
-import { TimedUpdatePermission, TimedUpdateWithBadgeIdsPermission } from './permissions';
-import { UintRange, UintRangeArray } from './uintRanges';
-import { AllDefaultValues, getPotentialUpdatesForTimelineValues, getUpdateCombinationsToCheck } from './validate-utils';
-import { BadgeMetadataDetails, CollectionMetadataDetails } from '@/api-indexer/metadata/badgeMetadata';
-export class BadgeMetadata extends BaseNumberTypeClass {
-    uri;
-    badgeIds;
-    customData;
-    constructor(badgeMetadata) {
-        super();
-        this.uri = badgeMetadata.uri;
-        this.badgeIds = UintRangeArray.From(badgeMetadata.badgeIds);
-        this.customData = badgeMetadata.customData;
-    }
-    convert(convertFunction) {
-        return new BadgeMetadata(deepCopyPrimitives({
-            uri: this.uri,
-            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
-            customData: this.customData
-        }));
-    }
-    toProto() {
-        return new badges.BadgeMetadata({
-            uri: this.uri,
-            badgeIds: this.badgeIds.map((b) => b.toProto()),
-            customData: this.customData
-        });
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return BadgeMetadata.fromProto(badges.BadgeMetadata.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BadgeMetadata.fromProto(badges.BadgeMetadata.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new BadgeMetadata({
-            uri: item.uri,
-            badgeIds: item.badgeIds.map((b) => UintRange.fromProto(b, convertFunction)),
-            customData: item.customData
-        });
-    }
-    static getFirstMatches(badgeMetadata) {
-        const metadataArr = badgeMetadata.map((b) => b.clone());
-        for (let i = 0; i < metadataArr.length; i++) {
-            const metadata = metadataArr[i];
-            for (let j = i + 1; j < metadataArr.length; j++) {
-                const otherMetadata = metadataArr[j];
-                otherMetadata.badgeIds.remove(metadata.badgeIds);
-            }
-        }
-        return metadataArr;
-    }
-}
-export class CollectionMetadata extends CustomTypeClass {
-    uri;
-    customData;
-    constructor(collectionMetadata) {
-        super();
-        this.uri = collectionMetadata.uri;
-        this.customData = collectionMetadata.customData;
-    }
-    toProto() {
-        return new badges.CollectionMetadata({
-            uri: this.uri,
-            customData: this.customData
-        });
-    }
-    static fromJson(jsonValue, options) {
-        return CollectionMetadata.fromProto(badges.CollectionMetadata.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return CollectionMetadata.fromProto(badges.CollectionMetadata.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new CollectionMetadata({
-            uri: item.uri,
-            customData: item.customData
-        });
-    }
-}
-export class OffChainBalancesMetadata extends CustomTypeClass {
-    uri;
-    customData;
-    constructor(offChainBalancesMetadata) {
-        super();
-        this.uri = offChainBalancesMetadata.uri;
-        this.customData = offChainBalancesMetadata.customData;
-    }
-    toProto() {
-        return new badges.OffChainBalancesMetadata({
-            uri: this.uri,
-            customData: this.customData
-        });
-    }
-    static fromJson(jsonValue, options) {
-        return OffChainBalancesMetadata.fromProto(badges.OffChainBalancesMetadata.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return OffChainBalancesMetadata.fromProto(badges.OffChainBalancesMetadata.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new OffChainBalancesMetadata({
-            uri: item.uri,
-            customData: item.customData
-        });
-    }
-}
-export class MustOwnBadges extends BaseNumberTypeClass {
-    collectionId;
-    amountRange;
-    ownershipTimes;
-    badgeIds;
-    overrideWithCurrentTime;
-    mustSatisfyForAllAssets;
-    constructor(mustOwn) {
-        super();
-        this.collectionId = mustOwn.collectionId;
-        this.amountRange = new UintRange(mustOwn.amountRange);
-        this.ownershipTimes = UintRangeArray.From(mustOwn.ownershipTimes);
-        this.badgeIds = UintRangeArray.From(mustOwn.badgeIds);
-        this.overrideWithCurrentTime = mustOwn.overrideWithCurrentTime;
-        this.mustSatisfyForAllAssets = mustOwn.mustSatisfyForAllAssets;
-    }
-    getNumberFieldNames() {
-        return ['collectionId'];
-    }
-    convert(convertFunction) {
-        return new MustOwnBadges(deepCopyPrimitives({
-            collectionId: convertFunction(this.collectionId),
-            amountRange: this.amountRange.convert(convertFunction),
-            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction)),
-            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
-            overrideWithCurrentTime: this.overrideWithCurrentTime,
-            mustSatisfyForAllAssets: this.mustSatisfyForAllAssets
-        }));
-    }
-    toProto() {
-        return new badges.MustOwnBadges(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return MustOwnBadges.fromProto(badges.MustOwnBadges.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return MustOwnBadges.fromProto(badges.MustOwnBadges.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        if (!item.amountRange) {
-            throw new Error('amountRange is required');
-        }
-        return new MustOwnBadges({
-            collectionId: convertFunction(BigInt(item.collectionId)),
-            amountRange: UintRange.fromProto(item.amountRange, convertFunction),
-            ownershipTimes: item.ownershipTimes.map((b) => UintRange.fromProto(b, convertFunction)),
-            badgeIds: item.badgeIds.map((b) => UintRange.fromProto(b, convertFunction)),
-            overrideWithCurrentTime: item.overrideWithCurrentTime,
-            mustSatisfyForAllAssets: item.mustSatisfyForAllAssets
-        });
-    }
-}
-export class ZkProof extends CustomTypeClass {
-    verificationKey;
-    uri;
-    customData;
-    zkpTrackerId;
-    constructor(zkProof) {
-        super();
-        this.verificationKey = zkProof.verificationKey;
-        this.uri = zkProof.uri;
-        this.zkpTrackerId = zkProof.zkpTrackerId;
-        this.customData = zkProof.customData;
-    }
-    toProto() {
-        return new badges.ZkProof(this.clone().toJson());
-    }
-    static fromJson(jsonValue, options) {
-        return ZkProof.fromProto(badges.ZkProof.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return ZkProof.fromProto(badges.ZkProof.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new ZkProof({ ...item });
-    }
-}
-export class CoinTransfer extends BaseNumberTypeClass {
-    to;
-    coins;
-    constructor(coinTransfer) {
-        super();
-        this.to = coinTransfer.to;
-        this.coins = coinTransfer.coins.map((b) => new CosmosCoin(b));
-    }
-    getNumberFieldNames() {
-        return [];
-    }
-    convert(convertFunction) {
-        return new CoinTransfer({
-            to: this.to,
-            coins: this.coins.map((b) => b.convert(convertFunction))
-        });
-    }
-    toProto() {
-        return new badges.CoinTransfer(this.convert(Stringify));
-    }
-    static fromProto(item, convertFunction) {
-        return new CoinTransfer({
-            to: item.to,
-            coins: item.coins.map((b) => CosmosCoin.fromProto(b, convertFunction))
-        });
-    }
-}
-export class ZkProofSolution extends CustomTypeClass {
-    proof;
-    publicInputs;
-    constructor(zkProofSolution) {
-        super();
-        this.proof = zkProofSolution.proof;
-        this.publicInputs = zkProofSolution.publicInputs;
-    }
-    toProto() {
-        return new badges.ZkProofSolution(this.clone().toJson());
-    }
-    static fromJson(jsonValue, options) {
-        return ZkProofSolution.fromProto(badges.ZkProofSolution.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return ZkProofSolution.fromProto(badges.ZkProofSolution.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new ZkProofSolution({ ...item });
-    }
-}
-export class ApprovalIdentifierDetails extends CustomTypeClass {
-    approvalId;
-    approvalLevel;
-    approverAddress;
-    constructor(approvalIdDetails) {
-        super();
-        this.approvalId = approvalIdDetails.approvalId;
-        this.approvalLevel = approvalIdDetails.approvalLevel;
-        this.approverAddress = approvalIdDetails.approverAddress;
-    }
-    static required() {
-        return new ApprovalIdentifierDetails({
-            approvalId: '',
-            approvalLevel: '',
-            approverAddress: ''
-        });
-    }
-    toProto() {
-        return new badges.ApprovalIdentifierDetails(this.clone().toJson());
-    }
-    clone() {
-        return new ApprovalIdentifierDetails({ ...this });
-    }
-    static fromJson(jsonValue, options) {
-        return ApprovalIdentifierDetails.fromProto(badges.ApprovalIdentifierDetails.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return ApprovalIdentifierDetails.fromProto(badges.ApprovalIdentifierDetails.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new ApprovalIdentifierDetails({ ...item });
-    }
-}
-export class AmountTrackerIdDetails extends BaseNumberTypeClass {
-    collectionId;
-    amountTrackerId;
-    approvalId;
-    approvalLevel;
-    approverAddress;
-    trackerType;
-    approvedAddress;
-    constructor(approvalIdDetails) {
-        super();
-        this.collectionId = approvalIdDetails.collectionId;
-        this.amountTrackerId = approvalIdDetails.amountTrackerId;
-        this.approvalLevel = approvalIdDetails.approvalLevel;
-        this.approverAddress = approvalIdDetails.approverAddress;
-        this.trackerType = approvalIdDetails.trackerType;
-        this.approvedAddress = approvalIdDetails.approvedAddress;
-        this.approvalId = approvalIdDetails.approvalId;
-    }
-    getNumberFieldNames() {
-        return ['collectionId'];
-    }
-    convert(convertFunction) {
-        return new AmountTrackerIdDetails(deepCopyPrimitives({
-            collectionId: convertFunction(this.collectionId),
-            amountTrackerId: this.amountTrackerId,
-            approvalLevel: this.approvalLevel,
-            approverAddress: this.approverAddress,
-            trackerType: this.trackerType,
-            approvedAddress: this.approvedAddress,
-            approvalId: this.approvalId
-        }));
-    }
-}
-export class MerkleChallenge extends BaseNumberTypeClass {
-    root;
-    expectedProofLength;
-    useCreatorAddressAsLeaf;
-    maxUsesPerLeaf;
-    uri;
-    customData;
-    challengeTrackerId;
-    constructor(merkleChallenge) {
-        super();
-        this.root = merkleChallenge.root;
-        this.expectedProofLength = merkleChallenge.expectedProofLength;
-        this.useCreatorAddressAsLeaf = merkleChallenge.useCreatorAddressAsLeaf;
-        this.maxUsesPerLeaf = merkleChallenge.maxUsesPerLeaf;
-        this.uri = merkleChallenge.uri;
-        this.customData = merkleChallenge.customData;
-        this.challengeTrackerId = merkleChallenge.challengeTrackerId;
-    }
-    static required() {
-        return new MerkleChallenge({
-            root: '',
-            expectedProofLength: 0,
-            useCreatorAddressAsLeaf: false,
-            maxUsesPerLeaf: 0,
-            uri: '',
-            customData: '',
-            challengeTrackerId: ''
-        });
-    }
-    getNumberFieldNames() {
-        return ['expectedProofLength', 'maxUsesPerLeaf'];
-    }
-    convert(convertFunction) {
-        return new MerkleChallenge(deepCopyPrimitives({
-            root: this.root,
-            expectedProofLength: convertFunction(this.expectedProofLength),
-            useCreatorAddressAsLeaf: this.useCreatorAddressAsLeaf,
-            maxUsesPerLeaf: convertFunction(this.maxUsesPerLeaf),
-            uri: this.uri,
-            customData: this.customData,
-            challengeTrackerId: this.challengeTrackerId
-        }));
-    }
-    toProto() {
-        return new badges.MerkleChallenge(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return MerkleChallenge.fromProto(badges.MerkleChallenge.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return MerkleChallenge.fromProto(badges.MerkleChallenge.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new MerkleChallenge({
-            root: item.root,
-            expectedProofLength: convertFunction(BigInt(item.expectedProofLength)),
-            useCreatorAddressAsLeaf: item.useCreatorAddressAsLeaf,
-            maxUsesPerLeaf: convertFunction(BigInt(item.maxUsesPerLeaf)),
-            uri: item.uri,
-            customData: item.customData,
-            challengeTrackerId: item.challengeTrackerId
-        });
-    }
-}
-export class MerklePathItem extends CustomTypeClass {
-    aunt;
-    onRight;
-    constructor(merklePathItem) {
-        super();
-        this.aunt = merklePathItem.aunt;
-        this.onRight = merklePathItem.onRight;
-    }
-    static required() {
-        return new MerklePathItem({
-            aunt: '',
-            onRight: false
-        });
-    }
-    toProto() {
-        return new badges.MerklePathItem(this.clone().toJson());
-    }
-    clone() {
-        return new MerklePathItem({ ...this });
-    }
-    static fromJson(jsonValue, options) {
-        return MerklePathItem.fromProto(badges.MerklePathItem.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return MerklePathItem.fromProto(badges.MerklePathItem.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new MerklePathItem({ ...item });
-    }
-}
-export class MerkleProof extends CustomTypeClass {
-    aunts;
-    leaf;
-    constructor(merkleProof) {
-        super();
-        this.aunts = merkleProof.aunts.map((b) => new MerklePathItem(b));
-        this.leaf = merkleProof.leaf;
-    }
-    static required() {
-        return new MerkleProof({
-            aunts: [],
-            leaf: ''
-        });
-    }
-    toProto() {
-        return new badges.MerkleProof(this.clone().toJson());
-    }
-    clone() {
-        return new MerkleProof({ ...this });
-    }
-    static fromJson(jsonValue, options) {
-        return MerkleProof.fromProto(badges.MerkleProof.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return MerkleProof.fromProto(badges.MerkleProof.fromJsonString(jsonString, options));
-    }
-    static fromProto(item) {
-        return new MerkleProof({
-            aunts: item.aunts.map((b) => MerklePathItem.fromProto(b)),
-            leaf: item.leaf
-        });
-    }
-}
-export class TimelineItem extends BaseNumberTypeClass {
-    timelineTimes;
-    constructor(timelineItem) {
-        super();
-        this.timelineTimes = UintRangeArray.From(timelineItem.timelineTimes);
-    }
-    convert(convertFunction) {
-        return new TimelineItem(deepCopyPrimitives({
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-}
-export class ManagerTimeline extends BaseNumberTypeClass {
-    manager;
-    timelineTimes;
-    constructor(managerTimeline) {
-        super();
-        this.manager = managerTimeline.manager;
-        this.timelineTimes = UintRangeArray.From(managerTimeline.timelineTimes);
-    }
-    static required() {
-        return new ManagerTimeline({
-            manager: '',
-            timelineTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new ManagerTimeline(deepCopyPrimitives({
-            manager: this.manager,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.ManagerTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ManagerTimeline.fromProto(badges.ManagerTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ManagerTimeline.fromProto(badges.ManagerTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new ManagerTimeline({
-            manager: item.manager,
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldManager, newManager, canUpdateManager) {
-        return validateManagerUpdate(oldManager.map((b) => b.convert(BigIntify)), newManager.map((b) => b.convert(BigIntify)), canUpdateManager.map((b) => b.convert(BigIntify)));
-    }
-}
-export class CollectionMetadataTimelineWithDetails extends BaseNumberTypeClass {
-    collectionMetadata;
-    timelineTimes;
-    constructor(collectionMetadataTimeline) {
-        super();
-        this.collectionMetadata = new CollectionMetadataDetails(collectionMetadataTimeline.collectionMetadata);
-        this.timelineTimes = UintRangeArray.From(collectionMetadataTimeline.timelineTimes);
-    }
-    convert(convertFunction) {
-        return new CollectionMetadataTimelineWithDetails(deepCopyPrimitives({
-            collectionMetadata: this.collectionMetadata.convert(convertFunction),
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.CollectionMetadataTimeline(this.convert(Stringify));
-    }
-}
-export class CollectionMetadataTimeline extends BaseNumberTypeClass {
-    collectionMetadata;
-    timelineTimes;
-    constructor(collectionMetadataTimeline) {
-        super();
-        this.collectionMetadata = new CollectionMetadata(collectionMetadataTimeline.collectionMetadata);
-        this.timelineTimes = UintRangeArray.From(collectionMetadataTimeline.timelineTimes);
-    }
-    convert(convertFunction) {
-        return new CollectionMetadataTimeline(deepCopyPrimitives({
-            collectionMetadata: this.collectionMetadata,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.CollectionMetadataTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionMetadataTimeline.fromProto(badges.CollectionMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionMetadataTimeline.fromProto(badges.CollectionMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        if (item.collectionMetadata === undefined) {
-            throw new Error('CollectionMetadataTimeline: invalid collectionMetadata');
-        }
-        return new CollectionMetadataTimeline({
-            collectionMetadata: CollectionMetadata.fromProto(item.collectionMetadata),
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldCollectionMetadata, newCollectionMetadata, canUpdateCollectionMetadata) {
-        return validateCollectionMetadataUpdate(oldCollectionMetadata.map((b) => b.convert(BigIntify)), newCollectionMetadata.map((b) => b.convert(BigIntify)), canUpdateCollectionMetadata.map((b) => b.convert(BigIntify)));
-    }
-}
-export class BadgeMetadataTimelineWithDetails extends BaseNumberTypeClass {
-    badgeMetadata;
-    timelineTimes;
-    constructor(badgeMetadataTimeline) {
-        super();
-        this.timelineTimes = UintRangeArray.From(badgeMetadataTimeline.timelineTimes);
-        this.badgeMetadata = badgeMetadataTimeline.badgeMetadata.map((b) => new BadgeMetadataDetails(b));
-    }
-    convert(convertFunction) {
-        return new BadgeMetadataTimelineWithDetails(deepCopyPrimitives({
-            badgeMetadata: this.badgeMetadata.map((b) => b.convert(convertFunction)),
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.BadgeMetadataTimeline(this.convert(Stringify));
-    }
-}
-export class BadgeMetadataTimeline extends BaseNumberTypeClass {
-    badgeMetadata;
-    timelineTimes;
-    constructor(badgeMetadataTimeline) {
-        super();
-        this.timelineTimes = UintRangeArray.From(badgeMetadataTimeline.timelineTimes);
-        this.badgeMetadata = badgeMetadataTimeline.badgeMetadata.map((b) => new BadgeMetadata(b));
-    }
-    static required() {
-        return new BadgeMetadataTimeline({
-            badgeMetadata: [],
-            timelineTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new BadgeMetadataTimeline(deepCopyPrimitives({
-            badgeMetadata: this.badgeMetadata.map((b) => b.convert(convertFunction)),
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.BadgeMetadataTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return BadgeMetadataTimeline.fromProto(badges.BadgeMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BadgeMetadataTimeline.fromProto(badges.BadgeMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new BadgeMetadataTimeline({
-            badgeMetadata: item.badgeMetadata.map((b) => BadgeMetadata.fromProto(b, convertFunction)),
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldBadgeMetadata, newBadgeMetadata, canUpdateBadgeMetadata) {
-        return validateBadgeMetadataUpdate(oldBadgeMetadata.map((b) => b.convert(BigIntify)), newBadgeMetadata.map((b) => b.convert(BigIntify)), canUpdateBadgeMetadata.map((b) => b.convert(BigIntify)));
-    }
-}
-export class OffChainBalancesMetadataTimeline extends BaseNumberTypeClass {
-    offChainBalancesMetadata;
-    timelineTimes;
-    constructor(offChainBalancesMetadataTimeline) {
-        super();
-        this.offChainBalancesMetadata = new OffChainBalancesMetadata(offChainBalancesMetadataTimeline.offChainBalancesMetadata);
-        this.timelineTimes = UintRangeArray.From(offChainBalancesMetadataTimeline.timelineTimes);
-    }
-    convert(convertFunction) {
-        return new OffChainBalancesMetadataTimeline(deepCopyPrimitives({
-            offChainBalancesMetadata: this.offChainBalancesMetadata,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.OffChainBalancesMetadataTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return OffChainBalancesMetadataTimeline.fromProto(badges.OffChainBalancesMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return OffChainBalancesMetadataTimeline.fromProto(badges.OffChainBalancesMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        if (!item.offChainBalancesMetadata) {
-            throw new Error('OffChainBalancesMetadataTimeline: offChainBalancesMetadata is required');
-        }
-        return new OffChainBalancesMetadataTimeline({
-            offChainBalancesMetadata: OffChainBalancesMetadata.fromProto(item.offChainBalancesMetadata),
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldOffChainBalancesMetadata, newOffChainBalancesMetadata, canUpdateOffChainBalancesMetadata) {
-        return validateOffChainBalancesMetadataUpdate(oldOffChainBalancesMetadata.map((b) => b.convert(BigIntify)), newOffChainBalancesMetadata.map((b) => b.convert(BigIntify)), canUpdateOffChainBalancesMetadata.map((b) => b.convert(BigIntify)));
-    }
-}
-export class CustomDataTimeline extends BaseNumberTypeClass {
-    customData;
-    timelineTimes;
-    constructor(customDataTimeline) {
-        super();
-        this.customData = customDataTimeline.customData;
-        this.timelineTimes = UintRangeArray.From(customDataTimeline.timelineTimes);
-    }
-    static required() {
-        return new CustomDataTimeline({
-            customData: '',
-            timelineTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new CustomDataTimeline(deepCopyPrimitives({
-            customData: this.customData,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.CustomDataTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CustomDataTimeline.fromProto(badges.CustomDataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CustomDataTimeline.fromProto(badges.CustomDataTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new CustomDataTimeline({
-            customData: item.customData,
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldCustomData, newCustomData, canUpdateCustomData) {
-        return validateCustomDataUpdate(oldCustomData.map((b) => b.convert(BigIntify)), newCustomData.map((b) => b.convert(BigIntify)), canUpdateCustomData.map((b) => b.convert(BigIntify)));
-    }
-}
-export class StandardsTimeline extends BaseNumberTypeClass {
-    standards;
-    timelineTimes;
-    constructor(standardsTimeline) {
-        super();
-        this.standards = standardsTimeline.standards;
-        this.timelineTimes = UintRangeArray.From(standardsTimeline.timelineTimes);
-    }
-    static required() {
-        return new StandardsTimeline({
-            standards: [],
-            timelineTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new StandardsTimeline(deepCopyPrimitives({
-            standards: this.standards,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.StandardsTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return StandardsTimeline.fromProto(badges.StandardsTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return StandardsTimeline.fromProto(badges.StandardsTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new StandardsTimeline({
-            standards: item.standards,
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldStandards, newStandards, canUpdateStandards) {
-        return validateStandardsUpdate(oldStandards.map((b) => b.convert(BigIntify)), newStandards.map((b) => b.convert(BigIntify)), canUpdateStandards.map((b) => b.convert(BigIntify)));
-    }
-}
-export class IsArchivedTimeline extends BaseNumberTypeClass {
-    isArchived;
-    timelineTimes;
-    constructor(isArchivedTimeline) {
-        super();
-        this.isArchived = isArchivedTimeline.isArchived;
-        this.timelineTimes = UintRangeArray.From(isArchivedTimeline.timelineTimes);
-    }
-    static required() {
-        return new IsArchivedTimeline({
-            isArchived: false,
-            timelineTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new IsArchivedTimeline(deepCopyPrimitives({
-            isArchived: this.isArchived,
-            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.IsArchivedTimeline(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return IsArchivedTimeline.fromProto(badges.IsArchivedTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return IsArchivedTimeline.fromProto(badges.IsArchivedTimeline.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new IsArchivedTimeline({
-            isArchived: item.isArchived,
-            timelineTimes: item.timelineTimes.map((b) => UintRange.fromProto(b, convertFunction))
-        });
-    }
-    static validateUpdate(oldIsArchived, newIsArchived, canArchiveCollection) {
-        return validateIsArchivedUpdate(oldIsArchived.map((b) => b.convert(BigIntify)), newIsArchived.map((b) => b.convert(BigIntify)), canArchiveCollection.map((b) => b.convert(BigIntify)));
-    }
-}
-export function validateIsArchivedUpdate(oldIsArchived, newIsArchived, canArchiveCollection) {
-    const { times: oldTimes, values: oldValues } = getIsArchivedTimesAndValues(oldIsArchived.map((b) => b.convert(BigIntify)));
-    const { times: newTimes, values: newValues } = getIsArchivedTimesAndValues(newIsArchived.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, false, getUpdatedBoolCombinations);
-    const details = UintRangeArray.From(updatedTimelineTimes.map((x) => x.timelineTime));
-    return TimedUpdatePermission.check(details, canArchiveCollection.map((b) => b.convert(BigIntify)));
-}
-const castBadgeMetadataToUniversalPermission = (badgeMetadata) => {
-    if (badgeMetadata.length === 0) {
-        return [];
-    }
-    const castedPermissions = [];
-    for (const metadata of badgeMetadata) {
-        castedPermissions.push({
-            ...AllDefaultValues,
-            badgeIds: metadata.badgeIds.convert(BigIntify),
-            usesBadgeIds: true,
-            arbitraryValue: metadata.uri + '<><><>' + metadata.customData
-        });
-    }
-    return castedPermissions;
-};
-export function validateBadgeMetadataUpdate(oldBadgeMetadata, newBadgeMetadata, canUpdateBadgeMetadata) {
-    const { times: oldTimes, values: oldValues } = getBadgeMetadataTimesAndValues(oldBadgeMetadata.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getBadgeMetadataTimesAndValues(newBadgeMetadata.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
-        const oldBadgeMetadata = oldValue;
-        const firstMatchesForOld = GetFirstMatchOnly(castBadgeMetadataToUniversalPermission(oldBadgeMetadata));
-        const newBadgeMetadata = newValue;
-        const firstMatchesForNew = GetFirstMatchOnly(castBadgeMetadataToUniversalPermission(newBadgeMetadata));
-        const detailsToReturn = [];
-        const [overlapObjects, inOldButNotNew, inNewButNotOld] = getOverlapsAndNonOverlaps(firstMatchesForOld, firstMatchesForNew);
-        for (const overlapObject of overlapObjects) {
-            const overlap = overlapObject.overlap;
-            const oldDetails = overlapObject.firstDetails;
-            const newDetails = overlapObject.secondDetails;
-            if ((oldDetails.arbitraryValue === null && newDetails.arbitraryValue !== null) ||
-                (oldDetails.arbitraryValue !== null && newDetails.arbitraryValue === null)) {
-                detailsToReturn.push(overlap);
-            }
-            else {
-                const oldVal = oldDetails.arbitraryValue;
-                const newVal = newDetails.arbitraryValue;
-                if (newVal !== oldVal) {
-                    detailsToReturn.push(overlap);
-                }
-            }
-        }
-        detailsToReturn.push(...inOldButNotNew);
-        detailsToReturn.push(...inNewButNotOld);
-        return detailsToReturn;
-    });
-    const details = detailsToCheck.map((x) => {
-        const result = {
-            timelineTimes: UintRangeArray.From([x.timelineTime]),
-            badgeIds: UintRangeArray.From([x.badgeId]),
-            ownershipTimes: UintRangeArray.From([x.ownershipTime]),
-            transferTimes: UintRangeArray.From([x.transferTime]),
-            toList: x.toList,
-            fromList: x.fromList,
-            initiatedByList: x.initiatedByList
-        };
-        return result;
-    });
-    const err = TimedUpdateWithBadgeIdsPermission.check(details, canUpdateBadgeMetadata.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function validateCollectionMetadataUpdate(oldCollectionMetadata, newCollectionMetadata, canUpdateCollectionMetadata) {
-    const { times: oldTimes, values: oldValues } = getCollectionMetadataTimesAndValues(oldCollectionMetadata.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getCollectionMetadataTimesAndValues(newCollectionMetadata.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
-        const detailsToCheck = [];
-        if (oldValue === null && newValue !== null) {
-            detailsToCheck.push({
-                timelineTime: new UintRange({ start: 1n, end: 1n }),
-                badgeId: new UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                transferTime: new UintRange({ start: 1n, end: 1n }),
-                toList: AddressList.AllAddresses(),
-                fromList: AddressList.AllAddresses(),
-                initiatedByList: AddressList.AllAddresses(),
-                approvalIdList: AddressList.AllAddresses(),
-                permanentlyPermittedTimes: UintRangeArray.From([]),
-                permanentlyForbiddenTimes: UintRangeArray.From([]),
-                arbitraryValue: undefined
-            });
-        }
-        else {
-            const oldVal = oldValue;
-            const newVal = newValue;
-            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
-                detailsToCheck.push({
-                    timelineTime: new UintRange({ start: 1n, end: 1n }),
-                    badgeId: new UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                    transferTime: new UintRange({ start: 1n, end: 1n }),
-                    toList: AddressList.AllAddresses(),
-                    fromList: AddressList.AllAddresses(),
-                    initiatedByList: AddressList.AllAddresses(),
-                    approvalIdList: AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: UintRangeArray.From([]),
-                    permanentlyForbiddenTimes: UintRangeArray.From([]),
-                    arbitraryValue: undefined
-                });
-            }
-        }
-        return detailsToCheck;
-    });
-    const details = UintRangeArray.From(detailsToCheck
-        .map((x) => {
-        return [x.timelineTime];
-    })
-        .flat());
-    const err = TimedUpdatePermission.check(details, canUpdateCollectionMetadata.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function validateOffChainBalancesMetadataUpdate(oldOffChainBalancesMetadata, newOffChainBalancesMetadata, canUpdateOffChainBalancesMetadata) {
-    const { times: oldTimes, values: oldValues } = getOffChainBalancesMetadataTimesAndValues(oldOffChainBalancesMetadata.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getOffChainBalancesMetadataTimesAndValues(newOffChainBalancesMetadata.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
-        const detailsToCheck = [];
-        if (oldValue === null && newValue !== null) {
-            detailsToCheck.push({
-                timelineTime: new UintRange({ start: 1n, end: 1n }),
-                badgeId: new UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                transferTime: new UintRange({ start: 1n, end: 1n }),
-                toList: AddressList.AllAddresses(),
-                fromList: AddressList.AllAddresses(),
-                initiatedByList: AddressList.AllAddresses(),
-                approvalIdList: AddressList.AllAddresses(),
-                permanentlyPermittedTimes: UintRangeArray.From([]),
-                permanentlyForbiddenTimes: UintRangeArray.From([]),
-                arbitraryValue: undefined
-            });
-        }
-        else {
-            const oldVal = oldValue;
-            const newVal = newValue;
-            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
-                detailsToCheck.push({
-                    timelineTime: new UintRange({ start: 1n, end: 1n }),
-                    badgeId: new UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                    transferTime: new UintRange({ start: 1n, end: 1n }),
-                    toList: AddressList.AllAddresses(),
-                    fromList: AddressList.AllAddresses(),
-                    initiatedByList: AddressList.AllAddresses(),
-                    approvalIdList: AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: UintRangeArray.From([]),
-                    permanentlyForbiddenTimes: UintRangeArray.From([]),
-                    arbitraryValue: undefined
-                });
-            }
-        }
-        return detailsToCheck;
-    });
-    const details = UintRangeArray.From(detailsToCheck.map((x) => x.timelineTime));
-    const err = TimedUpdatePermission.check(details, canUpdateOffChainBalancesMetadata.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-function getUpdatedStringCombinations(oldValue, newValue) {
-    const x = [];
-    if ((oldValue === null && newValue !== null) || (oldValue !== null && newValue === null) || oldValue !== newValue) {
-        x.push({
-            timelineTime: new UintRange({ start: 1n, end: 1n }),
-            badgeId: new UintRange({ start: 1n, end: 1n }),
-            ownershipTime: new UintRange({ start: 1n, end: 1n }),
-            transferTime: new UintRange({ start: 1n, end: 1n }),
-            toList: AddressList.AllAddresses(),
-            fromList: AddressList.AllAddresses(),
-            initiatedByList: AddressList.AllAddresses(),
-            approvalIdList: AddressList.AllAddresses(),
-            permanentlyPermittedTimes: UintRangeArray.From([]),
-            permanentlyForbiddenTimes: UintRangeArray.From([]),
-            arbitraryValue: undefined
-        });
-    }
-    return x;
-}
-function getUpdatedBoolCombinations(oldValue, newValue) {
-    if ((oldValue === null && newValue !== null) || (oldValue !== null && newValue === null) || oldValue !== newValue) {
-        return [
-            {
-                timelineTime: new UintRange({ start: 1n, end: 1n }),
-                badgeId: new UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                transferTime: new UintRange({ start: 1n, end: 1n }),
-                toList: AddressList.AllAddresses(),
-                fromList: AddressList.AllAddresses(),
-                initiatedByList: AddressList.AllAddresses(),
-                approvalIdList: AddressList.AllAddresses(),
-                permanentlyPermittedTimes: UintRangeArray.From([]),
-                permanentlyForbiddenTimes: UintRangeArray.From([]),
-                arbitraryValue: undefined
-            }
-        ];
-    }
-    return [];
-}
-export function validateManagerUpdate(oldManager, newManager, canUpdateManager) {
-    const { times: oldTimes, values: oldValues } = getManagerTimesAndValues(oldManager.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getManagerTimesAndValues(newManager.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, '', getUpdatedStringCombinations);
-    const details = UintRangeArray.From(updatedTimelineTimes.map((x) => x.timelineTime));
-    const err = TimedUpdatePermission.check(details, canUpdateManager.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function validateCustomDataUpdate(oldCustomData, newCustomData, canUpdateCustomData) {
-    const { times: oldTimes, values: oldValues } = getCustomDataTimesAndValues(oldCustomData.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getCustomDataTimesAndValues(newCustomData.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, '', getUpdatedStringCombinations);
-    const details = UintRangeArray.From(updatedTimelineTimes.map((x) => x.timelineTime));
-    const err = TimedUpdatePermission.check(details, canUpdateCustomData.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function validateStandardsUpdate(oldStandards, newStandards, canUpdateStandards) {
-    const { times: oldTimes, values: oldValues } = getStandardsTimesAndValues(oldStandards.map((b) => b.convert(BigIntify)));
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getStandardsTimesAndValues(newStandards.map((b) => b.convert(BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
-        if ((oldValue == null && newValue != null) || (oldValue != null && newValue == null)) {
-            return [
-                {
-                    timelineTime: new UintRange({ start: 1n, end: 1n }),
-                    badgeId: new UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                    transferTime: new UintRange({ start: 1n, end: 1n }),
-                    toList: AddressList.AllAddresses(),
-                    fromList: AddressList.AllAddresses(),
-                    initiatedByList: AddressList.AllAddresses(),
-                    approvalIdList: AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: UintRangeArray.From([]),
-                    permanentlyForbiddenTimes: UintRangeArray.From([]),
-                    arbitraryValue: undefined
-                }
-            ];
-        }
-        else if (oldValue.length != newValue.length) {
-            return [
-                {
-                    timelineTime: new UintRange({ start: 1n, end: 1n }),
-                    badgeId: new UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                    transferTime: new UintRange({ start: 1n, end: 1n }),
-                    toList: AddressList.AllAddresses(),
-                    fromList: AddressList.AllAddresses(),
-                    initiatedByList: AddressList.AllAddresses(),
-                    approvalIdList: AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: UintRangeArray.From([]),
-                    permanentlyForbiddenTimes: UintRangeArray.From([]),
-                    arbitraryValue: undefined
-                }
-            ];
-        }
-        else {
-            for (let i = 0; i < oldValue.length; i++) {
-                if (oldValue[i] != newValue[i]) {
-                    return [
-                        {
-                            timelineTime: new UintRange({ start: 1n, end: 1n }),
-                            badgeId: new UintRange({ start: 1n, end: 1n }),
-                            ownershipTime: new UintRange({ start: 1n, end: 1n }),
-                            transferTime: new UintRange({ start: 1n, end: 1n }),
-                            toList: AddressList.AllAddresses(),
-                            fromList: AddressList.AllAddresses(),
-                            initiatedByList: AddressList.AllAddresses(),
-                            approvalIdList: AddressList.AllAddresses(),
-                            permanentlyPermittedTimes: UintRangeArray.From([]),
-                            permanentlyForbiddenTimes: UintRangeArray.From([]),
-                            arbitraryValue: undefined
-                        }
-                    ];
-                }
-            }
-        }
-        return [];
-    });
-    const details = UintRangeArray.From(updatedTimelineTimes.map((x) => x.timelineTime));
-    const err = TimedUpdatePermission.check(details, canUpdateStandards.map((b) => b.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function getIsArchivedTimesAndValues(isArchivedTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of isArchivedTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.isArchived);
-    }
-    return { times, values };
-}
-export function getOffChainBalancesMetadataTimesAndValues(inheritedBalancesMetadata) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of inheritedBalancesMetadata) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.offChainBalancesMetadata);
-    }
-    return { times, values };
-}
-export function getCollectionMetadataTimesAndValues(timeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of timeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.collectionMetadata);
-    }
-    return { times, values };
-}
-export function getBadgeMetadataTimesAndValues(timeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of timeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.badgeMetadata);
-    }
-    return { times, values };
-}
-export function getManagerTimesAndValues(managerTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of managerTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.manager);
-    }
-    return { times, values };
-}
-export function getCustomDataTimesAndValues(customDataTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of customDataTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.customData);
-    }
-    return { times, values };
-}
-export function getStandardsTimesAndValues(standardsTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of standardsTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.standards);
-    }
-    return { times, values };
-}
-//# sourceMappingURL=misc.js.map