bitbadgesjs-sdk 0.1.2 → 0.1.4

package/dist/core/permissions.js

@@ -0,0 +1,987 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPermissionsWithDetails = exports.CollectionPermissionsWithDetails = exports.UserOutgoingApprovalPermissionWithDetails = exports.UserIncomingApprovalPermissionWithDetails = exports.CollectionApprovalPermissionWithDetails = exports.CollectionApprovalPermission = exports.TimedUpdateWithBadgeIdsPermission = exports.BalancesActionPermission = exports.TimedUpdatePermission = exports.ActionPermission = exports.CollectionPermissions = exports.UserIncomingApprovalPermission = exports.UserOutgoingApprovalPermission = exports.UserPermissions = void 0;
+const base_1 = require("../common/base");
+const proto_1 = require("../proto");
+const addressLists_1 = require("./addressLists");
+const overlaps_1 = require("./overlaps");
+const string_numbers_1 = require("../common/string-numbers");
+const uintRanges_1 = require("./uintRanges");
+const validate_utils_1 = require("./validate-utils");
+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));
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto_1.badges.UserPermissions(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserPermissions.fromProto(proto_1.badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserPermissions.fromProto(proto_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;
+    }
+}
+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 = uintRanges_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto_1.badges.UserOutgoingApprovalPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(proto_1.badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(proto_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_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_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_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_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_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 = uintRanges_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto_1.badges.UserIncomingApprovalPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(proto_1.badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(proto_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_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_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_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_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_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));
+    }
+    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.fromProto(proto_1.badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionPermissions.fromProto(proto_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)),
+            canCreateMoreBadges: protoMsg.canCreateMoreBadges.map(x => BalancesActionPermission.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),
+            BalancesActionPermission.validateUpdate(oldPermissions.canCreateMoreBadges, newPermissions.canCreateMoreBadges),
+            TimedUpdateWithBadgeIdsPermission.validateUpdate(oldPermissions.canUpdateBadgeMetadata, newPermissions.canUpdateBadgeMetadata),
+            CollectionApprovalPermission.validateUpdate(oldPermissions.canUpdateCollectionApprovals, newPermissions.canUpdateCollectionApprovals),
+        ];
+        return responses.find(x => x !== null) ?? null;
+    }
+}
+exports.CollectionPermissions = CollectionPermissions;
+class ActionPermission extends base_1.BaseNumberTypeClass {
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.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.fromProto(proto_1.badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ActionPermission.fromProto(proto_1.badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new ActionPermission({
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_1.BigIntify)
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map(x => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_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_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_1.BaseNumberTypeClass {
+    timelineTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(msg.timelineTimes);
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    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.fromProto(proto_1.badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdatePermission.fromProto(proto_1.badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdatePermission({
+            timelineTimes: protoMsg.timelineTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(string_numbers_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_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_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(timelineTimes, permissions, time) {
+        const detailsToCheck = [];
+        for (const timelineTime of timelineTimes) {
+            detailsToCheck.push({
+                ...AllDefaultDetailsValues,
+                timelineTime: timelineTime.convert(string_numbers_1.BigIntify),
+            });
+        }
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+exports.TimedUpdatePermission = TimedUpdatePermission;
+const AllDefaultDetailsValues = {
+    timelineTime: new uintRanges_1.UintRange({ start: -1n, end: -1n }),
+    badgeId: new uintRanges_1.UintRange({ start: -1n, end: -1n }),
+    ownershipTime: new uintRanges_1.UintRange({ start: -1n, end: -1n }),
+    transferTime: new uintRanges_1.UintRange({ start: -1n, end: -1n }),
+    toList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    fromList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    initiatedByList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    approvalIdList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    amountTrackerIdList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    challengeTrackerIdList: new addressLists_1.AddressList({ listId: 'All', addresses: [], whitelist: false, uri: "", customData: "", createdBy: "" }),
+    permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+    permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]),
+    arbitraryValue: undefined
+};
+class BalancesActionPermission extends base_1.BaseNumberTypeClass {
+    badgeIds;
+    ownershipTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.badgeIds = uintRanges_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(msg.ownershipTimes);
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.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.fromProto(proto_1.badges.BalancesActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return BalancesActionPermission.fromProto(proto_1.badges.BalancesActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new BalancesActionPermission({
+            badgeIds: protoMsg.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            badgeIds: this.badgeIds.convert(string_numbers_1.BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(string_numbers_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_1.BigIntify),
+            usesBadgeIds: true,
+            usesOwnershipTimes: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map(x => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_1.GetFirstMatchOnly)(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const ownershipTime of detail.ownershipTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    detailsToCheck.push({
+                        ...AllDefaultDetailsValues,
+                        ownershipTime: ownershipTime.convert(string_numbers_1.BigIntify),
+                        badgeId: badgeId.convert(string_numbers_1.BigIntify),
+                    });
+                }
+            }
+        }
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+exports.BalancesActionPermission = BalancesActionPermission;
+class TimedUpdateWithBadgeIdsPermission extends base_1.BaseNumberTypeClass {
+    timelineTimes;
+    badgeIds;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = uintRanges_1.UintRangeArray.From(msg.timelineTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(msg.badgeIds);
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.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.fromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdateWithBadgeIdsPermission.fromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission({
+            timelineTimes: protoMsg.timelineTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(string_numbers_1.BigIntify),
+            badgeIds: this.badgeIds.convert(string_numbers_1.BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_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_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_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_1.BigIntify),
+                        badgeId: badgeId.convert(string_numbers_1.BigIntify),
+                    });
+                }
+            }
+        }
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+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 = uintRanges_1.UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = uintRanges_1.UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = uintRanges_1.UintRangeArray.From(msg.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.fromProto(proto_1.badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionApprovalPermission.fromProto(proto_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_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            transferTimes: this.transferTimes.convert(string_numbers_1.BigIntify),
+            badgeIds: this.badgeIds.convert(string_numbers_1.BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(string_numbers_1.BigIntify),
+            approvalIdList: getReservedTrackerList(this.approvalId),
+            amountTrackerIdList: getReservedTrackerList(this.amountTrackerId),
+            challengeTrackerIdList: getReservedTrackerList(this.challengeTrackerId),
+            usesAmountTrackerIdList: true,
+            usesChallengeTrackerIdList: true,
+            usesApprovalIdList: true,
+            usesBadgeIds: true,
+            usesTransferTimes: true,
+            usesOwnershipTimes: true,
+            usesToList: true,
+            usesFromList: true,
+            usesInitiatedByList: true,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(string_numbers_1.BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(string_numbers_1.BigIntify)
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map(x => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate((0, overlaps_1.GetFirstMatchOnly)(castedPermissions), (0, overlaps_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_1.BigIntify),
+                            badgeId: badgeId.convert(string_numbers_1.BigIntify),
+                            ownershipTime: ownershipTime.convert(string_numbers_1.BigIntify),
+                            toList: detail.toList,
+                            fromList: detail.fromList,
+                            initiatedByList: detail.initiatedByList,
+                            approvalIdList: detail.approvalIdList,
+                            amountTrackerIdList: detail.amountTrackerIdList,
+                            challengeTrackerIdList: detail.challengeTrackerIdList,
+                        });
+                    }
+                }
+            }
+        }
+        const castedPermissions = permissions.map(x => x.castToUniversalPermission());
+        const permissionDetails = (0, overlaps_1.GetFirstMatchOnly)(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined, true);
+    }
+}
+exports.CollectionApprovalPermission = CollectionApprovalPermission;
+const { getReservedAddressList, getReservedTrackerList } = addressLists_1.AddressList;
+class CollectionApprovalPermissionWithDetails extends CollectionApprovalPermission {
+    toList;
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new addressLists_1.AddressList(data.toList);
+        this.fromList = new addressLists_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+}
+exports.CollectionApprovalPermissionWithDetails = CollectionApprovalPermissionWithDetails;
+class UserIncomingApprovalPermissionWithDetails extends UserIncomingApprovalPermission {
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.fromList = new addressLists_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return new UserIncomingApprovalPermissionWithDetails((0, base_1.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+        }));
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            toList: getReservedAddressList(address),
+            toListId: address,
+        });
+    }
+}
+exports.UserIncomingApprovalPermissionWithDetails = UserIncomingApprovalPermissionWithDetails;
+class UserOutgoingApprovalPermissionWithDetails extends UserOutgoingApprovalPermission {
+    toList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new addressLists_1.AddressList(data.toList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return new UserOutgoingApprovalPermissionWithDetails((0, base_1.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+        }));
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            fromList: getReservedAddressList(address),
+            fromListId: address,
+        });
+    }
+}
+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 super.convert(convertFunction); }
+    static validateUpdate(oldPermissions, newPermissions) {
+        return CollectionPermissions.validateUpdate(oldPermissions, newPermissions);
+    }
+}
+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 super.convert(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_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.timelineTime.start === -1n) {
+            usesTimelineTimes = false;
+            detailToCheck.timelineTime = new uintRanges_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.transferTime.start === -1n) {
+            usesTransferTimes = false;
+            detailToCheck.transferTime = new uintRanges_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.ownershipTime.start === -1n) {
+            usesOwnershipTimes = false;
+            detailToCheck.ownershipTime = new uintRanges_1.UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (!usesLists) {
+            usesToLists = false;
+            detailToCheck.toList = addressLists_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesFromLists = false;
+            detailToCheck.fromList = addressLists_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesInitiatedByLists = false;
+            detailToCheck.initiatedByList = addressLists_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesApprovalIdLists = false;
+            detailToCheck.approvalIdList = addressLists_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesAmountTrackerIdList = false;
+            detailToCheck.amountTrackerIdList = addressLists_1.AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesChallengeTrackerIdList = false;
+            detailToCheck.challengeTrackerIdList = addressLists_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;
+}
+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] = oldPermission.permanentlyPermittedTimes.remove(newPermission.permanentlyPermittedTimes);
+        const [leftoverForbiddenTimes] = oldPermission.permanentlyForbiddenTimes.remove(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