@pezkuwi/types 16.5.6 → 16.5.8

package/build-tsc/interfaces/xcm/v0.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v0: DefinitionsTypes;

package/build-tsc/interfaces/xcm/v1.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v1: DefinitionsTypes;

package/build-tsc/interfaces/xcm/v2.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v2: DefinitionsTypes;

package/build-tsc/interfaces/xcm/v3.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v3: DefinitionsTypes;

package/build-tsc/interfaces/xcm/v4.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v4: DefinitionsTypes;

package/build-tsc/interfaces/xcm/v5.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsTypes } from '../../types/index.js';
+export declare const v5: DefinitionsTypes;

package/build-tsc/interfaces/xcmPaymentApi/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { Definitions } from '../../types/index.js';
+declare const _default: Definitions;
+export default _default;

package/build-tsc/interfaces/xcmPaymentApi/index.d.ts

@@ -0,0 +1 @@
+export * from './types.js';

package/build-tsc/interfaces/xcmPaymentApi/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsCall } from '../../types/index.js';
+export declare const runtime: DefinitionsCall;

package/build-tsc/interfaces/xcmPaymentApi/types.d.ts

@@ -0,0 +1,11 @@
+import type { Enum } from '@pezkuwi/types-codec';
+/** @name XcmPaymentApiError */
+export interface XcmPaymentApiError extends Enum {
+    readonly isUnimplemented: boolean;
+    readonly isVersionedConversionFailed: boolean;
+    readonly isWeightNotComputable: boolean;
+    readonly isUnhandledXcmVersion: boolean;
+    readonly isAssetNotFound: boolean;
+    readonly type: 'Unimplemented' | 'VersionedConversionFailed' | 'WeightNotComputable' | 'UnhandledXcmVersion' | 'AssetNotFound';
+}
+export type PHANTOM_XCMPAYMENTAPI = 'xcmPaymentApi';

package/build-tsc/interfaces/xcmRuntimeApi/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { Definitions } from '../../types/index.js';
+declare const _default: Definitions;
+export default _default;

package/build-tsc/interfaces/xcmRuntimeApi/index.d.ts

@@ -0,0 +1 @@
+export * from './types.js';

package/build-tsc/interfaces/xcmRuntimeApi/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionsCall } from '../../types/index.js';
+export declare const runtime: DefinitionsCall;

package/build-tsc/interfaces/xcmRuntimeApi/types.d.ts

@@ -0,0 +1,8 @@
+import type { Enum } from '@pezkuwi/types-codec';
+/** @name Error */
+export interface Error extends Enum {
+    readonly isUnsupported: boolean;
+    readonly isVersionedConversionFailed: boolean;
+    readonly type: 'Unsupported' | 'VersionedConversionFailed';
+}
+export type PHANTOM_XCMRUNTIMEAPI = 'xcmRuntimeApi';

package/build-tsc/lookup.d.ts

@@ -0,0 +1 @@
+export declare const __TYPES_LOOKUP = "augmented";

package/build-tsc/metadata/MagicNumber.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNumber, Registry } from '@pezkuwi/types-codec/types';
+import { U32 } from '@pezkuwi/types-codec';
+export declare const MAGIC_NUMBER = 1635018093;
+export declare class MagicNumber extends U32 {
+    constructor(registry: Registry, value?: AnyNumber);
+}

package/build-tsc/metadata/Metadata.d.ts

@@ -0,0 +1,11 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { MetadataVersioned } from './MetadataVersioned.js';
+/**
+ * @name Metadata
+ * @description
+ * The versioned runtime metadata as a decoded structure
+ */
+export declare class Metadata extends MetadataVersioned {
+    constructor(registry: Registry, value?: Uint8Array | HexString | Map<string, unknown> | Record<string, unknown>);
+}

package/build-tsc/metadata/MetadataVersioned.d.ts

@@ -0,0 +1,69 @@
+import type { AnyJson } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV15, MetadataV16 } from '../interfaces/metadata/index.js';
+import type { Registry } from '../types/index.js';
+import type { MetaVersionAll } from './versions.js';
+import { Struct } from '@pezkuwi/types-codec';
+import { MagicNumber } from './MagicNumber.js';
+/**
+ * @name MetadataVersioned
+ * @description
+ * The versioned runtime metadata as a decoded structure
+ */
+export declare class MetadataVersioned extends Struct {
+    #private;
+    constructor(registry: Registry, value?: Uint8Array | HexString | Map<string, unknown> | Record<string, unknown>);
+    /**
+     * @description Returns the wrapped metadata as a limited calls-only (latest) version
+     */
+    get asCallsOnly(): MetadataVersioned;
+    /**
+     * @description Returns the wrapped metadata as a V9 object
+     */
+    get asV9(): MetadataV9;
+    /**
+     * @description Returns the wrapped values as a V10 object
+     */
+    get asV10(): MetadataV10;
+    /**
+     * @description Returns the wrapped values as a V11 object
+     */
+    get asV11(): MetadataV11;
+    /**
+     * @description Returns the wrapped values as a V12 object
+     */
+    get asV12(): MetadataV12;
+    /**
+     * @description Returns the wrapped values as a V13 object
+     */
+    get asV13(): MetadataV13;
+    /**
+     * @description Returns the wrapped values as a V14 object
+     */
+    get asV14(): MetadataV14;
+    /**
+     * @description Returns the wrapped values as a V15 object
+     */
+    get asV15(): MetadataV15;
+    /**
+    * @description Returns the wrapped values as a V16 object
+    */
+    get asV16(): MetadataV16;
+    /**
+     * @description Returns the wrapped values as a latest version object
+     */
+    get asLatest(): MetadataLatest;
+    /**
+     * @description The magicNumber for the Metadata (known constant)
+     */
+    get magicNumber(): MagicNumber;
+    /**
+     * @description the metadata version this structure represents
+     */
+    get version(): MetaVersionAll;
+    getUniqTypes(throwError: boolean): string[];
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): Record<string, AnyJson>;
+}

package/build-tsc/metadata/PortableRegistry/PortableRegistry.d.ts

@@ -0,0 +1,48 @@
+import type { Option, Text, Vec } from '@pezkuwi/types-codec';
+import type { LookupString, Registry } from '@pezkuwi/types-codec/types';
+import type { ILookup, TypeDef } from '@pezkuwi/types-create/types';
+import type { PortableType } from '../../interfaces/metadata/index.js';
+import type { SiLookupTypeId, SiType, SiTypeParameter } from '../../interfaces/scaleInfo/index.js';
+import { Struct } from '@pezkuwi/types-codec';
+interface TypeInfoParams {
+    PezframeSystemEventRecord: [event: SiTypeParameter, topic: SiTypeParameter];
+    PezspRuntimeUncheckedExtrinsic: [address: SiTypeParameter, call: SiTypeParameter, signature: SiTypeParameter, extra: SiTypeParameter];
+    [key: string]: SiTypeParameter[];
+}
+export declare class PortableRegistry extends Struct implements ILookup {
+    #private;
+    constructor(registry: Registry, value?: Uint8Array, isContract?: boolean);
+    /**
+     * @description Returns all the available type names for this chain
+     **/
+    get names(): string[];
+    /**
+     * @description Returns all the available parameterized types for this chain
+     **/
+    get paramTypes(): TypeInfoParams;
+    /**
+     * @description The types of the registry
+     */
+    get types(): Vec<PortableType>;
+    /**
+     * @description Register all available types into the registry (generally for internal usage)
+     */
+    register(): void;
+    /**
+     * @description Returns the name for a specific lookup
+     */
+    getName(lookupId: SiLookupTypeId | LookupString | number): string | undefined;
+    /**
+     * @description Finds a specific type in the registry
+     */
+    getSiType(lookupId: SiLookupTypeId | LookupString | number): SiType;
+    /**
+     * @description Lookup the type definition for the index
+     */
+    getTypeDef(lookupId: SiLookupTypeId | LookupString | number): TypeDef;
+    /**
+     * @description For a specific field, perform adjustments to not have built-in conflicts
+     */
+    sanitizeField(name: Option<Text>): [string | null, string | null];
+}
+export {};

package/build-tsc/metadata/PortableRegistry/index.d.ts

@@ -0,0 +1,2 @@
+export { PortableRegistry } from './PortableRegistry.js';
+export { toV1 as convertSiV0toV1 } from './toV1.js';

package/build-tsc/metadata/PortableRegistry/toV1.d.ts

@@ -0,0 +1,3 @@
+import type { PortableType, Si0Type } from '../../interfaces/index.js';
+import type { Registry } from '../../types/index.js';
+export declare function toV1(registry: Registry, types: Si0Type[]): PortableType[];

package/build-tsc/metadata/decorate/constants/index.d.ts

@@ -0,0 +1,5 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest } from '../../../interfaces/index.js';
+import type { Constants } from '../types.js';
+/** @internal */
+export declare function decorateConstants(registry: Registry, { pallets }: MetadataLatest, _version: number): Constants;

package/build-tsc/metadata/decorate/errors/index.d.ts

@@ -0,0 +1,16 @@
+import type { Text, u8 } from '@pezkuwi/types-codec';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, SiField, SiVariant } from '../../../interfaces/index.js';
+import type { PortableRegistry } from '../../../metadata/index.js';
+import type { Errors } from '../types.js';
+interface ItemMeta {
+    args: string[];
+    name: Text;
+    fields: SiField[];
+    index: u8;
+    docs: Text[];
+}
+export declare function variantToMeta(lookup: PortableRegistry, variant: SiVariant): ItemMeta;
+/** @internal */
+export declare function decorateErrors(registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Errors;
+export {};

package/build-tsc/metadata/decorate/events/index.d.ts

@@ -0,0 +1,6 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, PezpalletMetadataLatest } from '../../../interfaces/index.js';
+import type { Events } from '../types.js';
+export declare function filterEventsSome({ events }: PezpalletMetadataLatest): boolean;
+/** @internal */
+export declare function decorateEvents(registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Events;

package/build-tsc/metadata/decorate/extrinsics/createUnchecked.d.ts

@@ -0,0 +1,5 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { FunctionMetadataLatest } from '../../../interfaces/index.js';
+import type { CallFunction } from '../../../types/index.js';
+/** @internal */
+export declare function createUnchecked(registry: Registry, section: string, callIndex: Uint8Array, callMetadata: FunctionMetadataLatest): CallFunction;

package/build-tsc/metadata/decorate/extrinsics/index.d.ts

@@ -0,0 +1,9 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, PezpalletMetadataLatest, SiVariant } from '../../../interfaces/index.js';
+import type { PortableRegistry } from '../../../metadata/index.js';
+import type { CallFunction } from '../../../types/index.js';
+import type { Extrinsics } from '../types.js';
+export declare function filterCallsSome({ calls }: PezpalletMetadataLatest): boolean;
+export declare function createCallFunction(registry: Registry, lookup: PortableRegistry, variant: SiVariant, sectionName: string, sectionIndex: number): CallFunction;
+/** @internal */
+export declare function decorateExtrinsics(registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Extrinsics;

package/build-tsc/metadata/decorate/index.d.ts

@@ -0,0 +1,13 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { DecoratedMeta } from './types.js';
+import { Metadata } from '../Metadata.js';
+import { decorateConstants } from './constants/index.js';
+import { decorateErrors } from './errors/index.js';
+import { decorateEvents, filterEventsSome } from './events/index.js';
+import { decorateExtrinsics, filterCallsSome } from './extrinsics/index.js';
+import { decorateStorage } from './storage/index.js';
+/**
+ * Expands the metadata by decoration into consts, query and tx sections
+ */
+export declare function expandMetadata(registry: Registry, metadata: Metadata): DecoratedMeta;
+export { decorateConstants, decorateErrors, decorateEvents, decorateExtrinsics, decorateStorage, filterCallsSome, filterEventsSome };

package/build-tsc/metadata/decorate/storage/bizinikiwi.d.ts

@@ -0,0 +1,5 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { StorageEntry } from '../../../primitive/types.js';
+type Creator = (registry: Registry) => StorageEntry;
+export declare const bizinikiwi: Record<string, Creator>;
+export {};

package/build-tsc/metadata/decorate/storage/createFunction.d.ts

@@ -0,0 +1,31 @@
+import type { ICompact, Inspect, INumber } from '@pezkuwi/types-codec/types';
+import type { StorageEntryMetadataLatest, StorageHasher } from '../../../interfaces/metadata/index.js';
+import type { StorageEntry } from '../../../primitive/types.js';
+import type { Registry } from '../../../types/index.js';
+export interface CreateItemOptions {
+    key?: Uint8Array | string;
+    skipHashing?: boolean;
+}
+export interface CreateItemBase {
+    method: string;
+    prefix: string;
+}
+export interface CreateItemFn extends CreateItemBase {
+    meta: StorageEntryMetadataLatest;
+    section: string;
+}
+interface RawArgs {
+    args: unknown[];
+    hashers: StorageHasher[];
+    keys: ICompact<INumber>[];
+}
+export declare const NO_RAW_ARGS: RawArgs;
+/** @internal */
+export declare function createKeyRawParts(registry: Registry, itemFn: CreateItemBase, { args, hashers, keys }: RawArgs): [Uint8Array[], Uint8Array[]];
+/** @internal */
+export declare function createKeyInspect(registry: Registry, itemFn: CreateItemFn, args: RawArgs): Inspect;
+/** @internal */
+export declare function createKeyRaw(registry: Registry, itemFn: CreateItemBase, args: RawArgs): Uint8Array;
+/** @internal */
+export declare function createFunction(registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): StorageEntry;
+export {};

package/build-tsc/metadata/decorate/storage/getHasher.d.ts

@@ -0,0 +1,5 @@
+import type { StorageHasher } from '../../../interfaces/index.js';
+export type HasherInput = string | Buffer | Uint8Array;
+export type HasherFunction = (data: HasherInput) => Uint8Array;
+/** @internal */
+export declare function getHasher(hasher: StorageHasher): HasherFunction;

package/build-tsc/metadata/decorate/storage/getStorage.d.ts

@@ -0,0 +1,4 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { Storage } from '../types.js';
+/** @internal */
+export declare function getStorage(registry: Registry): Storage;

package/build-tsc/metadata/decorate/storage/index.d.ts

@@ -0,0 +1,5 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest } from '../../../interfaces/index.js';
+import type { Storage } from '../types.js';
+/** @internal */
+export declare function decorateStorage(registry: Registry, { pallets }: MetadataLatest, _metaVersion: number): Storage;

package/build-tsc/metadata/decorate/storage/util.d.ts

@@ -0,0 +1,14 @@
+import type { StorageEntry } from '../../../primitive/types.js';
+import type { Registry } from '../../../types/index.js';
+export interface ManualMetadata {
+    docs: string;
+    type: string;
+}
+interface ManualDefinition {
+    method: string;
+    prefix: string;
+    section: string;
+}
+/** @internal */
+export declare function createRuntimeFunction({ method, prefix, section }: ManualDefinition, key: Uint8Array | string, { docs, type }: ManualMetadata): (registry: Registry) => StorageEntry;
+export {};

package/build-tsc/metadata/decorate/types.d.ts

@@ -0,0 +1,33 @@
+import type { AnyTuple, Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, ErrorMetadataLatest, EventMetadataLatest, PezpalletConstantMetadataLatest } from '../../interfaces/index.js';
+import type { StorageEntry } from '../../primitive/types.js';
+import type { CallFunction, IEvent, IEventLike } from '../../types/index.js';
+export interface ConstantCodec extends Codec {
+    readonly meta: PezpalletConstantMetadataLatest;
+}
+export interface IsError {
+    readonly meta: ErrorMetadataLatest;
+    is: (moduleError: DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a) => boolean;
+}
+export interface IsEvent<T extends AnyTuple, N = unknown> {
+    readonly meta: EventMetadataLatest;
+    is: (event: IEventLike) => event is IEvent<T, N>;
+}
+export type ModuleConstants = Record<string, ConstantCodec>;
+export type ModuleErrors = Record<string, IsError>;
+export type ModuleEvents = Record<string, IsEvent<AnyTuple>>;
+export type ModuleExtrinsics = Record<string, CallFunction>;
+export type ModuleStorage = Record<string, StorageEntry>;
+export type Constants = Record<string, ModuleConstants>;
+export type Errors = Record<string, ModuleErrors>;
+export type Events = Record<string, ModuleEvents>;
+export type Extrinsics = Record<string, ModuleExtrinsics>;
+export type Storage = Record<string, ModuleStorage>;
+export interface DecoratedMeta {
+    readonly consts: Constants;
+    readonly errors: Errors;
+    readonly events: Events;
+    readonly query: Storage;
+    readonly registry: Registry;
+    readonly tx: Extrinsics;
+}

package/build-tsc/metadata/decorate/util.d.ts

@@ -0,0 +1,8 @@
+import type { Text } from '@pezkuwi/types-codec';
+type Name = string | Text;
+interface Named {
+    name: Name;
+}
+export declare const objectNameToCamel: (n: Named) => string;
+export declare const objectNameToString: (n: Named) => string;
+export {};

package/build-tsc/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export { decorateConstants, decorateExtrinsics, decorateStorage, expandMetadata } from './decorate/index.js';
+export { Metadata } from './Metadata.js';
+export { PortableRegistry } from './PortableRegistry/index.js';

package/build-tsc/metadata/types.d.ts

@@ -0,0 +1,5 @@
+import type { Vec } from '@pezkuwi/types-codec';
+import type { Codec } from '../types/index.js';
+export interface MetadataInterface<Modules extends Codec> extends Codec {
+    pallets: Vec<Modules>;
+}

package/build-tsc/metadata/util/extractTypes.d.ts

@@ -0,0 +1,4 @@
+type Extracted = string | Extracted[];
+/** @internal */
+export declare function extractTypes(types: string[]): Extracted[];
+export {};

package/build-tsc/metadata/util/flattenUniq.d.ts

@@ -0,0 +1,4 @@
+type Types = string | Types[];
+/** @internal */
+export declare function flattenUniq(list: Types[], result?: string[]): string[];
+export {};

package/build-tsc/metadata/util/getSiName.d.ts

@@ -0,0 +1,3 @@
+import type { ILookup } from '@pezkuwi/types-create/types';
+import type { SiLookupTypeId } from '../../interfaces/index.js';
+export declare function getSiName(lookup: ILookup, type: SiLookupTypeId): string;

package/build-tsc/metadata/util/getUniqTypes.d.ts

@@ -0,0 +1,4 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest } from '../../interfaces/index.js';
+/** @internal */
+export declare function getUniqTypes(registry: Registry, meta: MetadataLatest, throwError: boolean): string[];

package/build-tsc/metadata/util/index.d.ts

@@ -0,0 +1,5 @@
+export { flattenUniq } from './flattenUniq.js';
+export { getSiName } from './getSiName.js';
+export { getUniqTypes } from './getUniqTypes.js';
+export { toCallsOnly } from './toCallsOnly.js';
+export { validateTypes } from './validateTypes.js';

package/build-tsc/metadata/util/testUtil.d.ts

@@ -0,0 +1,10 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetaVersionAll } from '../versions.js';
+import type { Check } from './types.js';
+/** @internal */
+export declare function decodeLatestMeta(registry: Registry, type: string, version: MetaVersionAll, { data }: Check): void;
+/** @internal */
+export declare function toLatest(registry: Registry, version: MetaVersionAll, { data }: Check, withThrow?: boolean): void;
+/** @internal */
+export declare function defaultValues(registry: Registry, { data, fails }: Check, withThrow: boolean | undefined, withFallbackCheck: boolean | undefined, version: MetaVersionAll): void;
+export declare function testMeta(version: MetaVersionAll, matchers: Record<string, Check>, withFallback?: boolean): void;

package/build-tsc/metadata/util/toCallsOnly.d.ts

@@ -0,0 +1,4 @@
+import type { AnyJson, Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest } from '../../interfaces/metadata/index.js';
+/** @internal */
+export declare function toCallsOnly(registry: Registry, { extrinsic, lookup, pallets }: MetadataLatest): AnyJson;

package/build-tsc/metadata/util/types.d.ts

@@ -0,0 +1,5 @@
+import type { HexString } from '@pezkuwi/util/types';
+export interface Check {
+    data: HexString;
+    fails?: string[];
+}

package/build-tsc/metadata/util/validateTypes.d.ts

@@ -0,0 +1,3 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+/** @internal */
+export declare function validateTypes(registry: Registry, throwError: boolean, types: string[]): string[];

package/build-tsc/metadata/v10/toV11.d.ts

@@ -0,0 +1,4 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV10, MetadataV11 } from '../../interfaces/metadata/index.js';
+/** @internal */
+export declare function toV11(registry: Registry, { modules }: MetadataV10): MetadataV11;

package/build-tsc/metadata/v11/toV12.d.ts

@@ -0,0 +1,6 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV11, MetadataV12 } from '../../interfaces/metadata/index.js';
+/**
+ * @internal
+ **/
+export declare function toV12(registry: Registry, { extrinsic, modules }: MetadataV11): MetadataV12;

package/build-tsc/metadata/v12/toV13.d.ts

@@ -0,0 +1,6 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV12, MetadataV13 } from '../../interfaces/metadata/index.js';
+/**
+ * @internal
+ **/
+export declare function toV13(registry: Registry, v12: MetadataV12): MetadataV13;

package/build-tsc/metadata/v13/toV14.d.ts

@@ -0,0 +1,18 @@
+import type { MetadataV13, MetadataV14 } from '../../interfaces/metadata/index.js';
+import type { SiVariant } from '../../interfaces/scaleInfo/index.js';
+import type { Registry } from '../../types/index.js';
+export interface TypeSpec {
+    def: {
+        HistoricMetaCompat?: string;
+        Tuple?: number[];
+        Variant?: {
+            variants: SiVariant[];
+        };
+    };
+    path?: string[];
+}
+/**
+ * Convert the Metadata to v14
+ * @internal
+ **/
+export declare function toV14(registry: Registry, v13: MetadataV13, metaVersion: number): MetadataV14;

package/build-tsc/metadata/v14/toV15.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataV14, MetadataV15 } from '../../interfaces/metadata/index.js';
+import type { Registry } from '../../types/index.js';
+/**
+ * Convert the Metadata to v15
+ * @internal
+ **/
+export declare function toV15(registry: Registry, v14: MetadataV14, _: number): MetadataV15;

package/build-tsc/metadata/v15/toV16.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataV15, MetadataV16 } from '../../interfaces/metadata/index.js';
+import type { Registry } from '../../types/index.js';
+/**
+ * Convert the Metadata to v16
+ * @internal
+ **/
+export declare function toV16(registry: Registry, v15: MetadataV15, _: number): MetadataV16;

package/build-tsc/metadata/v16/toLatest.d.ts

@@ -0,0 +1,7 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, MetadataV16 } from '../../interfaces/metadata/index.js';
+/**
+ * Convert the Metadata (which is an alias) to latest
+ * @internal
+ **/
+export declare function toLatest(_registry: Registry, v16: MetadataV16, _metaVersion: number): MetadataLatest;

package/build-tsc/metadata/v9/toV10.d.ts

@@ -0,0 +1,4 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV9, MetadataV10 } from '../../interfaces/metadata/index.js';
+/** @internal */
+export declare function toV10(registry: Registry, { modules }: MetadataV9): MetadataV10;

package/build-tsc/metadata/versions.d.ts

@@ -0,0 +1,5 @@
+export declare const KNOWN_VERSIONS: readonly [16, 15, 14, 13, 12, 11, 10, 9];
+export declare const LATEST_VERSION: 16;
+export declare const TO_CALLS_VERSION = 14;
+export type MetaVersionAll = typeof KNOWN_VERSIONS[number];
+export type MetaVersionAsX = `asV${MetaVersionAll}`;

package/build-tsc/packageDetect.d.ts

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

package/build-tsc/packageInfo.d.ts

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

package/build-tsc/primitive/Data.d.ts

@@ -0,0 +1,31 @@
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { H256 } from '../interfaces/runtime/index.js';
+import { Enum } from '@pezkuwi/types-codec';
+/**
+ * @name Data
+ * @description
+ * A [[Data]] container with node, raw or hashed data
+ */
+export declare class Data extends Enum {
+    constructor(registry: Registry, value?: Record<string, any> | Uint8Array | Enum | string);
+    get asBlakeTwo256(): H256;
+    get asKeccak256(): H256;
+    get asRaw(): Bytes;
+    get asSha256(): H256;
+    get asShaThree256(): H256;
+    get isBlakeTwo256(): boolean;
+    get isKeccak256(): boolean;
+    get isNone(): boolean;
+    get isRaw(): boolean;
+    get isSha256(): boolean;
+    get isShaThree256(): boolean;
+    /**
+     * @description The encoded length
+     */
+    get encodedLength(): number;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     */
+    toU8a(): Uint8Array;
+}