bitbadgesjs-sdk 0.1.3 → 0.1.4

package/dist/types/badges/typeUtils.js

@@ -1,1342 +0,0 @@
-"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 UintRange.convertFromProto(proto.badges.UintRange.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UintRange.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) {
-        if (uintRanges.length === 0) {
-            return [];
-        }
-        uintRanges = uintRanges.map(x => x.convert((0, base_1.getConverterFunction)(x.start)));
-        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 deepCopy(ranges) {
-        const newRanges = [];
-        for (let i = 0; i < ranges.length; i++) {
-            const rangeObject = ranges[i];
-            newRanges.push(UintRange.createUintRange(rangeObject.start, rangeObject.end));
-        }
-        return newRanges;
-    }
-    static searchForId(id, uintRanges) {
-        let ranges = UintRange.deepCopy(uintRanges);
-        ranges = UintRange.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, _] = UintRange.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] = UintRange.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] = UintRange.removeUintRangeFromUintRange(newAllowedTime, oldAllowedTime);
-                if (removed.length > 0) {
-                    throw new Error("RangesOverlap");
-                }
-            }
-        }
-    }
-    static hasOverlaps(uintRanges) {
-        try {
-            UintRange.assertRangesDoNotOverlapAtAll(uintRanges, uintRanges);
-            return false;
-        }
-        catch (e) {
-            return true;
-        }
-    }
-    static isFull(uintRanges) {
-        uintRanges = UintRange.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 BadgeMetadata.convertFromProto(proto.badges.BadgeMetadata.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BadgeMetadata.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 CollectionMetadata.convertFromProto(proto.badges.CollectionMetadata.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionMetadata.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 OffChainBalancesMetadata.convertFromProto(proto.badges.OffChainBalancesMetadata.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return OffChainBalancesMetadata.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));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return MustOwnBadges.convertFromProto(proto.badges.MustOwnBadges.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return MustOwnBadges.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));
-    }
-    static deepCopyBalances(balances) {
-        return balances.map((b) => {
-            return new Balance({
-                amount: b.amount,
-                badgeIds: b.badgeIds.map((b) => { return { start: (0, base_1.deepCopy)(b.start), end: (0, base_1.deepCopy)(b.end) }; }),
-                ownershipTimes: b.ownershipTimes.map((b) => { return { start: (0, base_1.deepCopy)(b.start), end: (0, base_1.deepCopy)(b.end) }; })
-            });
-        });
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return Balance.convertFromProto(proto.badges.Balance.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return Balance.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 AddressList.convertFromProto(proto.badges.AddressList.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return AddressList.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 Transfer.convertFromProto(proto.badges.Transfer.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return Transfer.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 ApprovalIdentifierDetails.convertFromProto(proto.badges.ApprovalIdentifierDetails.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return ApprovalIdentifierDetails.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;
-    }
-    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
-        }));
-    }
-}
-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));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return MerkleChallenge.convertFromProto(proto.badges.MerkleChallenge.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return MerkleChallenge.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 MerklePathItem.convertFromProto(proto.badges.MerklePathItem.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return MerklePathItem.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 MerkleProof.convertFromProto(proto.badges.MerkleProof.fromJson(jsonValue, options));
-    }
-    static fromJsonString(jsonString, options) {
-        return MerkleProof.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 ManagerTimeline.convertFromProto(proto.badges.ManagerTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ManagerTimeline.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 CollectionMetadataTimeline.convertFromProto(proto.badges.CollectionMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionMetadataTimeline.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 BadgeMetadataTimeline.convertFromProto(proto.badges.BadgeMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return BadgeMetadataTimeline.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 OffChainBalancesMetadataTimeline.convertFromProto(proto.badges.OffChainBalancesMetadataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return OffChainBalancesMetadataTimeline.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 CustomDataTimeline.convertFromProto(proto.badges.CustomDataTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CustomDataTimeline.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 StandardsTimeline.convertFromProto(proto.badges.StandardsTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return StandardsTimeline.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 IsArchivedTimeline.convertFromProto(proto.badges.IsArchivedTimeline.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return IsArchivedTimeline.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