bitbadgesjs-sdk 0.0.7 → 0.1.1

package/dist/types/badges/typeUtils.js

@@ -0,0 +1,1376 @@
+"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.AllDefaultValues = exports.IsArchivedTimeline = exports.StandardsTimeline = exports.CustomDataTimeline = exports.OffChainBalancesMetadataTimeline = exports.BadgeMetadataTimeline = exports.CollectionMetadataTimeline = exports.ManagerTimeline = exports.TimelineItem = exports.MerkleProof = exports.MerklePathItem = exports.MerkleChallenge = exports.AmountTrackerIdDetails = exports.ApprovalIdentifierDetails = exports.Transfer = exports.AddressList = exports.Balance = exports.MustOwnBadges = exports.OffChainBalancesMetadata = exports.CollectionMetadata = exports.BadgeMetadata = exports.UintRange = void 0;
+const string_numbers_1 = require("../string-numbers");
+const base_1 = require("../base");
+const proto = __importStar(require("../../proto"));
+const math_1 = require("../math");
+const converter_1 = require("../../utils/converter");
+class UintRange extends base_1.BaseNumberTypeClass {
+    start;
+    end;
+    constructor(uintRange) {
+        super();
+        this.start = uintRange.start;
+        this.end = uintRange.end;
+    }
+    convert(convertFunction) {
+        return new UintRange((0, base_1.deepCopy)({
+            start: convertFunction(this.start),
+            end: convertFunction(this.end)
+        }));
+    }
+    toProto() {
+        return new proto.badges.UintRange(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.UintRange.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.UintRange.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new UintRange({
+            start: convertFunction(BigInt(item.start)),
+            end: convertFunction(BigInt(item.end))
+        });
+    }
+    size() {
+        const diff = (0, math_1.safeSubtractUints)(this.end, this.start);
+        return (0, math_1.safeAddKeepLeft)(diff, 1);
+    }
+    isFull() {
+        return BigInt(this.start) == 1n && BigInt(this.end) == math_1.GO_MAX_UINT_64;
+    }
+    static FullRange() {
+        return new UintRange({
+            start: 1n,
+            end: math_1.GO_MAX_UINT_64
+        });
+    }
+    static From(val) {
+        return new UintRange({
+            start: val,
+            end: val
+        });
+    }
+    overlaps(other) {
+        const otherArr = Array.isArray(other) ? other : [other];
+        try {
+            UintRange.assertRangesDoNotOverlapAtAll([this.convert(string_numbers_1.BigIntify)], [...otherArr.map((o) => o.convert(string_numbers_1.BigIntify))]);
+        }
+        catch (e) {
+            return true;
+        }
+        return false;
+    }
+    invert(minId = 1n, maxId = math_1.GO_MAX_UINT_64) {
+        const converterFunction = (0, base_1.getConverterFunction)(this.start);
+        const bounds = new UintRange({ start: minId, end: maxId }).convert(converterFunction);
+        return UintRange.invert([
+            new UintRange({ start: this.start, end: this.end })
+        ], bounds);
+    }
+    includes(id) {
+        return this.start <= id && this.end >= id;
+    }
+    static sortAndMerge(uintRanges) {
+        uintRanges = uintRanges.map(base_1.deepCopy);
+        if (uintRanges.length <= 1) {
+            return uintRanges;
+        }
+        for (let i = 1; i < uintRanges.length; i++) {
+            const uintRange = uintRanges[i];
+            let j = i - 1;
+            while (j >= 0 && uintRanges[j].start > uintRange.start) {
+                uintRanges[j + 1] = uintRanges[j];
+                j--;
+            }
+            uintRanges[j + 1] = uintRange;
+        }
+        const mergedRanges = [];
+        let currRange = uintRanges[0];
+        for (let i = 1; i < uintRanges.length; i++) {
+            const range = uintRanges[i];
+            if (BigInt(range.start) <= BigInt(currRange.end) + 1n) {
+                if (BigInt(range.end) > BigInt(currRange.end)) {
+                    currRange.end = range.end;
+                }
+            }
+            else {
+                mergedRanges.push(currRange);
+                currRange = range;
+            }
+        }
+        mergedRanges.push(currRange);
+        return mergedRanges;
+    }
+    static createUintRange(start, end) {
+        return new UintRange({
+            start: (0, base_1.deepCopy)(start),
+            end: (0, base_1.deepCopy)(end)
+        });
+    }
+    static deepCopyRanges(ranges) {
+        const newRanges = [];
+        for (let i = 0; i < ranges.length; i++) {
+            const rangeObject = ranges[i];
+            newRanges.push(this.createUintRange(rangeObject.start, rangeObject.end));
+        }
+        return newRanges;
+    }
+    static searchForId(id, uintRanges) {
+        let ranges = this.deepCopyRanges(uintRanges);
+        ranges = this.sortAndMerge(ranges);
+        let low = 0;
+        let high = ranges.length - 1;
+        while (low <= high) {
+            const median = Math.floor((low + high) / 2);
+            const currRange = ranges[median];
+            if (currRange.includes(id)) {
+                return [BigInt(median), true];
+            }
+            else if (currRange.start > id) {
+                high = median - 1;
+            }
+            else {
+                low = median + 1;
+            }
+        }
+        return [BigInt(-1), false];
+    }
+    static invert(uintRanges, bounds) {
+        let ranges = [bounds];
+        for (let i = 0; i < uintRanges.length; i++) {
+            const uintRange = uintRanges[i];
+            let newRanges = [];
+            for (let j = 0; j < ranges.length; j++) {
+                const rangeObject = ranges[j];
+                const [rangesAfterRemoval, _] = this.removeUintRangeFromUintRange(uintRange, rangeObject);
+                newRanges = newRanges.concat(rangesAfterRemoval);
+            }
+            ranges = newRanges;
+        }
+        return ranges;
+    }
+    static removeUintRangeFromUintRange(idxsToRemove, rangeObject) {
+        if (idxsToRemove.end < rangeObject.start || idxsToRemove.start > rangeObject.end) {
+            return [[rangeObject], []];
+        }
+        const newRanges = [];
+        let removedRanges = [];
+        if (idxsToRemove.start <= rangeObject.start && idxsToRemove.end >= rangeObject.end) {
+            return [newRanges, [rangeObject]];
+        }
+        if (idxsToRemove.start > rangeObject.start) {
+            newRanges.push(new UintRange({
+                start: rangeObject.start,
+                end: (0, math_1.safeSubtractKeepLeft)(idxsToRemove.start, 1n)
+            }));
+            const minEnd = (0, math_1.bigIntMin)(BigInt(idxsToRemove.end), BigInt(rangeObject.end));
+            removedRanges.push(new UintRange({
+                start: idxsToRemove.start,
+                end: (0, math_1.matchTypes)(idxsToRemove.end, minEnd)
+            }));
+        }
+        if (idxsToRemove.end < rangeObject.end) {
+            newRanges.push(new UintRange({
+                start: (0, math_1.safeAddKeepLeft)(idxsToRemove.end, 1n),
+                end: rangeObject.end
+            }));
+            const maxStart = (0, math_1.bigIntMax)(BigInt(idxsToRemove.start), BigInt(rangeObject.start));
+            removedRanges.push(new UintRange({
+                start: (0, math_1.matchTypes)(idxsToRemove.start, maxStart),
+                end: idxsToRemove.end
+            }));
+        }
+        if (idxsToRemove.end < rangeObject.end && idxsToRemove.start > rangeObject.start) {
+            removedRanges = [idxsToRemove];
+        }
+        return [newRanges, removedRanges];
+    }
+    static removeUintRangesFromUintRanges(idsToRemove, rangeToRemoveFrom) {
+        if (idsToRemove.length === 0) {
+            return [rangeToRemoveFrom, []];
+        }
+        let removedRanges = [];
+        for (let i = 0; i < idsToRemove.length; i++) {
+            const handledValue = idsToRemove[i];
+            let newRanges = [];
+            for (let j = 0; j < rangeToRemoveFrom.length; j++) {
+                const oldPermittedTime = rangeToRemoveFrom[j];
+                const [rangesAfterRemoval, removed] = this.removeUintRangeFromUintRange(handledValue, oldPermittedTime);
+                newRanges = newRanges.concat(rangesAfterRemoval);
+                removedRanges = removedRanges.concat(removed);
+            }
+            rangeToRemoveFrom = newRanges;
+        }
+        return [rangeToRemoveFrom, removedRanges];
+    }
+    static assertRangesDoNotOverlapAtAll(rangeToCheck, overlappingRange) {
+        for (let i = 0; i < rangeToCheck.length; i++) {
+            const oldAllowedTime = rangeToCheck[i];
+            for (let j = 0; j < overlappingRange.length; j++) {
+                const newAllowedTime = overlappingRange[j];
+                const [, removed] = this.removeUintRangeFromUintRange(newAllowedTime, oldAllowedTime);
+                if (removed.length > 0) {
+                    throw new Error("RangesOverlap");
+                }
+            }
+        }
+    }
+    static hasOverlaps(uintRanges) {
+        try {
+            this.assertRangesDoNotOverlapAtAll(uintRanges, uintRanges);
+            return false;
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    static isFull(uintRanges) {
+        uintRanges = this.sortAndMerge(uintRanges);
+        return uintRanges.length == 1 && uintRanges[0].isFull();
+    }
+    static getTotalNumberOfBadgeIds = (badgeIds) => {
+        let sum = 0n;
+        for (const range of badgeIds) {
+            sum = (0, math_1.safeAddKeepLeft)(range.size(), sum);
+        }
+        return sum;
+    };
+}
+exports.UintRange = UintRange;
+class BadgeMetadata extends base_1.BaseNumberTypeClass {
+    uri;
+    badgeIds;
+    customData;
+    constructor(badgeMetadata) {
+        super();
+        this.uri = badgeMetadata.uri;
+        this.badgeIds = badgeMetadata.badgeIds.map((b) => new UintRange(b));
+        this.customData = badgeMetadata.customData;
+    }
+    static required() {
+        return new BadgeMetadata({
+            uri: '',
+            badgeIds: [],
+            customData: ''
+        });
+    }
+    convert(convertFunction) {
+        return new BadgeMetadata((0, base_1.deepCopy)({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new proto.badges.BadgeMetadata({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.toProto()),
+            customData: this.customData
+        });
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.BadgeMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.BadgeMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new BadgeMetadata({
+            uri: item.uri,
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            customData: item.customData
+        });
+    }
+}
+exports.BadgeMetadata = BadgeMetadata;
+class CollectionMetadata extends base_1.CustomTypeClass {
+    uri;
+    customData;
+    constructor(collectionMetadata) {
+        super();
+        this.uri = collectionMetadata.uri;
+        this.customData = collectionMetadata.customData;
+    }
+    static required() {
+        return new CollectionMetadata({
+            uri: '',
+            customData: ''
+        });
+    }
+    toProto() {
+        return new proto.badges.CollectionMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    clone() {
+        return new CollectionMetadata({ uri: this.uri, customData: this.customData });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CollectionMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CollectionMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new CollectionMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.CollectionMetadata = CollectionMetadata;
+class OffChainBalancesMetadata extends base_1.CustomTypeClass {
+    uri;
+    customData;
+    constructor(offChainBalancesMetadata) {
+        super();
+        this.uri = offChainBalancesMetadata.uri;
+        this.customData = offChainBalancesMetadata.customData;
+    }
+    static required() {
+        return new OffChainBalancesMetadata({
+            uri: '',
+            customData: ''
+        });
+    }
+    toProto() {
+        return new proto.badges.OffChainBalancesMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    clone() {
+        return new OffChainBalancesMetadata({ uri: this.uri, customData: this.customData });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.OffChainBalancesMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.OffChainBalancesMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new OffChainBalancesMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.OffChainBalancesMetadata = OffChainBalancesMetadata;
+class MustOwnBadges extends base_1.BaseNumberTypeClass {
+    collectionId;
+    amountRange;
+    ownershipTimes;
+    badgeIds;
+    overrideWithCurrentTime;
+    mustSatisfyForAllAssets;
+    constructor(mustOwn) {
+        super();
+        this.collectionId = mustOwn.collectionId;
+        this.amountRange = new UintRange(mustOwn.amountRange);
+        this.ownershipTimes = mustOwn.ownershipTimes.map((b) => new UintRange(b));
+        this.badgeIds = mustOwn.badgeIds.map((b) => new UintRange(b));
+        this.overrideWithCurrentTime = mustOwn.overrideWithCurrentTime;
+        this.mustSatisfyForAllAssets = mustOwn.mustSatisfyForAllAssets;
+    }
+    convert(convertFunction) {
+        return new MustOwnBadges((0, base_1.deepCopy)({
+            collectionId: convertFunction(this.collectionId),
+            amountRange: this.amountRange.convert(convertFunction),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            overrideWithCurrentTime: this.overrideWithCurrentTime,
+            mustSatisfyForAllAssets: this.mustSatisfyForAllAssets
+        }));
+    }
+    toProto() {
+        return new proto.badges.MustOwnBadges(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, base_1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.MustOwnBadges.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.MustOwnBadges.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (!item.amountRange) {
+            throw new Error('amountRange is required');
+        }
+        return new MustOwnBadges({
+            collectionId: convertFunction(BigInt(item.collectionId)),
+            amountRange: UintRange.convertFromProto(item.amountRange, convertFunction),
+            ownershipTimes: item.ownershipTimes.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            overrideWithCurrentTime: item.overrideWithCurrentTime,
+            mustSatisfyForAllAssets: item.mustSatisfyForAllAssets
+        });
+    }
+}
+exports.MustOwnBadges = MustOwnBadges;
+class Balance extends base_1.BaseNumberTypeClass {
+    amount;
+    badgeIds;
+    ownershipTimes;
+    constructor(balance) {
+        super();
+        this.amount = balance.amount;
+        this.badgeIds = balance.badgeIds.map((b) => new UintRange(b));
+        this.ownershipTimes = balance.ownershipTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new Balance({
+            amount: 0,
+            badgeIds: [],
+            ownershipTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new Balance((0, base_1.deepCopy)({
+            amount: convertFunction(this.amount),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.Balance(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, base_1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.Balance.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.Balance.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new Balance({
+            amount: convertFunction(BigInt(item.amount)),
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.Balance = Balance;
+class AddressList extends base_1.CustomTypeClass {
+    listId;
+    addresses;
+    whitelist;
+    uri;
+    customData;
+    createdBy;
+    aliasAddress;
+    constructor(addressList) {
+        super();
+        this.listId = addressList.listId;
+        this.addresses = addressList.addresses;
+        this.whitelist = addressList.whitelist;
+        this.uri = addressList.uri;
+        this.customData = addressList.customData;
+        this.createdBy = addressList.createdBy;
+        this.aliasAddress = addressList.aliasAddress;
+    }
+    static required() {
+        return new AddressList({
+            listId: '',
+            addresses: [],
+            whitelist: false,
+            uri: '',
+            customData: ''
+        });
+    }
+    addDefaults() {
+        this.createdBy = this.createdBy ? this.createdBy : '';
+        this.aliasAddress = this.aliasAddress ? this.aliasAddress : '';
+    }
+    toProto() {
+        return new proto.badges.AddressList(this.clone().toJson());
+    }
+    clone() {
+        return new AddressList({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(proto.badges.AddressList.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(proto.badges.AddressList.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new AddressList({ ...item });
+    }
+    checkAddress(address) {
+        let found = this.addresses.includes(address);
+        if (!this.whitelist) {
+            found = !found;
+        }
+        return found;
+    }
+    isEmpty() {
+        return this.addresses.length === 0 && this.whitelist;
+    }
+    invert() {
+        this.whitelist = !this.whitelist;
+    }
+    removeAddress(address) {
+        const addressListToRemove = new AddressList({
+            listId: '',
+            addresses: [address],
+            whitelist: true,
+            uri: '',
+            customData: '',
+            createdBy: '',
+        });
+        const [remaining] = AddressList.removeAddressListFromAddressList(addressListToRemove, this);
+        this.addresses = remaining.addresses;
+        this.whitelist = remaining.whitelist;
+    }
+    removeAddressList(addressListToRemove) {
+        const [remaining] = AddressList.removeAddressListFromAddressList(addressListToRemove, this);
+        this.addresses = remaining.addresses;
+        this.whitelist = remaining.whitelist;
+    }
+    getOverlappingAddresses(addressList) {
+        const [, removed] = AddressList.removeAddressListFromAddressList(addressList, this);
+        return removed;
+    }
+    static AllAddresses() {
+        return AddressList.getReservedAddressList('All');
+    }
+    static removeAddressListFromAddressList(addressesToRemove, addressList) {
+        const duplicates = [];
+        const inToRemoveButNotList = [];
+        const inListButNotToRemove = [];
+        for (const address of addressesToRemove.addresses) {
+            const found = addressList.addresses.includes(address);
+            if (found) {
+                duplicates.push(address);
+            }
+            else {
+                inToRemoveButNotList.push(address);
+            }
+        }
+        for (const address of addressList.addresses) {
+            const found = addressesToRemove.addresses.includes(address);
+            if (!found) {
+                inListButNotToRemove.push(address);
+            }
+        }
+        const removed = new AddressList({
+            addresses: [],
+            whitelist: false,
+            listId: '',
+            uri: '',
+            customData: '',
+            createdBy: '',
+        });
+        const remaining = new AddressList({
+            addresses: [],
+            whitelist: false,
+            listId: '',
+            uri: '',
+            customData: '',
+            createdBy: '',
+        });
+        if (addressesToRemove.whitelist && addressList.whitelist) {
+            removed.whitelist = true;
+            removed.addresses = duplicates;
+            remaining.whitelist = true;
+            remaining.addresses = inListButNotToRemove;
+        }
+        else if (!addressesToRemove.whitelist &&
+            addressList.whitelist) {
+            removed.whitelist = true;
+            removed.addresses = inListButNotToRemove;
+            remaining.whitelist = true;
+            remaining.addresses = duplicates;
+        }
+        else if (addressesToRemove.whitelist &&
+            !addressList.whitelist) {
+            removed.whitelist = true;
+            removed.addresses = inToRemoveButNotList;
+            remaining.whitelist = false;
+            remaining.addresses = [
+                ...inListButNotToRemove,
+                ...inToRemoveButNotList,
+                ...duplicates,
+            ];
+        }
+        else if (!addressesToRemove.whitelist &&
+            !addressList.whitelist) {
+            removed.whitelist = false;
+            removed.addresses = [
+                ...inListButNotToRemove,
+                ...inToRemoveButNotList,
+                ...duplicates,
+            ];
+            remaining.whitelist = true;
+            remaining.addresses = inToRemoveButNotList;
+        }
+        return [remaining, removed];
+    }
+    static getReservedTrackerList(trackerListId) {
+        return AddressList.getReservedList(trackerListId, true);
+    }
+    static getReservedAddressList(addressListId) {
+        return AddressList.getReservedList(addressListId);
+    }
+    static getReservedList(addressListId, allowAliases) {
+        let inverted = false;
+        let addressList = undefined;
+        const addressListIdCopy = addressListId;
+        if (addressListId[0] === '!' && !addressListId.startsWith('!(')) {
+            inverted = true;
+            addressListId = addressListId.slice(1);
+        }
+        else if (addressListId.startsWith('!(') && addressListId.endsWith(')')) {
+            inverted = true;
+            addressListId = addressListId.slice(2, -1);
+        }
+        if (addressListId === 'Mint') {
+            addressList = new AddressList({
+                listId: 'Mint',
+                addresses: ['Mint'],
+                whitelist: true,
+                uri: '',
+                customData: '',
+                createdBy: '',
+            });
+        }
+        else if (addressListId.startsWith('AllWithout')) {
+            addressList = new AddressList({
+                listId: addressListId,
+                addresses: [],
+                whitelist: false,
+                uri: '',
+                customData: '',
+                createdBy: '',
+            });
+            const addresses = addressListId.slice(10).split(':');
+            for (const address of addresses) {
+                addressList.addresses.push(address);
+            }
+        }
+        else if (addressListId === 'AllWithMint' || addressListId === 'All') {
+            addressList = new AddressList({
+                listId: addressListId,
+                addresses: [],
+                whitelist: false,
+                uri: '',
+                customData: '',
+                createdBy: '',
+            });
+        }
+        else if (addressListId === 'None') {
+            addressList = new AddressList({
+                listId: 'None',
+                addresses: [],
+                whitelist: true,
+                uri: '',
+                customData: '',
+                createdBy: '',
+            });
+        }
+        else {
+            const addressesToCheck = addressListId.split(':');
+            let allAreValid = true;
+            if (!allowAliases) {
+                for (const address of addressesToCheck) {
+                    if (address != 'Mint' && !(0, converter_1.convertToCosmosAddress)(address)) {
+                        allAreValid = false;
+                    }
+                }
+            }
+            if (allAreValid) {
+                addressList = new AddressList({
+                    listId: addressListId,
+                    addresses: addressesToCheck,
+                    whitelist: true,
+                    uri: '',
+                    customData: '',
+                    createdBy: '',
+                });
+            }
+        }
+        if (inverted && addressList) {
+            addressList.whitelist = !addressList.whitelist;
+        }
+        if (!addressList) {
+            throw new Error(`Invalid address list ID: ${addressListId}`);
+        }
+        return new AddressList({
+            ...addressList,
+            listId: addressListIdCopy,
+        });
+    }
+    static generateReservedListId = (addressList) => {
+        let listId = '';
+        if (addressList.whitelist) {
+            if (addressList.addresses.length > 0) {
+                const addresses = addressList.addresses
+                    .map((x) => ((0, converter_1.isAddressValid)(x) ? (0, converter_1.convertToCosmosAddress)(x) : x))
+                    .join(':');
+                listId = `${addresses}`;
+            }
+            else {
+                listId = 'None';
+            }
+        }
+        else {
+            if (addressList.addresses.length > 0) {
+                const addresses = addressList.addresses
+                    .map((x) => ((0, converter_1.isAddressValid)(x) ? (0, converter_1.convertToCosmosAddress)(x) : x))
+                    .join(':');
+                listId = `!(${addresses})`;
+            }
+            else {
+                listId = 'All';
+            }
+        }
+        return listId;
+    };
+}
+exports.AddressList = AddressList;
+class Transfer extends base_1.BaseNumberTypeClass {
+    from;
+    toAddresses;
+    balances;
+    precalculateBalancesFromApproval;
+    merkleProofs;
+    memo;
+    prioritizedApprovals;
+    onlyCheckPrioritizedApprovals;
+    constructor(transfer) {
+        super();
+        this.from = transfer.from;
+        this.toAddresses = transfer.toAddresses;
+        this.balances = transfer.balances;
+        this.precalculateBalancesFromApproval = transfer.precalculateBalancesFromApproval;
+        this.merkleProofs = transfer.merkleProofs;
+        this.memo = transfer.memo;
+        this.prioritizedApprovals = transfer.prioritizedApprovals;
+        this.onlyCheckPrioritizedApprovals = transfer.onlyCheckPrioritizedApprovals;
+    }
+    static required() {
+        return new Transfer({
+            from: '',
+            toAddresses: [],
+            balances: [],
+            precalculateBalancesFromApproval: ApprovalIdentifierDetails.required(),
+            merkleProofs: [],
+            memo: '',
+            prioritizedApprovals: [],
+            onlyCheckPrioritizedApprovals: false
+        });
+    }
+    addDefaults() {
+        this.precalculateBalancesFromApproval = this.precalculateBalancesFromApproval ? this.precalculateBalancesFromApproval : ApprovalIdentifierDetails.required();
+        this.merkleProofs = this.merkleProofs ? this.merkleProofs : [];
+        this.memo = this.memo ? this.memo : '';
+        this.prioritizedApprovals = this.prioritizedApprovals ? this.prioritizedApprovals : [];
+        this.onlyCheckPrioritizedApprovals = this.onlyCheckPrioritizedApprovals ? this.onlyCheckPrioritizedApprovals : false;
+    }
+    convert(convertFunction) {
+        return new Transfer((0, base_1.deepCopy)({
+            from: this.from,
+            toAddresses: this.toAddresses,
+            balances: this.balances.map((b) => b.convert(convertFunction)),
+            precalculateBalancesFromApproval: this.precalculateBalancesFromApproval ? this.precalculateBalancesFromApproval : undefined,
+            merkleProofs: this.merkleProofs ? this.merkleProofs : undefined,
+            memo: this.memo ? this.memo : undefined,
+            prioritizedApprovals: this.prioritizedApprovals ? this.prioritizedApprovals : undefined,
+            onlyCheckPrioritizedApprovals: this.onlyCheckPrioritizedApprovals ? this.onlyCheckPrioritizedApprovals : undefined
+        }));
+    }
+    toProto() {
+        return new proto.badges.Transfer(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, base_1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.Transfer.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.Transfer.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new Transfer({
+            from: item.from,
+            toAddresses: item.toAddresses,
+            balances: item.balances.map((b) => Balance.convertFromProto(b, convertFunction)),
+            precalculateBalancesFromApproval: item.precalculateBalancesFromApproval ? ApprovalIdentifierDetails.convertFromProto(item.precalculateBalancesFromApproval) : undefined,
+            merkleProofs: item.merkleProofs ? item.merkleProofs.map((b) => MerkleProof.convertFromProto(b)) : undefined,
+            memo: item.memo ? item.memo : undefined,
+            prioritizedApprovals: item.prioritizedApprovals ? item.prioritizedApprovals.map((b) => ApprovalIdentifierDetails.convertFromProto(b)) : undefined,
+            onlyCheckPrioritizedApprovals: item.onlyCheckPrioritizedApprovals ? item.onlyCheckPrioritizedApprovals : undefined
+        });
+    }
+}
+exports.Transfer = Transfer;
+class ApprovalIdentifierDetails extends base_1.CustomTypeClass {
+    approvalId;
+    approvalLevel;
+    approverAddress;
+    constructor(approvalIdDetails) {
+        super();
+        this.approvalId = approvalIdDetails.approvalId;
+        this.approvalLevel = approvalIdDetails.approvalLevel;
+        this.approverAddress = approvalIdDetails.approverAddress;
+    }
+    static required() {
+        return new ApprovalIdentifierDetails({
+            approvalId: '',
+            approvalLevel: '',
+            approverAddress: ''
+        });
+    }
+    toProto() {
+        return new proto.badges.ApprovalIdentifierDetails(this.clone().toJson());
+    }
+    clone() {
+        return new ApprovalIdentifierDetails({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(proto.badges.ApprovalIdentifierDetails.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(proto.badges.ApprovalIdentifierDetails.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new ApprovalIdentifierDetails({ ...item });
+    }
+}
+exports.ApprovalIdentifierDetails = ApprovalIdentifierDetails;
+class AmountTrackerIdDetails extends base_1.BaseNumberTypeClass {
+    collectionId;
+    amountTrackerId;
+    approvalLevel;
+    approverAddress;
+    trackerType;
+    approvedAddress;
+    constructor(approvalIdDetails) {
+        super();
+        this.collectionId = approvalIdDetails.collectionId;
+        this.amountTrackerId = approvalIdDetails.amountTrackerId;
+        this.approvalLevel = approvalIdDetails.approvalLevel;
+        this.approverAddress = approvalIdDetails.approverAddress;
+        this.trackerType = approvalIdDetails.trackerType;
+        this.approvedAddress = approvalIdDetails.approvedAddress;
+    }
+    static required() {
+        return new AmountTrackerIdDetails({
+            collectionId: 0,
+            amountTrackerId: '',
+            approvalLevel: '',
+            approverAddress: '',
+            trackerType: '',
+            approvedAddress: ''
+        });
+    }
+    convert(convertFunction) {
+        return new AmountTrackerIdDetails((0, base_1.deepCopy)({
+            collectionId: convertFunction(this.collectionId),
+            amountTrackerId: this.amountTrackerId,
+            approvalLevel: this.approvalLevel,
+            approverAddress: this.approverAddress,
+            trackerType: this.trackerType,
+            approvedAddress: this.approvedAddress
+        }));
+    }
+    toJson() {
+        return (0, base_1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+}
+exports.AmountTrackerIdDetails = AmountTrackerIdDetails;
+class MerkleChallenge extends base_1.BaseNumberTypeClass {
+    root;
+    expectedProofLength;
+    useCreatorAddressAsLeaf;
+    maxUsesPerLeaf;
+    uri;
+    customData;
+    constructor(merkleChallenge) {
+        super();
+        this.root = merkleChallenge.root;
+        this.expectedProofLength = merkleChallenge.expectedProofLength;
+        this.useCreatorAddressAsLeaf = merkleChallenge.useCreatorAddressAsLeaf;
+        this.maxUsesPerLeaf = merkleChallenge.maxUsesPerLeaf;
+        this.uri = merkleChallenge.uri;
+        this.customData = merkleChallenge.customData;
+    }
+    static required() {
+        return new MerkleChallenge({
+            root: '',
+            expectedProofLength: 0,
+            useCreatorAddressAsLeaf: false,
+            maxUsesPerLeaf: 0,
+            uri: '',
+            customData: ''
+        });
+    }
+    convert(convertFunction) {
+        return new MerkleChallenge((0, base_1.deepCopy)({
+            root: this.root,
+            expectedProofLength: convertFunction(this.expectedProofLength),
+            useCreatorAddressAsLeaf: this.useCreatorAddressAsLeaf,
+            maxUsesPerLeaf: convertFunction(this.maxUsesPerLeaf),
+            uri: this.uri,
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new proto.badges.MerkleChallenge(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, base_1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, base_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.MerkleChallenge.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.MerkleChallenge.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new MerkleChallenge({
+            root: item.root,
+            expectedProofLength: convertFunction(BigInt(item.expectedProofLength)),
+            useCreatorAddressAsLeaf: item.useCreatorAddressAsLeaf,
+            maxUsesPerLeaf: convertFunction(BigInt(item.maxUsesPerLeaf)),
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.MerkleChallenge = MerkleChallenge;
+class MerklePathItem extends base_1.CustomTypeClass {
+    aunt;
+    onRight;
+    constructor(merklePathItem) {
+        super();
+        this.aunt = merklePathItem.aunt;
+        this.onRight = merklePathItem.onRight;
+    }
+    static required() {
+        return new MerklePathItem({
+            aunt: '',
+            onRight: false
+        });
+    }
+    toProto() {
+        return new proto.badges.MerklePathItem(this.clone().toJson());
+    }
+    clone() {
+        return new MerklePathItem({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(proto.badges.MerklePathItem.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(proto.badges.MerklePathItem.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new MerklePathItem({ ...item });
+    }
+}
+exports.MerklePathItem = MerklePathItem;
+class MerkleProof extends base_1.CustomTypeClass {
+    aunts;
+    leaf;
+    constructor(merkleProof) {
+        super();
+        this.aunts = merkleProof.aunts;
+        this.leaf = merkleProof.leaf;
+    }
+    static required() {
+        return new MerkleProof({
+            aunts: [],
+            leaf: ''
+        });
+    }
+    toProto() {
+        return new proto.badges.MerkleProof(this.clone().toJson());
+    }
+    clone() {
+        return new MerkleProof({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(proto.badges.MerkleProof.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(proto.badges.MerkleProof.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new MerkleProof({
+            aunts: item.aunts.map((b) => MerklePathItem.convertFromProto(b)),
+            leaf: item.leaf
+        });
+    }
+}
+exports.MerkleProof = MerkleProof;
+class TimelineItem extends base_1.BaseNumberTypeClass {
+    timelineTimes;
+    constructor(timelineItem) {
+        super();
+        this.timelineTimes = timelineItem.timelineTimes.map((b) => new UintRange(b));
+    }
+    convert(convertFunction) {
+        return new TimelineItem((0, base_1.deepCopy)({
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+}
+exports.TimelineItem = TimelineItem;
+class ManagerTimeline extends base_1.BaseNumberTypeClass {
+    manager;
+    timelineTimes;
+    constructor(managerTimeline) {
+        super();
+        this.manager = managerTimeline.manager;
+        this.timelineTimes = managerTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new ManagerTimeline({
+            manager: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new ManagerTimeline((0, base_1.deepCopy)({
+            manager: this.manager,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.ManagerTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.ManagerTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.ManagerTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new ManagerTimeline({
+            manager: item.manager,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.ManagerTimeline = ManagerTimeline;
+class CollectionMetadataTimeline extends base_1.BaseNumberTypeClass {
+    collectionMetadata;
+    timelineTimes;
+    constructor(collectionMetadataTimeline) {
+        super();
+        this.collectionMetadata = new CollectionMetadata(collectionMetadataTimeline.collectionMetadata);
+        this.timelineTimes = collectionMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new CollectionMetadataTimeline({
+            collectionMetadata: CollectionMetadata.required(),
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CollectionMetadataTimeline((0, base_1.deepCopy)({
+            collectionMetadata: this.collectionMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.CollectionMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CollectionMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CollectionMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (item.collectionMetadata === undefined) {
+            throw new Error('CollectionMetadataTimeline: invalid collectionMetadata');
+        }
+        return new CollectionMetadataTimeline({
+            collectionMetadata: CollectionMetadata.convertFromProto(item.collectionMetadata, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.CollectionMetadataTimeline = CollectionMetadataTimeline;
+class BadgeMetadataTimeline extends base_1.BaseNumberTypeClass {
+    badgeMetadata;
+    timelineTimes;
+    constructor(badgeMetadataTimeline) {
+        super();
+        this.timelineTimes = badgeMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+        this.badgeMetadata = badgeMetadataTimeline.badgeMetadata.map((b) => new BadgeMetadata(b));
+    }
+    static required() {
+        return new BadgeMetadataTimeline({
+            badgeMetadata: [],
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new BadgeMetadataTimeline((0, base_1.deepCopy)({
+            badgeMetadata: this.badgeMetadata.map((b) => b.convert(convertFunction)),
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.BadgeMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.BadgeMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.BadgeMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new BadgeMetadataTimeline({
+            badgeMetadata: item.badgeMetadata.map((b) => BadgeMetadata.convertFromProto(b, convertFunction)),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.BadgeMetadataTimeline = BadgeMetadataTimeline;
+class OffChainBalancesMetadataTimeline extends base_1.BaseNumberTypeClass {
+    offChainBalancesMetadata;
+    timelineTimes;
+    constructor(offChainBalancesMetadataTimeline) {
+        super();
+        this.offChainBalancesMetadata = new OffChainBalancesMetadata(offChainBalancesMetadataTimeline.offChainBalancesMetadata);
+        this.timelineTimes = offChainBalancesMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new OffChainBalancesMetadataTimeline({
+            offChainBalancesMetadata: OffChainBalancesMetadata.required(),
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new OffChainBalancesMetadataTimeline((0, base_1.deepCopy)({
+            offChainBalancesMetadata: this.offChainBalancesMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.OffChainBalancesMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.OffChainBalancesMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.OffChainBalancesMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (!item.offChainBalancesMetadata) {
+            throw new Error("OffChainBalancesMetadataTimeline: offChainBalancesMetadata is required");
+        }
+        return new OffChainBalancesMetadataTimeline({
+            offChainBalancesMetadata: OffChainBalancesMetadata.convertFromProto(item.offChainBalancesMetadata, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.OffChainBalancesMetadataTimeline = OffChainBalancesMetadataTimeline;
+class CustomDataTimeline extends base_1.BaseNumberTypeClass {
+    customData;
+    timelineTimes;
+    constructor(customDataTimeline) {
+        super();
+        this.customData = customDataTimeline.customData;
+        this.timelineTimes = customDataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new CustomDataTimeline({
+            customData: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CustomDataTimeline((0, base_1.deepCopy)({
+            customData: this.customData,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.CustomDataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CustomDataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.CustomDataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new CustomDataTimeline({
+            customData: item.customData,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.CustomDataTimeline = CustomDataTimeline;
+class StandardsTimeline extends base_1.BaseNumberTypeClass {
+    standards;
+    timelineTimes;
+    constructor(standardsTimeline) {
+        super();
+        this.standards = standardsTimeline.standards;
+        this.timelineTimes = standardsTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new StandardsTimeline({
+            standards: [],
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new StandardsTimeline((0, base_1.deepCopy)({
+            standards: this.standards,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.StandardsTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.StandardsTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.StandardsTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new StandardsTimeline({
+            standards: item.standards,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.StandardsTimeline = StandardsTimeline;
+class IsArchivedTimeline extends base_1.BaseNumberTypeClass {
+    isArchived;
+    timelineTimes;
+    constructor(isArchivedTimeline) {
+        super();
+        this.isArchived = isArchivedTimeline.isArchived;
+        this.timelineTimes = isArchivedTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new IsArchivedTimeline({
+            isArchived: false,
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new IsArchivedTimeline((0, base_1.deepCopy)({
+            isArchived: this.isArchived,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto.badges.IsArchivedTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto.badges.IsArchivedTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto.badges.IsArchivedTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new IsArchivedTimeline({
+            isArchived: item.isArchived,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.IsArchivedTimeline = IsArchivedTimeline;
+exports.AllDefaultValues = {
+    permanentlyPermittedTimes: [],
+    permanentlyForbiddenTimes: [],
+    badgeIds: [],
+    timelineTimes: [],
+    transferTimes: [],
+    ownershipTimes: [],
+    fromList: AddressList.AllAddresses(),
+    toList: AddressList.AllAddresses(),
+    initiatedByList: AddressList.AllAddresses(),
+    approvalIdList: AddressList.AllAddresses(),
+    amountTrackerIdList: AddressList.AllAddresses(),
+    challengeTrackerIdList: AddressList.AllAddresses(),
+    usesAmountTrackerIdList: false,
+    usesChallengeTrackerIdList: false,
+    usesApprovalIdList: false,
+    usesBadgeIds: false,
+    usesTimelineTimes: false,
+    usesTransferTimes: false,
+    usesToList: false,
+    usesFromList: false,
+    usesInitiatedByList: false,
+    usesOwnershipTimes: false,
+    arbitraryValue: undefined,
+};
+//# sourceMappingURL=typeUtils.js.map