@suigar/sdk 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/chunk-PPUDLRHA.js

@@ -0,0 +1,331 @@
+import { parseToMist, normalizeSuiAddress, parseStructTag, normalizeStructTag } from '@mysten/sui/utils';
+import { bcs, BcsStruct, TypeTagSerializer } from '@mysten/sui/bcs';
+import { isArgument } from '@mysten/sui/transactions';
+
+// src/utils/constants.ts
+var DEFAULT_GAS_BUDGET_MIST = parseToMist("0.05");
+var DEFAULT_RANGE_SCALE = 1e6;
+var RANGE_POINT_LIMIT = DEFAULT_RANGE_SCALE * 100;
+var DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+
+// src/utils/numeric.ts
+function isFiniteNumber(value, message) {
+  if (typeof value !== "number") {
+    throw new Error(`${message}: ${String(value)}`);
+  }
+  if (!Number.isFinite(value)) {
+    throw new Error(`Value must be a finite number: ${value}`);
+  }
+}
+function toBigInt(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error(`Value must be non-negative: ${value}`);
+    }
+    return value;
+  }
+  isFiniteNumber(value, "Value must be a bigint or number");
+  if (value < 0) {
+    throw new Error(`Value must be a finite non-negative number: ${value}`);
+  }
+  return BigInt(Math.trunc(value));
+}
+function toU8(value) {
+  isFiniteNumber(value, "Value must be a number");
+  if (!Number.isInteger(value)) {
+    throw new Error(`Value must be an integer: ${value}`);
+  }
+  if (value < 0 || value > 255) {
+    throw new Error(`Value must be an integer between 0 and 255: ${value}`);
+  }
+  return value;
+}
+var MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
+var SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
+function getPureBcsSchema(typeTag) {
+  const parsedTag = typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+  if ("u8" in parsedTag) {
+    return bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return bcs.U256;
+  } else if ("address" in parsedTag) {
+    return bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = normalizeSuiAddress(structTag.address);
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
+        return bcs.String;
+      }
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const inner = structTag.typeParams[0];
+        const type = inner ? getPureBcsSchema(inner) : null;
+        return type ? bcs.option(type) : null;
+      }
+    }
+    if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === "object" && (structTag.name === "ID" || structTag.name === "UID")) {
+      return bcs.Address;
+    }
+  }
+  return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+  if (parameterNames && argLen !== parameterNames.length) {
+    throw new Error(
+      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`
+    );
+  }
+  const normalizedArgs = [];
+  let index = 0;
+  for (const argType of argTypes) {
+    if (argType === "0x2::clock::Clock") {
+      normalizedArgs.push((tx) => tx.object.clock());
+      continue;
+    }
+    if (argType === "0x2::random::Random") {
+      normalizedArgs.push((tx) => tx.object.random());
+      continue;
+    }
+    if (argType === "0x2::deny_list::DenyList") {
+      normalizedArgs.push((tx) => tx.object.denyList());
+      continue;
+    }
+    if (argType === "0x3::sui_system::SuiSystemState") {
+      normalizedArgs.push((tx) => tx.object.system());
+      continue;
+    }
+    let arg;
+    if (Array.isArray(args)) {
+      if (index >= args.length) {
+        throw new Error(
+          `Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`
+        );
+      }
+      arg = args[index];
+    } else {
+      if (!parameterNames) {
+        throw new Error(`Expected arguments to be passed as an array`);
+      }
+      const name = parameterNames[index];
+      arg = args[name];
+      if (arg === void 0) {
+        throw new Error(`Parameter ${name} is required`);
+      }
+    }
+    index += 1;
+    if (typeof arg === "function" || isArgument(arg)) {
+      normalizedArgs.push(arg);
+      continue;
+    }
+    const bcsType = argType === null ? null : getPureBcsSchema(argType);
+    if (bcsType) {
+      const bytes = bcsType.serialize(arg);
+      normalizedArgs.push((tx) => tx.pure(bytes));
+      continue;
+    }
+    if (typeof arg === "string") {
+      normalizedArgs.push((tx) => tx.object(arg));
+      continue;
+    }
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${argType}`);
+  }
+  return normalizedArgs;
+}
+var MoveStruct = class extends BcsStruct {
+  async get({
+    objectId,
+    ...options
+  }) {
+    const [res] = await this.getMany({
+      ...options,
+      objectIds: [objectId]
+    });
+    if (!res) {
+      throw new Error(`No object found for id ${objectId}`);
+    }
+    return res;
+  }
+  async getMany({
+    client,
+    ...options
+  }) {
+    const response = await client.core.getObjects({
+      ...options,
+      include: {
+        ...options.include,
+        content: true
+      }
+    });
+    return response.objects.map((obj) => {
+      if (obj instanceof Error) {
+        throw obj;
+      }
+      return {
+        ...obj,
+        json: this.parse(obj.content)
+      };
+    });
+  }
+};
+function stringify(val) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val2) => val2);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+var $moduleName = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({
+  name: `${$moduleName}::I64`,
+  fields: {
+    bits: bcs.u64()
+  }
+});
+
+// src/contracts/core/float.ts
+var $moduleName2 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float = new MoveStruct({
+  name: `${$moduleName2}::Float`,
+  fields: {
+    is_negative: bcs.bool(),
+    exp: I64,
+    mant: bcs.u64()
+  }
+});
+
+// src/types/game-details.type.ts
+var COINFLIP_GAME_DETAILS_SCHEMA = {
+  player_bet: "string",
+  coin_outcome: "string"
+};
+var PVP_COINFLIP_GAME_DETAILS_SCHEMA = {
+  pvp_result: "string"
+};
+var LIMBO_GAME_DETAILS_SCHEMA = {
+  payout_amount: "u64",
+  win: "bool",
+  roll_multiplier: "float",
+  payout_multiplier: "float",
+  target_multiplier: "float",
+  actual_rtp: "float"
+};
+var RANGE_GAME_DETAILS_SCHEMA = {
+  roll_value: "u64",
+  win: "bool",
+  payout_amount: "u64",
+  payout_multiplier: "float",
+  left_point: "u64",
+  right_point: "u64",
+  zone_size: "u64",
+  winning_zone_size: "u64",
+  is_out_range: "bool",
+  bet_threshold: "u64",
+  roll_under: "bool",
+  range_mode: "u8",
+  win_probability: "float",
+  win_multiplier: "float",
+  actual_rtp: "float"
+};
+var PLINKO_GAME_DETAILS_SCHEMA = {
+  slot_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  plinko_config: "u8"
+};
+var WHEEL_GAME_DETAILS_SCHEMA = {
+  case_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  wheel_config: "u8",
+  spin_value: "u64"
+};
+var GAME_DETAILS_SCHEMA = {
+  ...COINFLIP_GAME_DETAILS_SCHEMA,
+  ...PVP_COINFLIP_GAME_DETAILS_SCHEMA,
+  ...LIMBO_GAME_DETAILS_SCHEMA,
+  ...RANGE_GAME_DETAILS_SCHEMA,
+  ...PLINKO_GAME_DETAILS_SCHEMA,
+  ...WHEEL_GAME_DETAILS_SCHEMA
+};
+
+// src/utils/parser.ts
+var textDecoder = new TextDecoder();
+var GAME_DETAIL_BCS = {
+  u8: bcs.U8,
+  u64: bcs.U64,
+  bool: bcs.Bool,
+  float: Float,
+  string: bcs.String
+};
+function fromMoveI64(i64) {
+  try {
+    return Number(BigInt.asIntN(64, BigInt(i64.bits ?? 0)));
+  } catch {
+    return 0;
+  }
+}
+function fromMoveFloat(float) {
+  const mantissa = BigInt(float.mant ?? 0);
+  if (mantissa === 0n) {
+    return 0;
+  }
+  const exponent = fromMoveI64(float.exp) - 52;
+  const magnitude = Number(mantissa) * 2 ** exponent;
+  return float.is_negative ? -magnitude : magnitude;
+}
+function parseCoinType(type) {
+  const coinType = parseStructTag(type).typeParams[0];
+  if (!coinType) {
+    throw new Error(`Unable to parse coin type from ${type}`);
+  }
+  return normalizeStructTag(coinType);
+}
+function normalizeGameDetailValue(valueType, parsed) {
+  if (valueType === "float") {
+    return fromMoveFloat(parsed);
+  }
+  if (valueType === "u64") {
+    return Number(parsed);
+  }
+  return parsed;
+}
+function parseStringGameDetail(value) {
+  const bytes = Uint8Array.from(value);
+  try {
+    return bcs.String.parse(bytes);
+  } catch {
+    return textDecoder.decode(bytes);
+  }
+}
+function parseGameDetail(valueType, value) {
+  if (valueType === "string") {
+    return parseStringGameDetail(value);
+  }
+  const parsed = GAME_DETAIL_BCS[valueType].parse(Uint8Array.from(value));
+  return normalizeGameDetailValue(valueType, parsed);
+}
+function parseGameDetails(gameDetails) {
+  return gameDetails.contents.reduce((details, entry) => {
+    const valueType = GAME_DETAILS_SCHEMA[entry.key] ?? "string";
+    details[entry.key] = parseGameDetail(valueType, entry.value);
+    return details;
+  }, {});
+}
+
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, Float, MoveStruct, RANGE_POINT_LIMIT, fromMoveFloat, fromMoveI64, normalizeMoveArguments, parseCoinType, parseGameDetails, toBigInt, toU8 };

package/dist/games-BccpPyWd.d.cts

@@ -0,0 +1,86 @@
+import { Transaction } from '@mysten/sui/transactions';
+
+declare const GAMES: readonly ["coinflip", "limbo", "plinko", "pvp-coinflip", "range", "wheel"];
+type Game = (typeof GAMES)[number];
+type StandardGame = Exclude<Game, PvPGame>;
+type PvPGame = 'pvp-coinflip';
+type CoinSide = 'heads' | 'tails';
+
+type BetMetadataPrimitive = string | number | boolean | bigint;
+type BetMetadataValue = BetMetadataPrimitive | Uint8Array | number[];
+type BetMetadataInput = Record<string, BetMetadataValue | null | undefined>;
+
+interface SuigarExtensionOptions<Name = 'suigar'> {
+    name?: Name;
+    partner?: string;
+}
+type SuigarCoin = 'sui' | 'usdc';
+type SuigarCoinTypes = Record<SuigarCoin, string>;
+type SuigarPackageKey = 'sweetHouse' | 'core' | 'coinflip' | 'limbo' | 'plinko' | 'pvpCoinflip' | 'range' | 'wheel';
+type SuigarPackage = Record<SuigarPackageKey, string>;
+type SuigarPriceInfoObjectId = Record<SuigarCoin, string>;
+type SuigarRegistryKey = 'pvpCoinflip';
+type SuigarRegistryId = Record<SuigarRegistryKey, string>;
+type SuigarConfig = {
+    packageIds: SuigarPackage;
+    registryIds: SuigarRegistryId;
+    coinTypes: SuigarCoinTypes;
+    priceInfoObjectIds: SuigarPriceInfoObjectId;
+};
+
+type WithGasBudget = {
+    gasBudget?: Parameters<Transaction['setGasBudgetIfNotSet']>[0];
+};
+type WithThrowOnError<T = object> = T & {
+    throwOnError?: boolean;
+};
+type BaseTransactionOptions = WithGasBudget & {
+    config: SuigarConfig;
+    playerAddress: string;
+};
+type CoinTransactionOptions = {
+    coinType: string;
+    metadata?: BetMetadataInput;
+    allowGasCoinShortcut?: boolean;
+};
+type StakeTransactionOptions = {
+    stake: number | bigint;
+    cashStake?: number | bigint;
+    betCount?: number | bigint;
+};
+type SharedBetTransactionOptions = BaseTransactionOptions & CoinTransactionOptions & StakeTransactionOptions;
+type BuildCoinflipTransactionOptions = SharedBetTransactionOptions & {
+    side: CoinSide;
+};
+type BuildLimboTransactionOptions = SharedBetTransactionOptions & {
+    targetMultiplier: number;
+    scale?: number;
+};
+type BuildPlinkoTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type BuildRangeTransactionOptions = SharedBetTransactionOptions & {
+    leftPoint: number;
+    rightPoint: number;
+    outOfRange?: boolean;
+    scale?: number;
+};
+type BuildWheelTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type PvPCoinflipAction = 'create' | 'join' | 'cancel';
+type SharedPvPCoinflipTransactionOptions = BaseTransactionOptions & CoinTransactionOptions;
+type BuildCreatePvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    stake: StakeTransactionOptions['stake'];
+    side: CoinSide;
+    isPrivate?: boolean;
+};
+type BuildJoinPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildCancelPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildPvPCoinflipTransactionOptions<Action extends PvPCoinflipAction = PvPCoinflipAction> = Action extends 'create' ? BuildCreatePvPCoinflipTransactionOptions : Action extends 'join' ? BuildJoinPvPCoinflipTransactionOptions : Action extends 'cancel' ? BuildCancelPvPCoinflipTransactionOptions : never;
+
+export type { BuildCoinflipTransactionOptions as B, CoinSide as C, PvPCoinflipAction as P, StandardGame as S, WithThrowOnError as W, BuildWheelTransactionOptions as a, BuildLimboTransactionOptions as b, BuildPlinkoTransactionOptions as c, BuildRangeTransactionOptions as d, SuigarConfig as e, BuildPvPCoinflipTransactionOptions as f, SuigarExtensionOptions as g, BuildCancelPvPCoinflipTransactionOptions as h, BuildCreatePvPCoinflipTransactionOptions as i, BuildJoinPvPCoinflipTransactionOptions as j };

package/dist/games-BccpPyWd.d.ts

@@ -0,0 +1,86 @@
+import { Transaction } from '@mysten/sui/transactions';
+
+declare const GAMES: readonly ["coinflip", "limbo", "plinko", "pvp-coinflip", "range", "wheel"];
+type Game = (typeof GAMES)[number];
+type StandardGame = Exclude<Game, PvPGame>;
+type PvPGame = 'pvp-coinflip';
+type CoinSide = 'heads' | 'tails';
+
+type BetMetadataPrimitive = string | number | boolean | bigint;
+type BetMetadataValue = BetMetadataPrimitive | Uint8Array | number[];
+type BetMetadataInput = Record<string, BetMetadataValue | null | undefined>;
+
+interface SuigarExtensionOptions<Name = 'suigar'> {
+    name?: Name;
+    partner?: string;
+}
+type SuigarCoin = 'sui' | 'usdc';
+type SuigarCoinTypes = Record<SuigarCoin, string>;
+type SuigarPackageKey = 'sweetHouse' | 'core' | 'coinflip' | 'limbo' | 'plinko' | 'pvpCoinflip' | 'range' | 'wheel';
+type SuigarPackage = Record<SuigarPackageKey, string>;
+type SuigarPriceInfoObjectId = Record<SuigarCoin, string>;
+type SuigarRegistryKey = 'pvpCoinflip';
+type SuigarRegistryId = Record<SuigarRegistryKey, string>;
+type SuigarConfig = {
+    packageIds: SuigarPackage;
+    registryIds: SuigarRegistryId;
+    coinTypes: SuigarCoinTypes;
+    priceInfoObjectIds: SuigarPriceInfoObjectId;
+};
+
+type WithGasBudget = {
+    gasBudget?: Parameters<Transaction['setGasBudgetIfNotSet']>[0];
+};
+type WithThrowOnError<T = object> = T & {
+    throwOnError?: boolean;
+};
+type BaseTransactionOptions = WithGasBudget & {
+    config: SuigarConfig;
+    playerAddress: string;
+};
+type CoinTransactionOptions = {
+    coinType: string;
+    metadata?: BetMetadataInput;
+    allowGasCoinShortcut?: boolean;
+};
+type StakeTransactionOptions = {
+    stake: number | bigint;
+    cashStake?: number | bigint;
+    betCount?: number | bigint;
+};
+type SharedBetTransactionOptions = BaseTransactionOptions & CoinTransactionOptions & StakeTransactionOptions;
+type BuildCoinflipTransactionOptions = SharedBetTransactionOptions & {
+    side: CoinSide;
+};
+type BuildLimboTransactionOptions = SharedBetTransactionOptions & {
+    targetMultiplier: number;
+    scale?: number;
+};
+type BuildPlinkoTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type BuildRangeTransactionOptions = SharedBetTransactionOptions & {
+    leftPoint: number;
+    rightPoint: number;
+    outOfRange?: boolean;
+    scale?: number;
+};
+type BuildWheelTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type PvPCoinflipAction = 'create' | 'join' | 'cancel';
+type SharedPvPCoinflipTransactionOptions = BaseTransactionOptions & CoinTransactionOptions;
+type BuildCreatePvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    stake: StakeTransactionOptions['stake'];
+    side: CoinSide;
+    isPrivate?: boolean;
+};
+type BuildJoinPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildCancelPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildPvPCoinflipTransactionOptions<Action extends PvPCoinflipAction = PvPCoinflipAction> = Action extends 'create' ? BuildCreatePvPCoinflipTransactionOptions : Action extends 'join' ? BuildJoinPvPCoinflipTransactionOptions : Action extends 'cancel' ? BuildCancelPvPCoinflipTransactionOptions : never;
+
+export type { BuildCoinflipTransactionOptions as B, CoinSide as C, PvPCoinflipAction as P, StandardGame as S, WithThrowOnError as W, BuildWheelTransactionOptions as a, BuildLimboTransactionOptions as b, BuildPlinkoTransactionOptions as c, BuildRangeTransactionOptions as d, SuigarConfig as e, BuildPvPCoinflipTransactionOptions as f, SuigarExtensionOptions as g, BuildCancelPvPCoinflipTransactionOptions as h, BuildCreatePvPCoinflipTransactionOptions as i, BuildJoinPvPCoinflipTransactionOptions as j };

package/dist/games.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/games.d.cts

@@ -0,0 +1,2 @@
+export { h as BuildCancelPvPCoinflipTransactionOptions, B as BuildCoinflipTransactionOptions, i as BuildCreatePvPCoinflipTransactionOptions, j as BuildJoinPvPCoinflipTransactionOptions, b as BuildLimboTransactionOptions, c as BuildPlinkoTransactionOptions, d as BuildRangeTransactionOptions, a as BuildWheelTransactionOptions, C as CoinSide, P as PvPCoinflipAction } from './games-BccpPyWd.cjs';
+import '@mysten/sui/transactions';

package/dist/games.d.ts

@@ -0,0 +1,2 @@
+export { h as BuildCancelPvPCoinflipTransactionOptions, B as BuildCoinflipTransactionOptions, i as BuildCreatePvPCoinflipTransactionOptions, j as BuildJoinPvPCoinflipTransactionOptions, b as BuildLimboTransactionOptions, c as BuildPlinkoTransactionOptions, d as BuildRangeTransactionOptions, a as BuildWheelTransactionOptions, C as CoinSide, P as PvPCoinflipAction } from './games-BccpPyWd.js';
+import '@mysten/sui/transactions';

package/dist/games.js

@@ -0,0 +1 @@
+

package/dist/index-3P_LBbDM.d.cts

@@ -0,0 +1,25 @@
+import { BcsType, BcsStruct } from '@mysten/sui/bcs';
+import { SuiClientTypes, ClientWithCoreApi } from '@mysten/sui/client';
+
+type GetOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectOptions<Include> & {
+    client: ClientWithCoreApi;
+};
+type GetManyOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectsOptions<Include> & {
+    client: ClientWithCoreApi;
+};
+declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+    get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ objectId, ...options }: GetOptions<Include>): Promise<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>;
+    getMany<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ client, ...options }: GetManyOptions<Include>): Promise<Array<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>>;
+}
+
+export { MoveStruct as M };

package/dist/index-3P_LBbDM.d.ts

@@ -0,0 +1,25 @@
+import { BcsType, BcsStruct } from '@mysten/sui/bcs';
+import { SuiClientTypes, ClientWithCoreApi } from '@mysten/sui/client';
+
+type GetOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectOptions<Include> & {
+    client: ClientWithCoreApi;
+};
+type GetManyOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> = SuiClientTypes.GetObjectsOptions<Include> & {
+    client: ClientWithCoreApi;
+};
+declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+    get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ objectId, ...options }: GetOptions<Include>): Promise<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>;
+    getMany<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ client, ...options }: GetManyOptions<Include>): Promise<Array<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>>;
+}
+
+export { MoveStruct as M };