@polkadot/types-create 9.14.2 → 10.1.1

package/create/class.js

@@ -1,183 +1,151 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@polkadot/types-codec';
 import { isNumber, stringify } from '@polkadot/util';
-import { TypeDefInfo } from "../types/index.js";
-import { getTypeDef } from "../util/getTypeDef.js";
-function getTypeDefType({
-  lookupName,
-  type
-}) {
-  return lookupName || type;
+import { TypeDefInfo } from '../types/index.js';
+import { getTypeDef } from '../util/getTypeDef.js';
+function getTypeDefType({ lookupName, type }) {
+    return lookupName || type;
 }
 function getSubDefArray(value) {
-  if (!Array.isArray(value.sub)) {
-    throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
-  }
-  return value.sub;
+    if (!Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
+    }
+    return value.sub;
 }
 function getSubDef(value) {
-  if (!value.sub || Array.isArray(value.sub)) {
-    throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
-  }
-  return value.sub;
+    if (!value.sub || Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
+    }
+    return value.sub;
 }
 function getSubType(value) {
-  return getTypeDefType(getSubDef(value));
+    return getTypeDefType(getSubDef(value));
 }
-
-// create a maps of type string CodecClasss from the input
 function getTypeClassMap(value) {
-  const subs = getSubDefArray(value);
-  const map = {};
-  for (let i = 0; i < subs.length; i++) {
-    map[subs[i].name] = getTypeDefType(subs[i]);
-  }
-  return map;
+    const subs = getSubDefArray(value);
+    const map = {};
+    for (let i = 0; i < subs.length; i++) {
+        map[subs[i].name] = getTypeDefType(subs[i]);
+    }
+    return map;
 }
-
-// create an array of type string CodecClasss from the input
 function getTypeClassArray(value) {
-  return getSubDefArray(value).map(getTypeDefType);
+    return getSubDefArray(value).map(getTypeDefType);
 }
-function createInt(Clazz, {
-  displayName,
-  length
-}) {
-  if (!isNumber(length)) {
-    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
-  }
-  return Clazz.with(length, displayName);
+function createInt(Clazz, { displayName, length }) {
+    if (!isNumber(length)) {
+        throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+    }
+    return Clazz.with(length, displayName);
 }
 function createHashMap(Clazz, value) {
-  const [keyType, valueType] = getTypeClassArray(value);
-  return Clazz.with(keyType, valueType);
+    const [keyType, valueType] = getTypeClassArray(value);
+    return Clazz.with(keyType, valueType);
 }
 function createWithSub(Clazz, value) {
-  return Clazz.with(getSubType(value));
+    return Clazz.with(getSubType(value));
 }
 const infoMapping = {
-  [TypeDefInfo.BTreeMap]: (registry, value) => createHashMap(BTreeMap, value),
-  [TypeDefInfo.BTreeSet]: (registry, value) => createWithSub(BTreeSet, value),
-  [TypeDefInfo.Compact]: (registry, value) => createWithSub(Compact, value),
-  [TypeDefInfo.DoNotConstruct]: (registry, value) => DoNotConstruct.with(value.displayName || value.type),
-  [TypeDefInfo.Enum]: (registry, value) => {
-    const subs = getSubDefArray(value);
-    return Enum.with(subs.every(({
-      type
-    }) => type === 'Null') ? subs.reduce((out, {
-      index,
-      name
-    }, count) => {
-      out[name] = index || count;
-      return out;
-    }, {}) : getTypeClassMap(value));
-  },
-  [TypeDefInfo.HashMap]: (registry, value) => createHashMap(HashMap, value),
-  [TypeDefInfo.Int]: (registry, value) => createInt(Int, value),
-  // We have circular deps between Linkage & Struct
-  [TypeDefInfo.Linkage]: (registry, value) => {
-    const type = `Option<${getSubType(value)}>`;
-    // eslint-disable-next-line sort-keys
-    const Clazz = Struct.with({
-      previous: type,
-      next: type
-    });
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    Clazz.prototype.toRawType = function () {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
-      return `Linkage<${this.next.toRawType(true)}>`;
-    };
-    return Clazz;
-  },
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Null]: (registry, _) => Null,
-  [TypeDefInfo.Option]: (registry, value) => {
-    if (!value.sub || Array.isArray(value.sub)) {
-      throw new Error('Expected type information for Option');
-    }
-
-    // NOTE This is opt-in (unhandled), not by default
-    // if (value.sub.type === 'bool') {
-    //   return OptionBool;
-    // }
-
-    return createWithSub(Option, value);
-  },
-  [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
-  [TypeDefInfo.Range]: (registry, value) => createWithSub(Range, value),
-  [TypeDefInfo.RangeInclusive]: (registry, value) => createWithSub(RangeInclusive, value),
-  [TypeDefInfo.Result]: (registry, value) => {
-    const [Ok, Err] = getTypeClassArray(value);
-
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return Result.with({
-      Err,
-      Ok
-    });
-  },
-  [TypeDefInfo.Set]: (registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, {
-    index,
-    name
-  }) => {
-    result[name] = index;
-    return result;
-  }, {}), value.length),
-  [TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
-  [TypeDefInfo.Struct]: (registry, value) => Struct.with(getTypeClassMap(value), value.alias),
-  [TypeDefInfo.Tuple]: (registry, value) => Tuple.with(getTypeClassArray(value)),
-  [TypeDefInfo.UInt]: (registry, value) => createInt(UInt, value),
-  [TypeDefInfo.Vec]: (registry, {
-    sub
-  }) => {
-    if (!sub || Array.isArray(sub)) {
-      throw new Error('Expected type information for vector');
-    }
-    return sub.type === 'u8' ? Bytes : Vec.with(getTypeDefType(sub));
-  },
-  [TypeDefInfo.VecFixed]: (registry, {
-    displayName,
-    length,
-    sub
-  }) => {
-    if (!isNumber(length) || !sub || Array.isArray(sub)) {
-      throw new Error('Expected length & type information for fixed vector');
-    }
-    return sub.type === 'u8' ? U8aFixed.with(length * 8, displayName) : VecFixed.with(getTypeDefType(sub), length);
-  },
-  [TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(WrapperKeepOpaque, value),
-  [TypeDefInfo.WrapperOpaque]: (registry, value) => createWithSub(WrapperOpaque, value)
+    [TypeDefInfo.BTreeMap]: (registry, value) => createHashMap(BTreeMap, value),
+    [TypeDefInfo.BTreeSet]: (registry, value) => createWithSub(BTreeSet, value),
+    [TypeDefInfo.Compact]: (registry, value) => createWithSub(Compact, value),
+    [TypeDefInfo.DoNotConstruct]: (registry, value) => DoNotConstruct.with(value.displayName || value.type),
+    [TypeDefInfo.Enum]: (registry, value) => {
+        const subs = getSubDefArray(value);
+        return Enum.with(subs.every(({ type }) => type === 'Null')
+            ? subs.reduce((out, { index, name }, count) => {
+                out[name] = index || count;
+                return out;
+            }, {})
+            : getTypeClassMap(value));
+    },
+    [TypeDefInfo.HashMap]: (registry, value) => createHashMap(HashMap, value),
+    [TypeDefInfo.Int]: (registry, value) => createInt(Int, value),
+    // We have circular deps between Linkage & Struct
+    [TypeDefInfo.Linkage]: (registry, value) => {
+        const type = `Option<${getSubType(value)}>`;
+        // eslint-disable-next-line sort-keys
+        const Clazz = Struct.with({ previous: type, next: type });
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        Clazz.prototype.toRawType = function () {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+            return `Linkage<${this.next.toRawType(true)}>`;
+        };
+        return Clazz;
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    [TypeDefInfo.Null]: (registry, _) => Null,
+    [TypeDefInfo.Option]: (registry, value) => {
+        if (!value.sub || Array.isArray(value.sub)) {
+            throw new Error('Expected type information for Option');
+        }
+        // NOTE This is opt-in (unhandled), not by default
+        // if (value.sub.type === 'bool') {
+        //   return OptionBool;
+        // }
+        return createWithSub(Option, value);
+    },
+    [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+    [TypeDefInfo.Range]: (registry, value) => createWithSub(Range, value),
+    [TypeDefInfo.RangeInclusive]: (registry, value) => createWithSub(RangeInclusive, value),
+    [TypeDefInfo.Result]: (registry, value) => {
+        const [Ok, Err] = getTypeClassArray(value);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return Result.with({ Err, Ok });
+    },
+    [TypeDefInfo.Set]: (registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
+        result[name] = index;
+        return result;
+    }, {}), value.length),
+    [TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
+    [TypeDefInfo.Struct]: (registry, value) => Struct.with(getTypeClassMap(value), value.alias),
+    [TypeDefInfo.Tuple]: (registry, value) => Tuple.with(getTypeClassArray(value)),
+    [TypeDefInfo.UInt]: (registry, value) => createInt(UInt, value),
+    [TypeDefInfo.Vec]: (registry, { sub }) => {
+        if (!sub || Array.isArray(sub)) {
+            throw new Error('Expected type information for vector');
+        }
+        return (sub.type === 'u8'
+            ? Bytes
+            : Vec.with(getTypeDefType(sub)));
+    },
+    [TypeDefInfo.VecFixed]: (registry, { displayName, length, sub }) => {
+        if (!isNumber(length) || !sub || Array.isArray(sub)) {
+            throw new Error('Expected length & type information for fixed vector');
+        }
+        return (sub.type === 'u8'
+            ? U8aFixed.with((length * 8), displayName)
+            : VecFixed.with(getTypeDefType(sub), length));
+    },
+    [TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(WrapperKeepOpaque, value),
+    [TypeDefInfo.WrapperOpaque]: (registry, value) => createWithSub(WrapperOpaque, value)
 };
 export function constructTypeClass(registry, typeDef) {
-  try {
-    const Type = infoMapping[typeDef.info](registry, typeDef);
-    if (!Type) {
-      throw new Error('No class created');
+    try {
+        const Type = infoMapping[typeDef.info](registry, typeDef);
+        if (!Type) {
+            throw new Error('No class created');
+        }
+        // don't clobber any existing
+        if (!Type.__fallbackType && typeDef.fallbackType) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore ...this is the only place we we actually assign this...
+            Type.__fallbackType = typeDef.fallbackType;
+        }
+        return Type;
     }
-
-    // don't clobber any existing
-    if (!Type.__fallbackType && typeDef.fallbackType) {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore ...this is the only place we we actually assign this...
-      Type.__fallbackType = typeDef.fallbackType;
+    catch (error) {
+        throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
     }
-    return Type;
-  } catch (error) {
-    throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
-  }
 }
-
-// Returns the type Class for construction
 export function getTypeClass(registry, typeDef) {
-  return registry.getUnsafe(typeDef.type, false, typeDef);
+    return registry.getUnsafe(typeDef.type, false, typeDef);
 }
 export function createClassUnsafe(registry, type) {
-  return (
+    return (
     // just retrieve via name, no creation via typeDef
     registry.getUnsafe(type) ||
-    // we don't have an existing type, create the class via typeDef
-    getTypeClass(registry, registry.isLookupType(type) ? registry.lookup.getTypeDef(type) : getTypeDef(type))
-  );
+        // we don't have an existing type, create the class via typeDef
+        getTypeClass(registry, registry.isLookupType(type)
+            ? registry.lookup.getTypeDef(type)
+            : getTypeDef(type)));
 }

package/create/index.d.ts

@@ -1,2 +1,2 @@
-export * from './class';
-export * from './type';
+export * from './class.js';
+export * from './type.js';

package/create/index.js

@@ -1,5 +1,2 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from "./class.js";
-export * from "./type.js";
+export * from './class.js';
+export * from './type.js';

package/create/type.d.ts

@@ -1,3 +1,3 @@
 import type { Codec, Registry } from '@polkadot/types-codec/types';
-import type { CreateOptions } from '../types';
+import type { CreateOptions } from '../types/index.js';
 export declare function createTypeUnsafe<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K, params?: unknown[], options?: CreateOptions): T;

package/create/type.js

@@ -1,72 +1,63 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { Option } from '@polkadot/types-codec';
 import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { createClassUnsafe } from "./class.js";
-
-// With isPedantic, actually check that the encoding matches that supplied. This
-// is much slower, but verifies that we have the correct types defined
+import { createClassUnsafe } from './class.js';
 function checkInstance(created, matcher) {
-  const u8a = created.toU8a();
-  const rawType = created.toRawType();
-  const isOk =
-  // full match, all ok
-  u8aEq(u8a, matcher) ||
-  // on a length-prefixed type, just check the actual length
-  ['Bytes', 'Text', 'Type'].includes(rawType) && matcher.length === created.length ||
-  // when the created is empty and matcher is also empty, let it slide...
-  created.isEmpty && matcher.every(v => !v);
-  if (!isOk) {
-    throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
-  }
+    const u8a = created.toU8a();
+    const rawType = created.toRawType();
+    const isOk = (
+    // full match, all ok
+    u8aEq(u8a, matcher) ||
+        (
+        // on a length-prefixed type, just check the actual length
+        ['Bytes', 'Text', 'Type'].includes(rawType) &&
+            matcher.length === created.length) ||
+        (
+        // when the created is empty and matcher is also empty, let it slide...
+        created.isEmpty &&
+            matcher.every((v) => !v)));
+    if (!isOk) {
+        throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
+    }
 }
 function checkPedantic(created, [value]) {
-  if (isU8a(value)) {
-    checkInstance(created, value);
-  } else if (isHex(value)) {
-    checkInstance(created, u8aToU8a(value));
-  }
+    if (isU8a(value)) {
+        checkInstance(created, value);
+    }
+    else if (isHex(value)) {
+        checkInstance(created, u8aToU8a(value));
+    }
 }
-
-// Initializes a type with a value. This also checks for fallbacks and in the cases
-// where isPedantic is specified (storage decoding), also check the format/structure
-function initType(registry, Type, params = [], {
-  blockHash,
-  isFallback,
-  isOptional,
-  isPedantic
-} = {}) {
-  const created = new (isOptional ? Option.with(Type) : Type)(registry, ...params);
-  isPedantic && checkPedantic(created, params);
-  if (blockHash) {
-    created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
-  }
-  if (isFallback) {
-    created.isStorageFallback = true;
-  }
-  return created;
+function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
+    const created = new (isOptional
+        ? Option.with(Type)
+        : Type)(registry, ...params);
+    isPedantic && checkPedantic(created, params);
+    if (blockHash) {
+        created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
+    }
+    if (isFallback) {
+        created.isStorageFallback = true;
+    }
+    return created;
 }
-
-// An unsafe version of the `createType` below. It's unsafe because the `type`
-// argument here can be any string, which, when it cannot parse, will yield a
-// runtime error.
 export function createTypeUnsafe(registry, type, params = [], options = {}) {
-  let Clazz = null;
-  let firstError = null;
-  try {
-    Clazz = createClassUnsafe(registry, type);
-    return initType(registry, Clazz, params, options);
-  } catch (error) {
-    firstError = new Error(`createType(${type}):: ${error.message}`);
-  }
-  if (Clazz && Clazz.__fallbackType) {
+    let Clazz = null;
+    let firstError = null;
     try {
-      Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
-      return initType(registry, Clazz, params, options);
-    } catch {
-      // swallow, we will throw the first error again
+        Clazz = createClassUnsafe(registry, type);
+        return initType(registry, Clazz, params, options);
+    }
+    catch (error) {
+        firstError = new Error(`createType(${type}):: ${error.message}`);
+    }
+    if (Clazz && Clazz.__fallbackType) {
+        try {
+            Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
+            return initType(registry, Clazz, params, options);
+        }
+        catch {
+            // swallow, we will throw the first error again
+        }
     }
-  }
-  throw firstError;
+    throw firstError;
 }

package/detectOther.js

@@ -1,5 +1,2 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { packageInfo as codecInfo } from '@polkadot/types-codec/packageInfo';
 export default [codecInfo];

package/detectPackage.js

@@ -1,9 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Do not edit, auto-generated by @polkadot/dev
-
 import { detectPackage } from '@polkadot/util';
-import others from "./detectOther.js";
-import { packageInfo } from "./packageInfo.js";
+import others from './detectOther.js';
+import { packageInfo } from './packageInfo.js';
 detectPackage(packageInfo, null, others);

package/index.d.ts

@@ -1,2 +1,2 @@
-import './detectPackage';
-export * from './bundle';
+import './detectPackage.js';
+export * from './bundle.js';

package/index.js

@@ -1,5 +1,2 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import "./detectPackage.js";
-export * from "./bundle.js";
+import './detectPackage.js';
+export * from './bundle.js';

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "9.14.2",
+  "version": "10.1.1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -62,7 +62,10 @@
       "require": "./cjs/detectPackage.js",
       "default": "./detectPackage.js"
     },
-    "./package.json": "./package.json",
+    "./package.json": {
+      "require": "./cjs/package.json",
+      "default": "./package.json"
+    },
     "./packageInfo.js": {
       "types": "./packageInfo.d.ts",
       "require": "./cjs/packageInfo.js",
@@ -120,8 +123,8 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.20.13",
-    "@polkadot/types-codec": "9.14.2",
-    "@polkadot/util": "^10.4.2"
+    "@polkadot/types-codec": "10.1.1",
+    "@polkadot/util": "^11.0.2",
+    "tslib": "^2.5.0"
   }
 }

package/packageInfo.js

@@ -1,11 +1 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Do not edit, auto-generated by @polkadot/dev
-
-export const packageInfo = {
-  name: '@polkadot/types-create',
-  path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
-  type: 'esm',
-  version: '9.14.2'
-};
+export const packageInfo = { name: '@polkadot/types-create', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.1.1' };

package/types/augmentRegistry.js

@@ -1,6 +1 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
 import '@polkadot/types-codec/types/registry';

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import './augmentRegistry';
+import './augmentRegistry.js';
 export type { CodecCreateOptions as CreateOptions } from '@polkadot/types-codec/types';
-export * from './lookup';
-export * from './types';
+export * from './lookup.js';
+export * from './types.js';

package/types/index.js

@@ -1,6 +1,3 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import "./augmentRegistry.js";
-export * from "./lookup.js";
-export * from "./types.js";
+import './augmentRegistry.js';
+export * from './lookup.js';
+export * from './types.js';

package/types/lookup.d.ts

@@ -1,6 +1,6 @@
 import type { Option, Text } from '@polkadot/types-codec';
 import type { ICompact, INumber, LookupString } from '@polkadot/types-codec/types';
-import type { TypeDef } from './types';
+import type { TypeDef } from './types.js';
 interface SiTypeBase {
     def: {
         asTuple: ICompact<INumber>[];

package/types/types.js

@@ -1,29 +1,26 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export let TypeDefInfo;
+export var TypeDefInfo;
 (function (TypeDefInfo) {
-  TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
-  TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
-  TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
-  TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
-  TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
-  TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
-  TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
-  TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
-  TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
-  TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
-  TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
-  TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
-  TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
-  TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
-  TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
-  TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
-  TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
-  TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
-  TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
-  TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
-  TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
-  TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
-  TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
+    TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
+    TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
+    TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
+    TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
+    TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
+    TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
+    TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
+    TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
+    TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
+    TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
+    TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
+    TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
+    TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
+    TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
+    TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
+    TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
+    TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
+    TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
+    TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
+    TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
+    TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
+    TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
+    TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
 })(TypeDefInfo || (TypeDefInfo = {}));