bitbadgesjs-sdk 0.1.2 → 0.1.4

package/dist/core/approvals.js

@@ -0,0 +1,1149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandCollectionApprovals = exports.validateCollectionApprovalsUpdate = exports.getFirstMatchOnlyWithApprovalCriteria = exports.CollectionApprovalWithDetails = exports.ApprovalCriteriaWithDetails = exports.MerkleChallengeWithDetails = exports.ApprovalInfoDetails = exports.ChallengeDetails = exports.UserIncomingApprovalWithDetails = exports.UserOutgoingApprovalWithDetails = exports.ApprovalCriteria = exports.CollectionApproval = exports.IncomingApprovalCriteria = exports.UserIncomingApproval = exports.MaxNumTransfers = exports.ApprovalAmounts = exports.PredeterminedOrderCalculationMethod = exports.IncrementedBalances = exports.ManualBalances = exports.PredeterminedBalances = exports.OutgoingApprovalCriteria = exports.UserOutgoingApproval = void 0;
+const base_1 = require("../common/base");
+const proto = __importStar(require("../proto"));
+const addressLists_1 = require("./addressLists");
+const balances_1 = require("./balances");
+const misc_1 = require("./misc");
+const overlaps_1 = require("./overlaps");
+const permissions_1 = require("./permissions");
+const string_numbers_1 = require("../common/string-numbers");
+const uintRanges_1 = require("./uintRanges");
+const validate_utils_1 = require("./validate-utils");
+const { getReservedAddressList, getReservedTrackerList } = addressLists_1.AddressList;
+class UserOutgoingApproval extends base_1.BaseNumberTypeClass {
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new OutgoingApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto.badges.UserOutgoingApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserOutgoingApproval.fromProto(proto.badges.UserOutgoingApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserOutgoingApproval.fromProto(proto.badges.UserOutgoingApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new UserOutgoingApproval({
+            toListId: item.toListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? OutgoingApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+}
+exports.UserOutgoingApproval = UserOutgoingApproval;
+class OutgoingApprovalCriteria extends base_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new misc_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new misc_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
+    }
+    convert(convertFunction) {
+        return new OutgoingApprovalCriteria((0, base_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge?.convert(convertFunction),
+            predeterminedBalances: this.predeterminedBalances?.convert(convertFunction),
+            approvalAmounts: this.approvalAmounts?.convert(convertFunction),
+            maxNumTransfers: this.maxNumTransfers?.convert(convertFunction),
+            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy
+        }));
+    }
+    toProto() {
+        return new proto.badges.OutgoingApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return OutgoingApprovalCriteria.fromProto(proto.badges.OutgoingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return OutgoingApprovalCriteria.fromProto(proto.badges.OutgoingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new OutgoingApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => misc_1.MustOwnBadges.fromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? misc_1.MerkleChallenge.fromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy
+        });
+    }
+    castToCollectionApprovalCriteria() {
+        return new ApprovalCriteria({
+            approvalAmounts: this.approvalAmounts,
+            maxNumTransfers: this.maxNumTransfers,
+            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy,
+            predeterminedBalances: this.predeterminedBalances,
+            mustOwnBadges: this.mustOwnBadges,
+            merkleChallenge: this.merkleChallenge,
+            requireFromEqualsInitiatedBy: false,
+            requireFromDoesNotEqualInitiatedBy: false,
+            overridesFromOutgoingApprovals: false,
+            overridesToIncomingApprovals: false,
+        });
+    }
+}
+exports.OutgoingApprovalCriteria = OutgoingApprovalCriteria;
+class PredeterminedBalances extends base_1.BaseNumberTypeClass {
+    manualBalances;
+    incrementedBalances;
+    orderCalculationMethod;
+    constructor(msg) {
+        super();
+        this.manualBalances = msg.manualBalances.map(x => new ManualBalances(x));
+        this.incrementedBalances = new IncrementedBalances(msg.incrementedBalances);
+        this.orderCalculationMethod = new PredeterminedOrderCalculationMethod(msg.orderCalculationMethod);
+    }
+    convert(convertFunction) {
+        return new PredeterminedBalances((0, base_1.deepCopy)({
+            manualBalances: this.manualBalances.map((x) => x.convert(convertFunction)),
+            incrementedBalances: this.incrementedBalances.convert(convertFunction),
+            orderCalculationMethod: this.orderCalculationMethod
+        }));
+    }
+    toProto() {
+        return new proto.badges.PredeterminedBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return PredeterminedBalances.fromProto(proto.badges.PredeterminedBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return PredeterminedBalances.fromProto(proto.badges.PredeterminedBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new PredeterminedBalances({
+            manualBalances: item.manualBalances.map(x => ManualBalances.fromProto(x, convertFunction)),
+            incrementedBalances: item.incrementedBalances ? IncrementedBalances.fromProto(item.incrementedBalances, convertFunction) : new IncrementedBalances({ startBalances: [], incrementBadgeIdsBy: convertFunction(0), incrementOwnershipTimesBy: convertFunction(0) }),
+            orderCalculationMethod: item.orderCalculationMethod ? PredeterminedOrderCalculationMethod.fromProto(item.orderCalculationMethod) : new PredeterminedOrderCalculationMethod({
+                useOverallNumTransfers: false,
+                usePerFromAddressNumTransfers: false,
+                usePerToAddressNumTransfers: false,
+                usePerInitiatedByAddressNumTransfers: false,
+                useMerkleChallengeLeafIndex: false,
+            })
+        });
+    }
+}
+exports.PredeterminedBalances = PredeterminedBalances;
+class ManualBalances extends base_1.BaseNumberTypeClass {
+    balances;
+    constructor(msg) {
+        super();
+        this.balances = balances_1.BalanceArray.From(msg.balances);
+    }
+    convert(convertFunction) {
+        return new ManualBalances((0, base_1.deepCopy)({
+            balances: this.balances.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.ManualBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ManualBalances.fromProto(proto.badges.ManualBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ManualBalances.fromProto(proto.badges.ManualBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new ManualBalances({
+            balances: item.balances.map(x => balances_1.Balance.fromProto(x, convertFunction))
+        });
+    }
+}
+exports.ManualBalances = ManualBalances;
+class IncrementedBalances extends base_1.BaseNumberTypeClass {
+    startBalances;
+    incrementBadgeIdsBy;
+    incrementOwnershipTimesBy;
+    constructor(msg) {
+        super();
+        this.startBalances = balances_1.BalanceArray.From(msg.startBalances);
+        this.incrementBadgeIdsBy = msg.incrementBadgeIdsBy;
+        this.incrementOwnershipTimesBy = msg.incrementOwnershipTimesBy;
+    }
+    getNumberFieldNames() {
+        return ['incrementBadgeIdsBy', 'incrementOwnershipTimesBy'];
+    }
+    convert(convertFunction) {
+        return new IncrementedBalances((0, base_1.deepCopy)({
+            startBalances: this.startBalances.map((x) => x.convert(convertFunction)),
+            incrementBadgeIdsBy: convertFunction(this.incrementBadgeIdsBy),
+            incrementOwnershipTimesBy: convertFunction(this.incrementOwnershipTimesBy)
+        }));
+    }
+    toProto() {
+        return new proto.badges.IncrementedBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return IncrementedBalances.fromProto(proto.badges.IncrementedBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return IncrementedBalances.fromProto(proto.badges.IncrementedBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new IncrementedBalances({
+            startBalances: item.startBalances.map(x => balances_1.Balance.fromProto(x, convertFunction)),
+            incrementBadgeIdsBy: convertFunction(item.incrementBadgeIdsBy),
+            incrementOwnershipTimesBy: convertFunction(item.incrementOwnershipTimesBy)
+        });
+    }
+}
+exports.IncrementedBalances = IncrementedBalances;
+class PredeterminedOrderCalculationMethod extends base_1.CustomTypeClass {
+    useOverallNumTransfers;
+    usePerToAddressNumTransfers;
+    usePerFromAddressNumTransfers;
+    usePerInitiatedByAddressNumTransfers;
+    useMerkleChallengeLeafIndex;
+    constructor(msg) {
+        super();
+        this.useOverallNumTransfers = msg.useOverallNumTransfers;
+        this.usePerToAddressNumTransfers = msg.usePerToAddressNumTransfers;
+        this.usePerFromAddressNumTransfers = msg.usePerFromAddressNumTransfers;
+        this.usePerInitiatedByAddressNumTransfers = msg.usePerInitiatedByAddressNumTransfers;
+        this.useMerkleChallengeLeafIndex = msg.useMerkleChallengeLeafIndex;
+    }
+    toProto() {
+        return new proto.badges.PredeterminedOrderCalculationMethod(this.toJson());
+    }
+    static fromJson(jsonValue, options) {
+        return PredeterminedOrderCalculationMethod.fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return PredeterminedOrderCalculationMethod.fromJsonString(jsonString, options);
+    }
+    static fromProto(item) {
+        return new PredeterminedOrderCalculationMethod({
+            useOverallNumTransfers: item.useOverallNumTransfers,
+            usePerToAddressNumTransfers: item.usePerToAddressNumTransfers,
+            usePerFromAddressNumTransfers: item.usePerFromAddressNumTransfers,
+            usePerInitiatedByAddressNumTransfers: item.usePerInitiatedByAddressNumTransfers,
+            useMerkleChallengeLeafIndex: item.useMerkleChallengeLeafIndex
+        });
+    }
+}
+exports.PredeterminedOrderCalculationMethod = PredeterminedOrderCalculationMethod;
+class ApprovalAmounts extends base_1.BaseNumberTypeClass {
+    overallApprovalAmount;
+    perToAddressApprovalAmount;
+    perFromAddressApprovalAmount;
+    perInitiatedByAddressApprovalAmount;
+    constructor(msg) {
+        super();
+        this.overallApprovalAmount = msg.overallApprovalAmount;
+        this.perToAddressApprovalAmount = msg.perToAddressApprovalAmount;
+        this.perFromAddressApprovalAmount = msg.perFromAddressApprovalAmount;
+        this.perInitiatedByAddressApprovalAmount = msg.perInitiatedByAddressApprovalAmount;
+    }
+    getNumberFieldNames() {
+        return ['overallApprovalAmount', 'perToAddressApprovalAmount', 'perFromAddressApprovalAmount', 'perInitiatedByAddressApprovalAmount'];
+    }
+    convert(convertFunction) {
+        return new ApprovalAmounts((0, base_1.deepCopy)({
+            overallApprovalAmount: convertFunction(this.overallApprovalAmount),
+            perToAddressApprovalAmount: convertFunction(this.perToAddressApprovalAmount),
+            perFromAddressApprovalAmount: convertFunction(this.perFromAddressApprovalAmount),
+            perInitiatedByAddressApprovalAmount: convertFunction(this.perInitiatedByAddressApprovalAmount)
+        }));
+    }
+    toProto() {
+        return new proto.badges.ApprovalAmounts(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ApprovalAmounts.fromProto(proto.badges.ApprovalAmounts.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ApprovalAmounts.fromProto(proto.badges.ApprovalAmounts.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new ApprovalAmounts({
+            overallApprovalAmount: convertFunction(item.overallApprovalAmount),
+            perToAddressApprovalAmount: convertFunction(item.perToAddressApprovalAmount),
+            perFromAddressApprovalAmount: convertFunction(item.perFromAddressApprovalAmount),
+            perInitiatedByAddressApprovalAmount: convertFunction(item.perInitiatedByAddressApprovalAmount)
+        });
+    }
+}
+exports.ApprovalAmounts = ApprovalAmounts;
+class MaxNumTransfers extends base_1.BaseNumberTypeClass {
+    overallMaxNumTransfers;
+    perToAddressMaxNumTransfers;
+    perFromAddressMaxNumTransfers;
+    perInitiatedByAddressMaxNumTransfers;
+    constructor(msg) {
+        super();
+        this.overallMaxNumTransfers = msg.overallMaxNumTransfers;
+        this.perToAddressMaxNumTransfers = msg.perToAddressMaxNumTransfers;
+        this.perFromAddressMaxNumTransfers = msg.perFromAddressMaxNumTransfers;
+        this.perInitiatedByAddressMaxNumTransfers = msg.perInitiatedByAddressMaxNumTransfers;
+    }
+    getNumberFieldNames() {
+        return ['overallMaxNumTransfers', 'perToAddressMaxNumTransfers', 'perFromAddressMaxNumTransfers', 'perInitiatedByAddressMaxNumTransfers'];
+    }
+    convert(convertFunction) {
+        return new MaxNumTransfers((0, base_1.deepCopy)({
+            overallMaxNumTransfers: convertFunction(this.overallMaxNumTransfers),
+            perToAddressMaxNumTransfers: convertFunction(this.perToAddressMaxNumTransfers),
+            perFromAddressMaxNumTransfers: convertFunction(this.perFromAddressMaxNumTransfers),
+            perInitiatedByAddressMaxNumTransfers: convertFunction(this.perInitiatedByAddressMaxNumTransfers)
+        }));
+    }
+    toProto() {
+        return new proto.badges.MaxNumTransfers(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return MaxNumTransfers.fromProto(proto.badges.MaxNumTransfers.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return MaxNumTransfers.fromProto(proto.badges.MaxNumTransfers.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new MaxNumTransfers({
+            overallMaxNumTransfers: convertFunction(item.overallMaxNumTransfers),
+            perToAddressMaxNumTransfers: convertFunction(item.perToAddressMaxNumTransfers),
+            perFromAddressMaxNumTransfers: convertFunction(item.perFromAddressMaxNumTransfers),
+            perInitiatedByAddressMaxNumTransfers: convertFunction(item.perInitiatedByAddressMaxNumTransfers)
+        });
+    }
+}
+exports.MaxNumTransfers = MaxNumTransfers;
+class UserIncomingApproval extends base_1.BaseNumberTypeClass {
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new IncomingApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto.badges.UserIncomingApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserIncomingApproval.fromProto(proto.badges.UserIncomingApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserIncomingApproval.fromProto(proto.badges.UserIncomingApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new UserIncomingApproval({
+            fromListId: item.fromListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? IncomingApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+}
+exports.UserIncomingApproval = UserIncomingApproval;
+class IncomingApprovalCriteria extends base_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireFromEqualsInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new misc_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new misc_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
+    }
+    convert(convertFunction) {
+        return new IncomingApprovalCriteria((0, base_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy
+        }));
+    }
+    toProto() {
+        return new proto.badges.IncomingApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return IncomingApprovalCriteria.fromProto(proto.badges.IncomingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return IncomingApprovalCriteria.fromProto(proto.badges.IncomingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new IncomingApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => misc_1.MustOwnBadges.fromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? misc_1.MerkleChallenge.fromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy
+        });
+    }
+    castToCollectionApprovalCriteria() {
+        return new ApprovalCriteria({
+            approvalAmounts: this.approvalAmounts,
+            maxNumTransfers: this.maxNumTransfers,
+            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy,
+            predeterminedBalances: this.predeterminedBalances,
+            mustOwnBadges: this.mustOwnBadges,
+            merkleChallenge: this.merkleChallenge,
+            requireToEqualsInitiatedBy: false,
+            requireToDoesNotEqualInitiatedBy: false,
+            overridesFromOutgoingApprovals: false,
+            overridesToIncomingApprovals: false,
+        });
+    }
+}
+exports.IncomingApprovalCriteria = IncomingApprovalCriteria;
+class CollectionApproval extends base_1.BaseNumberTypeClass {
+    toListId;
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    constructor(msg) {
+        super();
+        this.toListId = msg.toListId;
+        this.fromListId = msg.fromListId;
+        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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new ApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+    toProto() {
+        return new proto.badges.CollectionApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionApproval.fromProto(proto.badges.CollectionApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionApproval.fromProto(proto.badges.CollectionApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new CollectionApproval({
+            toListId: item.toListId,
+            fromListId: item.fromListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => uintRanges_1.UintRange.fromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? ApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            badgeIds: this.badgeIds.convert(string_numbers_1.BigIntify),
+            transferTimes: this.transferTimes.convert(string_numbers_1.BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(string_numbers_1.BigIntify),
+            fromList: getReservedAddressList(this.fromListId),
+            toList: getReservedAddressList(this.toListId),
+            initiatedByList: getReservedAddressList(this.initiatedByListId),
+            approvalIdList: getReservedTrackerList(this.approvalId),
+            amountTrackerIdList: getReservedTrackerList(this.amountTrackerId),
+            challengeTrackerIdList: getReservedTrackerList(this.challengeTrackerId),
+            usesAmountTrackerIdList: true,
+            usesChallengeTrackerIdList: true,
+            usesApprovalIdList: true,
+            usesBadgeIds: true,
+            usesTransferTimes: true,
+            usesToList: true,
+            usesFromList: true,
+            usesInitiatedByList: true,
+            usesOwnershipTimes: true,
+            arbitraryValue: {
+                approvalId: this.approvalId,
+                amountTrackerId: this.amountTrackerId,
+                challengeTrackerId: this.challengeTrackerId,
+                approvalCriteria: this.approvalCriteria,
+            }
+        };
+    }
+    castToOutgoingApproval() {
+        return new UserOutgoingApproval({
+            ...this,
+            toListId: this.toListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes,
+            badgeIds: this.badgeIds,
+            ownershipTimes: this.ownershipTimes,
+            approvalCriteria: this.approvalCriteria,
+        });
+    }
+    castToIncomingApproval() {
+        return new UserOutgoingApproval({
+            ...this,
+            fromListId: this.fromListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes,
+            badgeIds: this.badgeIds,
+            ownershipTimes: this.ownershipTimes,
+            approvalCriteria: this.approvalCriteria,
+        });
+    }
+    static validateUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
+        return validateCollectionApprovalsUpdate(oldApprovals.map(x => x.convert(string_numbers_1.BigIntify)), newApprovals.map(x => x.convert(string_numbers_1.BigIntify)), canUpdateCollectionApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.CollectionApproval = CollectionApproval;
+class ApprovalCriteria extends base_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireFromEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    overridesFromOutgoingApprovals;
+    overridesToIncomingApprovals;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new misc_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new misc_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
+        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
+        this.overridesFromOutgoingApprovals = msg.overridesFromOutgoingApprovals;
+        this.overridesToIncomingApprovals = msg.overridesToIncomingApprovals;
+    }
+    convert(convertFunction) {
+        return new ApprovalCriteria((0, base_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
+            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy,
+            overridesFromOutgoingApprovals: this.overridesFromOutgoingApprovals,
+            overridesToIncomingApprovals: this.overridesToIncomingApprovals
+        }));
+    }
+    toProto() {
+        return new proto.badges.ApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ApprovalCriteria.fromProto(proto.badges.ApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ApprovalCriteria.fromProto(proto.badges.ApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(item, convertFunction) {
+        return new ApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => misc_1.MustOwnBadges.fromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? misc_1.MerkleChallenge.fromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
+            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy,
+            overridesFromOutgoingApprovals: item.overridesFromOutgoingApprovals,
+            overridesToIncomingApprovals: item.overridesToIncomingApprovals
+        });
+    }
+}
+exports.ApprovalCriteria = ApprovalCriteria;
+class UserOutgoingApprovalWithDetails extends UserOutgoingApproval {
+    toList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new addressLists_1.AddressList(data.toList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+    }
+    convert(convertFunction) {
+        return new UserOutgoingApprovalWithDetails((0, base_1.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+            toList: this.toList,
+            initiatedByList: this.initiatedByList,
+        }));
+    }
+    castToCollectionTransfer(fromAddress) {
+        return new CollectionApprovalWithDetails({
+            ...this,
+            fromListId: fromAddress,
+            fromList: getReservedAddressList(fromAddress),
+            approvalCriteria: this.approvalCriteria?.castToCollectionApprovalCriteria(),
+        });
+    }
+    castToUniversalPermission() {
+        return this.castToCollectionTransfer(this.toListId).castToUniversalPermission();
+    }
+}
+exports.UserOutgoingApprovalWithDetails = UserOutgoingApprovalWithDetails;
+class UserIncomingApprovalWithDetails extends UserIncomingApproval {
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.fromList = new addressLists_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+    }
+    convert(convertFunction) {
+        return new UserIncomingApprovalWithDetails((0, base_1.deepCopy)({
+            ...this,
+            ...super.convert(convertFunction),
+            fromList: this.fromList,
+            initiatedByList: this.initiatedByList,
+        }));
+    }
+    castToCollectionTransfer(toAddress) {
+        return new CollectionApprovalWithDetails({
+            ...this,
+            toList: getReservedAddressList(toAddress),
+            toListId: toAddress,
+            approvalCriteria: this.approvalCriteria?.castToCollectionApprovalCriteria(),
+        });
+    }
+    castToUniversalPermission() {
+        return this.castToCollectionTransfer(this.fromListId).castToUniversalPermission();
+    }
+}
+exports.UserIncomingApprovalWithDetails = UserIncomingApprovalWithDetails;
+class ChallengeDetails extends base_1.BaseNumberTypeClass {
+    leavesDetails;
+    tree;
+    treeOptions;
+    numLeaves;
+    currCode;
+    hasPassword;
+    password;
+    constructor(data) {
+        super();
+        this.leavesDetails = data.leavesDetails;
+        this.tree = data.tree;
+        this.treeOptions = data.treeOptions;
+        this.numLeaves = data.numLeaves;
+        this.currCode = data.currCode;
+        this.hasPassword = data.hasPassword;
+        this.password = data.password;
+    }
+    getNumberFieldNames() {
+        return ['numLeaves', 'currCode'];
+    }
+    convert(convertFunction) {
+        return new ChallengeDetails((0, base_1.deepCopy)({
+            ...this,
+            numLeaves: this.numLeaves ? convertFunction(this.numLeaves) : undefined,
+            currCode: this.currCode !== undefined && BigInt(this.currCode ?? -1n) >= 0 ? convertFunction(this.currCode) : undefined,
+        }));
+    }
+}
+exports.ChallengeDetails = ChallengeDetails;
+class ApprovalInfoDetails extends base_1.BaseNumberTypeClass {
+    name;
+    description;
+    hasPassword;
+    password;
+    challengeDetails;
+    constructor(data) {
+        super();
+        this.name = data.name;
+        this.description = data.description;
+        this.hasPassword = data.hasPassword;
+        this.password = data.password;
+        this.challengeDetails = data.challengeDetails ? new ChallengeDetails(data.challengeDetails) : undefined;
+    }
+    convert(convertFunction) {
+        return new ApprovalInfoDetails((0, base_1.deepCopy)({
+            ...this,
+            challengeDetails: this.challengeDetails ? this.challengeDetails.convert(convertFunction) : undefined,
+        }));
+    }
+}
+exports.ApprovalInfoDetails = ApprovalInfoDetails;
+class MerkleChallengeWithDetails extends base_1.BaseNumberTypeClass {
+    details;
+    root;
+    expectedProofLength;
+    useCreatorAddressAsLeaf;
+    maxUsesPerLeaf;
+    uri;
+    customData;
+    constructor(data) {
+        super();
+        this.details = data.details ? new ApprovalInfoDetails(data.details) : undefined;
+        this.root = data.root;
+        this.expectedProofLength = data.expectedProofLength;
+        this.useCreatorAddressAsLeaf = data.useCreatorAddressAsLeaf;
+        this.maxUsesPerLeaf = data.maxUsesPerLeaf;
+        this.uri = data.uri;
+        this.customData = data.customData;
+    }
+    getNumberFieldNames() {
+        return ['expectedProofLength', 'maxUsesPerLeaf'];
+    }
+    convert(convertFunction) { return super.convert(convertFunction); }
+}
+exports.MerkleChallengeWithDetails = MerkleChallengeWithDetails;
+class ApprovalCriteriaWithDetails extends base_1.BaseNumberTypeClass {
+    merkleChallenge;
+    mustOwnBadges;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireFromEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    overridesFromOutgoingApprovals;
+    overridesToIncomingApprovals;
+    constructor(data) {
+        super();
+        this.merkleChallenge = data.merkleChallenge ? new MerkleChallengeWithDetails(data.merkleChallenge) : undefined;
+        this.mustOwnBadges = data.mustOwnBadges?.map((x) => new misc_1.MustOwnBadges(x));
+        this.predeterminedBalances = data.predeterminedBalances ? new PredeterminedBalances(data.predeterminedBalances) : undefined;
+        this.approvalAmounts = data.approvalAmounts ? new ApprovalAmounts(data.approvalAmounts) : undefined;
+        this.maxNumTransfers = data.maxNumTransfers ? new MaxNumTransfers(data.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = data.requireToEqualsInitiatedBy;
+        this.requireFromEqualsInitiatedBy = data.requireFromEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = data.requireToDoesNotEqualInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = data.requireFromDoesNotEqualInitiatedBy;
+        this.overridesFromOutgoingApprovals = data.overridesFromOutgoingApprovals;
+        this.overridesToIncomingApprovals = data.overridesToIncomingApprovals;
+    }
+    convert(convertFunction) {
+        return new ApprovalCriteriaWithDetails((0, base_1.deepCopy)({
+            ...this,
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+        }));
+    }
+}
+exports.ApprovalCriteriaWithDetails = ApprovalCriteriaWithDetails;
+class CollectionApprovalWithDetails extends base_1.BaseNumberTypeClass {
+    approvalCriteria;
+    details;
+    toList;
+    fromList;
+    initiatedByList;
+    toListId;
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    constructor(data) {
+        super();
+        this.approvalCriteria = data.approvalCriteria ? new ApprovalCriteriaWithDetails(data.approvalCriteria) : undefined;
+        this.details = data.details ? new ApprovalInfoDetails(data.details) : undefined;
+        this.toList = new addressLists_1.AddressList(data.toList);
+        this.fromList = new addressLists_1.AddressList(data.fromList);
+        this.initiatedByList = new addressLists_1.AddressList(data.initiatedByList);
+        this.toListId = data.toListId;
+        this.fromListId = data.fromListId;
+        this.initiatedByListId = data.initiatedByListId;
+        this.transferTimes = uintRanges_1.UintRangeArray.From(data.transferTimes);
+        this.badgeIds = uintRanges_1.UintRangeArray.From(data.badgeIds);
+        this.ownershipTimes = uintRanges_1.UintRangeArray.From(data.ownershipTimes);
+        this.approvalId = data.approvalId;
+        this.amountTrackerId = data.amountTrackerId;
+        this.challengeTrackerId = data.challengeTrackerId;
+        this.uri = data.uri;
+        this.customData = data.customData;
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalWithDetails((0, base_1.deepCopy)({
+            ...this,
+            approvalCriteria: this.approvalCriteria?.convert(convertFunction),
+            details: this.details?.convert(convertFunction),
+            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
+        }));
+    }
+    toProto() {
+        return CollectionApproval.prototype.toProto.call(this);
+    }
+    castToUniversalPermission() {
+        return {
+            ...validate_utils_1.AllDefaultValues,
+            badgeIds: this.badgeIds.convert(string_numbers_1.BigIntify),
+            transferTimes: this.transferTimes.convert(string_numbers_1.BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(string_numbers_1.BigIntify),
+            fromList: this.fromList,
+            toList: this.toList,
+            initiatedByList: this.initiatedByList,
+            approvalIdList: getReservedTrackerList(this.approvalId),
+            amountTrackerIdList: getReservedTrackerList(this.amountTrackerId),
+            challengeTrackerIdList: getReservedTrackerList(this.challengeTrackerId),
+            usesAmountTrackerIdList: true,
+            usesChallengeTrackerIdList: true,
+            usesApprovalIdList: true,
+            usesBadgeIds: true,
+            usesTransferTimes: true,
+            usesToList: true,
+            usesFromList: true,
+            usesInitiatedByList: true,
+            usesOwnershipTimes: true,
+            arbitraryValue: {
+                approvalId: this.approvalId,
+                amountTrackerId: this.amountTrackerId,
+                challengeTrackerId: this.challengeTrackerId,
+                approvalCriteria: this.approvalCriteria,
+            }
+        };
+    }
+    castToOutgoingApproval() {
+        return new UserOutgoingApprovalWithDetails({
+            ...this,
+            toListId: this.toListId,
+            toList: this.toList,
+            initiatedByList: this.initiatedByList,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes,
+            badgeIds: this.badgeIds,
+            ownershipTimes: this.ownershipTimes,
+            approvalCriteria: this.approvalCriteria,
+        });
+    }
+    castToIncomingApproval() {
+        return new UserOutgoingApprovalWithDetails({
+            ...this,
+            fromListId: this.fromListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes,
+            badgeIds: this.badgeIds,
+            ownershipTimes: this.ownershipTimes,
+            approvalCriteria: this.approvalCriteria,
+        });
+    }
+    static validateUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
+        return validateCollectionApprovalsUpdate(oldApprovals.map(x => x.convert(string_numbers_1.BigIntify)), newApprovals.map(x => x.convert(string_numbers_1.BigIntify)), canUpdateCollectionApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+}
+exports.CollectionApprovalWithDetails = CollectionApprovalWithDetails;
+function getFirstMatchOnlyWithApprovalCriteria(permissions) {
+    const handled = [];
+    for (const permission of permissions) {
+        const badgeIds = (0, overlaps_1.GetUintRangesWithOptions)(permission.badgeIds, permission.usesBadgeIds);
+        const timelineTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.timelineTimes, permission.usesTimelineTimes);
+        const transferTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.transferTimes, permission.usesTransferTimes);
+        const ownershipTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.ownershipTimes, permission.usesOwnershipTimes);
+        const permanentlyPermittedTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.permanentlyPermittedTimes, true);
+        const permanentlyForbiddenTimes = (0, overlaps_1.GetUintRangesWithOptions)(permission.permanentlyForbiddenTimes, true);
+        for (const badgeId of badgeIds) {
+            for (const timelineTime of timelineTimes) {
+                for (const transferTime of transferTimes) {
+                    for (const ownershipTime of ownershipTimes) {
+                        const approvalCriteria = [
+                            permission.arbitraryValue.approvalCriteria ?? null,
+                        ];
+                        const isApproved = permission.arbitraryValue.isApproved;
+                        const arbValue = {
+                            isApproved: isApproved,
+                            approvalCriteria: approvalCriteria,
+                        };
+                        const brokenDown = [
+                            {
+                                badgeId: badgeId,
+                                timelineTime: timelineTime,
+                                transferTime: transferTime,
+                                ownershipTime: ownershipTime,
+                                toList: permission.toList,
+                                fromList: permission.fromList,
+                                initiatedByList: permission.initiatedByList,
+                                approvalIdList: permission.approvalIdList,
+                                amountTrackerIdList: permission.amountTrackerIdList,
+                                challengeTrackerIdList: permission.challengeTrackerIdList,
+                                permanentlyPermittedTimes: permanentlyPermittedTimes,
+                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
+                                arbitraryValue: arbValue,
+                            },
+                        ];
+                        const [overlaps, inBrokenDownButNotHandled, inHandledButNotBrokenDown] = (0, overlaps_1.getOverlapsAndNonOverlaps)(brokenDown, handled);
+                        handled.length = 0;
+                        handled.push(...inHandledButNotBrokenDown);
+                        handled.push(...inBrokenDownButNotHandled);
+                        for (const overlap of overlaps) {
+                            const mergedApprovalCriteria = overlap.secondDetails.arbitraryValue.approvalCriteria.concat(overlap.firstDetails.arbitraryValue.approvalCriteria);
+                            const isApprovedFirst = overlap.firstDetails.arbitraryValue.isApproved;
+                            const isApprovedSecond = overlap.secondDetails.arbitraryValue.isApproved;
+                            const isApproved = isApprovedFirst && isApprovedSecond;
+                            const newArbValue = {
+                                isApproved: isApproved,
+                                approvalCriteria: mergedApprovalCriteria,
+                            };
+                            handled.push({
+                                timelineTime: overlap.overlap.timelineTime,
+                                badgeId: overlap.overlap.badgeId,
+                                transferTime: overlap.overlap.transferTime,
+                                ownershipTime: overlap.overlap.ownershipTime,
+                                toList: overlap.overlap.toList,
+                                fromList: overlap.overlap.fromList,
+                                initiatedByList: overlap.overlap.initiatedByList,
+                                approvalIdList: overlap.overlap.approvalIdList,
+                                amountTrackerIdList: overlap.overlap.amountTrackerIdList,
+                                challengeTrackerIdList: overlap.overlap.challengeTrackerIdList,
+                                permanentlyPermittedTimes: permanentlyPermittedTimes,
+                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
+                                arbitraryValue: newArbValue,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const returnArr = [];
+    for (const handledItem of handled) {
+        let idxToInsert = 0;
+        while (idxToInsert < returnArr.length && handledItem.badgeId.start > returnArr[idxToInsert].badgeId.start) {
+            idxToInsert++;
+        }
+        returnArr.push(null);
+        returnArr.copyWithin(idxToInsert + 1, idxToInsert);
+        returnArr[idxToInsert] = handledItem;
+    }
+    return returnArr;
+}
+exports.getFirstMatchOnlyWithApprovalCriteria = getFirstMatchOnlyWithApprovalCriteria;
+function validateCollectionApprovalsUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
+    const dummyRanges = [uintRanges_1.UintRangeArray.From([{ start: 1n, end: 1n }])];
+    const oldTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(dummyRanges.map(x => x.clone()), oldApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
+    const newTimelineFirstMatches = (0, validate_utils_1.getPotentialUpdatesForTimelineValues)(dummyRanges.map(x => x.clone()), newApprovals.map(x => x.convert(string_numbers_1.BigIntify)));
+    const detailsToCheck = (0, validate_utils_1.getUpdateCombinationsToCheck)(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
+        const expandedOldApprovals = expandCollectionApprovals(oldValue);
+        const expandedNewApprovals = expandCollectionApprovals(newValue);
+        const oldApprovals = expandedOldApprovals.map(x => x.castToUniversalPermission());
+        if (!oldApprovals) {
+            throw new Error("InvalidOldValue");
+        }
+        const newApprovals = expandedNewApprovals.map(x => x.castToUniversalPermission());
+        if (!newApprovals) {
+            throw new Error("InvalidNewValue");
+        }
+        const firstMatchesForOld = getFirstMatchOnlyWithApprovalCriteria(oldApprovals);
+        const firstMatchesForNew = getFirstMatchOnlyWithApprovalCriteria(newApprovals);
+        const detailsToReturn = [];
+        const [overlapObjects, inOldButNotNew, inNewButNotOld] = (0, overlaps_1.getOverlapsAndNonOverlaps)(firstMatchesForOld, firstMatchesForNew);
+        for (const overlapObject of overlapObjects) {
+            const overlap = overlapObject.overlap;
+            const oldDetails = overlapObject.firstDetails;
+            const newDetails = overlapObject.secondDetails;
+            let different = false;
+            if ((oldDetails.arbitraryValue === null && newDetails.arbitraryValue !== null) || (oldDetails.arbitraryValue !== null && newDetails.arbitraryValue === null)) {
+                different = true;
+            }
+            else {
+                const oldArbVal = oldDetails.arbitraryValue;
+                const newArbVal = newDetails.arbitraryValue;
+                const oldVal = oldArbVal.approvalCriteria;
+                const newVal = newArbVal.approvalCriteria;
+                if (oldArbVal.isApproved !== newArbVal.isApproved) {
+                    different = true;
+                }
+                if (oldVal.length !== newVal.length) {
+                    different = true;
+                }
+                else {
+                    for (let i = 0; i < oldVal.length; i++) {
+                        if (JSON.stringify(oldVal[i]) !== JSON.stringify(newVal[i])) {
+                            different = true;
+                        }
+                    }
+                }
+            }
+            if (different) {
+                detailsToReturn.push(overlap);
+            }
+        }
+        detailsToReturn.push(...inOldButNotNew);
+        detailsToReturn.push(...inNewButNotOld);
+        return detailsToReturn;
+    });
+    const details = detailsToCheck.map(x => {
+        const result = {
+            timelineTimes: uintRanges_1.UintRangeArray.From([x.timelineTime]),
+            badgeIds: uintRanges_1.UintRangeArray.From([x.badgeId]),
+            ownershipTimes: uintRanges_1.UintRangeArray.From([x.ownershipTime]),
+            transferTimes: uintRanges_1.UintRangeArray.From([x.transferTime]),
+            toList: x.toList,
+            fromList: x.fromList,
+            initiatedByList: x.initiatedByList,
+            approvalIdList: x.approvalIdList,
+            amountTrackerIdList: x.amountTrackerIdList,
+            challengeTrackerIdList: x.challengeTrackerIdList,
+        };
+        return result;
+    });
+    const err = permissions_1.CollectionApprovalPermission.check(details, canUpdateCollectionApprovals);
+    if (err) {
+        return err;
+    }
+    return null;
+}
+exports.validateCollectionApprovalsUpdate = validateCollectionApprovalsUpdate;
+function expandCollectionApprovals(approvals) {
+    const newCurrApprovals = [];
+    for (const approval of approvals) {
+        const badgeIds = (0, overlaps_1.GetUintRangesWithOptions)(approval.badgeIds, true);
+        const ownershipTimes = (0, overlaps_1.GetUintRangesWithOptions)(approval.ownershipTimes, true);
+        const times = (0, overlaps_1.GetUintRangesWithOptions)(approval.transferTimes, true);
+        const toListId = (0, overlaps_1.GetListIdWithOptions)(approval.toListId, true);
+        const fromListId = (0, overlaps_1.GetListIdWithOptions)(approval.fromListId, true);
+        const initiatedByListId = (0, overlaps_1.GetListIdWithOptions)(approval.initiatedByListId, true);
+        const toList = (0, overlaps_1.GetListWithOptions)(approval.toList, true);
+        const fromList = (0, overlaps_1.GetListWithOptions)(approval.fromList, true);
+        const initiatedByList = (0, overlaps_1.GetListWithOptions)(approval.initiatedByList, true);
+        newCurrApprovals.push(new CollectionApprovalWithDetails({
+            ...approval,
+            toListId: toListId,
+            fromListId: fromListId,
+            initiatedByListId: initiatedByListId,
+            transferTimes: times,
+            badgeIds: badgeIds,
+            ownershipTimes: ownershipTimes,
+            toList: toList,
+            fromList: fromList,
+            initiatedByList: initiatedByList,
+            approvalCriteria: approval.approvalCriteria,
+            approvalId: approval.approvalId,
+            amountTrackerId: approval.amountTrackerId,
+            challengeTrackerId: approval.challengeTrackerId,
+        }));
+    }
+    return newCurrApprovals;
+}
+exports.expandCollectionApprovals = expandCollectionApprovals;
+//# sourceMappingURL=approvals.js.map