@mysten/sui/src/graphql/generated/queries.ts

Sui TypeScript API(Work in Progress)

// Copyright (c) Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0
/* eslint-disable */

import { DocumentTypeDecoration } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  /** String containing Base64-encoded binary data. */
  Base64: { input: any; output: any; }
  /** String representation of an arbitrary width, possibly signed integer. */
  BigInt: { input: any; output: any; }
  /** ISO-8601 Date and Time: RFC3339 in UTC with format: YYYY-MM-DDTHH:MM:SS.mmmZ. Note that the milliseconds part is optional, and it may be omitted if its value is 0. */
  DateTime: { input: any; output: any; }
  /** Arbitrary JSON data. */
  JSON: { input: any; output: any; }
  /**
   * The contents of a Move Value, corresponding to the following recursive type:
   *
   * type MoveData =
   *     { Address: SuiAddress }
   *   | { UID:     SuiAddress }
   *   | { ID:      SuiAddress }
   *   | { Bool:    bool }
   *   | { Number:  BigInt }
   *   | { String:  string }
   *   | { Vector:  [MoveData] }
   *   | { Option:   MoveData? }
   *   | { Struct:  [{ name: string , value: MoveData }] }
   *   | { Variant: {
   *       name: string,
   *       fields: [{ name: string, value: MoveData }],
   *   }
   */
  MoveData: { input: any; output: any; }
  /**
   * The shape of a concrete Move Type (a type with all its type parameters instantiated with concrete types), corresponding to the following recursive type:
   *
   * type MoveTypeLayout =
   *     "address"
   *   | "bool"
   *   | "u8" | "u16" | ... | "u256"
   *   | { vector: MoveTypeLayout }
   *   | {
   *       struct: {
   *         type: string,
   *         fields: [{ name: string, layout: MoveTypeLayout }],
   *       }
   *     }
   *   | { enum: [{
   *           type: string,
   *           variants: [{
   *               name: string,
   *               fields: [{ name: string, layout: MoveTypeLayout }],
   *           }]
   *       }]
   *   }
   */
  MoveTypeLayout: { input: any; output: any; }
  /**
   * The signature of a concrete Move Type (a type with all its type parameters instantiated with concrete types, that contains no references), corresponding to the following recursive type:
   *
   * type MoveTypeSignature =
   *     "address"
   *   | "bool"
   *   | "u8" | "u16" | ... | "u256"
   *   | { vector: MoveTypeSignature }
   *   | {
   *       datatype: {
   *         package: string,
   *         module: string,
   *         type: string,
   *         typeParameters: [MoveTypeSignature],
   *       }
   *     }
   */
  MoveTypeSignature: { input: any; output: any; }
  /**
   * The shape of an abstract Move Type (a type that can contain free type parameters, and can optionally be taken by reference), corresponding to the following recursive type:
   *
   * type OpenMoveTypeSignature = {
   *   ref: ("&" | "&mut")?,
   *   body: OpenMoveTypeSignatureBody,
   * }
   *
   * type OpenMoveTypeSignatureBody =
   *     "address"
   *   | "bool"
   *   | "u8" | "u16" | ... | "u256"
   *   | { vector: OpenMoveTypeSignatureBody }
   *   | {
   *       datatype {
   *         package: string,
   *         module: string,
   *         type: string,
   *         typeParameters: [OpenMoveTypeSignatureBody]
   *       }
   *     }
   *   | { typeParameter: number }
   */
  OpenMoveTypeSignature: { input: any; output: any; }
  /** String containing 32B hex-encoded address, with a leading "0x". Leading zeroes can be omitted on input but will always appear in outputs (SuiAddress in output is guaranteed to be 66 characters long). */
  SuiAddress: { input: any; output: any; }
  /**
   * An unsigned integer that can hold values up to 2^53 - 1. This can be treated similarly to `Int`,
   * but it is guaranteed to be non-negative, and it may be larger than 2^32 - 1.
   */
  UInt53: { input: any; output: any; }
};

export type ActiveJwk = {
  __typename?: 'ActiveJwk';
  /** The JWK algorithm parameter, (RFC 7517, Section 4.4). */
  alg: Scalars['String']['output'];
  /** The JWK RSA public exponent, (RFC 7517, Section 9.3). */
  e: Scalars['String']['output'];
  /** The most recent epoch in which the JWK was validated. */
  epoch?: Maybe<Epoch>;
  /** The string (Issuing Authority) that identifies the OIDC provider. */
  iss: Scalars['String']['output'];
  /** The string (Key ID) that identifies the JWK among a set of JWKs, (RFC 7517, Section 4.5). */
  kid: Scalars['String']['output'];
  /** The JWK key type parameter, (RFC 7517, Section 4.1). */
  kty: Scalars['String']['output'];
  /** The JWK RSA modulus, (RFC 7517, Section 9.3). */
  n: Scalars['String']['output'];
};

export type ActiveJwkConnection = {
  __typename?: 'ActiveJwkConnection';
  /** A list of edges. */
  edges: Array<ActiveJwkEdge>;
  /** A list of nodes. */
  nodes: Array<ActiveJwk>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type ActiveJwkEdge = {
  __typename?: 'ActiveJwkEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: ActiveJwk;
};

/** The 32-byte address that is an account address (corresponding to a public key). */
export type Address = IOwner & {
  __typename?: 'Address';
  address: Scalars['SuiAddress']['output'];
  /**
   * Total balance of all coins with marker type owned by this address. If type is not supplied,
   * it defaults to `0x2::sui::SUI`.
   */
  balance?: Maybe<Balance>;
  /** The balances of all coin types owned by this address. */
  balances: BalanceConnection;
  /**
   * The coin objects for this address.
   *
   * `type` is a filter on the coin's type parameter, defaulting to `0x2::sui::SUI`.
   */
  coins: CoinConnection;
  /** The domain explicitly configured as the default domain pointing to this address. */
  defaultSuinsName?: Maybe<Scalars['String']['output']>;
  /** Objects owned by this address, optionally `filter`-ed. */
  objects: MoveObjectConnection;
  /** The `0x3::staking_pool::StakedSui` objects owned by this address. */
  stakedSuis: StakedSuiConnection;
  /**
   * The SuinsRegistration NFTs owned by this address. These grant the owner the capability to
   * manage the associated domain.
   */
  suinsRegistrations: SuinsRegistrationConnection;
  /**
   * Similar behavior to the `transactionBlocks` in Query but supporting the additional
   * `AddressTransactionBlockRelationship` filter, which defaults to `SENT`.
   *
   * `scanLimit` restricts the number of candidate transactions scanned when gathering a page of
   * results. It is required for queries that apply more than two complex filters (on function,
   * kind, sender, recipient, input object, changed object, or ids), and can be at most
   * `serviceConfig.maxScanLimit`.
   *
   * When the scan limit is reached the page will be returned even if it has fewer than `first`
   * results when paginating forward (`last` when paginating backwards). If there are more
   * transactions to scan, `pageInfo.hasNextPage` (or `pageInfo.hasPreviousPage`) will be set to
   * `true`, and `PageInfo.endCursor` (or `PageInfo.startCursor`) will be set to the last
   * transaction that was scanned as opposed to the last (or first) transaction in the page.
   *
   * Requesting the next (or previous) page after this cursor will resume the search, scanning
   * the next `scanLimit` many transactions in the direction of pagination, and so on until all
   * transactions in the scanning range have been visited.
   *
   * By default, the scanning range includes all transactions known to GraphQL, but it can be
   * restricted by the `after` and `before` cursors, and the `beforeCheckpoint`,
   * `afterCheckpoint` and `atCheckpoint` filters.
   */
  transactionBlocks: TransactionBlockConnection;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressBalanceArgs = {
  type?: InputMaybe<Scalars['String']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressBalancesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressCoinsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  type?: InputMaybe<Scalars['String']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressDefaultSuinsNameArgs = {
  format?: InputMaybe<DomainFormat>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressObjectsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<ObjectFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressStakedSuisArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressSuinsRegistrationsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The 32-byte address that is an account address (corresponding to a public key). */
export type AddressTransactionBlocksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<TransactionBlockFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  relation?: InputMaybe<AddressTransactionBlockRelationship>;
  scanLimit?: InputMaybe<Scalars['Int']['input']>;
};

export type AddressConnection = {
  __typename?: 'AddressConnection';
  /** A list of edges. */
  edges: Array<AddressEdge>;
  /** A list of nodes. */
  nodes: Array<Address>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type AddressEdge = {
  __typename?: 'AddressEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: Address;
};

/**
 * An address-owned object is owned by a specific 32-byte address that is
 * either an account address (derived from a particular signature scheme) or
 * an object ID. An address-owned object is accessible only to its owner and no others.
 */
export type AddressOwner = {
  __typename?: 'AddressOwner';
  owner?: Maybe<Owner>;
};

/** The possible relationship types for a transaction block: sent, or received. */
export enum AddressTransactionBlockRelationship {
  /**
   * Transactions that this address was involved in, either as the sender, sponsor, or as the
   * owner of some object that was created, modified or transfered.
   */
  Affected = 'AFFECTED',
  /** Transactions this address has sent. */
  Sent = 'SENT'
}

/** An Authenticator represents the access control rules for a ConsensusV2 object. */
export type Authenticator = Address;

/** System transaction for creating the on-chain state used by zkLogin. */
export type AuthenticatorStateCreateTransaction = {
  __typename?: 'AuthenticatorStateCreateTransaction';
  /** A workaround to define an empty variant of a GraphQL union. */
  _?: Maybe<Scalars['Boolean']['output']>;
};

export type AuthenticatorStateExpireTransaction = {
  __typename?: 'AuthenticatorStateExpireTransaction';
  /** The initial version that the AuthenticatorStateUpdate was shared at. */
  authenticatorObjInitialSharedVersion: Scalars['UInt53']['output'];
  /** Expire JWKs that have a lower epoch than this. */
  minEpoch?: Maybe<Epoch>;
};

/** System transaction for updating the on-chain state used by zkLogin. */
export type AuthenticatorStateUpdateTransaction = {
  __typename?: 'AuthenticatorStateUpdateTransaction';
  /** The initial version of the authenticator object that it was shared at. */
  authenticatorObjInitialSharedVersion: Scalars['UInt53']['output'];
  /** Epoch of the authenticator state update transaction. */
  epoch?: Maybe<Epoch>;
  /** Newly active JWKs (JSON Web Keys). */
  newActiveJwks: ActiveJwkConnection;
  /** Consensus round of the authenticator state update. */
  round: Scalars['UInt53']['output'];
};


/** System transaction for updating the on-chain state used by zkLogin. */
export type AuthenticatorStateUpdateTransactionNewActiveJwksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

/** Range of checkpoints that the RPC is guaranteed to produce a consistent response for. */
export type AvailableRange = {
  __typename?: 'AvailableRange';
  first?: Maybe<Checkpoint>;
  last?: Maybe<Checkpoint>;
};

/** The total balance for a particular coin type. */
export type Balance = {
  __typename?: 'Balance';
  /** How many coins of this type constitute the balance */
  coinObjectCount?: Maybe<Scalars['UInt53']['output']>;
  /** Coin type for the balance, such as 0x2::sui::SUI */
  coinType: MoveType;
  /** Total balance across all coin objects of the coin type */
  totalBalance?: Maybe<Scalars['BigInt']['output']>;
};

/** Effects to the balance (sum of coin values per coin type) owned by an address or object. */
export type BalanceChange = {
  __typename?: 'BalanceChange';
  /** The signed balance change. */
  amount?: Maybe<Scalars['BigInt']['output']>;
  /** The inner type of the coin whose balance has changed (e.g. `0x2::sui::SUI`). */
  coinType?: Maybe<MoveType>;
  /** The address or object whose balance has changed. */
  owner?: Maybe<Owner>;
};

export type BalanceChangeConnection = {
  __typename?: 'BalanceChangeConnection';
  /** A list of edges. */
  edges: Array<BalanceChangeEdge>;
  /** A list of nodes. */
  nodes: Array<BalanceChange>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type BalanceChangeEdge = {
  __typename?: 'BalanceChangeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: BalanceChange;
};

export type BalanceConnection = {
  __typename?: 'BalanceConnection';
  /** A list of edges. */
  edges: Array<BalanceEdge>;
  /** A list of nodes. */
  nodes: Array<Balance>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type BalanceEdge = {
  __typename?: 'BalanceEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: Balance;
};

export type BridgeCommitteeInitTransaction = {
  __typename?: 'BridgeCommitteeInitTransaction';
  bridgeObjInitialSharedVersion: Scalars['UInt53']['output'];
};

export type BridgeStateCreateTransaction = {
  __typename?: 'BridgeStateCreateTransaction';
  chainId: Scalars['String']['output'];
};

/**
 * A system transaction that updates epoch information on-chain (increments the current epoch).
 * Executed by the system once per epoch, without using gas. Epoch change transactions cannot be
 * submitted by users, because validators will refuse to sign them.
 *
 * This transaction kind is deprecated in favour of `EndOfEpochTransaction`.
 */
export type ChangeEpochTransaction = {
  __typename?: 'ChangeEpochTransaction';
  /** The total amount of gas charged for computation during the previous epoch (in MIST). */
  computationCharge: Scalars['BigInt']['output'];
  /** The next (to become) epoch. */
  epoch?: Maybe<Epoch>;
  /**
   * The total gas retained from storage fees, that will not be returned by storage rebates when
   * the relevant objects are cleaned up (in MIST).
   */
  nonRefundableStorageFee: Scalars['BigInt']['output'];
  /** The protocol version in effect in the new epoch. */
  protocolVersion: Scalars['UInt53']['output'];
  /** Time at which the next epoch will start. */
  startTimestamp: Scalars['DateTime']['output'];
  /** The total amount of gas charged for storage during the previous epoch (in MIST). */
  storageCharge: Scalars['BigInt']['output'];
  /** The SUI returned to transaction senders for cleaning up objects (in MIST). */
  storageRebate: Scalars['BigInt']['output'];
  /**
   * System packages (specifically framework and move stdlib) that are written before the new
   * epoch starts, to upgrade them on-chain. Validators write these packages out when running the
   * transaction.
   */
  systemPackages: MovePackageConnection;
};


/**
 * A system transaction that updates epoch information on-chain (increments the current epoch).
 * Executed by the system once per epoch, without using gas. Epoch change transactions cannot be
 * submitted by users, because validators will refuse to sign them.
 *
 * This transaction kind is deprecated in favour of `EndOfEpochTransaction`.
 */
export type ChangeEpochTransactionSystemPackagesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

/**
 * Checkpoints contain finalized transactions and are used for node synchronization
 * and global transaction ordering.
 */
export type Checkpoint = {
  __typename?: 'Checkpoint';
  /** The Base64 serialized BCS bytes of CheckpointSummary for this checkpoint. */
  bcs?: Maybe<Scalars['Base64']['output']>;
  /**
   * A 32-byte hash that uniquely identifies the checkpoint contents, encoded in Base58. This
   * hash can be used to verify checkpoint contents by checking signatures against the committee,
   * Hashing contents to match digest, and checking that the previous checkpoint digest matches.
   */
  digest: Scalars['String']['output'];
  /** The epoch this checkpoint is part of. */
  epoch?: Maybe<Epoch>;
  /** The total number of transaction blocks in the network by the end of this checkpoint. */
  networkTotalTransactions?: Maybe<Scalars['UInt53']['output']>;
  /** The digest of the checkpoint at the previous sequence number. */
  previousCheckpointDigest?: Maybe<Scalars['String']['output']>;
  /**
   * The computation cost, storage cost, storage rebate, and non-refundable storage fee
   * accumulated during this epoch, up to and including this checkpoint. These values increase
   * monotonically across checkpoints in the same epoch, and reset on epoch boundaries.
   */
  rollingGasSummary?: Maybe<GasCostSummary>;
  /**
   * This checkpoint's position in the total order of finalized checkpoints, agreed upon by
   * consensus.
   */
  sequenceNumber: Scalars['UInt53']['output'];
  /**
   * The timestamp at which the checkpoint is agreed to have happened according to consensus.
   * Transactions that access time in this checkpoint will observe this timestamp.
   */
  timestamp: Scalars['DateTime']['output'];
  /**
   * Transactions in this checkpoint.
   *
   * `scanLimit` restricts the number of candidate transactions scanned when gathering a page of
   * results. It is required for queries that apply more than two complex filters (on function,
   * kind, sender, recipient, input object, changed object, or ids), and can be at most
   * `serviceConfig.maxScanLimit`.
   *
   * When the scan limit is reached the page will be returned even if it has fewer than `first`
   * results when paginating forward (`last` when paginating backwards). If there are more
   * transactions to scan, `pageInfo.hasNextPage` (or `pageInfo.hasPreviousPage`) will be set to
   * `true`, and `PageInfo.endCursor` (or `PageInfo.startCursor`) will be set to the last
   * transaction that was scanned as opposed to the last (or first) transaction in the page.
   *
   * Requesting the next (or previous) page after this cursor will resume the search, scanning
   * the next `scanLimit` many transactions in the direction of pagination, and so on until all
   * transactions in the scanning range have been visited.
   *
   * By default, the scanning range consists of all transactions in this checkpoint.
   */
  transactionBlocks: TransactionBlockConnection;
  /**
   * This is an aggregation of signatures from a quorum of validators for the checkpoint
   * proposal.
   */
  validatorSignatures: Scalars['Base64']['output'];
};


/**
 * Checkpoints contain finalized transactions and are used for node synchronization
 * and global transaction ordering.
 */
export type CheckpointTransactionBlocksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<TransactionBlockFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  scanLimit?: InputMaybe<Scalars['Int']['input']>;
};

export type CheckpointConnection = {
  __typename?: 'CheckpointConnection';
  /** A list of edges. */
  edges: Array<CheckpointEdge>;
  /** A list of nodes. */
  nodes: Array<Checkpoint>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type CheckpointEdge = {
  __typename?: 'CheckpointEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: Checkpoint;
};

/** Filter either by the digest, or the sequence number, or neither, to get the latest checkpoint. */
export type CheckpointId = {
  digest?: InputMaybe<Scalars['String']['input']>;
  sequenceNumber?: InputMaybe<Scalars['UInt53']['input']>;
};

/** Some 0x2::coin::Coin Move object. */
export type Coin = IMoveObject & IObject & IOwner & {
  __typename?: 'Coin';
  address: Scalars['SuiAddress']['output'];
  /**
   * Total balance of all coins with marker type owned by this object. If type is not supplied,
   * it defaults to `0x2::sui::SUI`.
   */
  balance?: Maybe<Balance>;
  /** The balances of all coin types owned by this object. */
  balances: BalanceConnection;
  /** The Base64-encoded BCS serialization of the object's content. */
  bcs?: Maybe<Scalars['Base64']['output']>;
  /** Balance of this coin object. */
  coinBalance?: Maybe<Scalars['BigInt']['output']>;
  /**
   * The coin objects for this object.
   *
   * `type` is a filter on the coin's type parameter, defaulting to `0x2::sui::SUI`.
   */
  coins: CoinConnection;
  /**
   * Displays the contents of the Move object in a JSON string and through GraphQL types. Also
   * provides the flat representation of the type signature, and the BCS of the corresponding
   * data.
   */
  contents?: Maybe<MoveValue>;
  /** The domain explicitly configured as the default domain pointing to this object. */
  defaultSuinsName?: Maybe<Scalars['String']['output']>;
  /** 32-byte hash that identifies the object's contents, encoded as a Base58 string. */
  digest?: Maybe<Scalars['String']['output']>;
  /**
   * The set of named templates defined on-chain for the type of this object, to be handled
   * off-chain. The server substitutes data from the object into these templates to generate a
   * display string per template.
   */
  display?: Maybe<Array<DisplayEntry>>;
  /**
   * Access a dynamic field on an object using its name. Names are arbitrary Move values whose
   * type have `copy`, `drop`, and `store`, and are specified using their type, and their BCS
   * contents, Base64 encoded.
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicField?: Maybe<DynamicField>;
  /**
   * The dynamic fields and dynamic object fields on an object.
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicFields: DynamicFieldConnection;
  /**
   * Access a dynamic object field on an object using its name. Names are arbitrary Move values
   * whose type have `copy`, `drop`, and `store`, and are specified using their type, and their
   * BCS contents, Base64 encoded. The value of a dynamic object field can also be accessed
   * off-chain directly via its address (e.g. using `Query.object`).
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicObjectField?: Maybe<DynamicField>;
  /**
   * Determines whether a transaction can transfer this object, using the TransferObjects
   * transaction command or `sui::transfer::public_transfer`, both of which require the object to
   * have the `key` and `store` abilities.
   */
  hasPublicTransfer: Scalars['Boolean']['output'];
  /** Objects owned by this object, optionally `filter`-ed. */
  objects: MoveObjectConnection;
  /** The owner type of this object: Immutable, Shared, Parent, Address */
  owner?: Maybe<ObjectOwner>;
  /** The transaction block that created this version of the object. */
  previousTransactionBlock?: Maybe<TransactionBlock>;
  /**
   * The transaction blocks that sent objects to this object.
   *
   * `scanLimit` restricts the number of candidate transactions scanned when gathering a page of
   * results. It is required for queries that apply more than two complex filters (on function,
   * kind, sender, recipient, input object, changed object, or ids), and can be at most
   * `serviceConfig.maxScanLimit`.
   *
   * When the scan limit is reached the page will be returned even if it has fewer than `first`
   * results when paginating forward (`last` when paginating backwards). If there are more
   * transactions to scan, `pageInfo.hasNextPage` (or `pageInfo.hasPreviousPage`) will be set to
   * `true`, and `PageInfo.endCursor` (or `PageInfo.startCursor`) will be set to the last
   * transaction that was scanned as opposed to the last (or first) transaction in the page.
   *
   * Requesting the next (or previous) page after this cursor will resume the search, scanning
   * the next `scanLimit` many transactions in the direction of pagination, and so on until all
   * transactions in the scanning range have been visited.
   *
   * By default, the scanning range includes all transactions known to GraphQL, but it can be
   * restricted by the `after` and `before` cursors, and the `beforeCheckpoint`,
   * `afterCheckpoint` and `atCheckpoint` filters.
   */
  receivedTransactionBlocks: TransactionBlockConnection;
  /** The `0x3::staking_pool::StakedSui` objects owned by this object. */
  stakedSuis: StakedSuiConnection;
  /**
   * The current status of the object as read from the off-chain store. The possible states are:
   * NOT_INDEXED, the object is loaded from serialized data, such as the contents of a genesis or
   * system package upgrade transaction. LIVE, the version returned is the most recent for the
   * object, and it is not deleted or wrapped at that version. HISTORICAL, the object was
   * referenced at a specific version or checkpoint, so is fetched from historical tables and may
   * not be the latest version of the object. WRAPPED_OR_DELETED, the object is deleted or
   * wrapped and only partial information can be loaded."
   */
  status: ObjectKind;
  /**
   * The amount of SUI we would rebate if this object gets deleted or mutated. This number is
   * recalculated based on the present storage gas price.
   */
  storageRebate?: Maybe<Scalars['BigInt']['output']>;
  /**
   * The SuinsRegistration NFTs owned by this object. These grant the owner the capability to
   * manage the associated domain.
   */
  suinsRegistrations: SuinsRegistrationConnection;
  version: Scalars['UInt53']['output'];
};


/** Some 0x2::coin::Coin Move object. */
export type CoinBalanceArgs = {
  type?: InputMaybe<Scalars['String']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinBalancesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinCoinsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  type?: InputMaybe<Scalars['String']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinDefaultSuinsNameArgs = {
  format?: InputMaybe<DomainFormat>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinDynamicFieldArgs = {
  name: DynamicFieldName;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinDynamicFieldsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinDynamicObjectFieldArgs = {
  name: DynamicFieldName;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinObjectsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<ObjectFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinReceivedTransactionBlocksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<TransactionBlockFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  scanLimit?: InputMaybe<Scalars['Int']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinStakedSuisArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** Some 0x2::coin::Coin Move object. */
export type CoinSuinsRegistrationsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

export type CoinConnection = {
  __typename?: 'CoinConnection';
  /** A list of edges. */
  edges: Array<CoinEdge>;
  /** A list of nodes. */
  nodes: Array<Coin>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

export type CoinDenyListStateCreateTransaction = {
  __typename?: 'CoinDenyListStateCreateTransaction';
  /** A workaround to define an empty variant of a GraphQL union. */
  _?: Maybe<Scalars['Boolean']['output']>;
};

/** An edge in a connection. */
export type CoinEdge = {
  __typename?: 'CoinEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: Coin;
};

/** The metadata for a coin type. */
export type CoinMetadata = IMoveObject & IObject & IOwner & {
  __typename?: 'CoinMetadata';
  address: Scalars['SuiAddress']['output'];
  /**
   * Total balance of all coins with marker type owned by this object. If type is not supplied,
   * it defaults to `0x2::sui::SUI`.
   */
  balance?: Maybe<Balance>;
  /** The balances of all coin types owned by this object. */
  balances: BalanceConnection;
  /** The Base64-encoded BCS serialization of the object's content. */
  bcs?: Maybe<Scalars['Base64']['output']>;
  /**
   * The coin objects for this object.
   *
   * `type` is a filter on the coin's type parameter, defaulting to `0x2::sui::SUI`.
   */
  coins: CoinConnection;
  /**
   * Displays the contents of the Move object in a JSON string and through GraphQL types. Also
   * provides the flat representation of the type signature, and the BCS of the corresponding
   * data.
   */
  contents?: Maybe<MoveValue>;
  /** The number of decimal places used to represent the token. */
  decimals?: Maybe<Scalars['Int']['output']>;
  /** The domain explicitly configured as the default domain pointing to this object. */
  defaultSuinsName?: Maybe<Scalars['String']['output']>;
  /** Optional description of the token, provided by the creator of the token. */
  description?: Maybe<Scalars['String']['output']>;
  /** 32-byte hash that identifies the object's contents, encoded as a Base58 string. */
  digest?: Maybe<Scalars['String']['output']>;
  /**
   * The set of named templates defined on-chain for the type of this object, to be handled
   * off-chain. The server substitutes data from the object into these templates to generate a
   * display string per template.
   */
  display?: Maybe<Array<DisplayEntry>>;
  /**
   * Access a dynamic field on an object using its name. Names are arbitrary Move values whose
   * type have `copy`, `drop`, and `store`, and are specified using their type, and their BCS
   * contents, Base64 encoded.
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicField?: Maybe<DynamicField>;
  /**
   * The dynamic fields and dynamic object fields on an object.
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicFields: DynamicFieldConnection;
  /**
   * Access a dynamic object field on an object using its name. Names are arbitrary Move values
   * whose type have `copy`, `drop`, and `store`, and are specified using their type, and their
   * BCS contents, Base64 encoded. The value of a dynamic object field can also be accessed
   * off-chain directly via its address (e.g. using `Query.object`).
   *
   * Dynamic fields on wrapped objects can be accessed by using the same API under the Owner
   * type.
   */
  dynamicObjectField?: Maybe<DynamicField>;
  /**
   * Determines whether a transaction can transfer this object, using the TransferObjects
   * transaction command or `sui::transfer::public_transfer`, both of which require the object to
   * have the `key` and `store` abilities.
   */
  hasPublicTransfer: Scalars['Boolean']['output'];
  iconUrl?: Maybe<Scalars['String']['output']>;
  /** Full, official name of the token. */
  name?: Maybe<Scalars['String']['output']>;
  /** Objects owned by this object, optionally `filter`-ed. */
  objects: MoveObjectConnection;
  /** The owner type of this object: Immutable, Shared, Parent, Address */
  owner?: Maybe<ObjectOwner>;
  /** The transaction block that created this version of the object. */
  previousTransactionBlock?: Maybe<TransactionBlock>;
  /**
   * The transaction blocks that sent objects to this object.
   *
   * `scanLimit` restricts the number of candidate transactions scanned when gathering a page of
   * results. It is required for queries that apply more than two complex filters (on function,
   * kind, sender, recipient, input object, changed object, or ids), and can be at most
   * `serviceConfig.maxScanLimit`.
   *
   * When the scan limit is reached the page will be returned even if it has fewer than `first`
   * results when paginating forward (`last` when paginating backwards). If there are more
   * transactions to scan, `pageInfo.hasNextPage` (or `pageInfo.hasPreviousPage`) will be set to
   * `true`, and `PageInfo.endCursor` (or `PageInfo.startCursor`) will be set to the last
   * transaction that was scanned as opposed to the last (or first) transaction in the page.
   *
   * Requesting the next (or previous) page after this cursor will resume the search, scanning
   * the next `scanLimit` many transactions in the direction of pagination, and so on until all
   * transactions in the scanning range have been visited.
   *
   * By default, the scanning range includes all transactions known to GraphQL, but it can be
   * restricted by the `after` and `before` cursors, and the `beforeCheckpoint`,
   * `afterCheckpoint` and `atCheckpoint` filters.
   */
  receivedTransactionBlocks: TransactionBlockConnection;
  /** The `0x3::staking_pool::StakedSui` objects owned by this object. */
  stakedSuis: StakedSuiConnection;
  /**
   * The current status of the object as read from the off-chain store. The possible states are:
   * NOT_INDEXED, the object is loaded from serialized data, such as the contents of a genesis or
   * system package upgrade transaction. LIVE, the version returned is the most recent for the
   * object, and it is not deleted or wrapped at that version. HISTORICAL, the object was
   * referenced at a specific version or checkpoint, so is fetched from historical tables and may
   * not be the latest version of the object. WRAPPED_OR_DELETED, the object is deleted or
   * wrapped and only partial information can be loaded."
   */
  status: ObjectKind;
  /**
   * The amount of SUI we would rebate if this object gets deleted or mutated. This number is
   * recalculated based on the present storage gas price.
   */
  storageRebate?: Maybe<Scalars['BigInt']['output']>;
  /**
   * The SuinsRegistration NFTs owned by this object. These grant the owner the capability to
   * manage the associated domain.
   */
  suinsRegistrations: SuinsRegistrationConnection;
  /** The overall quantity of tokens that will be issued. */
  supply?: Maybe<Scalars['BigInt']['output']>;
  /** The token's identifying abbreviation. */
  symbol?: Maybe<Scalars['String']['output']>;
  version: Scalars['UInt53']['output'];
};


/** The metadata for a coin type. */
export type CoinMetadataBalanceArgs = {
  type?: InputMaybe<Scalars['String']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataBalancesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataCoinsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  type?: InputMaybe<Scalars['String']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataDefaultSuinsNameArgs = {
  format?: InputMaybe<DomainFormat>;
};


/** The metadata for a coin type. */
export type CoinMetadataDynamicFieldArgs = {
  name: DynamicFieldName;
};


/** The metadata for a coin type. */
export type CoinMetadataDynamicFieldsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataDynamicObjectFieldArgs = {
  name: DynamicFieldName;
};


/** The metadata for a coin type. */
export type CoinMetadataObjectsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<ObjectFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataReceivedTransactionBlocksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filter?: InputMaybe<TransactionBlockFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  scanLimit?: InputMaybe<Scalars['Int']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataStakedSuisArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** The metadata for a coin type. */
export type CoinMetadataSuinsRegistrationsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

/**
 * System transaction that runs at the beginning of a checkpoint, and is responsible for setting
 * the current value of the clock, based on the timestamp from consensus.
 */
export type ConsensusCommitPrologueTransaction = {
  __typename?: 'ConsensusCommitPrologueTransaction';
  /** Unix timestamp from consensus. */
  commitTimestamp: Scalars['DateTime']['output'];
  /**
   * Digest of consensus output, encoded as a Base58 string (only available from V2 of the
   * transaction).
   */
  consensusCommitDigest?: Maybe<Scalars['String']['output']>;
  /** Epoch of the commit prologue transaction. */
  epoch?: Maybe<Epoch>;
  /** Consensus round of the commit. */
  round: Scalars['UInt53']['output'];
};

/**
 * A ConsensusV2 object is an object that is automatically versioned by the consensus protocol
 * and allows different authentication modes based on the chosen authenticator.
 * (Initially, only single-owner authentication is supported.)
 */
export type ConsensusV2 = {
  __typename?: 'ConsensusV2';
  authenticator?: Maybe<Authenticator>;
  startVersion: Scalars['UInt53']['output'];
};

export type DependencyConnection = {
  __typename?: 'DependencyConnection';
  /** A list of edges. */
  edges: Array<DependencyEdge>;
  /** A list of nodes. */
  nodes: Array<TransactionBlock>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type DependencyEdge = {
  __typename?: 'DependencyEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<TransactionBlock>;
};

/**
 * The set of named templates defined on-chain for the type of this object,
 * to be handled off-chain. The server substitutes data from the object
 * into these templates to generate a display string per template.
 */
export type DisplayEntry = {
  __typename?: 'DisplayEntry';
  /** An error string describing why the template could not be rendered. */
  error?: Maybe<Scalars['String']['output']>;
  /** The identifier for a particular template string of the Display object. */
  key: Scalars['String']['output'];
  /** The template string for the key with placeholder values substituted. */
  value?: Maybe<Scalars['String']['output']>;
};

export enum DomainFormat {
  At = 'AT',
  Dot = 'DOT'
}

export type DryRunEffect = {
  __typename?: 'DryRunEffect';
  /** Changes made to arguments that were mutably borrowed by each command in this transaction. */
  mutatedReferences?: Maybe<Array<DryRunMutation>>;
  /** Return results of each command in this transaction. */
  returnValues?: Maybe<Array<DryRunReturn>>;
};

export type DryRunMutation = {
  __typename?: 'DryRunMutation';
  bcs: Scalars['Base64']['output'];
  input: TransactionArgument;
  type: MoveType;
};

export type DryRunResult = {
  __typename?: 'DryRunResult';
  /** The error that occurred during dry run execution, if any. */
  error?: Maybe<Scalars['String']['output']>;
  /**
   * The intermediate results for each command of the dry run execution, including
   * contents of mutated references and return values.
   */
  results?: Maybe<Array<DryRunEffect>>;
  /** The transaction block representing the dry run execution. */
  transaction?: Maybe<TransactionBlock>;
};

export type DryRunReturn = {
  __typename?: 'DryRunReturn';
  bcs: Scalars['Base64']['output'];
  type: MoveType;
};

/**
 * Dynamic fields are heterogeneous fields that can be added or removed at runtime,
 * and can have arbitrary user-assigned names. There are two sub-types of dynamic
 * fields:
 *
 * 1) Dynamic Fields can store any value that has the `store` ability, however an object
 * stored in this kind of field will be considered wrapped and will not be accessible
 * directly via its ID by external tools (explorers, wallets, etc) accessing storage.
 * 2) Dynamic Object Fields values must be Sui objects (have the `key` and `store`
 * abilities, and id: UID as the first field), but will still be directly accessible off-chain
 * via their object ID after being attached.
 */
export type DynamicField = {
  __typename?: 'DynamicField';
  /**
   * The string type, data, and serialized value of the DynamicField's 'name' field.
   * This field is used to uniquely identify a child of the parent object.
   */
  name?: Maybe<MoveValue>;
  /**
   * The returned dynamic field is an object if its return type is `MoveObject`,
   * in which case it is also accessible off-chain via its address. Its contents
   * will be from the latest version that is at most equal to its parent object's
   * version
   */
  value?: Maybe<DynamicFieldValue>;
};

export type DynamicFieldConnection = {
  __typename?: 'DynamicFieldConnection';
  /** A list of edges. */
  edges: Array<DynamicFieldEdge>;
  /** A list of nodes. */
  nodes: Array<DynamicField>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type DynamicFieldEdge = {
  __typename?: 'DynamicFieldEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: DynamicField;
};

export type DynamicFieldName = {
  /** The Base64 encoded bcs serialization of the DynamicField's 'name' field. */
  bcs: Scalars['Base64']['input'];
  /**
   * The string type of the DynamicField's 'name' field.
   * A string representation of a Move primitive like 'u64', or a struct type like '0x2::kiosk::Listing'
   */
  type: Scalars['String']['input'];
};

export type DynamicFieldValue = MoveObject | MoveValue;

/**
 * System transaction that supersedes `ChangeEpochTransaction` as the new way to run transactions
 * at the end of an epoch. Behaves similarly to `ChangeEpochTransaction` but can accommodate other
 * optional transactions to run at the end of the epoch.
 */
export type EndOfEpochTransaction = {
  __typename?: 'EndOfEpochTransaction';
  /** The list of system transactions that are allowed to run at the end of the epoch. */
  transactions: EndOfEpochTransactionKindConnection;
};


/**
 * System transaction that supersedes `ChangeEpochTransaction` as the new way to run transactions
 * at the end of an epoch. Behaves similarly to `ChangeEpochTransaction` but can accommodate other
 * optional transactions to run at the end of the epoch.
 */
export type EndOfEpochTransactionTransactionsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

export type EndOfEpochTransactionKind = AuthenticatorStateCreateTransaction | AuthenticatorStateExpireTransaction | BridgeCommitteeInitTransaction | BridgeStateCreateTransaction | ChangeEpochTransaction | CoinDenyListStateCreateTransaction | RandomnessStateCreateTransaction | StoreExecutionTimeObservationsTransaction;

export type EndOfEpochTransactionKindConnection = {
  __typename?: 'EndOfEpochTransactionKindConnection';
  /** A list of edges. */
  edges: Array<EndOfEpochTransactionKindEdge>;
  /** A list of nodes. */
  nodes: Array<EndOfEpochTransactionKind>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type EndOfEpochTransactionKindEdge = {
  __typename?: 'EndOfEpochTransactionKindEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node: EndOfEpochTransactionKind;
};

/**
 * Operation of the Sui network is temporally partitioned into non-overlapping epochs,
 * and the network aims to keep epochs roughly the same duration as each other.
 * During a particular epoch the following data is fixed:
 *
 * - the protocol version
 * - the reference gas price
 * - the set of participating validators
 */
export type Epoch = {
  __typename?: 'Epoch';
  /** The epoch's corresponding checkpoints. */
  checkpoints: CheckpointConnection;
  /** The epoch's ending timestamp. */
  endTimestamp?: Maybe<Scalars['DateTime']['output']>;
  /** The epoch's id as a sequence number that starts at 0 and is incremented by one at every epoch change. */
  epochId: Scalars['UInt53']['output'];
  /** The storage fees paid for transactions executed during the epoch. */
  fundInflow?: Maybe<Scalars['BigInt']['output']>;
  /**
   * The storage fee rebates paid to users who deleted the data associated with past
   * transactions.
   */
  fundOutflow?: Maybe<Scalars['BigInt']['output']>;
  /**
   * The storage fund available in this epoch.
   * This fund is used to redistribute storag