@pezkuwi/types-create 16.5.5

package/README.md

@@ -0,0 +1,3 @@
+# @pezkuwi/types-create
+
+Base type-creation functionality.

package/build/bundle.d.ts

@@ -0,0 +1,3 @@
+export { packageInfo } from './packageInfo.js';
+export { TypeDefInfo } from './types/index.js';
+export * from './exports.js';

package/build/create/class.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass, Registry } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '../types/index.js';
+export declare function constructTypeClass<T extends Codec = Codec>(registry: Registry, typeDef: TypeDef): CodecClass<T>;
+export declare function getTypeClass<T extends Codec = Codec>(registry: Registry, typeDef: TypeDef): CodecClass<T>;
+export declare function createClassUnsafe<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K): CodecClass<T>;

package/build/create/index.d.ts

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

package/build/create/type.d.ts

@@ -0,0 +1,3 @@
+import type { Codec, Registry } from '@pezkuwi/types-codec/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/build/exports.d.ts

@@ -0,0 +1,2 @@
+export * from './create/index.js';
+export * from './util/index.js';

package/build/index.d.ts

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

package/build/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/types/augmentRegistry.d.ts

@@ -0,0 +1,11 @@
+import '@pezkuwi/types-codec/types/registry';
+import type { Codec, CodecClass, ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { ILookup, TypeDef } from '@pezkuwi/types-create/types';
+declare module '@pezkuwi/types-codec/types/registry' {
+    interface Registry {
+        readonly lookup: ILookup;
+        createLookupType(lookupId: ICompact<INumber> | number): LookupString;
+        getUnsafe<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+        setLookup(lookup: ILookup): void;
+    }
+}

package/build/types/index.d.ts

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

package/build/types/lookup.d.ts

@@ -0,0 +1,14 @@
+import type { Option, Text } from '@pezkuwi/types-codec';
+import type { ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from './types.js';
+interface SiTypeBase {
+    def: {
+        asTuple: ICompact<INumber>[];
+    };
+}
+export interface ILookup {
+    getSiType(lookupId: ICompact<INumber> | LookupString | number): SiTypeBase;
+    getTypeDef(lookupId: ICompact<INumber> | LookupString | number): TypeDef;
+    sanitizeField(name: Option<Text>): [string | null, string | null];
+}
+export {};

package/build/types/types.d.ts

@@ -0,0 +1,43 @@
+export declare enum TypeDefInfo {
+    BTreeMap = 0,
+    BTreeSet = 1,
+    Compact = 2,
+    DoNotConstruct = 3,
+    Enum = 4,
+    HashMap = 5,
+    Int = 6,
+    Linkage = 7,
+    Null = 8,
+    Option = 9,
+    Plain = 10,
+    Range = 11,
+    RangeInclusive = 12,
+    Result = 13,
+    Set = 14,
+    Si = 15,
+    Struct = 16,
+    Tuple = 17,
+    UInt = 18,
+    Vec = 19,
+    VecFixed = 20,
+    WrapperKeepOpaque = 21,
+    WrapperOpaque = 22
+}
+export interface TypeDef {
+    alias?: Map<string, string> | undefined;
+    displayName?: string | undefined;
+    docs?: string[] | undefined;
+    fallbackType?: string | undefined;
+    info: TypeDefInfo;
+    index?: number;
+    isFromSi?: boolean;
+    length?: number;
+    lookupIndex?: number;
+    lookupName?: string | undefined;
+    lookupNameRoot?: string | undefined;
+    name?: string | undefined;
+    namespace?: string | undefined;
+    sub?: TypeDef | TypeDef[];
+    type: string;
+    typeName?: string | undefined;
+}

package/build/util/encodeTypes.d.ts

@@ -0,0 +1,11 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+interface ToString {
+    toString: () => string;
+}
+export declare function paramsNotation<T extends ToString>(outer: string, inner?: T | T[], transform?: (_: T) => string): string;
+export declare function encodeTypeDef(registry: Registry, typeDef: TypeDef): string;
+export declare function withTypeString(registry: Registry, typeDef: Omit<TypeDef, 'type'> & {
+    type?: string;
+}): TypeDef;
+export {};

package/build/util/getTypeDef.d.ts

@@ -0,0 +1,8 @@
+import type { AnyString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+interface TypeDefOptions {
+    name?: string;
+    displayName?: string;
+}
+export declare function getTypeDef(_type: AnyString, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
+export {};

package/build/util/index.d.ts

@@ -0,0 +1,4 @@
+export * from './encodeTypes.js';
+export * from './getTypeDef.js';
+export * from './typeSplit.js';
+export * from './xcm.js';

package/build/util/typeSplit.d.ts

@@ -0,0 +1 @@
+export declare function typeSplit(type: string): string[];

package/build/util/xcm.d.ts

@@ -0,0 +1,2 @@
+export declare const XCM_MAPPINGS: string[];
+export declare function mapXcmTypes(version: 'V0' | 'V1' | 'V2' | 'V3' | 'V4' | 'V5'): Record<string, string>;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Type creator helpers",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/types-create#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/types-create",
+  "repository": {
+    "directory": "packages/types-create",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "16.5.5",
+  "main": "index.js",
+  "dependencies": {
+    "@pezkuwi/types-codec": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@pezkuwi/types": "16.5.5"
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all named
+export { packageInfo } from './packageInfo.js';
+export { TypeDefInfo } from './types/index.js';
+
+// all starred
+export * from './exports.js';

package/src/create/class.ts

@@ -0,0 +1,257 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Codec, CodecClass, LookupString, Registry, U8aBitLength, UIntBitLength } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '../types/index.js';
+
+import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';
+import { isNumber, stringify } from '@pezkuwi/util';
+
+import { TypeDefInfo } from '../types/index.js';
+import { getTypeDef } from '../util/getTypeDef.js';
+
+function getTypeDefType ({ lookupName, type }: TypeDef): string {
+  return lookupName || type;
+}
+
+function getSubDefArray (value: TypeDef): TypeDef[] {
+  if (!Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
+  }
+
+  return value.sub;
+}
+
+function getSubDef (value: TypeDef): TypeDef {
+  if (!value.sub || Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
+  }
+
+  return value.sub;
+}
+
+function getSubType (value: TypeDef): string {
+  return getTypeDefType(getSubDef(value));
+}
+
+// create a maps of type string CodecClasss from the input
+function getTypeClassMap (value: TypeDef): Record<string, string> {
+  const subs = getSubDefArray(value);
+  const map: Record<string, string> = {};
+
+  for (let i = 0, count = subs.length; i < count; i++) {
+    const sub = subs[i];
+
+    if (!sub.name) {
+      throw new Error(`No name found in definition ${stringify(sub)}`);
+    }
+
+    map[sub.name] = getTypeDefType(sub);
+  }
+
+  return map;
+}
+
+// create an array of type string CodecClasss from the input
+function getTypeClassArray (value: TypeDef): string[] {
+  return getSubDefArray(value).map(getTypeDefType);
+}
+
+function createInt (Clazz: typeof Int | typeof UInt, { displayName, length }: TypeDef): CodecClass<Codec> {
+  if (!isNumber(length)) {
+    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+  }
+
+  return Clazz.with(length as UIntBitLength, displayName);
+}
+
+function createHashMap (Clazz: typeof BTreeMap | typeof HashMap, value: TypeDef): CodecClass<Codec> {
+  const [keyType, valueType] = getTypeClassArray(value);
+
+  return Clazz.with(keyType, valueType);
+}
+
+function createWithSub (Clazz: { with: (t: string) => CodecClass<Codec> }, value: TypeDef): CodecClass<Codec> {
+  return Clazz.with(getSubType(value));
+}
+
+const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => CodecClass<Codec>> = {
+  [TypeDefInfo.BTreeMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createHashMap(BTreeMap, value),
+
+  [TypeDefInfo.BTreeSet]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(BTreeSet, value),
+
+  [TypeDefInfo.Compact]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(Compact, value),
+
+  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    DoNotConstruct.with(value.displayName || value.type),
+
+  [TypeDefInfo.Enum]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const subs = getSubDefArray(value);
+
+    return Enum.with(
+      subs.every(({ type }) => type === 'Null')
+        ? subs.reduce<Record<string, number>>((out, { index, name }, count) => {
+          if (!name) {
+            throw new Error('No name found in sub definition');
+          }
+
+          out[name] = index || count;
+
+          return out;
+        }, {})
+        : getTypeClassMap(value)
+    );
+  },
+
+  [TypeDefInfo.HashMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createHashMap(HashMap, value),
+
+  [TypeDefInfo.Int]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createInt(Int, value),
+
+  // We have circular deps between Linkage & Struct
+  [TypeDefInfo.Linkage]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const type = `Option<${getSubType(value)}>`;
+    // eslint-disable-next-line sort-keys
+    const Clazz = Struct.with({ previous: type, next: type } as any);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    Clazz.prototype.toRawType = function (): string {
+      // 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;
+  },
+
+  [TypeDefInfo.Null]: (_registry: Registry, _value: TypeDef): CodecClass<Codec> =>
+    Null,
+
+  [TypeDefInfo.Option]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    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: Registry, value: TypeDef): CodecClass<Codec> =>
+    registry.getOrUnknown(value.type),
+
+  [TypeDefInfo.Range]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(Range, value),
+
+  [TypeDefInfo.RangeInclusive]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(RangeInclusive, value),
+
+  [TypeDefInfo.Result]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const [Ok, Err] = getTypeClassArray(value);
+
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    return Result.with({ Err, Ok });
+  },
+
+  [TypeDefInfo.Set]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    CodecSet.with(
+      getSubDefArray(value).reduce<Record<string, number>>((result, { index, name }) => {
+        if (!name || !isNumber(index)) {
+          throw new Error('No name found in sub definition');
+        }
+
+        result[name] = index;
+
+        return result;
+      }, {}),
+      value.length
+    ),
+
+  [TypeDefInfo.Si]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    getTypeClass(registry, registry.lookup.getTypeDef(value.type as LookupString)),
+
+  [TypeDefInfo.Struct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    Struct.with(getTypeClassMap(value), value.alias),
+
+  [TypeDefInfo.Tuple]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    Tuple.with(getTypeClassArray(value)),
+
+  [TypeDefInfo.UInt]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createInt(UInt, value),
+
+  [TypeDefInfo.Vec]: (_registry: Registry, { sub }: TypeDef): CodecClass<Codec> => {
+    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: Registry, { displayName, length, sub }: TypeDef): CodecClass<Codec> => {
+    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) as U8aBitLength, displayName)
+        : VecFixed.with(getTypeDefType(sub), length)
+    );
+  },
+
+  [TypeDefInfo.WrapperKeepOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(WrapperKeepOpaque, value),
+
+  [TypeDefInfo.WrapperOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(WrapperOpaque, value)
+};
+
+export function constructTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
+  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 as CodecClass<T>;
+  } catch (error) {
+    throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${(error as Error).message}`);
+  }
+}
+
+// Returns the type Class for construction
+export function getTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
+  return registry.getUnsafe(typeDef.type, false, typeDef) as unknown as CodecClass<T>;
+}
+
+export function createClassUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K): CodecClass<T> {
+  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)
+    )
+  );
+}

package/src/create/index.ts

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

package/src/create/type.ts

@@ -0,0 +1,94 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { Codec, CodecClass, IU8a, Registry } from '@pezkuwi/types-codec/types';
+import type { CreateOptions } from '../types/index.js';
+
+import { Option } from '@pezkuwi/types-codec';
+import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@pezkuwi/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
+function checkInstance (created: Codec, matcher: Uint8Array): void {
+  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 as unknown as Bytes).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: Codec, [value]: unknown[]): void {
+  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<T extends Codec> (registry: Registry, Type: CodecClass, params: unknown[] = [], { blockHash, isFallback, isOptional, isPedantic }: CreateOptions = {}): T {
+  const created = new (
+    isOptional
+      ? Option.with(Type)
+      : Type
+  )(registry, ...params);
+
+  isPedantic && checkPedantic(created, params);
+
+  if (blockHash) {
+    created.createdAtHash = createTypeUnsafe<IU8a>(registry, 'BlockHash', [blockHash]);
+  }
+
+  if (isFallback) {
+    created.isStorageFallback = true;
+  }
+
+  return created as T;
+}
+
+// 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<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K, params: unknown[] = [], options: CreateOptions = {}): T {
+  let Clazz: CodecClass | null = null;
+  let firstError: Error | null = null;
+
+  try {
+    Clazz = createClassUnsafe(registry, type);
+
+    return initType(registry, Clazz, params, options);
+  } catch (error) {
+    firstError = new Error(`createType(${type}):: ${(error as Error).message}`);
+  }
+
+  if (Clazz?.__fallbackType) {
+    try {
+      Clazz = createClassUnsafe(registry, Clazz.__fallbackType as unknown as K);
+
+      return initType(registry, Clazz, params, options);
+    } catch {
+      // swallow, we will throw the first error again
+    }
+  }
+
+  throw firstError;
+}

package/src/exports.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all starred
+export * from './create/index.js';
+export * from './util/index.js';

package/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './packageDetect.js';
+
+export * from './bundle.js';

package/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index.js';

package/src/packageDetect.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { packageInfo as codecInfo } from '@pezkuwi/types-codec/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [codecInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@pezkuwi/types-create', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/types/augmentRegistry.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @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 '@pezkuwi/types-codec/types/registry';
+
+import type { Codec, CodecClass, ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { ILookup, TypeDef } from '@pezkuwi/types-create/types';
+
+declare module '@pezkuwi/types-codec/types/registry' {
+  interface Registry {
+    readonly lookup: ILookup;
+
+    createLookupType (lookupId: ICompact<INumber> | number): LookupString;
+    getUnsafe <T extends Codec = Codec, K extends string = string> (name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    setLookup (lookup: ILookup): void;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './augmentRegistry.js';
+
+// all types
+export type { CodecCreateOptions as CreateOptions } from '@pezkuwi/types-codec/types';
+
+// all starred
+export * from './lookup.js';
+export * from './types.js';

package/src/types/lookup.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Option, Text } from '@pezkuwi/types-codec';
+import type { ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from './types.js';
+
+// A simplified SiType without the need for an interface import
+// (while type interfaces are still in @polkadot/types). This provides
+// the minimum interface allowing us to work with it here
+interface SiTypeBase {
+  def: {
+    asTuple: ICompact<INumber>[]
+  }
+}
+
+export interface ILookup {
+  getSiType (lookupId: ICompact<INumber> | LookupString | number): SiTypeBase;
+  getTypeDef (lookupId: ICompact<INumber> | LookupString | number): TypeDef;
+  sanitizeField (name: Option<Text>): [string | null, string | null];
+}