bitbadgesjs-sdk 0.3.96 → 0.3.99

package/dist/esm/core/permissions.js

@@ -1,956 +0,0 @@
-import { BaseNumberTypeClass, convertClassPropertiesAndMaintainNumberTypes, deepCopyPrimitives } from '@/common/base';
-import * as badges from '@/proto/badges';
-import { AddressList } from './addressLists';
-import { GetFirstMatchOnly, getOverlapsAndNonOverlaps, universalRemoveOverlaps } from './overlaps';
-import { BigIntify, Stringify } from '../common/string-numbers';
-import { UintRange, UintRangeArray } from './uintRanges';
-import { AllDefaultValues } from './validate-utils';
-export class UserPermissions extends 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 convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new badges.UserPermissions(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserPermissions.fromProto(badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserPermissions.fromProto(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: []
-        });
-    }
-}
-export class UserOutgoingApprovalPermission extends BaseNumberTypeClass {
-    toListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.toListId = msg.toListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new badges.UserOutgoingApprovalPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserOutgoingApprovalPermission.fromProto(badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserOutgoingApprovalPermission.fromProto(badges.UserOutgoingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new UserOutgoingApprovalPermission({
-            toListId: protoMsg.toListId,
-            initiatedByListId: protoMsg.initiatedByListId,
-            transferTimes: protoMsg.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => 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(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
-    }
-    static check(details, permissions, time) {
-        const dummyAddress = '0x';
-        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
-    }
-}
-export class UserIncomingApprovalPermission extends BaseNumberTypeClass {
-    fromListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.fromListId = msg.fromListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.approvalId = msg.approvalId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new badges.UserIncomingApprovalPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserIncomingApprovalPermission.fromProto(badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserIncomingApprovalPermission.fromProto(badges.UserIncomingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new UserIncomingApprovalPermission({
-            fromListId: protoMsg.fromListId,
-            initiatedByListId: protoMsg.initiatedByListId,
-            transferTimes: protoMsg.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => 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(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
-    }
-    static check(details, permissions, time) {
-        const dummyAddress = '0x';
-        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
-    }
-}
-export class CollectionPermissions extends 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(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)),
-            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 badges.CollectionPermissions(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionPermissions.fromProto(badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionPermissions.fromProto(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;
-    }
-    static InitEmpty() {
-        return new CollectionPermissions({
-            canDeleteCollection: [],
-            canArchiveCollection: [],
-            canUpdateOffChainBalancesMetadata: [],
-            canUpdateStandards: [],
-            canUpdateCustomData: [],
-            canUpdateManager: [],
-            canUpdateCollectionMetadata: [],
-            canCreateMoreBadges: [],
-            canUpdateBadgeMetadata: [],
-            canUpdateCollectionApprovals: []
-        });
-    }
-}
-export class ActionPermission extends BaseNumberTypeClass {
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return new ActionPermission(deepCopyPrimitives({
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new badges.ActionPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ActionPermission.fromProto(badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ActionPermission.fromProto(badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new ActionPermission({
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
-        });
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify)
-        };
-    }
-    static validateUpdate(permissions, newPermission) {
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
-        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
-    }
-    static check(permissions, time) {
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        return checkUniversalPermissionPermits(castedPermissions, time);
-    }
-}
-function checkUniversalPermissionPermits(permissions, time) {
-    const permissionDetails = GetFirstMatchOnly(permissions);
-    for (const permissionDetail of permissionDetails) {
-        const err = checkNotForbidden(permissionDetail, time ? BigInt(time) : undefined);
-        if (err) {
-            return err;
-        }
-    }
-    return null;
-}
-export class TimedUpdatePermission extends BaseNumberTypeClass {
-    timelineTimes;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.timelineTimes = UintRangeArray.From(msg.timelineTimes);
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return new TimedUpdatePermission(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 badges.TimedUpdatePermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return TimedUpdatePermission.fromProto(badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return TimedUpdatePermission.fromProto(badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new TimedUpdatePermission({
-            timelineTimes: protoMsg.timelineTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
-        });
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            timelineTimes: this.timelineTimes.convert(BigIntify),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify),
-            usesTimelineTimes: true
-        };
-    }
-    static validateUpdate(permissions, newPermission) {
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
-        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
-    }
-    static check(timelineTimes, permissions, time) {
-        const detailsToCheck = [];
-        for (const timelineTime of timelineTimes) {
-            detailsToCheck.push({
-                ...AllDefaultDetailsValues,
-                timelineTime: timelineTime.convert(BigIntify)
-            });
-        }
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const permissionDetails = GetFirstMatchOnly(castedPermissions);
-        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
-    }
-}
-const AllDefaultDetailsValues = {
-    timelineTime: new UintRange({ start: -1n, end: -1n }),
-    badgeId: new UintRange({ start: -1n, end: -1n }),
-    ownershipTime: new UintRange({ start: -1n, end: -1n }),
-    transferTime: new UintRange({ start: -1n, end: -1n }),
-    toList: new AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
-    fromList: new AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
-    initiatedByList: new AddressList({
-        listId: 'All',
-        addresses: [],
-        whitelist: false,
-        uri: '',
-        customData: '',
-        createdBy: ''
-    }),
-    approvalIdList: new AddressList({
-        listId: 'All',
-        addresses: [],
-        whitelist: false,
-        uri: '',
-        customData: '',
-        createdBy: ''
-    }),
-    permanentlyPermittedTimes: UintRangeArray.From([]),
-    permanentlyForbiddenTimes: UintRangeArray.From([]),
-    arbitraryValue: undefined
-};
-export class BalancesActionPermission extends BaseNumberTypeClass {
-    badgeIds;
-    ownershipTimes;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return new BalancesActionPermission(deepCopyPrimitives({
-            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 badges.BalancesActionPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return BalancesActionPermission.fromProto(badges.BalancesActionPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BalancesActionPermission.fromProto(badges.BalancesActionPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new BalancesActionPermission({
-            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
-        });
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            badgeIds: this.badgeIds.convert(BigIntify),
-            ownershipTimes: this.ownershipTimes.convert(BigIntify),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(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(GetFirstMatchOnly(castedPermissions), 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(BigIntify),
-                        badgeId: badgeId.convert(BigIntify)
-                    });
-                }
-            }
-        }
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const permissionDetails = GetFirstMatchOnly(castedPermissions);
-        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
-    }
-}
-export class TimedUpdateWithBadgeIdsPermission extends BaseNumberTypeClass {
-    timelineTimes;
-    badgeIds;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.timelineTimes = UintRangeArray.From(msg.timelineTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return new TimedUpdateWithBadgeIdsPermission(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 badges.TimedUpdateWithBadgeIdsPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return TimedUpdateWithBadgeIdsPermission.fromProto(badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return TimedUpdateWithBadgeIdsPermission.fromProto(badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(protoMsg, convertFunction) {
-        return new TimedUpdateWithBadgeIdsPermission({
-            timelineTimes: protoMsg.timelineTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
-        });
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            timelineTimes: this.timelineTimes.convert(BigIntify),
-            badgeIds: this.badgeIds.convert(BigIntify),
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(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(GetFirstMatchOnly(castedPermissions), 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(BigIntify),
-                        badgeId: badgeId.convert(BigIntify)
-                    });
-                }
-            }
-        }
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const permissionDetails = GetFirstMatchOnly(castedPermissions);
-        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
-    }
-}
-export class CollectionApprovalPermission extends BaseNumberTypeClass {
-    fromListId;
-    toListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    permanentlyPermittedTimes;
-    permanentlyForbiddenTimes;
-    constructor(msg) {
-        super();
-        this.fromListId = msg.fromListId;
-        this.toListId = msg.toListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
-        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
-    }
-    convert(convertFunction) {
-        return new CollectionApprovalPermission(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 badges.CollectionApprovalPermission(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionApprovalPermission.fromProto(badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionApprovalPermission.fromProto(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) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: protoMsg.approvalId,
-            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
-        });
-    }
-    static validateUpdate(permissions, newPermission) {
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
-        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), 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(BigIntify),
-                            badgeId: badgeId.convert(BigIntify),
-                            ownershipTime: ownershipTime.convert(BigIntify),
-                            toList: detail.toList,
-                            fromList: detail.fromList,
-                            initiatedByList: detail.initiatedByList,
-                            approvalIdList: detail.approvalIdList,
-                        });
-                    }
-                }
-            }
-        }
-        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
-        const permissionDetails = GetFirstMatchOnly(castedPermissions);
-        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined, true);
-    }
-}
-const { getReservedAddressList, getReservedTrackerList } = AddressList;
-export class CollectionApprovalPermissionWithDetails extends CollectionApprovalPermission {
-    toList;
-    fromList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.toList = new AddressList(data.toList);
-        this.fromList = new AddressList(data.fromList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-    }
-    clone() {
-        return super.clone();
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            toList: this.toList,
-            fromList: this.fromList,
-            initiatedByList: this.initiatedByList,
-            transferTimes: this.transferTimes.convert(BigIntify),
-            badgeIds: this.badgeIds.convert(BigIntify),
-            ownershipTimes: this.ownershipTimes.convert(BigIntify),
-            approvalIdList: getReservedTrackerList(this.approvalId),
-            usesApprovalIdList: true,
-            usesBadgeIds: true,
-            usesTransferTimes: true,
-            usesOwnershipTimes: true,
-            usesToList: true,
-            usesFromList: true,
-            usesInitiatedByList: true,
-            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
-            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify)
-        };
-    }
-}
-export class UserIncomingApprovalPermissionWithDetails extends UserIncomingApprovalPermission {
-    fromList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.fromList = new AddressList(data.fromList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-    }
-    clone() {
-        return super.clone();
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    castToCollectionApprovalPermission(address) {
-        return new CollectionApprovalPermissionWithDetails({
-            ...this,
-            toList: getReservedAddressList(address),
-            toListId: address
-        });
-    }
-}
-export class UserOutgoingApprovalPermissionWithDetails extends UserOutgoingApprovalPermission {
-    toList;
-    initiatedByList;
-    constructor(data) {
-        super(data);
-        this.toList = new AddressList(data.toList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-    }
-    clone() {
-        return super.clone();
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    castToCollectionApprovalPermission(address) {
-        return new CollectionApprovalPermissionWithDetails({
-            ...this,
-            fromList: getReservedAddressList(address),
-            fromListId: address
-        });
-    }
-}
-export class CollectionPermissionsWithDetails extends CollectionPermissions {
-    canUpdateCollectionApprovals;
-    constructor(data) {
-        super(data);
-        this.canUpdateCollectionApprovals = data.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => new CollectionApprovalPermissionWithDetails(canUpdateCollectionApproval));
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-    static validateUpdate(oldPermissions, newPermissions) {
-        return CollectionPermissions.validateUpdate(oldPermissions, newPermissions);
-    }
-}
-export class UserPermissionsWithDetails extends UserPermissions {
-    canUpdateIncomingApprovals;
-    canUpdateOutgoingApprovals;
-    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
-    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
-    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 convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-}
-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 UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.timelineTime.start === -1n) {
-            usesTimelineTimes = false;
-            detailToCheck.timelineTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.transferTime.start === -1n) {
-            usesTransferTimes = false;
-            detailToCheck.transferTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (detailToCheck.ownershipTime.start === -1n) {
-            usesOwnershipTimes = false;
-            detailToCheck.ownershipTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
-        }
-        if (!usesLists) {
-            usesToLists = false;
-            detailToCheck.toList = AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesFromLists = false;
-            detailToCheck.fromList = AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesInitiatedByLists = false;
-            detailToCheck.initiatedByList = AddressList.AllAddresses();
-        }
-        if (!usesLists) {
-            usesApprovalIdLists = false;
-            detailToCheck.approvalIdList = AddressList.AllAddresses();
-        }
-    }
-    for (const permissionDetail of permissionDetails) {
-        for (const detailToCheck of detailsToCheck) {
-            const [, overlap] = 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] = 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