bitbadgesjs-sdk 0.1.2 → 0.1.4

package/dist/core/misc.js

@@ -0,0 +1,1038 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStandardsTimesAndValues = exports.getCustomDataTimesAndValues = exports.getManagerTimesAndValues = exports.getBadgeMetadataTimesAndValues = exports.getCollectionMetadataTimesAndValues = exports.getOffChainBalancesMetadataTimesAndValues = exports.getIsArchivedTimesAndValues = exports.IsArchivedTimeline = exports.StandardsTimeline = exports.CustomDataTimeline = exports.OffChainBalancesMetadataTimeline = exports.BadgeMetadataTimeline = exports.CollectionMetadataTimeline = exports.ManagerTimeline = exports.TimelineItem = exports.MerkleProof = exports.MerklePathItem = exports.MerkleChallenge = exports.AmountTrackerIdDetails = exports.ApprovalIdentifierDetails = exports.MustOwnBadges = exports.OffChainBalancesMetadata = exports.CollectionMetadata = exports.BadgeMetadata = void 0;
+const base_1 = require("../common/base");
+const proto = __importStar(require("../proto"));
+const addressLists_1 = require("./addressLists");
+const overlaps_1 = require("./overlaps");
+const permissions_1 = require("./permissions");
+const string_numbers_1 = require("../common/string-numbers");
+const uintRanges_1 = require("./uintRanges");
+const validate_utils_1 = require("./validate-utils");
+class BadgeMetadata extends base_1.BaseNumberTypeClass {
+    uri;
+    badgeIds;
+    customData;
+    constructor(badgeMetadata) {
+        super();
+        this.uri = badgeMetadata.uri;
+        this.badgeIds = uintRanges_1.UintRangeArray.From(badgeMetadata.badgeIds);
+        this.customData = badgeMetadata.customData;
+    }
+    convert(convertFunction) {
+        return new BadgeMetadata((0, base_1.deepCopy)({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new proto.badges.BadgeMetadata({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.toProto()),
+            customData: this.customData
+        });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return BadgeMetadata.fromProto(proto.badges.BadgeMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return BadgeMetadata.fromProto(proto.badges.BadgeMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new BadgeMetadata({
+            uri: item.uri,
+            badgeIds: item.badgeIds.map((b) => uintRanges_1.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];
+                const [remaining,] = otherMetadata.badgeIds.remove(metadata.badgeIds);
+                otherMetadata.badgeIds = remaining;
+            }
+        }
+        return metadataArr;
+    }
+}
+exports.BadgeMetadata = BadgeMetadata;
+class CollectionMetadata extends base_1.CustomTypeClass {
+    uri;
+    customData;
+    constructor(collectionMetadata) {
+        super();
+        this.uri = collectionMetadata.uri;
+        this.customData = collectionMetadata.customData;
+    }
+    toProto() {
+        return new proto.badges.CollectionMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionMetadata.fromProto(proto.badges.CollectionMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionMetadata.fromProto(proto.badges.CollectionMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new CollectionMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.CollectionMetadata = CollectionMetadata;
+class OffChainBalancesMetadata extends base_1.CustomTypeClass {
+    uri;
+    customData;
+    constructor(offChainBalancesMetadata) {
+        super();
+        this.uri = offChainBalancesMetadata.uri;
+        this.customData = offChainBalancesMetadata.customData;
+    }
+    toProto() {
+        return new proto.badges.OffChainBalancesMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return OffChainBalancesMetadata.fromProto(proto.badges.OffChainBalancesMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return OffChainBalancesMetadata.fromProto(proto.badges.OffChainBalancesMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new OffChainBalancesMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.OffChainBalancesMetadata = OffChainBalancesMetadata;
+class MustOwnBadges extends base_1.BaseNumberTypeClass {
+    collectionId;
+    amountRange;
+    ownershipTimes;
+    badgeIds;
+    overrideWithCurrentTime;
+    mustSatisfyForAllAssets;
+    constructor(mustOwn) {
+        super();
+        this.collectionId = mustOwn.collectionId;
+        this.amountRange = new uintRanges_1.UintRange(mustOwn.amountRange);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(mustOwn.ownershipTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(mustOwn.badgeIds);
+        this.overrideWithCurrentTime = mustOwn.overrideWithCurrentTime;
+        this.mustSatisfyForAllAssets = mustOwn.mustSatisfyForAllAssets;
+    }
+    getNumberFieldNames() {
+        return ['collectionId'];
+    }
+    convert(convertFunction) {
+        return new MustOwnBadges((0, base_1.deepCopy)({
+            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 proto.badges.MustOwnBadges(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return MustOwnBadges.fromProto(proto.badges.MustOwnBadges.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return MustOwnBadges.fromProto(proto.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: uintRanges_1.UintRange.fromProto(item.amountRange, convertFunction),
+            ownershipTimes: item.ownershipTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction)),
+            badgeIds: item.badgeIds.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction)),
+            overrideWithCurrentTime: item.overrideWithCurrentTime,
+            mustSatisfyForAllAssets: item.mustSatisfyForAllAssets
+        });
+    }
+}
+exports.MustOwnBadges = MustOwnBadges;
+class ApprovalIdentifierDetails extends base_1.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 proto.badges.ApprovalIdentifierDetails(this.clone().toJson());
+    }
+    clone() {
+        return new ApprovalIdentifierDetails({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return ApprovalIdentifierDetails.fromProto(proto.badges.ApprovalIdentifierDetails.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return ApprovalIdentifierDetails.fromProto(proto.badges.ApprovalIdentifierDetails.fromJsonString(jsonString, options));
+    }
+    static fromProto(item) {
+        return new ApprovalIdentifierDetails({ ...item });
+    }
+}
+exports.ApprovalIdentifierDetails = ApprovalIdentifierDetails;
+class AmountTrackerIdDetails extends base_1.BaseNumberTypeClass {
+    collectionId;
+    amountTrackerId;
+    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;
+    }
+    getNumberFieldNames() {
+        return ['collectionId'];
+    }
+    convert(convertFunction) {
+        return new AmountTrackerIdDetails((0, base_1.deepCopy)({
+            collectionId: convertFunction(this.collectionId),
+            amountTrackerId: this.amountTrackerId,
+            approvalLevel: this.approvalLevel,
+            approverAddress: this.approverAddress,
+            trackerType: this.trackerType,
+            approvedAddress: this.approvedAddress
+        }));
+    }
+}
+exports.AmountTrackerIdDetails = AmountTrackerIdDetails;
+class MerkleChallenge extends base_1.BaseNumberTypeClass {
+    root;
+    expectedProofLength;
+    useCreatorAddressAsLeaf;
+    maxUsesPerLeaf;
+    uri;
+    customData;
+    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;
+    }
+    static required() {
+        return new MerkleChallenge({
+            root: '',
+            expectedProofLength: 0,
+            useCreatorAddressAsLeaf: false,
+            maxUsesPerLeaf: 0,
+            uri: '',
+            customData: ''
+        });
+    }
+    getNumberFieldNames() {
+        return ['expectedProofLength', 'maxUsesPerLeaf'];
+    }
+    convert(convertFunction) {
+        return new MerkleChallenge((0, base_1.deepCopy)({
+            root: this.root,
+            expectedProofLength: convertFunction(this.expectedProofLength),
+            useCreatorAddressAsLeaf: this.useCreatorAddressAsLeaf,
+            maxUsesPerLeaf: convertFunction(this.maxUsesPerLeaf),
+            uri: this.uri,
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new proto.badges.MerkleChallenge(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return MerkleChallenge.fromProto(proto.badges.MerkleChallenge.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return MerkleChallenge.fromProto(proto.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
+        });
+    }
+}
+exports.MerkleChallenge = MerkleChallenge;
+class MerklePathItem extends base_1.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 proto.badges.MerklePathItem(this.clone().toJson());
+    }
+    clone() {
+        return new MerklePathItem({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return MerklePathItem.fromProto(proto.badges.MerklePathItem.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return MerklePathItem.fromProto(proto.badges.MerklePathItem.fromJsonString(jsonString, options));
+    }
+    static fromProto(item) {
+        return new MerklePathItem({ ...item });
+    }
+}
+exports.MerklePathItem = MerklePathItem;
+class MerkleProof extends base_1.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 proto.badges.MerkleProof(this.clone().toJson());
+    }
+    clone() {
+        return new MerkleProof({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return MerkleProof.fromProto(proto.badges.MerkleProof.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return MerkleProof.fromProto(proto.badges.MerkleProof.fromJsonString(jsonString, options));
+    }
+    static fromProto(item) {
+        return new MerkleProof({
+            aunts: item.aunts.map((b) => MerklePathItem.fromProto(b)),
+            leaf: item.leaf
+        });
+    }
+}
+exports.MerkleProof = MerkleProof;
+class TimelineItem extends base_1.BaseNumberTypeClass {
+    timelineTimes;
+    constructor(timelineItem) {
+        super();
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(timelineItem.timelineTimes);
+    }
+    convert(convertFunction) {
+        return new TimelineItem((0, base_1.deepCopy)({
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+}
+exports.TimelineItem = TimelineItem;
+class ManagerTimeline extends base_1.BaseNumberTypeClass {
+    manager;
+    timelineTimes;
+    constructor(managerTimeline) {
+        super();
+        this.manager = managerTimeline.manager;
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(managerTimeline.timelineTimes);
+    }
+    static required() {
+        return new ManagerTimeline({
+            manager: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new ManagerTimeline((0, base_1.deepCopy)({
+            manager: this.manager,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.ManagerTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ManagerTimeline.fromProto(proto.badges.ManagerTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ManagerTimeline.fromProto(proto.badges.ManagerTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new ManagerTimeline({
+            manager: item.manager,
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldManager, newManager, canUpdateManager) {
+        return validateManagerUpdate(oldManager.map((b) => b.convert(string_numbers_1.BigIntify)), newManager.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateManager.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.ManagerTimeline = ManagerTimeline;
+class CollectionMetadataTimeline extends base_1.BaseNumberTypeClass {
+    collectionMetadata;
+    timelineTimes;
+    constructor(collectionMetadataTimeline) {
+        super();
+        this.collectionMetadata = new CollectionMetadata(collectionMetadataTimeline.collectionMetadata);
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(collectionMetadataTimeline.timelineTimes);
+    }
+    convert(convertFunction) {
+        return new CollectionMetadataTimeline((0, base_1.deepCopy)({
+            collectionMetadata: this.collectionMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.CollectionMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionMetadataTimeline.fromProto(proto.badges.CollectionMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionMetadataTimeline.fromProto(proto.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, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldCollectionMetadata, newCollectionMetadata, canUpdateCollectionMetadata) {
+        return validateCollectionMetadataUpdate(oldCollectionMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), newCollectionMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateCollectionMetadata.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.CollectionMetadataTimeline = CollectionMetadataTimeline;
+class BadgeMetadataTimeline extends base_1.BaseNumberTypeClass {
+    badgeMetadata;
+    timelineTimes;
+    constructor(badgeMetadataTimeline) {
+        super();
+        this.timelineTimes = uintRanges_1.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((0, base_1.deepCopy)({
+            badgeMetadata: this.badgeMetadata.map((b) => b.convert(convertFunction)),
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.BadgeMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return BadgeMetadataTimeline.fromProto(proto.badges.BadgeMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return BadgeMetadataTimeline.fromProto(proto.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) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldBadgeMetadata, newBadgeMetadata, canUpdateBadgeMetadata) {
+        return validateBadgeMetadataUpdate(oldBadgeMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), newBadgeMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateBadgeMetadata.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.BadgeMetadataTimeline = BadgeMetadataTimeline;
+class OffChainBalancesMetadataTimeline extends base_1.BaseNumberTypeClass {
+    offChainBalancesMetadata;
+    timelineTimes;
+    constructor(offChainBalancesMetadataTimeline) {
+        super();
+        this.offChainBalancesMetadata = new OffChainBalancesMetadata(offChainBalancesMetadataTimeline.offChainBalancesMetadata);
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(offChainBalancesMetadataTimeline.timelineTimes);
+    }
+    convert(convertFunction) {
+        return new OffChainBalancesMetadataTimeline((0, base_1.deepCopy)({
+            offChainBalancesMetadata: this.offChainBalancesMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.OffChainBalancesMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return OffChainBalancesMetadataTimeline.fromProto(proto.badges.OffChainBalancesMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return OffChainBalancesMetadataTimeline.fromProto(proto.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, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldOffChainBalancesMetadata, newOffChainBalancesMetadata, canUpdateOffChainBalancesMetadata) {
+        return validateOffChainBalancesMetadataUpdate(oldOffChainBalancesMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), newOffChainBalancesMetadata.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateOffChainBalancesMetadata.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.OffChainBalancesMetadataTimeline = OffChainBalancesMetadataTimeline;
+class CustomDataTimeline extends base_1.BaseNumberTypeClass {
+    customData;
+    timelineTimes;
+    constructor(customDataTimeline) {
+        super();
+        this.customData = customDataTimeline.customData;
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(customDataTimeline.timelineTimes);
+    }
+    static required() {
+        return new CustomDataTimeline({
+            customData: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CustomDataTimeline((0, base_1.deepCopy)({
+            customData: this.customData,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.CustomDataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CustomDataTimeline.fromProto(proto.badges.CustomDataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CustomDataTimeline.fromProto(proto.badges.CustomDataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new CustomDataTimeline({
+            customData: item.customData,
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldCustomData, newCustomData, canUpdateCustomData) {
+        return validateCustomDataUpdate(oldCustomData.map((b) => b.convert(string_numbers_1.BigIntify)), newCustomData.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateCustomData.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.CustomDataTimeline = CustomDataTimeline;
+class StandardsTimeline extends base_1.BaseNumberTypeClass {
+    standards;
+    timelineTimes;
+    constructor(standardsTimeline) {
+        super();
+        this.standards = standardsTimeline.standards;
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(standardsTimeline.timelineTimes);
+    }
+    static required() {
+        return new StandardsTimeline({
+            standards: [],
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new StandardsTimeline((0, base_1.deepCopy)({
+            standards: this.standards,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.StandardsTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return StandardsTimeline.fromProto(proto.badges.StandardsTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return StandardsTimeline.fromProto(proto.badges.StandardsTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new StandardsTimeline({
+            standards: item.standards,
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldStandards, newStandards, canUpdateStandards) {
+        return validateStandardsUpdate(oldStandards.map((b) => b.convert(string_numbers_1.BigIntify)), newStandards.map((b) => b.convert(string_numbers_1.BigIntify)), canUpdateStandards.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.StandardsTimeline = StandardsTimeline;
+class IsArchivedTimeline extends base_1.BaseNumberTypeClass {
+    isArchived;
+    timelineTimes;
+    constructor(isArchivedTimeline) {
+        super();
+        this.isArchived = isArchivedTimeline.isArchived;
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(isArchivedTimeline.timelineTimes);
+    }
+    static required() {
+        return new IsArchivedTimeline({
+            isArchived: false,
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new IsArchivedTimeline((0, base_1.deepCopy)({
+            isArchived: this.isArchived,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.IsArchivedTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return IsArchivedTimeline.fromProto(proto.badges.IsArchivedTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return IsArchivedTimeline.fromProto(proto.badges.IsArchivedTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new IsArchivedTimeline({
+            isArchived: item.isArchived,
+            timelineTimes: item.timelineTimes.map((b) => uintRanges_1.UintRange.fromProto(b, convertFunction))
+        });
+    }
+    static validateUpdate(oldIsArchived, newIsArchived, canArchiveCollection) {
+        const { times: oldTimes, values: oldValues } = getIsArchivedTimesAndValues(oldIsArchived.map((b) => b.convert(string_numbers_1.BigIntify)));
+        const { times: newTimes, values: newValues } = getIsArchivedTimesAndValues(newIsArchived.map((b) => b.convert(string_numbers_1.BigIntify)));
+        const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+        const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+        const updatedTimelineTimes = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, false, getUpdatedBoolCombinations);
+        const details = uintRanges_1.UintRangeArray.From(updatedTimelineTimes.map((x) => x.timelineTime));
+        return permissions_1.TimedUpdatePermission.check(details, canArchiveCollection.map((b) => b.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.IsArchivedTimeline = IsArchivedTimeline;
+const castBadgeMetadataToUniversalPermission = (badgeMetadata) => {
+    const castedPermissions = [];
+    for (const metadata of badgeMetadata) {
+        castedPermissions.push({
+            ...validate_utils_1.AllDefaultValues,
+            badgeIds: metadata.badgeIds,
+            usesBadgeIds: true,
+            arbitraryValue: metadata.uri + "<><><>" + metadata.customData,
+        });
+    }
+    return castedPermissions;
+};
+function validateBadgeMetadataUpdate(oldBadgeMetadata, newBadgeMetadata, canUpdateBadgeMetadata) {
+    const { times: oldTimes, values: oldValues } = getBadgeMetadataTimesAndValues(oldBadgeMetadata);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getBadgeMetadataTimesAndValues(newBadgeMetadata);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const detailsToCheck = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
+        const oldBadgeMetadata = oldValue;
+        const firstMatchesForOld = (0, overlaps_1.GetFirstMatchOnly)(castBadgeMetadataToUniversalPermission(oldBadgeMetadata));
+        const newBadgeMetadata = newValue;
+        const firstMatchesForNew = (0, overlaps_1.GetFirstMatchOnly)(castBadgeMetadataToUniversalPermission(newBadgeMetadata));
+        const detailsToReturn = [];
+        const [overlapObjects, inOldButNotNew, inNewButNotOld] = (0, overlaps_1.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: uintRanges_1.UintRangeArray.From([x.timelineTime]),
+            badgeIds: uintRanges_1.UintRangeArray.From([x.badgeId]),
+            ownershipTimes: uintRanges_1.UintRangeArray.From([x.ownershipTime]),
+            transferTimes: uintRanges_1.UintRangeArray.From([x.transferTime]),
+            toList: x.toList,
+            fromList: x.fromList,
+            initiatedByList: x.initiatedByList,
+        };
+        return result;
+    });
+    const err = permissions_1.TimedUpdateWithBadgeIdsPermission.check(details, canUpdateBadgeMetadata);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+function validateCollectionMetadataUpdate(oldCollectionMetadata, newCollectionMetadata, canUpdateCollectionMetadata) {
+    const { times: oldTimes, values: oldValues } = getCollectionMetadataTimesAndValues(oldCollectionMetadata);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getCollectionMetadataTimesAndValues(newCollectionMetadata);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const detailsToCheck = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
+        const detailsToCheck = [];
+        if (oldValue === null && newValue !== null) {
+            detailsToCheck.push({
+                timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                toList: addressLists_1.AddressList.AllAddresses(),
+                fromList: addressLists_1.AddressList.AllAddresses(),
+                initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+            });
+        }
+        else {
+            const oldVal = oldValue;
+            const newVal = newValue;
+            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
+                detailsToCheck.push({
+                    timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    toList: addressLists_1.AddressList.AllAddresses(),
+                    fromList: addressLists_1.AddressList.AllAddresses(),
+                    initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                    approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                    amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+                });
+            }
+        }
+        return detailsToCheck;
+    });
+    const details = uintRanges_1.UintRangeArray.From(detailsToCheck.map(x => {
+        return [x.timelineTime];
+    }).flat());
+    const err = permissions_1.TimedUpdatePermission.check(details, canUpdateCollectionMetadata);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+function validateOffChainBalancesMetadataUpdate(oldOffChainBalancesMetadata, newOffChainBalancesMetadata, canUpdateOffChainBalancesMetadata) {
+    const { times: oldTimes, values: oldValues } = getOffChainBalancesMetadataTimesAndValues(oldOffChainBalancesMetadata);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getOffChainBalancesMetadataTimesAndValues(newOffChainBalancesMetadata);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const detailsToCheck = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
+        const detailsToCheck = [];
+        if (oldValue === null && newValue !== null) {
+            detailsToCheck.push({
+                timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                toList: addressLists_1.AddressList.AllAddresses(),
+                fromList: addressLists_1.AddressList.AllAddresses(),
+                initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+            });
+        }
+        else {
+            const oldVal = oldValue;
+            const newVal = newValue;
+            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
+                detailsToCheck.push({
+                    timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    toList: addressLists_1.AddressList.AllAddresses(),
+                    fromList: addressLists_1.AddressList.AllAddresses(),
+                    initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                    approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                    amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+                });
+            }
+        }
+        return detailsToCheck;
+    });
+    const details = uintRanges_1.UintRangeArray.From(detailsToCheck.map(x => x.timelineTime));
+    const err = permissions_1.TimedUpdatePermission.check(details, canUpdateOffChainBalancesMetadata);
+    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 uintRanges_1.UintRange({ start: 1n, end: 1n }),
+            badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+            ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+            transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+            toList: addressLists_1.AddressList.AllAddresses(),
+            fromList: addressLists_1.AddressList.AllAddresses(),
+            initiatedByList: addressLists_1.AddressList.AllAddresses(),
+            approvalIdList: addressLists_1.AddressList.AllAddresses(),
+            amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+            challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+        });
+    }
+    return x;
+}
+function getUpdatedBoolCombinations(oldValue, newValue) {
+    if ((oldValue === null && newValue !== null) || (oldValue !== null && newValue === null) || oldValue !== newValue) {
+        return [{
+                timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                toList: addressLists_1.AddressList.AllAddresses(),
+                fromList: addressLists_1.AddressList.AllAddresses(),
+                initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+            }];
+    }
+    return [];
+}
+function validateManagerUpdate(oldManager, newManager, canUpdateManager) {
+    const { times: oldTimes, values: oldValues } = getManagerTimesAndValues(oldManager);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getManagerTimesAndValues(newManager);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const updatedTimelineTimes = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, "", getUpdatedStringCombinations);
+    const details = uintRanges_1.UintRangeArray.From(updatedTimelineTimes.map(x => x.timelineTime));
+    const err = permissions_1.TimedUpdatePermission.check(details, canUpdateManager);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+function validateCustomDataUpdate(oldCustomData, newCustomData, canUpdateCustomData) {
+    const { times: oldTimes, values: oldValues } = getCustomDataTimesAndValues(oldCustomData);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getCustomDataTimesAndValues(newCustomData);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const updatedTimelineTimes = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, "", getUpdatedStringCombinations);
+    const details = uintRanges_1.UintRangeArray.From(updatedTimelineTimes.map(x => x.timelineTime));
+    const err = permissions_1.TimedUpdatePermission.check(details, canUpdateCustomData);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+function validateStandardsUpdate(oldStandards, newStandards, canUpdateStandards) {
+    const { times: oldTimes, values: oldValues } = getStandardsTimesAndValues(oldStandards);
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(oldTimes, oldValues);
+    const { times: newTimes, values: newValues } = getStandardsTimesAndValues(newStandards);
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(newTimes, newValues);
+    const updatedTimelineTimes = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
+        if ((oldValue == null && newValue != null) || (oldValue != null && newValue == null)) {
+            return [{
+                    timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    toList: addressLists_1.AddressList.AllAddresses(),
+                    fromList: addressLists_1.AddressList.AllAddresses(),
+                    initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                    approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                    amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+                }];
+        }
+        else if (oldValue.length != newValue.length) {
+            return [{
+                    timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                    toList: addressLists_1.AddressList.AllAddresses(),
+                    fromList: addressLists_1.AddressList.AllAddresses(),
+                    initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                    approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                    amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                    permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+                }];
+        }
+        else {
+            for (let i = 0; i < oldValue.length; i++) {
+                if (oldValue[i] != newValue[i]) {
+                    return [{
+                            timelineTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                            badgeId: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                            ownershipTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                            transferTime: new uintRanges_1.UintRange({ start: 1n, end: 1n }),
+                            toList: addressLists_1.AddressList.AllAddresses(),
+                            fromList: addressLists_1.AddressList.AllAddresses(),
+                            initiatedByList: addressLists_1.AddressList.AllAddresses(),
+                            approvalIdList: addressLists_1.AddressList.AllAddresses(),
+                            amountTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                            challengeTrackerIdList: addressLists_1.AddressList.AllAddresses(),
+                            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]), permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]), arbitraryValue: undefined
+                        }];
+                }
+            }
+        }
+        return [];
+    });
+    const details = uintRanges_1.UintRangeArray.From(updatedTimelineTimes.map(x => x.timelineTime));
+    const err = permissions_1.TimedUpdatePermission.check(details, canUpdateStandards);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+function getIsArchivedTimesAndValues(isArchivedTimeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of isArchivedTimeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.isArchived);
+    }
+    return { times, values };
+}
+exports.getIsArchivedTimesAndValues = getIsArchivedTimesAndValues;
+function getOffChainBalancesMetadataTimesAndValues(inheritedBalancesMetadata) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of inheritedBalancesMetadata) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.offChainBalancesMetadata);
+    }
+    return { times, values };
+}
+exports.getOffChainBalancesMetadataTimesAndValues = getOffChainBalancesMetadataTimesAndValues;
+function getCollectionMetadataTimesAndValues(timeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of timeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.collectionMetadata);
+    }
+    return { times, values };
+}
+exports.getCollectionMetadataTimesAndValues = getCollectionMetadataTimesAndValues;
+function getBadgeMetadataTimesAndValues(timeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of timeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.badgeMetadata);
+    }
+    return { times, values };
+}
+exports.getBadgeMetadataTimesAndValues = getBadgeMetadataTimesAndValues;
+function getManagerTimesAndValues(managerTimeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of managerTimeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.manager);
+    }
+    return { times, values };
+}
+exports.getManagerTimesAndValues = getManagerTimesAndValues;
+function getCustomDataTimesAndValues(customDataTimeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of customDataTimeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.customData);
+    }
+    return { times, values };
+}
+exports.getCustomDataTimesAndValues = getCustomDataTimesAndValues;
+function getStandardsTimesAndValues(standardsTimeline) {
+    const times = [];
+    const values = [];
+    for (const timelineVal of standardsTimeline) {
+        times.push(timelineVal.timelineTimes);
+        values.push(timelineVal.standards);
+    }
+    return { times, values };
+}
+exports.getStandardsTimesAndValues = getStandardsTimesAndValues;
+//# sourceMappingURL=misc.js.map