bitbadgesjs-sdk 0.3.149 → 0.3.151

package/dist/cjs/core/permissions.js

@@ -0,0 +1,901 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPermissionsWithDetails = exports.CollectionPermissionsWithDetails = exports.UserOutgoingApprovalPermissionWithDetails = exports.UserIncomingApprovalPermissionWithDetails = exports.CollectionApprovalPermissionWithDetails = exports.CollectionApprovalPermission = exports.TimedUpdateWithBadgeIdsPermission = exports.BadgeIdsActionPermission = exports.TimedUpdatePermission = exports.ActionPermission = exports.CollectionPermissions = exports.UserIncomingApprovalPermission = exports.UserOutgoingApprovalPermission = exports.UserPermissions = void 0;
+const base_js_1 = require("../common/base.js");
+const index_js_1 = require("../proto/index.js");
+const addressLists_js_1 = require("./addressLists.js");
+const overlaps_js_1 = require("./overlaps.js");
+const string_numbers_js_1 = require("../common/string-numbers.js");
+const uintRanges_js_1 = require("./uintRanges.js");
+const validate_utils_js_1 = require("./validate-utils.js");
+class UserPermissions extends base_js_1.BaseNumberTypeClass {
+    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));
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    toProto() {
+        return new index_js_1.badges.UserPermissions(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserPermissions.fromProto(index_js_1.badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserPermissions.fromProto(index_js_1.badges.UserPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: protoMsg.canUpdateOutgoingApprovals.map((x) => UserOutgoingApprovalPermission.fromProto(x, convertFunction)),
+            canUpdateIncomingApprovals: protoMsg.canUpdateIncomingApprovals.map((x) => UserIncomingApprovalPermission.fromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((x) => ActionPermission.fromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((x) => ActionPermission.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        const responses = [
+            UserOutgoingApprovalPermission.validateUpdate(oldPermissions.canUpdateOutgoingApprovals, newPermissions.canUpdateOutgoingApprovals),
+            UserIncomingApprovalPermission.validateUpdate(oldPermissions.canUpdateIncomingApprovals, newPermissions.canUpdateIncomingApprovals),
+            ActionPermission.validateUpdate(oldPermissions.canUpdateAutoApproveSelfInitiatedOutgoingTransfers, newPermissions.canUpdateAutoApproveSelfInitiatedOutgoingTransfers),
+            ActionPermission.validateUpdate(oldPermissions.canUpdateAutoApproveSelfInitiatedIncomingTransfers, newPermissions.canUpdateAutoApproveSelfInitiatedIncomingTransfers)
+        ];
+        return responses.find((x) => x !== null) ?? null;
+    }
+    static InitEmpty() {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: [],
+            canUpdateIncomingApprovals: [],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: []
+        });
+    }
+}
+exports.UserPermissions = UserPermissions;
+class UserOutgoingApprovalPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = uintRanges_js_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_js_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_js_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    toProto() {
+        return new index_js_1.badges.UserOutgoingApprovalPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(index_js_1.badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(index_js_1.badges.UserOutgoingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserOutgoingApprovalPermission({
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermission({
+            ...this,
+            fromList: getReservedAddressList(address),
+            fromListId: address
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const dummyAddress = '0x';
+        const castedPermissions = permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const dummyAddress = '0x';
+        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
+    }
+}
+exports.UserOutgoingApprovalPermission = UserOutgoingApprovalPermission;
+class UserIncomingApprovalPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.approvalId = msg.approvalId;
+        this.transferTimes = uintRanges_js_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_js_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_js_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    toProto() {
+        return new index_js_1.badges.UserIncomingApprovalPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(index_js_1.badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(index_js_1.badges.UserIncomingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserIncomingApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermission({
+            ...this,
+            toList: getReservedAddressList(address),
+            toListId: address
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const dummyAddress = '0x';
+        const castedPermissions = permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const dummyAddress = '0x';
+        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
+    }
+}
+exports.UserIncomingApprovalPermission = UserIncomingApprovalPermission;
+class CollectionPermissions extends base_js_1.BaseNumberTypeClass {
+    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.canUpdateValidBadgeIds = msg.canUpdateValidBadgeIds.map((x) => new BadgeIdsActionPermission(x));
+        this.canUpdateBadgeMetadata = msg.canUpdateBadgeMetadata.map((x) => new TimedUpdateWithBadgeIdsPermission(x));
+        this.canUpdateCollectionApprovals = msg.canUpdateCollectionApprovals.map((x) => new CollectionApprovalPermission(x));
+    }
+    convert(convertFunction) {
+        return new CollectionPermissions((0, base_js_1.deepCopyPrimitives)({
+            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)),
+            canUpdateValidBadgeIds: this.canUpdateValidBadgeIds.map((x) => x.convert(convertFunction)),
+            canUpdateBadgeMetadata: this.canUpdateBadgeMetadata.map((x) => x.convert(convertFunction)),
+            canUpdateCollectionApprovals: this.canUpdateCollectionApprovals.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new index_js_1.badges.CollectionPermissions(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionPermissions.fromProto(index_js_1.badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionPermissions.fromProto(index_js_1.badges.CollectionPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new CollectionPermissions({
+            canDeleteCollection: protoMsg.canDeleteCollection.map((x) => ActionPermission.fromProto(x, convertFunction)),
+            canArchiveCollection: protoMsg.canArchiveCollection.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateOffChainBalancesMetadata: protoMsg.canUpdateOffChainBalancesMetadata.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateStandards: protoMsg.canUpdateStandards.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateCustomData: protoMsg.canUpdateCustomData.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateManager: protoMsg.canUpdateManager.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateCollectionMetadata: protoMsg.canUpdateCollectionMetadata.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateValidBadgeIds: protoMsg.canUpdateValidBadgeIds.map((x) => BadgeIdsActionPermission.fromProto(x, convertFunction)),
+            canUpdateBadgeMetadata: protoMsg.canUpdateBadgeMetadata.map((x) => TimedUpdateWithBadgeIdsPermission.fromProto(x, convertFunction)),
+            canUpdateCollectionApprovals: protoMsg.canUpdateCollectionApprovals.map((x) => CollectionApprovalPermission.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        const responses = [
+            ActionPermission.validateUpdate(oldPermissions.canDeleteCollection, newPermissions.canDeleteCollection),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateManager, newPermissions.canUpdateManager),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateCustomData, newPermissions.canUpdateCustomData),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateStandards, newPermissions.canUpdateStandards),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canArchiveCollection, newPermissions.canArchiveCollection),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateOffChainBalancesMetadata, newPermissions.canUpdateOffChainBalancesMetadata),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateCollectionMetadata, newPermissions.canUpdateCollectionMetadata),
+            BadgeIdsActionPermission.validateUpdate(oldPermissions.canUpdateValidBadgeIds, newPermissions.canUpdateValidBadgeIds),
+            TimedUpdateWithBadgeIdsPermission.validateUpdate(oldPermissions.canUpdateBadgeMetadata, newPermissions.canUpdateBadgeMetadata),
+            CollectionApprovalPermission.validateUpdate(oldPermissions.canUpdateCollectionApprovals, newPermissions.canUpdateCollectionApprovals)
+        ];
+        return responses.find((x) => x !== null) ?? null;
+    }
+    static InitEmpty() {
+        return new CollectionPermissions({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateOffChainBalancesMetadata: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canUpdateValidBadgeIds: [],
+            canUpdateBadgeMetadata: [],
+            canUpdateCollectionApprovals: []
+        });
+    }
+}
+exports.CollectionPermissions = CollectionPermissions;
+class ActionPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new ActionPermission((0, base_js_1.deepCopyPrimitives)({
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new index_js_1.badges.ActionPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ActionPermission.fromProto(index_js_1.badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ActionPermission.fromProto(index_js_1.badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new ActionPermission({
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_js_1.AllDefaultValues,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_js_1.BigIntify)
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(permissions, time) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        return checkUniversalPermissionPermits(castedPermissions, time);
+    }
+}
+exports.ActionPermission = ActionPermission;
+function checkUniversalPermissionPermits(permissions, time) {
+    const permissionDetails = (0, overlaps_js_1.GetFirstMatchOnly)(permissions);
+    for (const permissionDetail of permissionDetails) {
+        const err = checkNotForbidden(permissionDetail, time ? BigInt(time) : undefined);
+        if (err) {
+            return err;
+        }
+    }
+    return null;
+}
+class TimedUpdatePermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.timelineTimes = uintRanges_js_1.UintRangeArray.From(msg.timelineTimes);
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new TimedUpdatePermission((0, base_js_1.deepCopyPrimitives)({
+            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 index_js_1.badges.TimedUpdatePermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return TimedUpdatePermission.fromProto(index_js_1.badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdatePermission.fromProto(index_js_1.badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdatePermission({
+            timelineTimes: protoMsg.timelineTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_js_1.AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_js_1.BigIntify),
+            usesTimelineTimes: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(timelineTimes, permissions, time) {
+        const detailsToCheck = [];
+        for (const timelineTime of timelineTimes) {
+            detailsToCheck.push({
+                ...AllDefaultDetailsValues,
+                timelineTime: timelineTime.convert(string_numbers_js_1.BigIntify)
+            });
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+exports.TimedUpdatePermission = TimedUpdatePermission;
+const AllDefaultDetailsValues = {
+    timelineTime: new uintRanges_js_1.UintRange({ start: -1n, end: -1n }),
+    badgeId: new uintRanges_js_1.UintRange({ start: -1n, end: -1n }),
+    ownershipTime: new uintRanges_js_1.UintRange({ start: -1n, end: -1n }),
+    transferTime: new uintRanges_js_1.UintRange({ start: -1n, end: -1n }),
+    toList: new addressLists_js_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
+    fromList: new addressLists_js_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
+    initiatedByList: new addressLists_js_1.AddressList({
+        listId: 'All',
+        addresses: [],
+        whitelist: false,
+        uri: '',
+        customData: '',
+        createdBy: ''
+    }),
+    approvalIdList: new addressLists_js_1.AddressList({
+        listId: 'All',
+        addresses: [],
+        whitelist: false,
+        uri: '',
+        customData: '',
+        createdBy: ''
+    }),
+    permanentlyPermittedTimes: uintRanges_js_1.UintRangeArray.From([]),
+    permanentlyForbiddenTimes: uintRanges_js_1.UintRangeArray.From([]),
+    arbitraryValue: undefined
+};
+class BadgeIdsActionPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.badgeIds = uintRanges_js_1.UintRangeArray.From(msg.badgeIds);
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new BadgeIdsActionPermission((0, base_js_1.deepCopyPrimitives)({
+            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 index_js_1.badges.BadgeIdsActionPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return BadgeIdsActionPermission.fromProto(index_js_1.badges.BadgeIdsActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return BadgeIdsActionPermission.fromProto(index_js_1.badges.BadgeIdsActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new BadgeIdsActionPermission({
+            badgeIds: protoMsg.badgeIds.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_js_1.AllDefaultValues,
+            badgeIds: this.badgeIds.convert(string_numbers_js_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_js_1.BigIntify),
+            usesBadgeIds: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const badgeId of detail.badgeIds) {
+                detailsToCheck.push({
+                    ...AllDefaultDetailsValues,
+                    badgeId: badgeId.convert(string_numbers_js_1.BigIntify)
+                });
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+exports.BadgeIdsActionPermission = BadgeIdsActionPermission;
+class TimedUpdateWithBadgeIdsPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.timelineTimes = uintRanges_js_1.UintRangeArray.From(msg.timelineTimes);
+        this.badgeIds = uintRanges_js_1.UintRangeArray.From(msg.badgeIds);
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission((0, base_js_1.deepCopyPrimitives)({
+            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 index_js_1.badges.TimedUpdateWithBadgeIdsPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return TimedUpdateWithBadgeIdsPermission.fromProto(index_js_1.badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdateWithBadgeIdsPermission.fromProto(index_js_1.badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission({
+            timelineTimes: protoMsg.timelineTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_js_1.AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(string_numbers_js_1.BigIntify),
+            badgeIds: this.badgeIds.convert(string_numbers_js_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_js_1.BigIntify),
+            usesTimelineTimes: true,
+            usesBadgeIds: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const timelineTime of detail.timelineTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    detailsToCheck.push({
+                        ...AllDefaultDetailsValues,
+                        timelineTime: timelineTime.convert(string_numbers_js_1.BigIntify),
+                        badgeId: badgeId.convert(string_numbers_js_1.BigIntify)
+                    });
+                }
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+exports.TimedUpdateWithBadgeIdsPermission = TimedUpdateWithBadgeIdsPermission;
+class CollectionApprovalPermission extends base_js_1.BaseNumberTypeClass {
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = uintRanges_js_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_js_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_js_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_js_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalPermission((0, base_js_1.deepCopyPrimitives)({
+            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,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new index_js_1.badges.CollectionApprovalPermission(this.convert(string_numbers_js_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionApprovalPermission.fromProto(index_js_1.badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionApprovalPermission.fromProto(index_js_1.badges.CollectionApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new CollectionApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => uintRanges_js_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_js_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const transferTime of detail.transferTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    for (const ownershipTime of detail.ownershipTimes) {
+                        detailsToCheck.push({
+                            ...AllDefaultDetailsValues,
+                            transferTime: transferTime.convert(string_numbers_js_1.BigIntify),
+                            badgeId: badgeId.convert(string_numbers_js_1.BigIntify),
+                            ownershipTime: ownershipTime.convert(string_numbers_js_1.BigIntify),
+                            toList: detail.toList,
+                            fromList: detail.fromList,
+                            initiatedByList: detail.initiatedByList,
+                            approvalIdList: detail.approvalIdList
+                        });
+                    }
+                }
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_js_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined, true);
+    }
+}
+exports.CollectionApprovalPermission = CollectionApprovalPermission;
+const { getReservedAddressList, getReservedTrackerList } = addressLists_js_1.AddressList;
+class CollectionApprovalPermissionWithDetails extends CollectionApprovalPermission {
+    constructor(data) {
+        super(data);
+        this.toList = new addressLists_js_1.AddressList(data.toList);
+        this.fromList = new addressLists_js_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_js_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_js_1.AllDefaultValues,
+            toList: this.toList,
+            fromList: this.fromList,
+            initiatedByList: this.initiatedByList,
+            transferTimes: this.transferTimes.convert(string_numbers_js_1.BigIntify),
+            badgeIds: this.badgeIds.convert(string_numbers_js_1.BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(string_numbers_js_1.BigIntify),
+            approvalIdList: getReservedTrackerList(this.approvalId),
+            usesApprovalIdList: true,
+            usesBadgeIds: true,
+            usesTransferTimes: true,
+            usesOwnershipTimes: true,
+            usesToList: true,
+            usesFromList: true,
+            usesInitiatedByList: true,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_js_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_js_1.BigIntify)
+        };
+    }
+}
+exports.CollectionApprovalPermissionWithDetails = CollectionApprovalPermissionWithDetails;
+class UserIncomingApprovalPermissionWithDetails extends UserIncomingApprovalPermission {
+    constructor(data) {
+        super(data);
+        this.fromList = new addressLists_js_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_js_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            toList: getReservedAddressList(address),
+            toListId: address
+        });
+    }
+}
+exports.UserIncomingApprovalPermissionWithDetails = UserIncomingApprovalPermissionWithDetails;
+class UserOutgoingApprovalPermissionWithDetails extends UserOutgoingApprovalPermission {
+    constructor(data) {
+        super(data);
+        this.toList = new addressLists_js_1.AddressList(data.toList);
+        this.initiatedByList = new addressLists_js_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            fromList: getReservedAddressList(address),
+            fromListId: address
+        });
+    }
+}
+exports.UserOutgoingApprovalPermissionWithDetails = UserOutgoingApprovalPermissionWithDetails;
+class CollectionPermissionsWithDetails extends CollectionPermissions {
+    constructor(data) {
+        super(data);
+        this.canUpdateCollectionApprovals = data.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => new CollectionApprovalPermissionWithDetails(canUpdateCollectionApproval));
+    }
+    convert(convertFunction) {
+        return (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+    clone() {
+        return super.clone();
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        return CollectionPermissions.validateUpdate(oldPermissions, newPermissions);
+    }
+}
+exports.CollectionPermissionsWithDetails = CollectionPermissionsWithDetails;
+class UserPermissionsWithDetails extends UserPermissions {
+    constructor(data) {
+        super(data);
+        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 (0, base_js_1.convertClassPropertiesAndMaintainNumberTypes)(this, convertFunction);
+    }
+}
+exports.UserPermissionsWithDetails = UserPermissionsWithDetails;
+function checkNotForbidden(permission, time) {
+    const blockTime = time ?? BigInt(Date.now());
+    const [, found] = permission.permanentlyForbiddenTimes.search(blockTime);
+    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 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 uintRanges_js_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.timelineTime.start === -1n) {
+            usesTimelineTimes = false;
+            detailToCheck.timelineTime = new uintRanges_js_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.transferTime.start === -1n) {
+            usesTransferTimes = false;
+            detailToCheck.transferTime = new uintRanges_js_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.ownershipTime.start === -1n) {
+            usesOwnershipTimes = false;
+            detailToCheck.ownershipTime = new uintRanges_js_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (!usesLists) {
+            usesToLists = false;
+            detailToCheck.toList = addressLists_js_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesFromLists = false;
+            detailToCheck.fromList = addressLists_js_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesInitiatedByLists = false;
+            detailToCheck.initiatedByList = addressLists_js_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesApprovalIdLists = false;
+            detailToCheck.approvalIdList = addressLists_js_1.AddressList.AllAddresses();
+        }
+    }
+    for (const permissionDetail of permissionDetails) {
+        for (const detailToCheck of detailsToCheck) {
+            const [, overlap] = (0, overlaps_js_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}`;
+                    }
+                    return new Error(errStr);
+                }
+            }
+        }
+    }
+    return null;
+}
+function validateUniversalPermissionUpdate(oldPermissions, newPermissions) {
+    const [allOverlaps, inOldButNotNew] = (0, overlaps_js_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] = oldPermission.permanentlyPermittedTimes.getOverlapDetails(newPermission.permanentlyPermittedTimes);
+        const [leftoverForbiddenTimes] = oldPermission.permanentlyForbiddenTimes.getOverlapDetails(newPermission.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;
+}
+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