@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/_dependencies/{source/0x2 → sui}/balance/structs.d.ts

@@ -1,80 +1,100 @@
-import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { PKG_V30 } from "../index";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-export declare function isBalance(type: string): boolean;
-export interface BalanceFields<T extends PhantomTypeArgument> {
-    value: ToField<"u64">;
-}
-export type BalanceReified<T extends PhantomTypeArgument> = Reified<Balance<T>, BalanceFields<T>>;
-export declare class Balance<T extends PhantomTypeArgument> implements StructClass {
-    __StructClass: true;
-    static readonly $typeName = "0x2::balance::Balance";
-    static readonly $numTypeParams = 1;
-    static readonly $isPhantom: readonly [true];
-    readonly $typeName = "0x2::balance::Balance";
-    readonly $fullTypeName: `${typeof PKG_V30}::balance::Balance<${PhantomToTypeStr<T>}>`;
-    readonly $typeArgs: [PhantomToTypeStr<T>];
-    readonly $isPhantom: readonly [true];
-    readonly value: ToField<"u64">;
-    private constructor();
-    static reified<T extends PhantomReified<PhantomTypeArgument>>(T: T): BalanceReified<ToPhantomTypeArgument<T>>;
-    static get r(): typeof Balance.reified;
-    static phantom<T extends PhantomReified<PhantomTypeArgument>>(T: T): PhantomReified<ToTypeStr<Balance<ToPhantomTypeArgument<T>>>>;
-    static get p(): typeof Balance.phantom;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-    }, string>;
-    static fromFields<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, fields: Record<string, any>): Balance<ToPhantomTypeArgument<T>>;
-    static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, item: FieldsWithTypes): Balance<ToPhantomTypeArgument<T>>;
-    static fromBcs<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, data: Uint8Array): Balance<ToPhantomTypeArgument<T>>;
-    toJSONField(): {
-        value: string;
-    };
-    toJSON(): {
-        value: string;
-        $typeName: string;
-        $typeArgs: [PhantomToTypeStr<T>];
-    };
-    static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, field: any): Balance<ToPhantomTypeArgument<T>>;
-    static fromJSON<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, json: Record<string, any>): Balance<ToPhantomTypeArgument<T>>;
-    static fetch<T extends PhantomReified<PhantomTypeArgument>>(client: SuiGrpcClient, typeArg: T, id: string): Promise<Balance<ToPhantomTypeArgument<T>>>;
-}
+/**
+ * A storable handler for Balances in general. Is used in the `Coin`
+ * module to allow balance operations and can be used to implement
+ * custom coins with `Supply` and `Balance`s.
+ */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
 export declare function isSupply(type: string): boolean;
 export interface SupplyFields<T extends PhantomTypeArgument> {
-    value: ToField<"u64">;
+    value: ToField<'u64'>;
 }
 export type SupplyReified<T extends PhantomTypeArgument> = Reified<Supply<T>, SupplyFields<T>>;
+export type SupplyJSONField<T extends PhantomTypeArgument> = {
+    value: string;
+};
+export type SupplyJSON<T extends PhantomTypeArgument> = {
+    $typeName: typeof Supply.$typeName;
+    $typeArgs: [PhantomToTypeStr<T>];
+} & SupplyJSONField<T>;
+/**
+ * A Supply of T. Used for minting and burning.
+ * Wrapped into a `TreasuryCap` in the `Coin` module.
+ */
 export declare class Supply<T extends PhantomTypeArgument> implements StructClass {
     __StructClass: true;
-    static readonly $typeName = "0x2::balance::Supply";
+    static readonly $typeName: `0x2::balance::Supply`;
     static readonly $numTypeParams = 1;
     static readonly $isPhantom: readonly [true];
-    readonly $typeName = "0x2::balance::Supply";
-    readonly $fullTypeName: `${typeof PKG_V30}::balance::Supply<${PhantomToTypeStr<T>}>`;
+    readonly $typeName: typeof Supply.$typeName;
+    readonly $fullTypeName: `0x2::balance::Supply<${PhantomToTypeStr<T>}>`;
     readonly $typeArgs: [PhantomToTypeStr<T>];
-    readonly $isPhantom: readonly [true];
-    readonly value: ToField<"u64">;
+    readonly $isPhantom: typeof Supply.$isPhantom;
+    readonly value: ToField<'u64'>;
     private constructor();
     static reified<T extends PhantomReified<PhantomTypeArgument>>(T: T): SupplyReified<ToPhantomTypeArgument<T>>;
     static get r(): typeof Supply.reified;
     static phantom<T extends PhantomReified<PhantomTypeArgument>>(T: T): PhantomReified<ToTypeStr<Supply<ToPhantomTypeArgument<T>>>>;
     static get p(): typeof Supply.phantom;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-    }, string>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Supply.instantiateBcs>;
     static fromFields<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, fields: Record<string, any>): Supply<ToPhantomTypeArgument<T>>;
     static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, item: FieldsWithTypes): Supply<ToPhantomTypeArgument<T>>;
     static fromBcs<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, data: Uint8Array): Supply<ToPhantomTypeArgument<T>>;
-    toJSONField(): {
-        value: string;
-    };
-    toJSON(): {
-        value: string;
-        $typeName: string;
-        $typeArgs: [PhantomToTypeStr<T>];
-    };
+    toJSONField(): SupplyJSONField<T>;
+    toJSON(): SupplyJSON<T>;
     static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, field: any): Supply<ToPhantomTypeArgument<T>>;
     static fromJSON<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, json: Record<string, any>): Supply<ToPhantomTypeArgument<T>>;
-    static fetch<T extends PhantomReified<PhantomTypeArgument>>(client: SuiGrpcClient, typeArg: T, id: string): Promise<Supply<ToPhantomTypeArgument<T>>>;
+    static fromCoreObject<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Supply<ToPhantomTypeArgument<T>>;
+    static fetch<T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: T, id: string): Promise<Supply<ToPhantomTypeArgument<T>>>;
+}
+export declare function isBalance(type: string): boolean;
+export interface BalanceFields<T extends PhantomTypeArgument> {
+    value: ToField<'u64'>;
+}
+export type BalanceReified<T extends PhantomTypeArgument> = Reified<Balance<T>, BalanceFields<T>>;
+export type BalanceJSONField<T extends PhantomTypeArgument> = {
+    value: string;
+};
+export type BalanceJSON<T extends PhantomTypeArgument> = {
+    $typeName: typeof Balance.$typeName;
+    $typeArgs: [PhantomToTypeStr<T>];
+} & BalanceJSONField<T>;
+/**
+ * Storable balance - an inner struct of a Coin type.
+ * Can be used to store coins which don't need the key ability.
+ */
+export declare class Balance<T extends PhantomTypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x2::balance::Balance`;
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [true];
+    readonly $typeName: typeof Balance.$typeName;
+    readonly $fullTypeName: `0x2::balance::Balance<${PhantomToTypeStr<T>}>`;
+    readonly $typeArgs: [PhantomToTypeStr<T>];
+    readonly $isPhantom: typeof Balance.$isPhantom;
+    readonly value: ToField<'u64'>;
+    private constructor();
+    static reified<T extends PhantomReified<PhantomTypeArgument>>(T: T): BalanceReified<ToPhantomTypeArgument<T>>;
+    static get r(): typeof Balance.reified;
+    static phantom<T extends PhantomReified<PhantomTypeArgument>>(T: T): PhantomReified<ToTypeStr<Balance<ToPhantomTypeArgument<T>>>>;
+    static get p(): typeof Balance.phantom;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Balance.instantiateBcs>;
+    static fromFields<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, fields: Record<string, any>): Balance<ToPhantomTypeArgument<T>>;
+    static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, item: FieldsWithTypes): Balance<ToPhantomTypeArgument<T>>;
+    static fromBcs<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, data: Uint8Array): Balance<ToPhantomTypeArgument<T>>;
+    toJSONField(): BalanceJSONField<T>;
+    toJSON(): BalanceJSON<T>;
+    static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, field: any): Balance<ToPhantomTypeArgument<T>>;
+    static fromJSON<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, json: Record<string, any>): Balance<ToPhantomTypeArgument<T>>;
+    static fromCoreObject<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Balance<ToPhantomTypeArgument<T>>;
+    static fetch<T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: T, id: string): Promise<Balance<ToPhantomTypeArgument<T>>>;
 }

package/_generated/_dependencies/sui/balance/structs.js

@@ -0,0 +1,306 @@
+/**
+ * A storable handler for Balances in general. Is used in the `Coin`
+ * module to allow balance operations and can be used to implement
+ * custom coins with `Supply` and `Balance`s.
+ */
+import { bcs } from '@mysten/sui/bcs';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../../_framework/util.js';
+/* ============================== Supply =============================== */
+export function isSupply(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`0x2::balance::Supply` + '<');
+}
+/**
+ * A Supply of T. Used for minting and burning.
+ * Wrapped into a `TreasuryCap` in the `Coin` module.
+ */
+export class Supply {
+    __StructClass = true;
+    static $typeName = `0x2::balance::Supply`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Supply.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Supply.$isPhantom;
+    value;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(Supply.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.value = fields.value;
+    }
+    static reified(T) {
+        const reifiedBcs = Supply.bcs;
+        return {
+            get typeName() {
+                return Supply.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Supply.$typeName, ...[extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(T)];
+            },
+            isPhantom: Supply.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (fields) => Supply.fromFields(T, fields),
+            fromFieldsWithTypes: (item) => Supply.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => Supply.fromFields(T, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Supply.fromJSONField(T, field),
+            fromJSON: (json) => Supply.fromJSON(T, json),
+            fromCoreObject: (obj) => Supply.fromCoreObject(T, obj),
+            fetch: async (client, id) => Supply.fetch(client, T, id),
+            new: (fields) => {
+                return new Supply([extractType(T)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return Supply.reified;
+    }
+    static phantom(T) {
+        return phantom(Supply.reified(T));
+    }
+    static get p() {
+        return Supply.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('Supply', {
+            value: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Supply.cachedBcs) {
+            Supply.cachedBcs = Supply.instantiateBcs();
+        }
+        return Supply.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return Supply.reified(typeArg).new({
+            value: decodeFromFields('u64', fields.value),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isSupply(item.type)) {
+            throw new Error('not a Supply type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return Supply.reified(typeArg).new({
+            value: decodeFromFieldsWithTypes('u64', item.fields.value),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return Supply.fromFields(typeArg, Supply.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            value: this.value.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return Supply.reified(typeArg).new({
+            value: decodeFromJSONField('u64', field.value),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Supply.$typeName) {
+            throw new Error(`not a Supply json object: expected '${Supply.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(Supply.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return Supply.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isSupply(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Supply object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Supply.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isSupply(object.type)) {
+            throw new Error(`object at id ${id} is not a Supply object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Supply.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== Balance =============================== */
+export function isBalance(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`0x2::balance::Balance` + '<');
+}
+/**
+ * Storable balance - an inner struct of a Coin type.
+ * Can be used to store coins which don't need the key ability.
+ */
+export class Balance {
+    __StructClass = true;
+    static $typeName = `0x2::balance::Balance`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Balance.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Balance.$isPhantom;
+    value;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(Balance.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.value = fields.value;
+    }
+    static reified(T) {
+        const reifiedBcs = Balance.bcs;
+        return {
+            get typeName() {
+                return Balance.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Balance.$typeName, ...[extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(T)];
+            },
+            isPhantom: Balance.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (fields) => Balance.fromFields(T, fields),
+            fromFieldsWithTypes: (item) => Balance.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => Balance.fromFields(T, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Balance.fromJSONField(T, field),
+            fromJSON: (json) => Balance.fromJSON(T, json),
+            fromCoreObject: (obj) => Balance.fromCoreObject(T, obj),
+            fetch: async (client, id) => Balance.fetch(client, T, id),
+            new: (fields) => {
+                return new Balance([extractType(T)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return Balance.reified;
+    }
+    static phantom(T) {
+        return phantom(Balance.reified(T));
+    }
+    static get p() {
+        return Balance.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('Balance', {
+            value: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Balance.cachedBcs) {
+            Balance.cachedBcs = Balance.instantiateBcs();
+        }
+        return Balance.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return Balance.reified(typeArg).new({
+            value: decodeFromFields('u64', fields.value),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isBalance(item.type)) {
+            throw new Error('not a Balance type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return Balance.reified(typeArg).new({
+            value: decodeFromFieldsWithTypes('u64', item.fields.value),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return Balance.fromFields(typeArg, Balance.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            value: this.value.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return Balance.reified(typeArg).new({
+            value: decodeFromJSONField('u64', field.value),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Balance.$typeName) {
+            throw new Error(`not a Balance json object: expected '${Balance.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(Balance.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return Balance.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isBalance(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Balance object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Balance.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBalance(object.type)) {
+            throw new Error(`object at id ${id} is not a Balance object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Balance.fromBcs(typeArg, object.content);
+    }
+}

package/_generated/_dependencies/sui/object/structs.d.ts

@@ -0,0 +1,104 @@
+/** Sui object identifiers */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+export declare function isID(type: string): boolean;
+export interface IDFields {
+    bytes: ToField<'address'>;
+}
+export type IDReified = Reified<ID, IDFields>;
+export type IDJSONField = {
+    bytes: string;
+};
+export type IDJSON = {
+    $typeName: typeof ID.$typeName;
+    $typeArgs: [];
+} & IDJSONField;
+/**
+ * An object ID. This is used to reference Sui Objects.
+ * This is *not* guaranteed to be globally unique--anyone can create an `ID` from a `UID` or
+ * from an object, and ID's can be freely copied and dropped.
+ * Here, the values are not globally unique because there can be multiple values of type `ID`
+ * with the same underlying bytes. For example, `object::id(&obj)` can be called as many times
+ * as you want for a given `obj`, and each `ID` value will be identical.
+ */
+export declare class ID implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x2::object::ID`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof ID.$typeName;
+    readonly $fullTypeName: `0x2::object::ID`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof ID.$isPhantom;
+    readonly bytes: ToField<'address'>;
+    private constructor();
+    static reified(): IDReified;
+    static get r(): IDReified;
+    static phantom(): PhantomReified<ToTypeStr<ID>>;
+    static get p(): PhantomReified<ToTypeStr<ID>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof ID.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): ID;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ID;
+    static fromBcs(data: Uint8Array): ID;
+    toJSONField(): IDJSONField;
+    toJSON(): IDJSON;
+    static fromJSONField(field: any): ID;
+    static fromJSON(json: Record<string, any>): ID;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): ID;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<ID>;
+}
+export declare function isUID(type: string): boolean;
+export interface UIDFields {
+    id: ToField<ID>;
+}
+export type UIDReified = Reified<UID, UIDFields>;
+export type UIDJSONField = {
+    id: string;
+};
+export type UIDJSON = {
+    $typeName: typeof UID.$typeName;
+    $typeArgs: [];
+} & UIDJSONField;
+/**
+ * Globally unique IDs that define an object's ID in storage. Any Sui Object, that is a struct
+ * with the `key` ability, must have `id: UID` as its first field.
+ * These are globally unique in the sense that no two values of type `UID` are ever equal, in
+ * other words for any two values `id1: UID` and `id2: UID`, `id1` != `id2`.
+ * This is a privileged type that can only be derived from a `TxContext`.
+ * `UID` doesn't have the `drop` ability, so deleting a `UID` requires a call to `delete`.
+ */
+export declare class UID implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x2::object::UID`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof UID.$typeName;
+    readonly $fullTypeName: `0x2::object::UID`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof UID.$isPhantom;
+    readonly id: ToField<ID>;
+    private constructor();
+    static reified(): UIDReified;
+    static get r(): UIDReified;
+    static phantom(): PhantomReified<ToTypeStr<UID>>;
+    static get p(): PhantomReified<ToTypeStr<UID>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof UID.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): UID;
+    static fromFieldsWithTypes(item: FieldsWithTypes): UID;
+    static fromBcs(data: Uint8Array): UID;
+    toJSONField(): UIDJSONField;
+    toJSON(): UIDJSON;
+    static fromJSONField(field: any): UID;
+    static fromJSON(json: Record<string, any>): UID;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): UID;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<UID>;
+}