/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

/* Generated types for 0x1, original address 0x1 */

import { TypeDescriptor, ANY_TYPE } from "@typemove/move";
import { MoveCoder, TypedEventInstance } from "@typemove/sui";

import { defaultMoveCoder } from "@sentio/sdk/sui";

import {
  ZERO_ADDRESS,
  TypedSimulateResults,
  getMoveCoder,
} from "@typemove/sui";
import {
  Transaction,
  TransactionArgument,
  TransactionObjectArgument,
} from "@mysten/sui/transactions";
import { SuiGrpcClient } from "@mysten/sui/grpc";
import {
  transactionArgumentOrObject,
  transactionArgumentOrVec,
  transactionArgumentOrPure,
  transactionArgumentOrPureU8,
  transactionArgumentOrPureU16,
  transactionArgumentOrPureU32,
  transactionArgumentOrPureU64,
  transactionArgumentOrPureU128,
  transactionArgumentOrPureU256,
  transactionArgumentOrPureBool,
  transactionArgumentOrPureString,
  transactionArgumentOrPureAddress,
} from "@typemove/sui";

import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move";
import { HandlerOptions } from "@sentio/sdk";
import {
  SuiBindOptions,
  SuiBaseProcessor,
  SuiNetwork,
  TypedFunctionPayload,
  SuiContext,
} from "@sentio/sdk/sui";

export namespace address {
  export namespace builder {
    export function length(
      tx: Transaction,
      args: [],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::address::length",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function length(
      client: SuiGrpcClient,
      args: [],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.length(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
  }
}

export namespace ascii {
  export type Char = string;
  export namespace Char {
    export const TYPE_QNAME = "0x1::ascii::Char";

    const TYPE = new TypeDescriptor<Char>(Char.TYPE_QNAME);

    export function type(): TypeDescriptor<Char> {
      return TYPE.apply();
    }
  }

  export type String = string;
  export namespace String {
    export const TYPE_QNAME = "0x1::ascii::String";

    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);

    export function type(): TypeDescriptor<String> {
      return TYPE.apply();
    }
  }

  export namespace builder {
    export function allCharactersPrintable(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::all_characters_printable",
        arguments: _args,
      });
    }
    export function append(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        ascii.String | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::append",
        arguments: _args,
      });
    }
    export function asBytes(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::as_bytes",
        arguments: _args,
      });
    }
    export function byte(
      tx: Transaction,
      args: [ascii.Char | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::byte",
        arguments: _args,
      });
    }
    export function char(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::char",
        arguments: _args,
      });
    }

    export function indexOf(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::index_of",
        arguments: _args,
      });
    }
    export function insert(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        ascii.String | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPure(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::insert",
        arguments: _args,
      });
    }
    export function intoBytes(
      tx: Transaction,
      args: [ascii.String | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::into_bytes",
        arguments: _args,
      });
    }
    export function isEmpty(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::is_empty",
        arguments: _args,
      });
    }
    export function isPrintableChar(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::is_printable_char",
        arguments: _args,
      });
    }
    export function isValidChar(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::is_valid_char",
        arguments: _args,
      });
    }
    export function length(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::length",
        arguments: _args,
      });
    }
    export function popChar(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::pop_char",
        arguments: _args,
      });
    }
    export function pushChar(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        ascii.Char | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::push_char",
        arguments: _args,
      });
    }
    export function string$(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::string",
        arguments: _args,
      });
    }
    export function substring(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::substring",
        arguments: _args,
      });
    }
    export function toLowercase(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::to_lowercase",
        arguments: _args,
      });
    }
    export function toUppercase(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::to_uppercase",
        arguments: _args,
      });
    }
    export function tryString(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::ascii::try_string",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function allCharactersPrintable(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.allCharactersPrintable(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function append(
      client: SuiGrpcClient,
      args: [string, ascii.String],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.append(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function asBytes(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.asBytes(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function byte(
      client: SuiGrpcClient,
      args: [ascii.Char],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.byte(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function char(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[ascii.Char]>> {
      const tx = new Transaction();
      builder.char(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.Char]>(
        simulateRes,
        ["0x1::ascii::Char"],
      );
    }

    export async function indexOf(
      client: SuiGrpcClient,
      args: [string, string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.indexOf(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function insert(
      client: SuiGrpcClient,
      args: [string, bigint, ascii.String],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.insert(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function intoBytes(
      client: SuiGrpcClient,
      args: [ascii.String],
    ): Promise<TypedSimulateResults<[number[]]>> {
      const tx = new Transaction();
      builder.intoBytes(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number[]]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function isEmpty(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isEmpty(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function isPrintableChar(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isPrintableChar(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function isValidChar(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isValidChar(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function length(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.length(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function popChar(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.Char]>> {
      const tx = new Transaction();
      builder.popChar(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.Char]>(
        simulateRes,
        ["0x1::ascii::Char"],
      );
    }
    export async function pushChar(
      client: SuiGrpcClient,
      args: [string, ascii.Char],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.pushChar(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function string$(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.string$(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function substring(
      client: SuiGrpcClient,
      args: [string, bigint, bigint],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.substring(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function toLowercase(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.toLowercase(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function toUppercase(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.toUppercase(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function tryString(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[option.Option<ascii.String>]>> {
      const tx = new Transaction();
      builder.tryString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<ascii.String>]
      >(simulateRes, ["0x1::option::Option<0x1::ascii::String>"]);
    }
  }
}

export namespace bcs {
  export namespace builder {
    export function toBytes<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bcs::to_bytes",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
  }
  export namespace view {
    export async function toBytes<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[number[]]>> {
      const tx = new Transaction();
      builder.toBytes(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number[]]>(
        simulateRes,
        ["Vector<U8>"],
        typeArguments,
      );
    }
  }
}

export class bit_vector extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("bit_vector", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): bit_vector {
    return new bit_vector({ ...bit_vector.DEFAULT_OPTIONS, ...options });
  }

  onEventBitVector(
    func: (event: bit_vector.BitVectorInstance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      bit_vector.BitVectorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): bit_vector {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "bit_vector::BitVector" },
      handlerOptions,
    );
    return this;
  }
}

export namespace bit_vector {
  export interface BitVector {
    length: bigint;
    bit_field: boolean[];
  }

  export namespace BitVector {
    export const TYPE_QNAME = "0x1::bit_vector::BitVector";

    const TYPE = new TypeDescriptor<BitVector>(BitVector.TYPE_QNAME);

    export function type(): TypeDescriptor<BitVector> {
      return TYPE.apply();
    }
  }

  export type BitVectorInstance = TypedEventInstance<BitVector> & {
    data_decoded: BitVector;
    type_arguments: [];
  };

  export namespace builder {
    export function isIndexSet(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::is_index_set",
        arguments: _args,
      });
    }
    export function length(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::length",
        arguments: _args,
      });
    }
    export function longestSetSequenceStartingAt(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::longest_set_sequence_starting_at",
        arguments: _args,
      });
    }
    export function new$(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::new",
        arguments: _args,
      });
    }
    export function set(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::set",
        arguments: _args,
      });
    }
    export function shiftLeft(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::shift_left",
        arguments: _args,
      });
    }
    export function unset(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::bit_vector::unset",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function isIndexSet(
      client: SuiGrpcClient,
      args: [string, bigint],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isIndexSet(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function length(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.length(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function longestSetSequenceStartingAt(
      client: SuiGrpcClient,
      args: [string, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.longestSetSequenceStartingAt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function new$(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bit_vector.BitVector]>> {
      const tx = new Transaction();
      builder.new$(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [bit_vector.BitVector]
      >(simulateRes, ["0x1::bit_vector::BitVector"]);
    }
    export async function set(
      client: SuiGrpcClient,
      args: [string, bigint],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.set(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function shiftLeft(
      client: SuiGrpcClient,
      args: [string, bigint],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.shiftLeft(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function unset(
      client: SuiGrpcClient,
      args: [string, bigint],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.unset(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
  }
}

export namespace bool {
  export namespace builder {}
  export namespace view {}
}

export namespace debug {
  export namespace builder {
    export function print<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::debug::print",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function printStackTrace(
      tx: Transaction,
      args: [],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::debug::print_stack_trace",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function print<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.print(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function printStackTrace(
      client: SuiGrpcClient,
      args: [],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.printStackTrace(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
  }
}

export class fixed_point32 extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("fixed_point32", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): fixed_point32 {
    return new fixed_point32({ ...fixed_point32.DEFAULT_OPTIONS, ...options });
  }

  onEventFixedPoint32(
    func: (event: fixed_point32.FixedPoint32Instance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fixed_point32.FixedPoint32Instance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fixed_point32 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fixed_point32::FixedPoint32" },
      handlerOptions,
    );
    return this;
  }
}

export namespace fixed_point32 {
  export interface FixedPoint32 {
    value: bigint;
  }

  export namespace FixedPoint32 {
    export const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";

    const TYPE = new TypeDescriptor<FixedPoint32>(FixedPoint32.TYPE_QNAME);

    export function type(): TypeDescriptor<FixedPoint32> {
      return TYPE.apply();
    }
  }

  export type FixedPoint32Instance = TypedEventInstance<FixedPoint32> & {
    data_decoded: FixedPoint32;
    type_arguments: [];
  };

  export namespace builder {
    export function createFromRational(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::create_from_rational",
        arguments: _args,
      });
    }
    export function createFromRawValue(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::create_from_raw_value",
        arguments: _args,
      });
    }
    export function divideU64(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        fixed_point32.FixedPoint32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::divide_u64",
        arguments: _args,
      });
    }
    export function getRawValue(
      tx: Transaction,
      args: [fixed_point32.FixedPoint32 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::get_raw_value",
        arguments: _args,
      });
    }
    export function isZero(
      tx: Transaction,
      args: [fixed_point32.FixedPoint32 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::is_zero",
        arguments: _args,
      });
    }
    export function multiplyU64(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        fixed_point32.FixedPoint32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::fixed_point32::multiply_u64",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function createFromRational(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[fixed_point32.FixedPoint32]>> {
      const tx = new Transaction();
      builder.createFromRational(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [fixed_point32.FixedPoint32]
      >(simulateRes, ["0x1::fixed_point32::FixedPoint32"]);
    }
    export async function createFromRawValue(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[fixed_point32.FixedPoint32]>> {
      const tx = new Transaction();
      builder.createFromRawValue(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [fixed_point32.FixedPoint32]
      >(simulateRes, ["0x1::fixed_point32::FixedPoint32"]);
    }
    export async function divideU64(
      client: SuiGrpcClient,
      args: [bigint, fixed_point32.FixedPoint32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divideU64(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function getRawValue(
      client: SuiGrpcClient,
      args: [fixed_point32.FixedPoint32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.getRawValue(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function isZero(
      client: SuiGrpcClient,
      args: [fixed_point32.FixedPoint32],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isZero(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function multiplyU64(
      client: SuiGrpcClient,
      args: [bigint, fixed_point32.FixedPoint32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.multiplyU64(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
  }
}

export namespace hash {
  export namespace builder {
    export function sha2256(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::hash::sha2_256",
        arguments: _args,
      });
    }
    export function sha3256(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::hash::sha3_256",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function sha2256(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[number[]]>> {
      const tx = new Transaction();
      builder.sha2256(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number[]]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function sha3256(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[number[]]>> {
      const tx = new Transaction();
      builder.sha3256(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number[]]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
  }
}

export namespace internal {
  export interface Permit<T0> {
    dummy_field: boolean;
  }

  export namespace Permit {
    export const TYPE_QNAME = "0x1::internal::Permit";

    const TYPE = new TypeDescriptor<Permit<any>>(Permit.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Permit<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace builder {
    export function permit<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::internal::permit",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
  }
  export namespace view {
    export async function permit<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[internal.Permit<T0>]>> {
      const tx = new Transaction();
      builder.permit(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [internal.Permit<T0>]
      >(simulateRes, ["0x1::internal::Permit<T0>"], typeArguments);
    }
  }
}

export namespace macros {
  export namespace builder {}
  export namespace view {}
}

export namespace option {
  export type Option<T> = T | undefined;
  export namespace Option {
    export const TYPE_QNAME = "0x1::option::Option";

    const TYPE = new TypeDescriptor<Option<any>>(Option.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Option<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace builder {
    export function borrow<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::borrow",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function borrowMut<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::borrow_mut",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function borrowWithDefault<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::borrow_with_default",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function contains<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::contains",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function destroyNone<T0 = any>(
      tx: Transaction,
      args: [option.Option<T0> | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::destroy_none",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function destroySome<T0 = any>(
      tx: Transaction,
      args: [option.Option<T0> | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::destroy_some",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function destroyWithDefault<T0 = any>(
      tx: Transaction,
      args: [option.Option<T0> | TransactionArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::destroy_with_default",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function extract<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::extract",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function fill<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::fill",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function getWithDefault<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::get_with_default",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function isNone<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::is_none",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function isSome<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::is_some",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function none<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::none",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function some<T0 = any>(
      tx: Transaction,
      args: [T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::some",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function swap<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::swap",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function swapOrFill<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::swap_or_fill",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function toVec<T0 = any>(
      tx: Transaction,
      args: [option.Option<T0> | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::option::to_vec",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
  }
  export namespace view {
    export async function borrow<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrow(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function borrowMut<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrowMut(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function borrowWithDefault<T0 = any>(
      client: SuiGrpcClient,
      args: [string, string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrowWithDefault(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function contains<T0 = any>(
      client: SuiGrpcClient,
      args: [string, string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.contains(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
        typeArguments,
      );
    }
    export async function destroyNone<T0 = any>(
      client: SuiGrpcClient,
      args: [option.Option<T0>],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.destroyNone(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function destroySome<T0 = any>(
      client: SuiGrpcClient,
      args: [option.Option<T0>],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.destroySome(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function destroyWithDefault<T0 = any>(
      client: SuiGrpcClient,
      args: [option.Option<T0>, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.destroyWithDefault(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function extract<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.extract(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function fill<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.fill(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function getWithDefault<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.getWithDefault(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function isNone<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isNone(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
        typeArguments,
      );
    }
    export async function isSome<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isSome(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
        typeArguments,
      );
    }
    export async function none<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[option.Option<T0>]>> {
      const tx = new Transaction();
      builder.none(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<T0>]
      >(simulateRes, ["0x1::option::Option<T0>"], typeArguments);
    }
    export async function some<T0 = any>(
      client: SuiGrpcClient,
      args: [T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[option.Option<T0>]>> {
      const tx = new Transaction();
      builder.some(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<T0>]
      >(simulateRes, ["0x1::option::Option<T0>"], typeArguments);
    }
    export async function swap<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.swap(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function swapOrFill<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[option.Option<T0>]>> {
      const tx = new Transaction();
      builder.swapOrFill(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<T0>]
      >(simulateRes, ["0x1::option::Option<T0>"], typeArguments);
    }
    export async function toVec<T0 = any>(
      client: SuiGrpcClient,
      args: [option.Option<T0>],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.toVec(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
  }
}

export class string$ extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("string", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): string$ {
    return new string$({ ...string$.DEFAULT_OPTIONS, ...options });
  }

  onEventString(
    func: (event: string$.StringInstance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, string$.StringInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): string$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "string::String" },
      handlerOptions,
    );
    return this;
  }
}

export namespace string$ {
  export interface String {
    bytes: number[];
  }

  export namespace String {
    export const TYPE_QNAME = "0x1::string::String";

    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);

    export function type(): TypeDescriptor<String> {
      return TYPE.apply();
    }
  }

  export type StringInstance = TypedEventInstance<String> & {
    data_decoded: String;
    type_arguments: [];
  };

  export namespace builder {
    export function append(
      tx: Transaction,
      args: [string | TransactionObjectArgument, string | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::append",
        arguments: _args,
      });
    }
    export function appendUtf8(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        (string | TransactionObjectArgument)[] | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrVec(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::append_utf8",
        arguments: _args,
      });
    }
    export function asBytes(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::as_bytes",
        arguments: _args,
      });
    }
    export function bytes(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::bytes",
        arguments: _args,
      });
    }
    export function fromAscii(
      tx: Transaction,
      args: [ascii.String | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::from_ascii",
        arguments: _args,
      });
    }
    export function indexOf(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::index_of",
        arguments: _args,
      });
    }
    export function insert(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        string | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPure(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::insert",
        arguments: _args,
      });
    }

    export function intoBytes(
      tx: Transaction,
      args: [string | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::into_bytes",
        arguments: _args,
      });
    }
    export function isEmpty(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::is_empty",
        arguments: _args,
      });
    }
    export function length(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::length",
        arguments: _args,
      });
    }
    export function subString(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::sub_string",
        arguments: _args,
      });
    }
    export function substring(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::substring",
        arguments: _args,
      });
    }
    export function toAscii(
      tx: Transaction,
      args: [string | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::to_ascii",
        arguments: _args,
      });
    }
    export function tryUtf8(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::try_utf8",
        arguments: _args,
      });
    }
    export function utf8(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::string::utf8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function append(
      client: SuiGrpcClient,
      args: [string, string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.append(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function appendUtf8(
      client: SuiGrpcClient,
      args: [string, string[]],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.appendUtf8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }
    export async function asBytes(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.asBytes(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function bytes(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.bytes(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function fromAscii(
      client: SuiGrpcClient,
      args: [ascii.String],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.fromAscii(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function indexOf(
      client: SuiGrpcClient,
      args: [string, string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.indexOf(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function insert(
      client: SuiGrpcClient,
      args: [string, bigint, string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.insert(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
      );
    }

    export async function intoBytes(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[number[]]>> {
      const tx = new Transaction();
      builder.intoBytes(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number[]]>(
        simulateRes,
        ["Vector<U8>"],
      );
    }
    export async function isEmpty(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isEmpty(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function length(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.length(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function subString(
      client: SuiGrpcClient,
      args: [string, bigint, bigint],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.subString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function substring(
      client: SuiGrpcClient,
      args: [string, bigint, bigint],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.substring(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function toAscii(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.toAscii(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function tryUtf8(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[option.Option<string>]>> {
      const tx = new Transaction();
      builder.tryUtf8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<string>]
      >(simulateRes, ["0x1::option::Option<0x1::string::String>"]);
    }
    export async function utf8(
      client: SuiGrpcClient,
      args: [string[]],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.utf8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
  }
}

export class type_name extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("type_name", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): type_name {
    return new type_name({ ...type_name.DEFAULT_OPTIONS, ...options });
  }

  onEventTypeName(
    func: (event: type_name.TypeNameInstance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      type_name.TypeNameInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): type_name {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "type_name::TypeName" },
      handlerOptions,
    );
    return this;
  }
}

export namespace type_name {
  export interface TypeName {
    name: ascii.String;
  }

  export namespace TypeName {
    export const TYPE_QNAME = "0x1::type_name::TypeName";

    const TYPE = new TypeDescriptor<TypeName>(TypeName.TYPE_QNAME);

    export function type(): TypeDescriptor<TypeName> {
      return TYPE.apply();
    }
  }

  export type TypeNameInstance = TypedEventInstance<TypeName> & {
    data_decoded: TypeName;
    type_arguments: [];
  };

  export namespace builder {
    export function addressString(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::address_string",
        arguments: _args,
      });
    }
    export function asString(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::as_string",
        arguments: _args,
      });
    }
    export function borrowString(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::borrow_string",
        arguments: _args,
      });
    }
    export function datatypeString(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::datatype_string",
        arguments: _args,
      });
    }
    export function definingId<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::defining_id",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function get<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::get",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function getAddress(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::get_address",
        arguments: _args,
      });
    }
    export function getModule(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::get_module",
        arguments: _args,
      });
    }
    export function getWithOriginalIds<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::get_with_original_ids",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function intoString(
      tx: Transaction,
      args: [type_name.TypeName | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::into_string",
        arguments: _args,
      });
    }
    export function isPrimitive(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::is_primitive",
        arguments: _args,
      });
    }
    export function moduleString(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::module_string",
        arguments: _args,
      });
    }
    export function originalId<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::original_id",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function withDefiningIds<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::with_defining_ids",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function withOriginalIds<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::type_name::with_original_ids",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
  }
  export namespace view {
    export async function addressString(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.addressString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function asString(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.asString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function borrowString(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrowString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function datatypeString(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.datatypeString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function definingId<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.definingId(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["Address"],
        typeArguments,
      );
    }
    export async function get<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[type_name.TypeName]>> {
      const tx = new Transaction();
      builder.get(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [type_name.TypeName]
      >(simulateRes, ["0x1::type_name::TypeName"], typeArguments);
    }
    export async function getAddress(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.getAddress(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function getModule(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.getModule(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function getWithOriginalIds<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[type_name.TypeName]>> {
      const tx = new Transaction();
      builder.getWithOriginalIds(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [type_name.TypeName]
      >(simulateRes, ["0x1::type_name::TypeName"], typeArguments);
    }
    export async function intoString(
      client: SuiGrpcClient,
      args: [type_name.TypeName],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.intoString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function isPrimitive(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isPrimitive(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function moduleString(
      client: SuiGrpcClient,
      args: [string],
    ): Promise<TypedSimulateResults<[ascii.String]>> {
      const tx = new Transaction();
      builder.moduleString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[ascii.String]>(
        simulateRes,
        ["0x1::ascii::String"],
      );
    }
    export async function originalId<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.originalId(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["Address"],
        typeArguments,
      );
    }
    export async function withDefiningIds<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[type_name.TypeName]>> {
      const tx = new Transaction();
      builder.withDefiningIds(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [type_name.TypeName]
      >(simulateRes, ["0x1::type_name::TypeName"], typeArguments);
    }
    export async function withOriginalIds<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[type_name.TypeName]>> {
      const tx = new Transaction();
      builder.withOriginalIds(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [type_name.TypeName]
      >(simulateRes, ["0x1::type_name::TypeName"], typeArguments);
    }
  }
}

export namespace u128 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_mul",
        arguments: _args,
      });
    }
    export function checkedShl(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_shl",
        arguments: _args,
      });
    }
    export function checkedShr(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_shr",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::min",
        arguments: _args,
      });
    }
    export function mulDiv(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));
      _args.push(transactionArgumentOrPureU128(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::mul_div",
        arguments: _args,
      });
    }
    export function mulDivCeil(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));
      _args.push(transactionArgumentOrPureU128(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::mul_div_ceil",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::saturating_sub",
        arguments: _args,
      });
    }
    export function sqrt(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::sqrt",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::to_string",
        arguments: _args,
      });
    }
    export function tryAsU16(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::try_as_u16",
        arguments: _args,
      });
    }
    export function tryAsU32(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::try_as_u32",
        arguments: _args,
      });
    }
    export function tryAsU64(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::try_as_u64",
        arguments: _args,
      });
    }
    export function tryAsU8(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u128::try_as_u8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function checkedShl(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function checkedShr(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function mulDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.mulDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function mulDivCeil(
      client: SuiGrpcClient,
      args: [bigint, bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.mulDivCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function sqrt(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.sqrt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function tryAsU16(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU16(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function tryAsU32(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU32(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function tryAsU64(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.tryAsU64(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function tryAsU8(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
  }
}

export namespace u16 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_mul",
        arguments: _args,
      });
    }
    export function checkedShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_shl",
        arguments: _args,
      });
    }
    export function checkedShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_shr",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::min",
        arguments: _args,
      });
    }
    export function mulDiv(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));
      _args.push(transactionArgumentOrPureU16(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::mul_div",
        arguments: _args,
      });
    }
    export function mulDivCeil(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));
      _args.push(transactionArgumentOrPureU16(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::mul_div_ceil",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));
      _args.push(transactionArgumentOrPureU16(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::saturating_sub",
        arguments: _args,
      });
    }
    export function sqrt(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::sqrt",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::to_string",
        arguments: _args,
      });
    }
    export function tryAsU8(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU16(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u16::try_as_u8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function checkedShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function checkedShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function mulDiv(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function mulDivCeil(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDivCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function sqrt(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.sqrt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U16"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function tryAsU8(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
  }
}

export namespace u256 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::checked_mul",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::min",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));
      _args.push(transactionArgumentOrPureU256(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::saturating_sub",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::to_string",
        arguments: _args,
      });
    }
    export function tryAsU128(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::try_as_u128",
        arguments: _args,
      });
    }
    export function tryAsU16(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::try_as_u16",
        arguments: _args,
      });
    }
    export function tryAsU32(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::try_as_u32",
        arguments: _args,
      });
    }
    export function tryAsU64(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::try_as_u64",
        arguments: _args,
      });
    }
    export function tryAsU8(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU256(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u256::try_as_u8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U256>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U256"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function tryAsU128(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.tryAsU128(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U128>"]);
    }
    export async function tryAsU16(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU16(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function tryAsU32(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU32(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function tryAsU64(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.tryAsU64(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function tryAsU8(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
  }
}

export namespace u32 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_mul",
        arguments: _args,
      });
    }
    export function checkedShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_shl",
        arguments: _args,
      });
    }
    export function checkedShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_shr",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::min",
        arguments: _args,
      });
    }
    export function mulDiv(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));
      _args.push(transactionArgumentOrPureU32(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::mul_div",
        arguments: _args,
      });
    }
    export function mulDivCeil(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));
      _args.push(transactionArgumentOrPureU32(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::mul_div_ceil",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));
      _args.push(transactionArgumentOrPureU32(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::saturating_sub",
        arguments: _args,
      });
    }
    export function sqrt(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::sqrt",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::to_string",
        arguments: _args,
      });
    }
    export function tryAsU16(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::try_as_u16",
        arguments: _args,
      });
    }
    export function tryAsU8(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u32::try_as_u8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function checkedShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function checkedShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function mulDiv(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function mulDivCeil(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDivCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function sqrt(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.sqrt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function tryAsU16(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU16(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function tryAsU8(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
  }
}

export namespace u64 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_mul",
        arguments: _args,
      });
    }
    export function checkedShl(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_shl",
        arguments: _args,
      });
    }
    export function checkedShr(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_shr",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::min",
        arguments: _args,
      });
    }
    export function mulDiv(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::mul_div",
        arguments: _args,
      });
    }
    export function mulDivCeil(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::mul_div_ceil",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [bigint | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::saturating_sub",
        arguments: _args,
      });
    }
    export function sqrt(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::sqrt",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::to_string",
        arguments: _args,
      });
    }
    export function tryAsU16(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::try_as_u16",
        arguments: _args,
      });
    }
    export function tryAsU32(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::try_as_u32",
        arguments: _args,
      });
    }
    export function tryAsU8(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u64::try_as_u8",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function checkedShl(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function checkedShr(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[option.Option<bigint>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<bigint>]
      >(simulateRes, ["0x1::option::Option<U64>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function mulDiv(
      client: SuiGrpcClient,
      args: [bigint, bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.mulDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function mulDivCeil(
      client: SuiGrpcClient,
      args: [bigint, bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.mulDivCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [bigint, number],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function sqrt(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.sqrt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
    export async function tryAsU16(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU16(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U16>"]);
    }
    export async function tryAsU32(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU32(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U32>"]);
    }
    export async function tryAsU8(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.tryAsU8(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
  }
}

export namespace u8 {
  export namespace builder {
    export function bitwiseNot(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::bitwise_not",
        arguments: _args,
      });
    }
    export function checkedAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_add",
        arguments: _args,
      });
    }
    export function checkedDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_div",
        arguments: _args,
      });
    }
    export function checkedMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_mul",
        arguments: _args,
      });
    }
    export function checkedShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_shl",
        arguments: _args,
      });
    }
    export function checkedShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_shr",
        arguments: _args,
      });
    }
    export function checkedSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::checked_sub",
        arguments: _args,
      });
    }
    export function diff(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::diff",
        arguments: _args,
      });
    }
    export function divCeil(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::div_ceil",
        arguments: _args,
      });
    }
    export function divideAndRoundUp(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::divide_and_round_up",
        arguments: _args,
      });
    }
    export function losslessDiv(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::lossless_div",
        arguments: _args,
      });
    }
    export function losslessShl(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::lossless_shl",
        arguments: _args,
      });
    }
    export function losslessShr(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::lossless_shr",
        arguments: _args,
      });
    }
    export function max(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::max",
        arguments: _args,
      });
    }
    export function min(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::min",
        arguments: _args,
      });
    }
    export function mulDiv(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));
      _args.push(transactionArgumentOrPureU8(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::mul_div",
        arguments: _args,
      });
    }
    export function mulDivCeil(
      tx: Transaction,
      args: [
        number | TransactionArgument,
        number | TransactionArgument,
        number | TransactionArgument,
      ],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));
      _args.push(transactionArgumentOrPureU8(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::mul_div_ceil",
        arguments: _args,
      });
    }
    export function pow(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::pow",
        arguments: _args,
      });
    }
    export function saturatingAdd(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::saturating_add",
        arguments: _args,
      });
    }
    export function saturatingMul(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::saturating_mul",
        arguments: _args,
      });
    }
    export function saturatingSub(
      tx: Transaction,
      args: [number | TransactionArgument, number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));
      _args.push(transactionArgumentOrPureU8(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::saturating_sub",
        arguments: _args,
      });
    }
    export function sqrt(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::sqrt",
        arguments: _args,
      });
    }
    export function toString(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU8(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::u8::to_string",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function bitwiseNot(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.bitwiseNot(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function checkedAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function checkedDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function checkedMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function checkedShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function checkedShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function checkedSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.checkedSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function diff(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.diff(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function divCeil(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function divideAndRoundUp(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.divideAndRoundUp(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function losslessDiv(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function losslessShl(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShl(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function losslessShr(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[option.Option<number>]>> {
      const tx = new Transaction();
      builder.losslessShr(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [option.Option<number>]
      >(simulateRes, ["0x1::option::Option<U8>"]);
    }
    export async function max(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.max(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function min(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.min(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function mulDiv(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function mulDivCeil(
      client: SuiGrpcClient,
      args: [number, number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.mulDivCeil(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function pow(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.pow(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function saturatingAdd(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingAdd(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function saturatingMul(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function saturatingSub(
      client: SuiGrpcClient,
      args: [number, number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.saturatingSub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function sqrt(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.sqrt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U8"],
      );
    }
    export async function toString(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.toString(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["0x1::string::String"],
      );
    }
  }
}

export class uq32_32 extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("uq32_32", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): uq32_32 {
    return new uq32_32({ ...uq32_32.DEFAULT_OPTIONS, ...options });
  }

  onEventUQ32_32(
    func: (event: uq32_32.UQ32_32Instance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, uq32_32.UQ32_32Instance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): uq32_32 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "uq32_32::UQ32_32" },
      handlerOptions,
    );
    return this;
  }
}

export namespace uq32_32 {
  export interface UQ32_32 {
    pos0: bigint;
  }

  export namespace UQ32_32 {
    export const TYPE_QNAME = "0x1::uq32_32::UQ32_32";

    const TYPE = new TypeDescriptor<UQ32_32>(UQ32_32.TYPE_QNAME);

    export function type(): TypeDescriptor<UQ32_32> {
      return TYPE.apply();
    }
  }

  export type UQ32_32Instance = TypedEventInstance<UQ32_32> & {
    data_decoded: UQ32_32;
    type_arguments: [];
  };

  export namespace builder {
    export function add(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::add",
        arguments: _args,
      });
    }
    export function div(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::div",
        arguments: _args,
      });
    }
    export function fromInt(
      tx: Transaction,
      args: [number | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU32(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::from_int",
        arguments: _args,
      });
    }
    export function fromQuotient(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::from_quotient",
        arguments: _args,
      });
    }
    export function fromRaw(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::from_raw",
        arguments: _args,
      });
    }
    export function ge(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::ge",
        arguments: _args,
      });
    }
    export function gt(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::gt",
        arguments: _args,
      });
    }
    export function intDiv(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::int_div",
        arguments: _args,
      });
    }
    export function intMul(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::int_mul",
        arguments: _args,
      });
    }
    export function le(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::le",
        arguments: _args,
      });
    }
    export function lt(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::lt",
        arguments: _args,
      });
    }
    export function mul(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::mul",
        arguments: _args,
      });
    }
    export function sub(
      tx: Transaction,
      args: [
        uq32_32.UQ32_32 | TransactionArgument,
        uq32_32.UQ32_32 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::sub",
        arguments: _args,
      });
    }
    export function toInt(
      tx: Transaction,
      args: [uq32_32.UQ32_32 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::to_int",
        arguments: _args,
      });
    }
    export function toRaw(
      tx: Transaction,
      args: [uq32_32.UQ32_32 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq32_32::to_raw",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function add(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.add(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function div(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.div(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function fromInt(
      client: SuiGrpcClient,
      args: [number],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.fromInt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function fromQuotient(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.fromQuotient(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function fromRaw(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.fromRaw(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function ge(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.ge(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function gt(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.gt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function intDiv(
      client: SuiGrpcClient,
      args: [bigint, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.intDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function intMul(
      client: SuiGrpcClient,
      args: [bigint, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.intMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function le(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.le(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function lt(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.lt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function mul(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.mul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function sub(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32, uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[uq32_32.UQ32_32]>> {
      const tx = new Transaction();
      builder.sub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq32_32.UQ32_32]
      >(simulateRes, ["0x1::uq32_32::UQ32_32"]);
    }
    export async function toInt(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[number]>> {
      const tx = new Transaction();
      builder.toInt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[number]>(
        simulateRes,
        ["U32"],
      );
    }
    export async function toRaw(
      client: SuiGrpcClient,
      args: [uq32_32.UQ32_32],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.toRaw(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
  }
}

export class uq64_64 extends SuiBaseProcessor {
  constructor(options: SuiBindOptions) {
    super("uq64_64", options);
  }
  static DEFAULT_OPTIONS: SuiBindOptions = {
    address: "0x1",
    network: SuiNetwork.MAIN_NET,
  };

  static bind(options: Partial<SuiBindOptions> = {}): uq64_64 {
    return new uq64_64({ ...uq64_64.DEFAULT_OPTIONS, ...options });
  }

  onEventUQ64_64(
    func: (event: uq64_64.UQ64_64Instance, ctx: SuiContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, uq64_64.UQ64_64Instance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): uq64_64 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "uq64_64::UQ64_64" },
      handlerOptions,
    );
    return this;
  }
}

export namespace uq64_64 {
  export interface UQ64_64 {
    pos0: bigint;
  }

  export namespace UQ64_64 {
    export const TYPE_QNAME = "0x1::uq64_64::UQ64_64";

    const TYPE = new TypeDescriptor<UQ64_64>(UQ64_64.TYPE_QNAME);

    export function type(): TypeDescriptor<UQ64_64> {
      return TYPE.apply();
    }
  }

  export type UQ64_64Instance = TypedEventInstance<UQ64_64> & {
    data_decoded: UQ64_64;
    type_arguments: [];
  };

  export namespace builder {
    export function add(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::add",
        arguments: _args,
      });
    }
    export function div(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::div",
        arguments: _args,
      });
    }
    export function fromInt(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU64(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::from_int",
        arguments: _args,
      });
    }
    export function fromQuotient(
      tx: Transaction,
      args: [bigint | TransactionArgument, bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPureU128(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::from_quotient",
        arguments: _args,
      });
    }
    export function fromRaw(
      tx: Transaction,
      args: [bigint | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::from_raw",
        arguments: _args,
      });
    }
    export function ge(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::ge",
        arguments: _args,
      });
    }
    export function gt(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::gt",
        arguments: _args,
      });
    }
    export function intDiv(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::int_div",
        arguments: _args,
      });
    }
    export function intMul(
      tx: Transaction,
      args: [
        bigint | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPureU128(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::int_mul",
        arguments: _args,
      });
    }
    export function le(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::le",
        arguments: _args,
      });
    }
    export function lt(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::lt",
        arguments: _args,
      });
    }
    export function mul(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::mul",
        arguments: _args,
      });
    }
    export function sub(
      tx: Transaction,
      args: [
        uq64_64.UQ64_64 | TransactionArgument,
        uq64_64.UQ64_64 | TransactionArgument,
      ],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::sub",
        arguments: _args,
      });
    }
    export function toInt(
      tx: Transaction,
      args: [uq64_64.UQ64_64 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::to_int",
        arguments: _args,
      });
    }
    export function toRaw(
      tx: Transaction,
      args: [uq64_64.UQ64_64 | TransactionArgument],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::uq64_64::to_raw",
        arguments: _args,
      });
    }
  }
  export namespace view {
    export async function add(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.add(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function div(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.div(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function fromInt(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.fromInt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function fromQuotient(
      client: SuiGrpcClient,
      args: [bigint, bigint],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.fromQuotient(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function fromRaw(
      client: SuiGrpcClient,
      args: [bigint],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.fromRaw(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function ge(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.ge(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function gt(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.gt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function intDiv(
      client: SuiGrpcClient,
      args: [bigint, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.intDiv(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function intMul(
      client: SuiGrpcClient,
      args: [bigint, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.intMul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
    export async function le(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.le(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function lt(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.lt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
      );
    }
    export async function mul(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.mul(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function sub(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64, uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[uq64_64.UQ64_64]>> {
      const tx = new Transaction();
      builder.sub(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [uq64_64.UQ64_64]
      >(simulateRes, ["0x1::uq64_64::UQ64_64"]);
    }
    export async function toInt(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.toInt(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
      );
    }
    export async function toRaw(
      client: SuiGrpcClient,
      args: [uq64_64.UQ64_64],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.toRaw(tx, args);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U128"],
      );
    }
  }
}

export namespace vector {
  export namespace builder {
    export function append<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        (string | TransactionObjectArgument)[] | TransactionArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrVec(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::append",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function borrow<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::borrow",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function borrowMut<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::borrow_mut",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function contains<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::contains",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function destroyEmpty<T0 = any>(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::destroy_empty",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function empty<T0 = any>(
      tx: Transaction,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [] {
      const _args: any[] = [];

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::empty",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function flatten<T0 = any>(
      tx: Transaction,
      args: [(string | TransactionObjectArgument)[] | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::flatten",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function indexOf<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        string | TransactionObjectArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrObject(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::index_of",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function insert<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        T0 | TransactionArgument,
        bigint | TransactionArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::insert",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function isEmpty<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::is_empty",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function length<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::length",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function popBack<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::pop_back",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function pushBack<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPure(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::push_back",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function remove<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::remove",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function reverse<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::reverse",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function singleton<T0 = any>(
      tx: Transaction,
      args: [T0 | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrPure(args[0], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::singleton",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function skip<T0 = any>(
      tx: Transaction,
      args: [
        (string | TransactionObjectArgument)[] | TransactionArgument,
        bigint | TransactionArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::skip",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function swap<T0 = any>(
      tx: Transaction,
      args: [
        string | TransactionObjectArgument,
        bigint | TransactionArgument,
        bigint | TransactionArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument &
      [TransactionArgument, TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));
      _args.push(transactionArgumentOrPureU64(args[2], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::swap",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function swapRemove<T0 = any>(
      tx: Transaction,
      args: [string | TransactionObjectArgument, bigint | TransactionArgument],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrObject(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::swap_remove",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
    export function take<T0 = any>(
      tx: Transaction,
      args: [
        (string | TransactionObjectArgument)[] | TransactionArgument,
        bigint | TransactionArgument,
      ],
      typeArguments: [TypeDescriptor<T0> | string],
    ): TransactionArgument & [TransactionArgument, TransactionArgument] {
      const _args: any[] = [];
      _args.push(transactionArgumentOrVec(args[0], tx));
      _args.push(transactionArgumentOrPureU64(args[1], tx));

      // @ts-ignore
      return tx.moveCall({
        target: "0x1::vector::take",
        arguments: _args,
        typeArguments: [
          typeof typeArguments[0] === "string"
            ? typeArguments[0]
            : typeArguments[0].getSignature(),
        ],
      });
    }
  }
  export namespace view {
    export async function append<T0 = any>(
      client: SuiGrpcClient,
      args: [string, string[]],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.append(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function borrow<T0 = any>(
      client: SuiGrpcClient,
      args: [string, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrow(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function borrowMut<T0 = any>(
      client: SuiGrpcClient,
      args: [string, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[string]>> {
      const tx = new Transaction();
      builder.borrowMut(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[string]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function contains<T0 = any>(
      client: SuiGrpcClient,
      args: [string, string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.contains(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
        typeArguments,
      );
    }
    export async function destroyEmpty<T0 = any>(
      client: SuiGrpcClient,
      args: [string[]],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.destroyEmpty(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function empty<T0 = any>(
      client: SuiGrpcClient,
      args: [],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.empty(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
    export async function flatten<T0 = any>(
      client: SuiGrpcClient,
      args: [string[]],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.flatten(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
    export async function indexOf<T0 = any>(
      client: SuiGrpcClient,
      args: [string, string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean, bigint]>> {
      const tx = new Transaction();
      builder.indexOf(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<
        [boolean, bigint]
      >(simulateRes, ["Bool", "U64"], typeArguments);
    }
    export async function insert<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.insert(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function isEmpty<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[boolean]>> {
      const tx = new Transaction();
      builder.isEmpty(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[boolean]>(
        simulateRes,
        ["Bool"],
        typeArguments,
      );
    }
    export async function length<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[bigint]>> {
      const tx = new Transaction();
      builder.length(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[bigint]>(
        simulateRes,
        ["U64"],
        typeArguments,
      );
    }
    export async function popBack<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.popBack(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function pushBack<T0 = any>(
      client: SuiGrpcClient,
      args: [string, T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.pushBack(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function remove<T0 = any>(
      client: SuiGrpcClient,
      args: [string, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.remove(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function reverse<T0 = any>(
      client: SuiGrpcClient,
      args: [string],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.reverse(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function singleton<T0 = any>(
      client: SuiGrpcClient,
      args: [T0],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.singleton(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
    export async function skip<T0 = any>(
      client: SuiGrpcClient,
      args: [string[], bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.skip(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
    export async function swap<T0 = any>(
      client: SuiGrpcClient,
      args: [string, bigint, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[]>> {
      const tx = new Transaction();
      builder.swap(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[]>(
        simulateRes,
        [],
        typeArguments,
      );
    }
    export async function swapRemove<T0 = any>(
      client: SuiGrpcClient,
      args: [string, bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0]>> {
      const tx = new Transaction();
      builder.swapRemove(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0]>(
        simulateRes,
        ["T0"],
        typeArguments,
      );
    }
    export async function take<T0 = any>(
      client: SuiGrpcClient,
      args: [string[], bigint],
      typeArguments: [TypeDescriptor<T0> | string],
    ): Promise<TypedSimulateResults<[T0[]]>> {
      const tx = new Transaction();
      builder.take(tx, args, typeArguments);
      // checksEnabled: false matches the old devInspectTransactionBlock
      // semantics — allow simulating view calls without validating object
      // ownership or signer, which view callers obviously can't satisfy.
      const simulateRes = await client.simulateTransaction({
        transaction: tx,
        sender: ZERO_ADDRESS,
        include: { commandResults: true },
        checksEnabled: false,
      } as any);

      return (await getMoveCoder(client)).decodeSimulateResult<[T0[]]>(
        simulateRes,
        ["Vector<T0>"],
        typeArguments,
      );
    }
  }
}

const MODULES = JSON.parse(
  '[{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"length","visibility":2,"isEntry":false}],"name":"address"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"byte","position":0,"type":{"typeParameterInstantiation":[],"type":3}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::Char","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"ascii","name":"Char","kind":1},{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"bytes","position":0,"type":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"ascii","name":"String","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"all_characters_printable","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[],"name":"append","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"as_bytes","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::Char"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"byte","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::Char"}}],"name":"char","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"char_to_lowercase","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"char_to_uppercase","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"index_of","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[],"name":"insert","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"into_bytes","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_empty","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_printable_char","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_valid_char","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"length","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::Char"}}],"name":"pop_char","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::Char"}}],"returns":[],"name":"push_char","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"substring","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"to_lowercase","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"to_uppercase","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_string","visibility":2,"isEntry":false}],"name":"ascii"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"to_bytes","visibility":2,"isEntry":false}],"name":"bcs"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"length","position":0,"type":{"typeParameterInstantiation":[],"type":6}},{"name":"bit_field","position":1,"type":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":2}],"type":9}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"bit_vector","name":"BitVector","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_index_set","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"length","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"longest_set_sequence_starting_at","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}}],"name":"new","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[],"name":"set","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[],"name":"shift_left","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::bit_vector::BitVector"}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[],"name":"unset","visibility":2,"isEntry":false}],"name":"bit_vector"}},{"address":"0x1","module":{"datatypes":[],"functions":[],"name":"bool"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[],"name":"print","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[],"returns":[],"name":"print_stack_trace","visibility":2,"isEntry":false}],"name":"debug"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"value","position":0,"type":{"typeParameterInstantiation":[],"type":6}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"fixed_point32","name":"FixedPoint32","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"name":"create_from_rational","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"name":"create_from_raw_value","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"divide_u64","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"get_raw_value","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_zero","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::fixed_point32::FixedPoint32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"multiply_u64","visibility":2,"isEntry":false}],"name":"fixed_point32"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"sha2_256","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"sha3_256","visibility":2,"isEntry":false}],"name":"hash"}},{"address":"0x1","module":{"datatypes":[{"abilities":[2],"typeParameters":[{"constraints":[],"isPhantom":true}],"fields":[{"name":"dummy_field","position":0,"type":{"typeParameterInstantiation":[],"type":2}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::internal::Permit","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"internal","name":"Permit","kind":1}],"functions":[{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::internal::Permit"}}],"name":"permit","visibility":2,"isEntry":false}],"name":"internal"}},{"address":"0x1","module":{"datatypes":[],"functions":[],"name":"macros"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[{"constraints":[],"isPhantom":false}],"fields":[{"name":"vec","position":0,"type":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"option","name":"Option","kind":1}],"functions":[{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"borrow","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"borrow_mut","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"borrow_with_default","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"contains","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[],"name":"destroy_none","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"destroy_some","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[2]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"destroy_with_default","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"extract","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[],"name":"fill","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[1,2]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"get_with_default","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_none","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_some","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"none","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"some","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"swap","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"swap_or_fill","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"to_vec","visibility":2,"isEntry":false}],"name":"option"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"bytes","position":0,"type":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"string","name":"String","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[],"name":"append","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[],"name":"append_utf8","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"as_bytes","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"bytes","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"from_ascii","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"index_of","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[],"name":"insert","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"internal_check_utf8","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}},{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"internal_index_of","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"internal_is_char_boundary","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"internal_sub_string","visibility":1,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"name":"into_bytes","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_empty","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"length","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"sub_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"substring","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"to_ascii","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_utf8","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"utf8","visibility":2,"isEntry":false}],"name":"string"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"name","position":0,"type":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"type_name","name":"TypeName","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"address_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"as_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"borrow_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"datatype_string","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":1}}],"name":"defining_id","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"name":"get","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"get_address","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"get_module","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"name":"get_with_original_ids","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"into_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_primitive","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"}}],"name":"module_string","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":1}}],"name":"original_id","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"name":"with_defining_ids","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName"}}],"name":"with_original_ids","visibility":2,"isEntry":false}],"name":"type_name"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"mul_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"mul_div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"sqrt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u16","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u32","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u64","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u8","visibility":2,"isEntry":false}],"name":"u128"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"mul_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"mul_div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}},{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":4}}],"name":"sqrt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":4}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u8","visibility":2,"isEntry":false}],"name":"u16"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":8}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}},{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":8}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":7}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u128","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u16","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u32","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u64","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":8}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u8","visibility":2,"isEntry":false}],"name":"u256"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"mul_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"mul_div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}},{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"sqrt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u16","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u8","visibility":2,"isEntry":false}],"name":"u32"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":6}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"mul_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"mul_div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"sqrt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":4}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u16","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":5}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u32","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"try_as_u8","visibility":2,"isEntry":false}],"name":"u64"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"bitwise_not","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"checked_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"diff","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"divide_and_round_up","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shl","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":3}],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::option::Option"}}],"name":"lossless_shr","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"max","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"min","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"mul_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"mul_div_ceil","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"pow","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"saturating_add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"saturating_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}},{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"saturating_sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":3}}],"name":"sqrt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":3}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::string::String"}}],"name":"to_string","visibility":2,"isEntry":false}],"name":"u8"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"pos0","position":0,"type":{"typeParameterInstantiation":[],"type":6}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"uq32_32","name":"UQ32_32","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":5}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"from_int","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"from_quotient","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"from_raw","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"ge","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"gt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"int_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"int_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"le","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"lt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"name":"sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":5}}],"name":"to_int","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq32_32::UQ32_32"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"to_raw","visibility":2,"isEntry":false}],"name":"uq32_32"}},{"address":"0x1","module":{"datatypes":[{"abilities":[1,2,3],"typeParameters":[],"fields":[{"name":"pos0","position":0,"type":{"typeParameterInstantiation":[],"type":7}}],"variants":[],"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64","definingId":"0x0000000000000000000000000000000000000000000000000000000000000001","module":"uq64_64","name":"UQ64_64","kind":1}],"functions":[{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"add","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"from_int","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"from_quotient","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"from_raw","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"ge","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"gt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"int_div","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":7}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"int_mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"le","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"lt","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"mul","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}},{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"name":"sub","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"to_int","visibility":2,"isEntry":false},{"typeParameters":[],"parameters":[{"body":{"typeParameterInstantiation":[],"type":10,"typeName":"0x0000000000000000000000000000000000000000000000000000000000000001::uq64_64::UQ64_64"}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":7}}],"name":"to_raw","visibility":2,"isEntry":false}],"name":"uq64_64"}},{"address":"0x1","module":{"datatypes":[],"functions":[{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[],"name":"append","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"borrow","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"reference":2,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"borrow_mut","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"contains","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[],"name":"destroy_empty","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"empty","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"flatten","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"reference":1,"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}},{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"index_of","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[],"name":"insert","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":2}}],"name":"is_empty","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":1,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":6}}],"name":"length","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"pop_back","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[],"name":"push_back","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"remove","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"returns":[],"name":"reverse","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"singleton","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[2]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"skip","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[],"name":"swap","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[]}],"parameters":[{"reference":2,"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[],"type":11,"typeParameter":0}}],"name":"swap_remove","visibility":2,"isEntry":false},{"typeParameters":[{"constraints":[2]}],"parameters":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}},{"body":{"typeParameterInstantiation":[],"type":6}}],"returns":[{"body":{"typeParameterInstantiation":[{"typeParameterInstantiation":[],"type":11,"typeParameter":0}],"type":9}}],"name":"take","visibility":2,"isEntry":false}],"name":"vector"}}]',
);

export function loadAllTypes(coder: MoveCoder) {
  for (const m of Object.values(MODULES)) {
    coder.load(m as any, "0x1");
  }
}

loadAllTypes(defaultMoveCoder(SuiNetwork.MAIN_NET));
loadAllTypes(defaultMoveCoder(SuiNetwork.TEST_NET));