bitbadgesjs-sdk 0.1.3 → 0.1.6

package/dist/types/badges/permissions.js

@@ -1,2030 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePermissionsUpdate = exports.validateActionPermissionUpdate = exports.validateCollectionApprovalPermissionsUpdate = exports.validateTimedUpdateWithBadgeIdsPermissionUpdate = exports.validateTimedUpdatePermissionUpdate = exports.validateBalancesActionPermissionUpdate = exports.checkNotForbiddenForAllOverlaps = exports.checkIfUserIncomingApprovalPermissionPermits = exports.checkIfUserOutgoingApprovalPermissionPermits = exports.checkIfCollectionApprovalPermissionPermits = exports.checkIfTimedUpdateWithBadgeIdsPermissionPermits = exports.checkIfBalancesActionPermissionPermits = exports.checkIfTimedUpdatePermissionPermits = exports.checkIfActionPermissionPermits = exports.getUpdateCombinationsToCheck = exports.validateIsArchivedUpdate = exports.validateStandardsUpdate = exports.validateCustomDataUpdate = exports.validateManagerUpdate = exports.getUpdatedBoolCombinations = exports.getUpdatedStringCombinations = exports.validateOffChainBalancesMetadataUpdate = exports.validateCollectionMetadataUpdate = exports.validateBadgeMetadataUpdate = exports.validateCollectionApprovalsUpdate = exports.getPotentialUpdatesForTimelineValues = exports.castUserOutgoingApprovalPermissionToCollectionApprovalPermission = exports.castUserIncomingApprovalPermissionToCollectionApprovalPermission = exports.UserPermissionsWithDetails = exports.CollectionPermissionsWithDetails = exports.UserOutgoingApprovalPermissionWithDetails = exports.UserIncomingApprovalPermissionWithDetails = exports.CollectionApprovalPermissionWithDetails = exports.castBadgeMetadataToUniversalPermission = exports.castBalancesActionPermissionToUniversalPermission = exports.castTimedUpdatePermissionToUniversalPermission = exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission = exports.castCollectionApprovalPermissionToUniversalPermission = exports.castActionPermissionToUniversalPermission = exports.isCurrentTimeForbidden = exports.CollectionApprovalPermission = exports.TimedUpdateWithBadgeIdsPermission = exports.BalancesActionPermission = exports.TimedUpdatePermission = exports.ActionPermission = exports.CollectionPermissions = exports.getPermissionVariablesFromName = exports.UserIncomingApprovalPermission = exports.UserOutgoingApprovalPermission = exports.UserPermissions = void 0;
-exports.validateUniversalPermissionUpdate = void 0;
-const proto_1 = require("../../proto");
-const utils_1 = require("../../utils");
-const overlaps_1 = require("../../utils/overlaps");
-const collections_1 = require("../../utils/types/collections");
-const base_1 = require("../base");
-const string_numbers_1 = require("../string-numbers");
-const typeUtils_1 = require("./typeUtils");
-const { removeUintRangesFromUintRanges } = typeUtils_1.UintRange;
-class UserPermissions extends base_1.BaseNumberTypeClass {
-    canUpdateOutgoingApprovals;
-    canUpdateIncomingApprovals;
-    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
-    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
-    constructor(msg) {
-        super();
-        this.canUpdateOutgoingApprovals = msg.canUpdateOutgoingApprovals.map(x => new UserOutgoingApprovalPermission(x));
-        this.canUpdateIncomingApprovals = msg.canUpdateIncomingApprovals.map(x => new UserIncomingApprovalPermission(x));
-        this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers = msg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map(x => new ActionPermission(x));
-        this.canUpdateAutoApproveSelfInitiatedIncomingTransfers = msg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map(x => new ActionPermission(x));
-    }
-    static required() {
-        return new UserPermissions({
-            canUpdateOutgoingApprovals: [],
-            canUpdateIncomingApprovals: [],
-            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [],
-            canUpdateAutoApproveSelfInitiatedIncomingTransfers: []
-        });
-    }
-    convert(convertFunction) {
-        return new UserPermissions((0, base_1.deepCopy)({
-            canUpdateOutgoingApprovals: this.canUpdateOutgoingApprovals.map((x) => x.convert(convertFunction)),
-            canUpdateIncomingApprovals: this.canUpdateIncomingApprovals.map((x) => x.convert(convertFunction)),
-            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((x) => x.convert(convertFunction)),
-            canUpdateAutoApproveSelfInitiatedIncomingTransfers: this.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.UserPermissions(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserPermissions.convertFromProto(proto_1.badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserPermissions.convertFromProto(proto_1.badges.UserPermissions.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new UserPermissions({
-            canUpdateOutgoingApprovals: protoMsg.canUpdateOutgoingApprovals.map(x => UserOutgoingApprovalPermission.convertFromProto(x, convertFunction)),
-            canUpdateIncomingApprovals: protoMsg.canUpdateIncomingApprovals.map(x => UserIncomingApprovalPermission.convertFromProto(x, convertFunction)),
-            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map(x => ActionPermission.convertFromProto(x, convertFunction)),
-            canUpdateAutoApproveSelfInitiatedIncomingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map(x => ActionPermission.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.UserPermissions = UserPermissions;
-class UserOutgoingApprovalPermission extends base_1.BaseNumberTypeClass {
-    toListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    amountTrackerId;
-    challengeTrackerId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.toListId = msg.toListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
-        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
-        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
-        this.approvalId = msg.approvalId;
-        this.amountTrackerId = msg.amountTrackerId;
-        this.challengeTrackerId = msg.challengeTrackerId;
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new UserOutgoingApprovalPermission({
-            toListId: '',
-            initiatedByListId: '',
-            transferTimes: [],
-            badgeIds: [],
-            ownershipTimes: [],
-            approvalId: '',
-            amountTrackerId: '',
-            challengeTrackerId: '',
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new UserOutgoingApprovalPermission((0, base_1.deepCopy)({
-            toListId: this.toListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
-            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
-            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
-            approvalId: this.approvalId,
-            amountTrackerId: this.amountTrackerId,
-            challengeTrackerId: this.challengeTrackerId,
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.UserOutgoingApprovalPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserOutgoingApprovalPermission.convertFromProto(proto_1.badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserOutgoingApprovalPermission.convertFromProto(proto_1.badges.UserOutgoingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new UserOutgoingApprovalPermission({
-            toListId: protoMsg.toListId,
-            initiatedByListId: protoMsg.initiatedByListId,
-            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            amountTrackerId: protoMsg.amountTrackerId,
-            challengeTrackerId: protoMsg.challengeTrackerId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.UserOutgoingApprovalPermission = UserOutgoingApprovalPermission;
-class UserIncomingApprovalPermission extends base_1.BaseNumberTypeClass {
-    fromListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    amountTrackerId;
-    challengeTrackerId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.fromListId = msg.fromListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.approvalId = msg.approvalId;
-        this.amountTrackerId = msg.amountTrackerId;
-        this.challengeTrackerId = msg.challengeTrackerId;
-        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
-        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
-        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
-        this.approvalId = msg.approvalId;
-        this.amountTrackerId = msg.amountTrackerId;
-        this.challengeTrackerId = msg.challengeTrackerId;
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new UserIncomingApprovalPermission({
-            fromListId: '',
-            initiatedByListId: '',
-            transferTimes: [],
-            badgeIds: [],
-            ownershipTimes: [],
-            approvalId: '',
-            amountTrackerId: '',
-            challengeTrackerId: '',
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new UserIncomingApprovalPermission((0, base_1.deepCopy)({
-            fromListId: this.fromListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
-            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
-            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
-            approvalId: this.approvalId,
-            amountTrackerId: this.amountTrackerId,
-            challengeTrackerId: this.challengeTrackerId,
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.UserIncomingApprovalPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserIncomingApprovalPermission.convertFromProto(proto_1.badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserIncomingApprovalPermission.convertFromProto(proto_1.badges.UserIncomingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new UserIncomingApprovalPermission({
-            fromListId: protoMsg.fromListId,
-            initiatedByListId: protoMsg.initiatedByListId,
-            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            amountTrackerId: protoMsg.amountTrackerId,
-            challengeTrackerId: protoMsg.challengeTrackerId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.UserIncomingApprovalPermission = UserIncomingApprovalPermission;
-const getPermissionVariablesFromName = (permissionName) => {
-    let castFunction = () => { return []; };
-    let flags = overlaps_1.ApprovalPermissionUsedFlags;
-    let validateFunction = undefined;
-    let validatePermissionUpdateFunction = undefined;
-    switch (permissionName) {
-        case 'canArchiveCollection':
-            validateFunction = validateIsArchivedUpdate;
-            break;
-        case 'canUpdateOffChainBalancesMetadata':
-            validateFunction = validateOffChainBalancesMetadataUpdate;
-            break;
-        case 'canUpdateManager':
-            validateFunction = validateManagerUpdate;
-            break;
-        case 'canUpdateCollectionMetadata':
-            validateFunction = validateCollectionMetadataUpdate;
-            break;
-        case 'canUpdateBadgeMetadata':
-            validateFunction = validateBadgeMetadataUpdate;
-            break;
-        case 'canUpdateCollectionApprovals':
-            validateFunction = validateCollectionApprovalsUpdate;
-            break;
-    }
-    switch (permissionName) {
-        case 'canDeleteCollection':
-        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
-        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
-            validatePermissionUpdateFunction = validateActionPermissionUpdate;
-            break;
-        case 'canArchiveCollection':
-        case 'canUpdateOffChainBalancesMetadata':
-        case 'canUpdateStandards':
-        case 'canUpdateCustomData':
-        case 'canUpdateManager':
-        case 'canUpdateCollectionMetadata':
-            validatePermissionUpdateFunction = validateTimedUpdatePermissionUpdate;
-            break;
-        case 'canCreateMoreBadges':
-            validatePermissionUpdateFunction = validateBalancesActionPermissionUpdate;
-            break;
-        case 'canUpdateBadgeMetadata':
-            validatePermissionUpdateFunction = validateTimedUpdateWithBadgeIdsPermissionUpdate;
-            break;
-        case 'canUpdateCollectionApprovals':
-            validatePermissionUpdateFunction = validateCollectionApprovalPermissionsUpdate;
-            break;
-    }
-    let question = "";
-    switch (permissionName) {
-        case 'canDeleteCollection':
-            question = "Can delete the collection?";
-            break;
-        case 'canArchiveCollection':
-            question = "Can archive the collection?";
-            break;
-        case 'canUpdateOffChainBalancesMetadata':
-            question = "Can update the off-chain balances metadata?";
-            break;
-        case 'canUpdateStandards':
-            question = "Can update the standards?";
-            break;
-        case 'canUpdateCustomData':
-            question = "Can update the custom data?";
-            break;
-        case 'canUpdateManager':
-            question = "Can update the manager?";
-            break;
-        case 'canUpdateCollectionMetadata':
-            question = "Can update the collection metadata?";
-            break;
-        case 'canCreateMoreBadges':
-            question = "Can create more badges?";
-            break;
-        case 'canUpdateBadgeMetadata':
-            question = "Can update the badge metadata?";
-            break;
-        case 'canUpdateCollectionApprovals':
-            question = "Can update collection approvals?";
-            break;
-        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
-            question = "Can update auto approve self initiated outgoing transfers?";
-            break;
-        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
-            question = "Can update auto approve self initiated incoming transfers?";
-            break;
-    }
-    switch (permissionName) {
-        case 'canDeleteCollection':
-        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
-        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
-            castFunction = exports.castActionPermissionToUniversalPermission;
-            flags = overlaps_1.ActionPermissionUsedFlags;
-            break;
-        case 'canArchiveCollection':
-        case 'canUpdateOffChainBalancesMetadata':
-        case 'canUpdateStandards':
-        case 'canUpdateCustomData':
-        case 'canUpdateManager':
-        case 'canUpdateCollectionMetadata':
-            castFunction = exports.castTimedUpdatePermissionToUniversalPermission;
-            flags = overlaps_1.TimedUpdatePermissionUsedFlags;
-            break;
-        case 'canCreateMoreBadges':
-            castFunction = exports.castBalancesActionPermissionToUniversalPermission;
-            flags = overlaps_1.BalancesActionPermissionUsedFlags;
-            break;
-        case 'canUpdateBadgeMetadata':
-            castFunction = exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission;
-            flags = overlaps_1.TimedUpdateWithBadgeIdsPermissionUsedFlags;
-            break;
-        case 'canUpdateCollectionApprovals':
-            castFunction = exports.castCollectionApprovalPermissionToUniversalPermission;
-            flags = overlaps_1.ApprovalPermissionUsedFlags;
-            break;
-    }
-    if (!castFunction)
-        throw new Error('');
-    return {
-        castFunction,
-        flags,
-        question,
-        validateFunction,
-        validatePermissionUpdateFunction
-    };
-};
-exports.getPermissionVariablesFromName = getPermissionVariablesFromName;
-class CollectionPermissions extends base_1.BaseNumberTypeClass {
-    canDeleteCollection;
-    canArchiveCollection;
-    canUpdateOffChainBalancesMetadata;
-    canUpdateStandards;
-    canUpdateCustomData;
-    canUpdateManager;
-    canUpdateCollectionMetadata;
-    canCreateMoreBadges;
-    canUpdateBadgeMetadata;
-    canUpdateCollectionApprovals;
-    constructor(msg) {
-        super();
-        this.canDeleteCollection = msg.canDeleteCollection.map(x => new ActionPermission(x));
-        this.canArchiveCollection = msg.canArchiveCollection.map(x => new TimedUpdatePermission(x));
-        this.canUpdateOffChainBalancesMetadata = msg.canUpdateOffChainBalancesMetadata.map(x => new TimedUpdatePermission(x));
-        this.canUpdateStandards = msg.canUpdateStandards.map(x => new TimedUpdatePermission(x));
-        this.canUpdateCustomData = msg.canUpdateCustomData.map(x => new TimedUpdatePermission(x));
-        this.canUpdateManager = msg.canUpdateManager.map(x => new TimedUpdatePermission(x));
-        this.canUpdateCollectionMetadata = msg.canUpdateCollectionMetadata.map(x => new TimedUpdatePermission(x));
-        this.canCreateMoreBadges = msg.canCreateMoreBadges.map(x => new BalancesActionPermission(x));
-        this.canUpdateBadgeMetadata = msg.canUpdateBadgeMetadata.map(x => new TimedUpdateWithBadgeIdsPermission(x));
-        this.canUpdateCollectionApprovals = msg.canUpdateCollectionApprovals.map(x => new CollectionApprovalPermission(x));
-    }
-    static required() {
-        return new CollectionPermissions({
-            canDeleteCollection: [],
-            canArchiveCollection: [],
-            canUpdateOffChainBalancesMetadata: [],
-            canUpdateStandards: [],
-            canUpdateCustomData: [],
-            canUpdateManager: [],
-            canUpdateCollectionMetadata: [],
-            canCreateMoreBadges: [],
-            canUpdateBadgeMetadata: [],
-            canUpdateCollectionApprovals: []
-        });
-    }
-    convert(convertFunction) {
-        return new CollectionPermissions((0, base_1.deepCopy)({
-            canDeleteCollection: this.canDeleteCollection.map((x) => x.convert(convertFunction)),
-            canArchiveCollection: this.canArchiveCollection.map((x) => x.convert(convertFunction)),
-            canUpdateOffChainBalancesMetadata: this.canUpdateOffChainBalancesMetadata.map((x) => x.convert(convertFunction)),
-            canUpdateStandards: this.canUpdateStandards.map((x) => x.convert(convertFunction)),
-            canUpdateCustomData: this.canUpdateCustomData.map((x) => x.convert(convertFunction)),
-            canUpdateManager: this.canUpdateManager.map((x) => x.convert(convertFunction)),
-            canUpdateCollectionMetadata: this.canUpdateCollectionMetadata.map((x) => x.convert(convertFunction)),
-            canCreateMoreBadges: this.canCreateMoreBadges.map((x) => x.convert(convertFunction)),
-            canUpdateBadgeMetadata: this.canUpdateBadgeMetadata.map((x) => x.convert(convertFunction)),
-            canUpdateCollectionApprovals: this.canUpdateCollectionApprovals.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.CollectionPermissions(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionPermissions.convertFromProto(proto_1.badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionPermissions.convertFromProto(proto_1.badges.CollectionPermissions.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new CollectionPermissions({
-            canDeleteCollection: protoMsg.canDeleteCollection.map(x => ActionPermission.convertFromProto(x, convertFunction)),
-            canArchiveCollection: protoMsg.canArchiveCollection.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canUpdateOffChainBalancesMetadata: protoMsg.canUpdateOffChainBalancesMetadata.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canUpdateStandards: protoMsg.canUpdateStandards.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canUpdateCustomData: protoMsg.canUpdateCustomData.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canUpdateManager: protoMsg.canUpdateManager.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canUpdateCollectionMetadata: protoMsg.canUpdateCollectionMetadata.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
-            canCreateMoreBadges: protoMsg.canCreateMoreBadges.map(x => BalancesActionPermission.convertFromProto(x, convertFunction)),
-            canUpdateBadgeMetadata: protoMsg.canUpdateBadgeMetadata.map(x => TimedUpdateWithBadgeIdsPermission.convertFromProto(x, convertFunction)),
-            canUpdateCollectionApprovals: protoMsg.canUpdateCollectionApprovals.map(x => CollectionApprovalPermission.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.CollectionPermissions = CollectionPermissions;
-class ActionPermission extends base_1.BaseNumberTypeClass {
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new ActionPermission({
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new ActionPermission((0, base_1.deepCopy)({
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.ActionPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ActionPermission.convertFromProto(proto_1.badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ActionPermission.convertFromProto(proto_1.badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new ActionPermission({
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.ActionPermission = ActionPermission;
-class TimedUpdatePermission extends base_1.BaseNumberTypeClass {
-    timelineTimes;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.timelineTimes = msg.timelineTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    convert(convertFunction) {
-        return new TimedUpdatePermission((0, base_1.deepCopy)({
-            timelineTimes: this.timelineTimes.map((x) => x.convert(convertFunction)),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.TimedUpdatePermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return TimedUpdatePermission.convertFromProto(proto_1.badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return TimedUpdatePermission.convertFromProto(proto_1.badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new TimedUpdatePermission({
-            timelineTimes: protoMsg.timelineTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.TimedUpdatePermission = TimedUpdatePermission;
-class BalancesActionPermission extends base_1.BaseNumberTypeClass {
-    badgeIds;
-    ownershipTimes;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
-        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new BalancesActionPermission({
-            badgeIds: [],
-            ownershipTimes: [],
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new BalancesActionPermission((0, base_1.deepCopy)({
-            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
-            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.BalancesActionPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return BalancesActionPermission.convertFromProto(proto_1.badges.BalancesActionPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BalancesActionPermission.convertFromProto(proto_1.badges.BalancesActionPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new BalancesActionPermission({
-            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.BalancesActionPermission = BalancesActionPermission;
-class TimedUpdateWithBadgeIdsPermission extends base_1.BaseNumberTypeClass {
-    timelineTimes;
-    badgeIds;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.timelineTimes = msg.timelineTimes.map(x => new typeUtils_1.UintRange(x));
-        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new TimedUpdateWithBadgeIdsPermission({
-            timelineTimes: [],
-            badgeIds: [],
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new TimedUpdateWithBadgeIdsPermission((0, base_1.deepCopy)({
-            timelineTimes: this.timelineTimes.map((x) => x.convert(convertFunction)),
-            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.TimedUpdateWithBadgeIdsPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return TimedUpdateWithBadgeIdsPermission.convertFromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return TimedUpdateWithBadgeIdsPermission.convertFromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new TimedUpdateWithBadgeIdsPermission({
-            timelineTimes: protoMsg.timelineTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.TimedUpdateWithBadgeIdsPermission = TimedUpdateWithBadgeIdsPermission;
-class CollectionApprovalPermission extends base_1.BaseNumberTypeClass {
-    fromListId;
-    toListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    amountTrackerId;
-    challengeTrackerId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.fromListId = msg.fromListId;
-        this.toListId = msg.toListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
-        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
-        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
-        this.approvalId = msg.approvalId;
-        this.amountTrackerId = msg.amountTrackerId;
-        this.challengeTrackerId = msg.challengeTrackerId;
-        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
-        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
-    }
-    static required() {
-        return new CollectionApprovalPermission({
-            fromListId: '',
-            toListId: '',
-            initiatedByListId: '',
-            transferTimes: [],
-            badgeIds: [],
-            ownershipTimes: [],
-            approvalId: '',
-            amountTrackerId: '',
-            challengeTrackerId: '',
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: []
-        });
-    }
-    convert(convertFunction) {
-        return new CollectionApprovalPermission((0, base_1.deepCopy)({
-            fromListId: this.fromListId,
-            toListId: this.toListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
-            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
-            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
-            approvalId: this.approvalId,
-            amountTrackerId: this.amountTrackerId,
-            challengeTrackerId: this.challengeTrackerId,
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto_1.badges.CollectionApprovalPermission(this.convert(string_numbers_1.Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionApprovalPermission.convertFromProto(proto_1.badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionApprovalPermission.convertFromProto(proto_1.badges.CollectionApprovalPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static convertFromProto(protoMsg, convertFunction) {
-        return new CollectionApprovalPermission({
-            fromListId: protoMsg.fromListId,
-            toListId: protoMsg.toListId,
-            initiatedByListId: protoMsg.initiatedByListId,
-            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            amountTrackerId: protoMsg.amountTrackerId,
-            challengeTrackerId: protoMsg.challengeTrackerId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
-        });
-    }
-}
-exports.CollectionApprovalPermission = CollectionApprovalPermission;
-const { getReservedAddressList, getReservedTrackerList } = typeUtils_1.AddressList;
-const { searchForId } = typeUtils_1.UintRange;
-function isCurrentTimeForbidden(permanentlyForbiddenTimes) {
-    const currentTime = BigInt(Date.now());
-    const [_, found] = searchForId(currentTime, permanentlyForbiddenTimes);
-    return found;
-}
-exports.isCurrentTimeForbidden = isCurrentTimeForbidden;
-const castActionPermissionToUniversalPermission = (actionPermission) => {
-    const castedPermissions = [];
-    for (const permission of actionPermission) {
-        castedPermissions.push({
-            permanentlyPermittedTimes: permission.permanentlyPermittedTimes,
-            permanentlyForbiddenTimes: permission.permanentlyForbiddenTimes,
-            badgeIds: [],
-            timelineTimes: [],
-            transferTimes: [],
-            ownershipTimes: [],
-            fromList: typeUtils_1.AddressList.AllAddresses(),
-            toList: typeUtils_1.AddressList.AllAddresses(),
-            initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-            approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-            amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            usesAmountTrackerIdList: false,
-            usesChallengeTrackerIdList: false,
-            usesApprovalIdList: false,
-            usesBadgeIds: false,
-            usesTimelineTimes: false,
-            usesTransferTimes: false,
-            usesToList: false,
-            usesFromList: false,
-            usesInitiatedByList: false,
-            usesOwnershipTimes: false,
-            arbitraryValue: undefined,
-        });
-    }
-    return castedPermissions;
-};
-exports.castActionPermissionToUniversalPermission = castActionPermissionToUniversalPermission;
-const castCollectionApprovalPermissionToUniversalPermission = (collectionUpdatePermission) => {
-    const castedPermissions = [];
-    for (const collectionPermission of collectionUpdatePermission) {
-        castedPermissions.push({
-            ...typeUtils_1.AllDefaultValues,
-            transferTimes: collectionPermission.transferTimes,
-            ownershipTimes: collectionPermission.ownershipTimes,
-            fromList: collectionPermission.fromList,
-            toList: collectionPermission.toList,
-            initiatedByList: collectionPermission.initiatedByList,
-            badgeIds: collectionPermission.badgeIds,
-            approvalIdList: getReservedTrackerList(collectionPermission.approvalId),
-            amountTrackerIdList: getReservedTrackerList(collectionPermission.amountTrackerId),
-            challengeTrackerIdList: getReservedTrackerList(collectionPermission.challengeTrackerId),
-            usesAmountTrackerIdList: true,
-            usesChallengeTrackerIdList: true,
-            usesApprovalIdList: true,
-            usesBadgeIds: true,
-            usesTransferTimes: true,
-            usesOwnershipTimes: true,
-            usesToList: true,
-            usesFromList: true,
-            usesInitiatedByList: true,
-            permanentlyPermittedTimes: collectionPermission.permanentlyPermittedTimes,
-            permanentlyForbiddenTimes: collectionPermission.permanentlyForbiddenTimes,
-            arbitraryValue: undefined,
-        });
-    }
-    return castedPermissions;
-};
-exports.castCollectionApprovalPermissionToUniversalPermission = castCollectionApprovalPermissionToUniversalPermission;
-const castTimedUpdateWithBadgeIdsPermissionToUniversalPermission = (timedUpdateWithBadgeIdsPermission) => {
-    const castedPermissions = [];
-    for (const timedPermission of timedUpdateWithBadgeIdsPermission) {
-        castedPermissions.push({
-            ...typeUtils_1.AllDefaultValues,
-            timelineTimes: timedPermission.timelineTimes,
-            badgeIds: timedPermission.badgeIds,
-            usesTimelineTimes: true,
-            usesBadgeIds: true,
-            permanentlyPermittedTimes: timedPermission.permanentlyPermittedTimes,
-            permanentlyForbiddenTimes: timedPermission.permanentlyForbiddenTimes,
-        });
-    }
-    return castedPermissions;
-};
-exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission = castTimedUpdateWithBadgeIdsPermissionToUniversalPermission;
-const castTimedUpdatePermissionToUniversalPermission = (timedUpdatePermission) => {
-    const castedPermissions = [];
-    for (const timedPermission of timedUpdatePermission) {
-        castedPermissions.push({
-            ...typeUtils_1.AllDefaultValues,
-            timelineTimes: timedPermission.timelineTimes,
-            usesTimelineTimes: true,
-            permanentlyPermittedTimes: timedPermission.permanentlyPermittedTimes,
-            permanentlyForbiddenTimes: timedPermission.permanentlyForbiddenTimes,
-        });
-    }
-    return castedPermissions;
-};
-exports.castTimedUpdatePermissionToUniversalPermission = castTimedUpdatePermissionToUniversalPermission;
-const castBalancesActionPermissionToUniversalPermission = (balancesActionPermission) => {
-    const castedPermissions = [];
-    for (const permission of balancesActionPermission) {
-        castedPermissions.push({
-            ...typeUtils_1.AllDefaultValues,
-            badgeIds: permission.badgeIds,
-            ownershipTimes: permission.ownershipTimes,
-            usesBadgeIds: true,
-            usesOwnershipTimes: true,
-            permanentlyPermittedTimes: permission.permanentlyPermittedTimes,
-            permanentlyForbiddenTimes: permission.permanentlyForbiddenTimes,
-        });
-    }
-    return castedPermissions;
-};
-exports.castBalancesActionPermissionToUniversalPermission = castBalancesActionPermissionToUniversalPermission;
-const castBadgeMetadataToUniversalPermission = (badgeMetadata) => {
-    const castedPermissions = [];
-    for (const metadata of badgeMetadata) {
-        castedPermissions.push({
-            ...typeUtils_1.AllDefaultValues,
-            badgeIds: metadata.badgeIds,
-            usesBadgeIds: true,
-            arbitraryValue: metadata.uri + "<><><>" + metadata.customData,
-        });
-    }
-    return castedPermissions;
-};
-exports.castBadgeMetadataToUniversalPermission = castBadgeMetadataToUniversalPermission;
-class CollectionApprovalPermissionWithDetails extends CollectionApprovalPermission {
-    toList;
-    fromList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.toList = new typeUtils_1.AddressList(data.toList);
-        this.fromList = new typeUtils_1.AddressList(data.fromList);
-        this.initiatedByList = new typeUtils_1.AddressList(data.initiatedByList);
-    }
-    convert(convertFunction) {
-        return new CollectionApprovalPermissionWithDetails((0, base_1.deepCopy)({
-            ...this,
-            ...super.convert(convertFunction),
-        }));
-    }
-}
-exports.CollectionApprovalPermissionWithDetails = CollectionApprovalPermissionWithDetails;
-class UserIncomingApprovalPermissionWithDetails extends UserIncomingApprovalPermission {
-    fromList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.fromList = new typeUtils_1.AddressList(data.fromList);
-        this.initiatedByList = new typeUtils_1.AddressList(data.initiatedByList);
-    }
-    convert(convertFunction) {
-        return new UserIncomingApprovalPermissionWithDetails((0, base_1.deepCopy)({
-            ...this,
-            ...super.convert(convertFunction),
-        }));
-    }
-}
-exports.UserIncomingApprovalPermissionWithDetails = UserIncomingApprovalPermissionWithDetails;
-class UserOutgoingApprovalPermissionWithDetails extends UserOutgoingApprovalPermission {
-    toList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.toList = new typeUtils_1.AddressList(data.toList);
-        this.initiatedByList = new typeUtils_1.AddressList(data.initiatedByList);
-    }
-    convert(convertFunction) {
-        return new UserOutgoingApprovalPermissionWithDetails((0, base_1.deepCopy)({
-            ...this,
-            ...super.convert(convertFunction),
-        }));
-    }
-}
-exports.UserOutgoingApprovalPermissionWithDetails = UserOutgoingApprovalPermissionWithDetails;
-class CollectionPermissionsWithDetails extends base_1.BaseNumberTypeClass {
-    canUpdateCollectionApprovals;
-    canDeleteCollection;
-    canArchiveCollection;
-    canUpdateOffChainBalancesMetadata;
-    canUpdateStandards;
-    canUpdateCustomData;
-    canUpdateManager;
-    canUpdateCollectionMetadata;
-    canCreateMoreBadges;
-    canUpdateBadgeMetadata;
-    constructor(data) {
-        super();
-        this.canUpdateCollectionApprovals = data.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => new CollectionApprovalPermissionWithDetails(canUpdateCollectionApproval));
-        this.canDeleteCollection = data.canDeleteCollection.map((actionPermission) => new ActionPermission(actionPermission));
-        this.canArchiveCollection = data.canArchiveCollection.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canUpdateOffChainBalancesMetadata = data.canUpdateOffChainBalancesMetadata.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canUpdateStandards = data.canUpdateStandards.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canUpdateCustomData = data.canUpdateCustomData.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canUpdateManager = data.canUpdateManager.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canUpdateCollectionMetadata = data.canUpdateCollectionMetadata.map((timedUpdatePermission) => new TimedUpdatePermission(timedUpdatePermission));
-        this.canCreateMoreBadges = data.canCreateMoreBadges.map((balancesActionPermission) => new BalancesActionPermission(balancesActionPermission));
-        this.canUpdateBadgeMetadata = data.canUpdateBadgeMetadata.map((timedUpdateWithBadgeIdsPermission) => new TimedUpdateWithBadgeIdsPermission(timedUpdateWithBadgeIdsPermission));
-    }
-    convert(convertFunction) {
-        return new CollectionPermissionsWithDetails((0, base_1.deepCopy)({
-            ...this,
-            canUpdateCollectionApprovals: this.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => canUpdateCollectionApproval.convert(convertFunction)),
-            canDeleteCollection: this.canDeleteCollection.map((actionPermission) => actionPermission.convert(convertFunction)),
-            canArchiveCollection: this.canArchiveCollection.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canUpdateOffChainBalancesMetadata: this.canUpdateOffChainBalancesMetadata.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canUpdateStandards: this.canUpdateStandards.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canUpdateCustomData: this.canUpdateCustomData.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canUpdateManager: this.canUpdateManager.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canUpdateCollectionMetadata: this.canUpdateCollectionMetadata.map((timedUpdatePermission) => timedUpdatePermission.convert(convertFunction)),
-            canCreateMoreBadges: this.canCreateMoreBadges.map((balancesActionPermission) => balancesActionPermission.convert(convertFunction)),
-            canUpdateBadgeMetadata: this.canUpdateBadgeMetadata.map((timedUpdateWithBadgeIdsPermission) => timedUpdateWithBadgeIdsPermission.convert(convertFunction)),
-        }));
-    }
-}
-exports.CollectionPermissionsWithDetails = CollectionPermissionsWithDetails;
-class UserPermissionsWithDetails extends base_1.BaseNumberTypeClass {
-    canUpdateIncomingApprovals;
-    canUpdateOutgoingApprovals;
-    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
-    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
-    constructor(data) {
-        super();
-        this.canUpdateIncomingApprovals = data.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => new UserIncomingApprovalPermissionWithDetails(canUpdateUserIncomingApproval));
-        this.canUpdateOutgoingApprovals = data.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => new UserOutgoingApprovalPermissionWithDetails(canUpdateUserOutgoingApproval));
-        this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers = data.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((actionPermission) => new ActionPermission(actionPermission));
-        this.canUpdateAutoApproveSelfInitiatedIncomingTransfers = data.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((actionPermission) => new ActionPermission(actionPermission));
-    }
-    convert(convertFunction) {
-        return new UserPermissionsWithDetails((0, base_1.deepCopy)({
-            ...this,
-            canUpdateIncomingApprovals: this.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => canUpdateUserIncomingApproval.convert(convertFunction)),
-            canUpdateOutgoingApprovals: this.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => canUpdateUserOutgoingApproval.convert(convertFunction)),
-            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((actionPermission) => actionPermission.convert(convertFunction)),
-            canUpdateAutoApproveSelfInitiatedIncomingTransfers: this.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((actionPermission) => actionPermission.convert(convertFunction)),
-        }));
-    }
-}
-exports.UserPermissionsWithDetails = UserPermissionsWithDetails;
-const castUserIncomingApprovalPermissionToCollectionApprovalPermission = (userIncomingApprovals, toAddress) => {
-    return userIncomingApprovals.map((approval) => {
-        return new CollectionApprovalPermissionWithDetails({
-            ...approval,
-            toList: getReservedAddressList(toAddress),
-            toListId: toAddress,
-        });
-    });
-};
-exports.castUserIncomingApprovalPermissionToCollectionApprovalPermission = castUserIncomingApprovalPermissionToCollectionApprovalPermission;
-const castUserOutgoingApprovalPermissionToCollectionApprovalPermission = (userOutgoingApprovals, fromAddress) => {
-    return userOutgoingApprovals.map((approval) => {
-        return new CollectionApprovalPermissionWithDetails({
-            ...approval,
-            fromList: getReservedAddressList(fromAddress),
-            fromListId: fromAddress,
-        });
-    });
-};
-exports.castUserOutgoingApprovalPermissionToCollectionApprovalPermission = castUserOutgoingApprovalPermissionToCollectionApprovalPermission;
-function getPotentialUpdatesForTimelineValues(times, values) {
-    const castedPermissions = [];
-    for (let idx = 0; idx < times.length; idx++) {
-        castedPermissions.push({
-            timelineTimes: times[idx],
-            arbitraryValue: values[idx],
-            usesTimelineTimes: true,
-            usesBadgeIds: false,
-            usesOwnershipTimes: false,
-            usesTransferTimes: false,
-            usesToList: false,
-            usesFromList: false,
-            usesInitiatedByList: false,
-            usesApprovalIdList: false,
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: [],
-            badgeIds: [],
-            ownershipTimes: [],
-            transferTimes: [],
-            toList: typeUtils_1.AddressList.AllAddresses(),
-            fromList: typeUtils_1.AddressList.AllAddresses(),
-            initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-            approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-            amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            usesAmountTrackerIdList: false,
-            usesChallengeTrackerIdList: false,
-        });
-    }
-    const firstMatches = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    return firstMatches;
-}
-exports.getPotentialUpdatesForTimelineValues = getPotentialUpdatesForTimelineValues;
-function getFirstMatchOnlyWithApprovalCriteria(permissions) {
-    const handled = [];
-    for (const permission of permissions) {
-        const badgeIds = (0, overlaps_1.GetUintRangesWithOptions)(permission.badgeIds, permission.usesBadgeIds);
-        const timelineTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.timelineTimes, permission.usesTimelineTimes);
-        const transferTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.transferTimes, permission.usesTransferTimes);
-        const ownershipTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.ownershipTimes, permission.usesOwnershipTimes);
-        const permanentlyPermittedTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.permanentlyPermittedTimes, true);
-        const permanentlyForbiddenTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.permanentlyForbiddenTimes, true);
-        for (const badgeId of badgeIds) {
-            for (const timelineTime of timelineTimes) {
-                for (const transferTime of transferTimes) {
-                    for (const ownershipTime of ownershipTimes) {
-                        const approvalCriteria = [
-                            permission.arbitraryValue.approvalCriteria ?? null,
-                        ];
-                        const isApproved = permission.arbitraryValue.isApproved;
-                        const arbValue = {
-                            isApproved: isApproved,
-                            approvalCriteria: approvalCriteria,
-                        };
-                        const brokenDown = [
-                            {
-                                badgeId: badgeId,
-                                timelineTime: timelineTime,
-                                transferTime: transferTime,
-                                ownershipTime: ownershipTime,
-                                toList: permission.toList,
-                                fromList: permission.fromList,
-                                initiatedByList: permission.initiatedByList,
-                                approvalIdList: permission.approvalIdList,
-                                amountTrackerIdList: permission.amountTrackerIdList,
-                                challengeTrackerIdList: permission.challengeTrackerIdList,
-                                permanentlyPermittedTimes: permanentlyPermittedTimes,
-                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
-                                arbitraryValue: arbValue,
-                            },
-                        ];
-                        const [overlaps, inBrokenDownButNotHandled, inHandledButNotBrokenDown] = (0, overlaps_1.getOverlapsAndNonOverlaps)(brokenDown, handled);
-                        handled.length = 0;
-                        handled.push(...inHandledButNotBrokenDown);
-                        handled.push(...inBrokenDownButNotHandled);
-                        for (const overlap of overlaps) {
-                            const mergedApprovalCriteria = overlap.secondDetails.arbitraryValue.approvalCriteria.concat(overlap.firstDetails.arbitraryValue.approvalCriteria);
-                            const isApprovedFirst = overlap.firstDetails.arbitraryValue.isApproved;
-                            const isApprovedSecond = overlap.secondDetails.arbitraryValue.isApproved;
-                            const isApproved = isApprovedFirst && isApprovedSecond;
-                            const newArbValue = {
-                                isApproved: isApproved,
-                                approvalCriteria: mergedApprovalCriteria,
-                            };
-                            handled.push({
-                                timelineTime: overlap.overlap.timelineTime,
-                                badgeId: overlap.overlap.badgeId,
-                                transferTime: overlap.overlap.transferTime,
-                                ownershipTime: overlap.overlap.ownershipTime,
-                                toList: overlap.overlap.toList,
-                                fromList: overlap.overlap.fromList,
-                                initiatedByList: overlap.overlap.initiatedByList,
-                                approvalIdList: overlap.overlap.approvalIdList,
-                                amountTrackerIdList: overlap.overlap.amountTrackerIdList,
-                                challengeTrackerIdList: overlap.overlap.challengeTrackerIdList,
-                                permanentlyPermittedTimes: permanentlyPermittedTimes,
-                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
-                                arbitraryValue: newArbValue,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-    const returnArr = [];
-    for (const handledItem of handled) {
-        let idxToInsert = 0;
-        while (idxToInsert < returnArr.length && handledItem.badgeId.start > returnArr[idxToInsert].badgeId.start) {
-            idxToInsert++;
-        }
-        returnArr.push(null);
-        returnArr.copyWithin(idxToInsert + 1, idxToInsert);
-        returnArr[idxToInsert] = handledItem;
-    }
-    return returnArr;
-}
-function validateCollectionApprovalsUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
-    const dummyRanges = [[new typeUtils_1.UintRange(new typeUtils_1.UintRange({ start: 1n, end: 1n }))]];
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(dummyRanges.map(x => x.map(y => y.convert(string_numbers_1.BigIntify))), oldApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(dummyRanges.map(x => x.map(y => y.convert(string_numbers_1.BigIntify))), newApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
-        const expandedOldApprovals = (0, utils_1.expandCollectionApprovals)(oldValue);
-        const expandedNewApprovals = (0, utils_1.expandCollectionApprovals)(newValue);
-        const oldApprovals = (0, collections_1.castCollectionApprovalToUniversalPermission)(expandedOldApprovals);
-        if (!oldApprovals) {
-            throw new Error("InvalidOldValue");
-        }
-        const newApprovals = (0, collections_1.castCollectionApprovalToUniversalPermission)(expandedNewApprovals);
-        if (!newApprovals) {
-            throw new Error("InvalidNewValue");
-        }
-        const firstMatchesForOld = getFirstMatchOnlyWithApprovalCriteria(oldApprovals);
-        const firstMatchesForNew = getFirstMatchOnlyWithApprovalCriteria(newApprovals);
-        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;
-            let different = false;
-            if ((oldDetails.arbitraryValue === null && newDetails.arbitraryValue !== null) || (oldDetails.arbitraryValue !== null && newDetails.arbitraryValue === null)) {
-                different = true;
-            }
-            else {
-                const oldArbVal = oldDetails.arbitraryValue;
-                const newArbVal = newDetails.arbitraryValue;
-                const oldVal = oldArbVal.approvalCriteria;
-                const newVal = newArbVal.approvalCriteria;
-                if (oldArbVal.isApproved !== newArbVal.isApproved) {
-                    different = true;
-                }
-                if (oldVal.length !== newVal.length) {
-                    different = true;
-                }
-                else {
-                    for (let i = 0; i < oldVal.length; i++) {
-                        if (JSON.stringify(oldVal[i]) !== JSON.stringify(newVal[i])) {
-                            different = true;
-                        }
-                    }
-                }
-            }
-            if (different) {
-                detailsToReturn.push(overlap);
-            }
-        }
-        detailsToReturn.push(...inOldButNotNew);
-        detailsToReturn.push(...inNewButNotOld);
-        return detailsToReturn;
-    });
-    const details = detailsToCheck.map(x => {
-        const result = {
-            timelineTimes: [x.timelineTime],
-            badgeIds: [x.badgeId],
-            ownershipTimes: [x.ownershipTime],
-            transferTimes: [x.transferTime],
-            toList: x.toList,
-            fromList: x.fromList,
-            initiatedByList: x.initiatedByList,
-            approvalIdList: x.approvalIdList,
-            amountTrackerIdList: x.amountTrackerIdList,
-            challengeTrackerIdList: x.challengeTrackerIdList,
-        };
-        return result;
-    });
-    const err = checkIfCollectionApprovalPermissionPermits(details, canUpdateCollectionApprovals);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateCollectionApprovalsUpdate = validateCollectionApprovalsUpdate;
-function validateBadgeMetadataUpdate(oldBadgeMetadata, newBadgeMetadata, canUpdateBadgeMetadata) {
-    const { times: oldTimes, values: oldValues } = getBadgeMetadataTimesAndValues(oldBadgeMetadata);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getBadgeMetadataTimesAndValues(newBadgeMetadata);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
-        const oldBadgeMetadata = oldValue;
-        const firstMatchesForOld = (0, overlaps_1.GetFirstMatchOnly)((0, exports.castBadgeMetadataToUniversalPermission)(oldBadgeMetadata));
-        const newBadgeMetadata = newValue;
-        const firstMatchesForNew = (0, overlaps_1.GetFirstMatchOnly)((0, exports.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: [x.timelineTime],
-            badgeIds: [x.badgeId],
-            ownershipTimes: [x.ownershipTime],
-            transferTimes: [x.transferTime],
-            toList: x.toList,
-            fromList: x.fromList,
-            initiatedByList: x.initiatedByList,
-        };
-        return result;
-    });
-    const err = checkIfTimedUpdateWithBadgeIdsPermissionPermits(details, canUpdateBadgeMetadata);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateBadgeMetadataUpdate = validateBadgeMetadataUpdate;
-function validateCollectionMetadataUpdate(oldCollectionMetadata, newCollectionMetadata, canUpdateCollectionMetadata) {
-    const { times: oldTimes, values: oldValues } = getCollectionMetadataTimesAndValues(oldCollectionMetadata);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getCollectionMetadataTimesAndValues(newCollectionMetadata);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
-        const detailsToCheck = [];
-        if (oldValue === null && newValue !== null) {
-            detailsToCheck.push({
-                timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                toList: typeUtils_1.AddressList.AllAddresses(),
-                fromList: typeUtils_1.AddressList.AllAddresses(),
-                initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-            });
-        }
-        else {
-            const oldVal = oldValue;
-            const newVal = newValue;
-            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
-                detailsToCheck.push({
-                    timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    toList: typeUtils_1.AddressList.AllAddresses(),
-                    fromList: typeUtils_1.AddressList.AllAddresses(),
-                    initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                    approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                    amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-                });
-            }
-        }
-        return detailsToCheck;
-    });
-    const details = detailsToCheck.map(x => {
-        return [x.timelineTime];
-    }).flat();
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateCollectionMetadata);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateCollectionMetadataUpdate = validateCollectionMetadataUpdate;
-function validateOffChainBalancesMetadataUpdate(oldOffChainBalancesMetadata, newOffChainBalancesMetadata, canUpdateOffChainBalancesMetadata) {
-    const { times: oldTimes, values: oldValues } = getOffChainBalancesMetadataTimesAndValues(oldOffChainBalancesMetadata);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getOffChainBalancesMetadataTimesAndValues(newOffChainBalancesMetadata);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, {}, function (oldValue, newValue) {
-        const detailsToCheck = [];
-        if (oldValue === null && newValue !== null) {
-            detailsToCheck.push({
-                timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                toList: typeUtils_1.AddressList.AllAddresses(),
-                fromList: typeUtils_1.AddressList.AllAddresses(),
-                initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-            });
-        }
-        else {
-            const oldVal = oldValue;
-            const newVal = newValue;
-            if (oldVal.uri !== newVal.uri || oldVal.customData !== newVal.customData) {
-                detailsToCheck.push({
-                    timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    toList: typeUtils_1.AddressList.AllAddresses(),
-                    fromList: typeUtils_1.AddressList.AllAddresses(),
-                    initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                    approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                    amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-                });
-            }
-        }
-        return detailsToCheck;
-    });
-    const details = detailsToCheck.map(x => x.timelineTime);
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateOffChainBalancesMetadata);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateOffChainBalancesMetadataUpdate = validateOffChainBalancesMetadataUpdate;
-function getUpdatedStringCombinations(oldValue, newValue) {
-    const x = [];
-    if ((oldValue === null && newValue !== null) || (oldValue !== null && newValue === null) || oldValue !== newValue) {
-        x.push({
-            timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-            badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-            ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-            transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-            toList: typeUtils_1.AddressList.AllAddresses(),
-            fromList: typeUtils_1.AddressList.AllAddresses(),
-            initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-            approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-            amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-            permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-        });
-    }
-    return x;
-}
-exports.getUpdatedStringCombinations = getUpdatedStringCombinations;
-function getUpdatedBoolCombinations(oldValue, newValue) {
-    if ((oldValue === null && newValue !== null) || (oldValue !== null && newValue === null) || oldValue !== newValue) {
-        return [{
-                timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                toList: typeUtils_1.AddressList.AllAddresses(),
-                fromList: typeUtils_1.AddressList.AllAddresses(),
-                initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-            }];
-    }
-    return [];
-}
-exports.getUpdatedBoolCombinations = getUpdatedBoolCombinations;
-function validateManagerUpdate(oldManager, newManager, canUpdateManager) {
-    const { times: oldTimes, values: oldValues } = getManagerTimesAndValues(oldManager);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getManagerTimesAndValues(newManager);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, "", getUpdatedStringCombinations);
-    const details = updatedTimelineTimes.map(x => x.timelineTime);
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateManager);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateManagerUpdate = validateManagerUpdate;
-function validateCustomDataUpdate(oldCustomData, newCustomData, canUpdateCustomData) {
-    const { times: oldTimes, values: oldValues } = getCustomDataTimesAndValues(oldCustomData);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getCustomDataTimesAndValues(newCustomData);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, "", getUpdatedStringCombinations);
-    const details = updatedTimelineTimes.map(x => x.timelineTime);
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateCustomData);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateCustomDataUpdate = validateCustomDataUpdate;
-function validateStandardsUpdate(oldStandards, newStandards, canUpdateStandards) {
-    const { times: oldTimes, values: oldValues } = getStandardsTimesAndValues(oldStandards);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getStandardsTimesAndValues(newStandards);
-    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 typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    toList: typeUtils_1.AddressList.AllAddresses(),
-                    fromList: typeUtils_1.AddressList.AllAddresses(),
-                    initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                    approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                    amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-                }];
-        }
-        else if (oldValue.length != newValue.length) {
-            return [{
-                    timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                    toList: typeUtils_1.AddressList.AllAddresses(),
-                    fromList: typeUtils_1.AddressList.AllAddresses(),
-                    initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                    approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                    amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                    permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-                }];
-        }
-        else {
-            for (let i = 0; i < oldValue.length; i++) {
-                if (oldValue[i] != newValue[i]) {
-                    return [{
-                            timelineTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                            badgeId: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                            ownershipTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                            transferTime: new typeUtils_1.UintRange({ start: 1n, end: 1n }),
-                            toList: typeUtils_1.AddressList.AllAddresses(),
-                            fromList: typeUtils_1.AddressList.AllAddresses(),
-                            initiatedByList: typeUtils_1.AddressList.AllAddresses(),
-                            approvalIdList: typeUtils_1.AddressList.AllAddresses(),
-                            amountTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                            challengeTrackerIdList: typeUtils_1.AddressList.AllAddresses(),
-                            permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [], arbitraryValue: undefined
-                        }];
-                }
-            }
-        }
-        return [];
-    });
-    const details = updatedTimelineTimes.map(x => x.timelineTime);
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateStandards);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateStandardsUpdate = validateStandardsUpdate;
-function validateIsArchivedUpdate(oldIsArchived, newIsArchived, canUpdateIsArchived) {
-    const { times: oldTimes, values: oldValues } = getIsArchivedTimesAndValues(oldIsArchived);
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(oldTimes, oldValues);
-    const { times: newTimes, values: newValues } = getIsArchivedTimesAndValues(newIsArchived);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(newTimes, newValues);
-    const updatedTimelineTimes = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, false, getUpdatedBoolCombinations);
-    const details = updatedTimelineTimes.map(x => x.timelineTime);
-    const err = checkIfTimedUpdatePermissionPermits(details, canUpdateIsArchived);
-    if (err) {
-        return err;
-    }
-    return null;
-}
-exports.validateIsArchivedUpdate = validateIsArchivedUpdate;
-function getIsArchivedTimesAndValues(isArchivedTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of isArchivedTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.isArchived);
-    }
-    return { times, values };
-}
-function getOffChainBalancesMetadataTimesAndValues(inheritedBalancesMetadata) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of inheritedBalancesMetadata) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.offChainBalancesMetadata);
-    }
-    return { times, values };
-}
-function getCollectionMetadataTimesAndValues(timeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of timeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.collectionMetadata);
-    }
-    return { times, values };
-}
-function getBadgeMetadataTimesAndValues(timeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of timeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.badgeMetadata);
-    }
-    return { times, values };
-}
-function getManagerTimesAndValues(managerTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of managerTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.manager);
-    }
-    return { times, values };
-}
-function getCustomDataTimesAndValues(customDataTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of customDataTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.customData);
-    }
-    return { times, values };
-}
-function getStandardsTimesAndValues(standardsTimeline) {
-    const times = [];
-    const values = [];
-    for (const timelineVal of standardsTimeline) {
-        times.push(timelineVal.timelineTimes);
-        values.push(timelineVal.standards);
-    }
-    return { times, values };
-}
-function getUpdateCombinationsToCheck(firstMatchesForOld, firstMatchesForNew, emptyValue, compareAndGetUpdateCombosToCheck) {
-    const detailsToCheck = [];
-    const [overlapObjects, inOldButNotNew, inNewButNotOld,] = (0, overlaps_1.getOverlapsAndNonOverlaps)(firstMatchesForOld, firstMatchesForNew);
-    for (const detail of inOldButNotNew) {
-        const detailsToAdd = compareAndGetUpdateCombosToCheck(detail.arbitraryValue, emptyValue);
-        for (const detailToAdd of detailsToAdd) {
-            detailsToCheck.push({
-                timelineTime: detail.timelineTime,
-                badgeId: detailToAdd.badgeId,
-                transferTime: detailToAdd.transferTime,
-                toList: detailToAdd.toList,
-                fromList: detailToAdd.fromList,
-                initiatedByList: detailToAdd.initiatedByList,
-                ownershipTime: detailToAdd.ownershipTime,
-                approvalIdList: detailToAdd.approvalIdList,
-                amountTrackerIdList: detailToAdd.amountTrackerIdList,
-                challengeTrackerIdList: detailToAdd.challengeTrackerIdList,
-                permanentlyPermittedTimes: [],
-                permanentlyForbiddenTimes: [],
-                arbitraryValue: undefined
-            });
-        }
-    }
-    for (const detail of inNewButNotOld) {
-        const detailsToAdd = compareAndGetUpdateCombosToCheck(detail.arbitraryValue, emptyValue);
-        for (const detailToAdd of detailsToAdd) {
-            detailsToCheck.push({
-                timelineTime: detail.timelineTime,
-                badgeId: detailToAdd.badgeId,
-                transferTime: detailToAdd.transferTime,
-                toList: detailToAdd.toList,
-                fromList: detailToAdd.fromList,
-                initiatedByList: detailToAdd.initiatedByList,
-                approvalIdList: detailToAdd.approvalIdList,
-                amountTrackerIdList: detailToAdd.amountTrackerIdList,
-                challengeTrackerIdList: detailToAdd.challengeTrackerIdList,
-                ownershipTime: detailToAdd.ownershipTime,
-                permanentlyPermittedTimes: [],
-                permanentlyForbiddenTimes: [],
-                arbitraryValue: undefined
-            });
-        }
-    }
-    for (const overlapObj of overlapObjects) {
-        const overlap = overlapObj.overlap;
-        const oldDetails = overlapObj.firstDetails;
-        const newDetails = overlapObj.secondDetails;
-        const detailsToAdd = compareAndGetUpdateCombosToCheck(oldDetails.arbitraryValue, newDetails.arbitraryValue);
-        for (const detailToAdd of detailsToAdd) {
-            detailsToCheck.push({
-                timelineTime: overlap.timelineTime,
-                badgeId: detailToAdd.badgeId,
-                transferTime: detailToAdd.transferTime,
-                toList: detailToAdd.toList,
-                fromList: detailToAdd.fromList,
-                initiatedByList: detailToAdd.initiatedByList,
-                approvalIdList: detailToAdd.approvalIdList,
-                amountTrackerIdList: detailToAdd.amountTrackerIdList,
-                challengeTrackerIdList: detailToAdd.challengeTrackerIdList,
-                ownershipTime: detailToAdd.ownershipTime,
-                permanentlyPermittedTimes: [],
-                permanentlyForbiddenTimes: [],
-                arbitraryValue: undefined
-            });
-        }
-    }
-    return detailsToCheck;
-}
-exports.getUpdateCombinationsToCheck = getUpdateCombinationsToCheck;
-function checkNotForbidden(permission, time) {
-    const blockTime = time ?? BigInt(Date.now());
-    const [, found] = searchForId(blockTime, permission.permanentlyForbiddenTimes);
-    if (found) {
-        return new Error(`permission is forbidden from being executed at current time ${new Date(Number(blockTime)).toLocaleDateString() + ' ' + new Date(Number(blockTime)).toLocaleTimeString()}`);
-    }
-    return null;
-}
-function checkIfActionPermissionPermits(permissions, time) {
-    const castedPermissions = (0, exports.castActionPermissionToUniversalPermission)(permissions);
-    const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    for (const permissionDetail of permissionDetails) {
-        const err = checkNotForbidden(permissionDetail, time);
-        if (err) {
-            return err;
-        }
-    }
-    return null;
-}
-exports.checkIfActionPermissionPermits = checkIfActionPermissionPermits;
-function checkIfTimedUpdatePermissionPermits(timelineTimes, permissions, time) {
-    const detailsToCheck = [];
-    for (const timelineTime of timelineTimes) {
-        detailsToCheck.push({
-            timelineTime,
-            badgeId: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-            ownershipTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-            transferTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-            toList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            fromList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            initiatedByList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            approvalIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            amountTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            challengeTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-            permanentlyPermittedTimes: [],
-            permanentlyForbiddenTimes: [],
-            arbitraryValue: undefined
-        });
-    }
-    const castedPermissions = (0, exports.castTimedUpdatePermissionToUniversalPermission)(permissions);
-    const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time);
-}
-exports.checkIfTimedUpdatePermissionPermits = checkIfTimedUpdatePermissionPermits;
-function checkIfBalancesActionPermissionPermits(balances, permissions, time) {
-    const detailsToCheck = [];
-    for (const badgeToCreate of balances) {
-        for (const badgeIdRange of badgeToCreate.badgeIds) {
-            for (const ownershipTime of badgeToCreate.ownershipTimes) {
-                detailsToCheck.push({
-                    badgeId: badgeIdRange,
-                    ownershipTime: ownershipTime,
-                    timelineTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-                    toList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    fromList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    initiatedByList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    approvalIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    amountTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    challengeTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    permanentlyPermittedTimes: [],
-                    permanentlyForbiddenTimes: [],
-                    arbitraryValue: undefined
-                });
-            }
-        }
-    }
-    const castedPermissions = (0, exports.castBalancesActionPermissionToUniversalPermission)(permissions);
-    const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time);
-}
-exports.checkIfBalancesActionPermissionPermits = checkIfBalancesActionPermissionPermits;
-function checkIfTimedUpdateWithBadgeIdsPermissionPermits(details, permissions, time) {
-    const detailsToCheck = [];
-    for (const detail of details) {
-        for (const timelineTime of detail.timelineTimes) {
-            for (const badgeId of detail.badgeIds) {
-                detailsToCheck.push({
-                    timelineTime,
-                    badgeId,
-                    ownershipTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-                    transferTime: new typeUtils_1.UintRange({ start: -1n, end: -1n }),
-                    toList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    fromList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    initiatedByList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    approvalIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    amountTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    challengeTrackerIdList: new typeUtils_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
-                    permanentlyPermittedTimes: [],
-                    permanentlyForbiddenTimes: [],
-                    arbitraryValue: undefined
-                });
-            }
-        }
-    }
-    const castedPermissions = (0, exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission)(permissions);
-    const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time);
-}
-exports.checkIfTimedUpdateWithBadgeIdsPermissionPermits = checkIfTimedUpdateWithBadgeIdsPermissionPermits;
-function checkIfCollectionApprovalPermissionPermits(details, permissions, time) {
-    const castedPermissions = (0, exports.castCollectionApprovalPermissionToUniversalPermission)(permissions);
-    const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
-    const detailsToCheck = [];
-    for (const detail of details) {
-        for (const timelineTime of detail.timelineTimes) {
-            for (const badgeId of detail.badgeIds) {
-                for (const ownershipTime of detail.ownershipTimes) {
-                    for (const transferTime of detail.transferTimes) {
-                        detailsToCheck.push({
-                            timelineTime,
-                            badgeId,
-                            ownershipTime: ownershipTime,
-                            transferTime,
-                            toList: detail.toList,
-                            fromList: detail.fromList,
-                            initiatedByList: detail.initiatedByList,
-                            approvalIdList: detail.approvalIdList,
-                            amountTrackerIdList: detail.amountTrackerIdList,
-                            challengeTrackerIdList: detail.challengeTrackerIdList,
-                            permanentlyPermittedTimes: [],
-                            permanentlyForbiddenTimes: [],
-                            arbitraryValue: undefined
-                        });
-                    }
-                }
-            }
-        }
-    }
-    return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time, true);
-}
-exports.checkIfCollectionApprovalPermissionPermits = checkIfCollectionApprovalPermissionPermits;
-function checkIfUserOutgoingApprovalPermissionPermits(detailsToCheck, permissions, userAddress, time) {
-    const newDetails = detailsToCheck.map(x => {
-        return {
-            ...x,
-            fromList: getReservedAddressList(userAddress),
-        };
-    });
-    const castedPermissions = (0, exports.castUserOutgoingApprovalPermissionToCollectionApprovalPermission)(permissions, userAddress);
-    return checkIfCollectionApprovalPermissionPermits(newDetails, castedPermissions, time);
-}
-exports.checkIfUserOutgoingApprovalPermissionPermits = checkIfUserOutgoingApprovalPermissionPermits;
-function checkIfUserIncomingApprovalPermissionPermits(detailsToCheck, permissions, userAddress, time) {
-    const newDetails = detailsToCheck.map(x => {
-        return {
-            ...x,
-            toList: getReservedAddressList(userAddress),
-        };
-    });
-    const castedPermissions = (0, exports.castUserIncomingApprovalPermissionToCollectionApprovalPermission)(permissions, userAddress);
-    return checkIfCollectionApprovalPermissionPermits(newDetails, castedPermissions, time);
-}
-exports.checkIfUserIncomingApprovalPermissionPermits = checkIfUserIncomingApprovalPermissionPermits;
-function checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time = undefined, usesLists) {
-    let usesBadgeIds = true;
-    let usesTimelineTimes = true;
-    let usesTransferTimes = true;
-    let usesOwnershipTimes = true;
-    let usesToLists = true;
-    let usesFromLists = true;
-    let usesInitiatedByLists = true;
-    let usesApprovalIdLists = true;
-    let usesAmountTrackerIdList = true;
-    let usesChallengeTrackerIdList = true;
-    for (const detailToCheck of detailsToCheck) {
-        if (detailToCheck.badgeId.start === -1n) {
-            usesBadgeIds = false;
-            detailToCheck.badgeId = new typeUtils_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.timelineTime.start === -1n) {
-            usesTimelineTimes = false;
-            detailToCheck.timelineTime = new typeUtils_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.transferTime.start === -1n) {
-            usesTransferTimes = false;
-            detailToCheck.transferTime = new typeUtils_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.ownershipTime.start === -1n) {
-            usesOwnershipTimes = false;
-            detailToCheck.ownershipTime = new typeUtils_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (!usesLists) {
-            usesToLists = false;
-            detailToCheck.toList = typeUtils_1.AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesFromLists = false;
-            detailToCheck.fromList = typeUtils_1.AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesInitiatedByLists = false;
-            detailToCheck.initiatedByList = typeUtils_1.AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesApprovalIdLists = false;
-            detailToCheck.approvalIdList = typeUtils_1.AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesAmountTrackerIdList = false;
-            detailToCheck.amountTrackerIdList = typeUtils_1.AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesChallengeTrackerIdList = false;
-            detailToCheck.challengeTrackerIdList = typeUtils_1.AddressList.AllAddresses();
-        }
-    }
-    for (const permissionDetail of permissionDetails) {
-        for (const detailToCheck of detailsToCheck) {
-            const [, overlap] = (0, overlaps_1.universalRemoveOverlaps)(permissionDetail, detailToCheck);
-            if (overlap.length > 0) {
-                const err = checkNotForbidden(permissionDetail, time);
-                if (err) {
-                    let errStr = err.message;
-                    if (usesTimelineTimes) {
-                        errStr += ` for the timeline times ${new Date(Number(permissionDetail.timelineTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.timelineTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.timelineTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.timelineTime.end)).toLocaleTimeString()}`;
-                    }
-                    if (usesTransferTimes) {
-                        errStr += ` for the transfer times ${new Date(Number(permissionDetail.transferTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.transferTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.transferTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.transferTime.end)).toLocaleTimeString()}`;
-                    }
-                    if (usesBadgeIds) {
-                        errStr += ` for the badge ids ${permissionDetail.badgeId.start} to ${permissionDetail.badgeId.end}`;
-                    }
-                    if (usesOwnershipTimes) {
-                        errStr += ` for the ownership times ${new Date(Number(permissionDetail.ownershipTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.ownershipTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.ownershipTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.ownershipTime.end)).toLocaleTimeString()}`;
-                    }
-                    if (usesToLists) {
-                        errStr += ` for the to lists ${permissionDetail.toList.listId}`;
-                    }
-                    if (usesFromLists) {
-                        errStr += ` for the from lists ${permissionDetail.fromList.listId}`;
-                    }
-                    if (usesInitiatedByLists) {
-                        errStr += ` for the initiated by lists ${permissionDetail.initiatedByList.listId}`;
-                    }
-                    if (usesApprovalIdLists) {
-                        errStr += ` for the approval id ${permissionDetail.approvalIdList.listId}`;
-                    }
-                    if (usesAmountTrackerIdList) {
-                        errStr += ` for the amount tracker id ${permissionDetail.amountTrackerIdList.listId}`;
-                    }
-                    if (usesChallengeTrackerIdList) {
-                        errStr += ` for the challenge tracker id ${permissionDetail.challengeTrackerIdList.listId}`;
-                    }
-                    return new Error(errStr);
-                }
-            }
-        }
-    }
-    return null;
-}
-exports.checkNotForbiddenForAllOverlaps = checkNotForbiddenForAllOverlaps;
-function validateBalancesActionPermissionUpdate(oldPermissions, newPermissions) {
-    const castedOldPermissions = (0, exports.castBalancesActionPermissionToUniversalPermission)(oldPermissions);
-    const castedNewPermissions = (0, exports.castBalancesActionPermissionToUniversalPermission)(newPermissions);
-    const err = validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedOldPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
-    if (err) {
-        return new Error(`Error validating update in permissions: ${err}`);
-    }
-    return null;
-}
-exports.validateBalancesActionPermissionUpdate = validateBalancesActionPermissionUpdate;
-function validateTimedUpdatePermissionUpdate(oldPermissions, newPermissions) {
-    const castedOldPermissions = (0, exports.castTimedUpdatePermissionToUniversalPermission)(oldPermissions);
-    const castedNewPermissions = (0, exports.castTimedUpdatePermissionToUniversalPermission)(newPermissions);
-    const err = validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedOldPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
-    if (err) {
-        return new Error(`Error validating update in permissions: ${err}`);
-    }
-    return null;
-}
-exports.validateTimedUpdatePermissionUpdate = validateTimedUpdatePermissionUpdate;
-function validateTimedUpdateWithBadgeIdsPermissionUpdate(oldPermissions, newPermissions) {
-    const castedOldPermissions = (0, base_1.deepCopy)((0, exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission)(oldPermissions));
-    const castedNewPermissions = (0, base_1.deepCopy)((0, exports.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission)(newPermissions));
-    const err = validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedOldPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
-    if (err) {
-        return new Error(`Error validating update in permissions: ${err}`);
-    }
-    return null;
-}
-exports.validateTimedUpdateWithBadgeIdsPermissionUpdate = validateTimedUpdateWithBadgeIdsPermissionUpdate;
-function validateCollectionApprovalPermissionsUpdate(oldPermissions, newPermissions) {
-    const castedOldPermissions = (0, exports.castCollectionApprovalPermissionToUniversalPermission)(oldPermissions);
-    const castedNewPermissions = (0, exports.castCollectionApprovalPermissionToUniversalPermission)(newPermissions);
-    const err = validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedOldPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
-    if (err) {
-        return new Error(`Error validating update in permissions: ${err}`);
-    }
-    return null;
-}
-exports.validateCollectionApprovalPermissionsUpdate = validateCollectionApprovalPermissionsUpdate;
-function validateActionPermissionUpdate(oldPermissions, newPermissions) {
-    const castedOldPermissions = (0, exports.castActionPermissionToUniversalPermission)(oldPermissions);
-    const castedNewPermissions = (0, exports.castActionPermissionToUniversalPermission)(newPermissions);
-    const err = validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedOldPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
-    if (err) {
-        return new Error(`Error validating update in permissions: ${err}`);
-    }
-    return null;
-}
-exports.validateActionPermissionUpdate = validateActionPermissionUpdate;
-function validatePermissionsUpdate(oldPermissions, newPermissions) {
-    if (newPermissions.canDeleteCollection !== null) {
-        const error = validateActionPermissionUpdate(oldPermissions.canDeleteCollection, newPermissions.canDeleteCollection);
-        if (error) {
-            return new Error(`Error validating update in canDeleteCollection permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateManager !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canUpdateManager, newPermissions.canUpdateManager);
-        if (error) {
-            return new Error(`Error validating update in canUpdateManager permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateCustomData !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canUpdateCustomData, newPermissions.canUpdateCustomData);
-        if (error) {
-            return new Error(`Error validating update in canUpdateCustomData permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateStandards !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canUpdateStandards, newPermissions.canUpdateStandards);
-        if (error) {
-            return new Error(`Error validating update in canUpdateStandards permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canArchiveCollection !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canArchiveCollection, newPermissions.canArchiveCollection);
-        if (error) {
-            return new Error(`Error validating update in canArchiveCollection permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateOffChainBalancesMetadata !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canUpdateOffChainBalancesMetadata, newPermissions.canUpdateOffChainBalancesMetadata);
-        if (error) {
-            return new Error(`Error validating update in canUpdateOffChainBalancesMetadata permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateCollectionMetadata !== null) {
-        const error = validateTimedUpdatePermissionUpdate(oldPermissions.canUpdateCollectionMetadata, newPermissions.canUpdateCollectionMetadata);
-        if (error) {
-            return new Error(`Error validating update in canUpdateCollectionMetadata permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canCreateMoreBadges !== null) {
-        const error = validateBalancesActionPermissionUpdate(oldPermissions.canCreateMoreBadges, newPermissions.canCreateMoreBadges);
-        if (error) {
-            return new Error(`Error validating update in canCreateMoreBadges permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateBadgeMetadata !== null) {
-        const error = validateTimedUpdateWithBadgeIdsPermissionUpdate(oldPermissions.canUpdateBadgeMetadata, newPermissions.canUpdateBadgeMetadata);
-        if (error) {
-            return new Error(`Error validating update in canUpdateBadgeMetadata permissions: ${error}`);
-        }
-    }
-    if (newPermissions.canUpdateCollectionApprovals !== null) {
-        const error = validateCollectionApprovalPermissionsUpdate(oldPermissions.canUpdateCollectionApprovals, newPermissions.canUpdateCollectionApprovals);
-        if (error) {
-            return new Error(`Error validating update in canUpdateCollectionApprovals permissions: ${error}`);
-        }
-    }
-    return null;
-}
-exports.validatePermissionsUpdate = validatePermissionsUpdate;
-function validateUniversalPermissionUpdate(oldPermissions, newPermissions) {
-    const [allOverlaps, inOldButNotNew] = (0, overlaps_1.getOverlapsAndNonOverlaps)(oldPermissions, newPermissions);
-    if (inOldButNotNew.length > 0) {
-        let errMsg = `Permission ${getPermissionString(inOldButNotNew[0])} found in old permissions but not in new permissions`;
-        if (inOldButNotNew.length > 1) {
-            errMsg += ` (along with ${inOldButNotNew.length - 1} more)`;
-        }
-        return new Error(errMsg);
-    }
-    for (const overlapObj of allOverlaps) {
-        const oldPermission = overlapObj.firstDetails;
-        const newPermission = overlapObj.secondDetails;
-        const [leftoverPermittedTimes] = removeUintRangesFromUintRanges(newPermission.permanentlyPermittedTimes, oldPermission.permanentlyPermittedTimes);
-        const [leftoverForbiddenTimes] = removeUintRangesFromUintRanges(newPermission.permanentlyForbiddenTimes, oldPermission.permanentlyForbiddenTimes);
-        if (leftoverPermittedTimes.length > 0 || leftoverForbiddenTimes.length > 0) {
-            let errMsg = `Permission ${getPermissionString(oldPermission)} found in both new and old permissions but `;
-            if (leftoverPermittedTimes.length > 0) {
-                errMsg += 'previously explicitly allowed the times ( ';
-                for (const oldPermittedTime of leftoverPermittedTimes) {
-                    errMsg += `${oldPermittedTime.start}-${oldPermittedTime.end} `;
-                }
-                errMsg += ') which are now set to disApproved';
-            }
-            if (leftoverForbiddenTimes.length > 0 && leftoverPermittedTimes.length > 0) {
-                errMsg += ' and';
-            }
-            if (leftoverForbiddenTimes.length > 0) {
-                errMsg += ' previously explicitly disApproved the times ( ';
-                for (const oldForbiddenTime of leftoverForbiddenTimes) {
-                    errMsg += `${oldForbiddenTime.start}-${oldForbiddenTime.end} `;
-                }
-                errMsg += ') which are now set to allowed.';
-            }
-            return new Error(errMsg);
-        }
-    }
-    return null;
-}
-exports.validateUniversalPermissionUpdate = validateUniversalPermissionUpdate;
-function getPermissionString(permission) {
-    let str = "(";
-    const maxUint64 = 18446744073709551615n;
-    if (permission.badgeId.start === maxUint64 || permission.badgeId.end === maxUint64) {
-        str += `badgeId: ${permission.badgeId.start} `;
-    }
-    if (permission.timelineTime.start === maxUint64 || permission.timelineTime.end === maxUint64) {
-        str += `timelineTime: ${permission.timelineTime.start} `;
-    }
-    if (permission.transferTime.start === maxUint64 || permission.transferTime.end === maxUint64) {
-        str += `transferTime: ${permission.transferTime.start} `;
-    }
-    if (permission.ownershipTime.start === maxUint64 || permission.ownershipTime.end === maxUint64) {
-        str += `ownershipTime: ${permission.ownershipTime.start} `;
-    }
-    if (permission.toList) {
-        str += "toList: ";
-        if (!permission.toList.whitelist) {
-            str += `${permission.toList.addresses.length} addresses `;
-        }
-        else {
-            str += `all except ${permission.toList.addresses.length} addresses `;
-        }
-        if (permission.toList.addresses.length > 0 && permission.toList.addresses.length <= 5) {
-            str += "(";
-            for (const address of permission.toList.addresses) {
-                str += address + " ";
-            }
-            str += ")";
-        }
-    }
-    if (permission.fromList) {
-        str += "fromList: ";
-        if (!permission.fromList.whitelist) {
-            str += `${permission.fromList.addresses.length} addresses `;
-        }
-        else {
-            str += `all except ${permission.fromList.addresses.length} addresses `;
-        }
-        if (permission.fromList.addresses.length > 0 && permission.fromList.addresses.length <= 5) {
-            str += "(";
-            for (const address of permission.fromList.addresses) {
-                str += address + " ";
-            }
-            str += ")";
-        }
-    }
-    if (permission.initiatedByList) {
-        str += "initiatedByList: ";
-        if (!permission.initiatedByList.whitelist) {
-            str += `${permission.initiatedByList.addresses.length} addresses `;
-        }
-        else {
-            str += `all except ${permission.initiatedByList.addresses.length} addresses `;
-        }
-        if (permission.initiatedByList.addresses.length > 0 && permission.initiatedByList.addresses.length <= 5) {
-            str += "(";
-            for (const address of permission.initiatedByList.addresses) {
-                str += address + " ";
-            }
-            str += ")";
-        }
-    }
-    str += ") ";
-    return str;
-}
-//# sourceMappingURL=permissions.js.map