@iota/graphql-transport 0.18.0 → 0.19.0

package/dist/esm/generated/queries.d.ts

@@ -215,10 +215,11 @@ export type Address = IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -237,6 +238,10 @@ export type Address = IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     transactionBlocks: TransactionBlockConnection;
 };
@@ -346,8 +351,16 @@ export type AddressOwner = {
     __typename?: 'AddressOwner';
     owner?: Maybe<Owner>;
 };
-/** The possible relationship types for a transaction block: sent or received. */
+/**
+ * The possible relationship types for a transaction block: sent, received,
+ * or affected.
+ */
 export declare enum AddressTransactionBlockRelationship {
+    /**
+     * Transactions that affected this address (the address is the sender,
+     * a recipient, or the owner of the gas payment).
+     */
+    Affected = "AFFECTED",
     /** Transactions that sent objects to this address. */
     Recv = "RECV",
     /** Transactions this address has sent. */
@@ -546,6 +559,15 @@ export type ChangeEpochTransactionV2SystemPackagesArgs = {
  */
 export type Checkpoint = {
     __typename?: 'Checkpoint';
+    /**
+     * The Base64-encoded BCS serialization of this checkpoint's
+     * `CheckpointSummary`.
+     *
+     * # Note
+     * For older checkpoints, where this data was not recorded, `null` is
+     * returned.
+     */
+    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
@@ -584,10 +606,11 @@ export type Checkpoint = {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -604,6 +627,10 @@ export type Checkpoint = {
      *
      * By default, the scanning range consists of all transactions in this
      * checkpoint.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     transactionBlocks: TransactionBlockConnection;
     /**
@@ -735,10 +762,11 @@ export type Coin = IMoveObject & IObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -757,6 +785,10 @@ export type Coin = IMoveObject & IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The `0x3::staking_pool::StakedIota` objects owned by this object. */
@@ -955,10 +987,11 @@ export type CoinMetadata = IMoveObject & IObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -977,6 +1010,10 @@ export type CoinMetadata = IMoveObject & IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The `0x3::staking_pool::StakedIota` objects owned by this object. */
@@ -1234,7 +1271,7 @@ export type EndOfEpochTransactionTransactionsArgs = {
     first?: InputMaybe<Scalars['Int']['input']>;
     last?: InputMaybe<Scalars['Int']['input']>;
 };
-export type EndOfEpochTransactionKind = ChangeEpochTransaction | ChangeEpochTransactionV2;
+export type EndOfEpochTransactionKind = ChangeEpochTransaction | ChangeEpochTransactionV2 | TransactionDenyRulesCreateTransaction;
 export type EndOfEpochTransactionKindConnection = {
     __typename?: 'EndOfEpochTransactionKindConnection';
     /** A list of edges. */
@@ -1343,10 +1380,11 @@ export type Epoch = {
      * The epoch's corresponding transaction blocks.
      *
      * `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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -1363,6 +1401,10 @@ export type Epoch = {
      *
      * By default, the scanning range consists of all transactions in this
      * epoch.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     transactionBlocks: TransactionBlockConnection;
     /**
@@ -2347,10 +2389,11 @@ export type MoveObject = IMoveObject & IObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -2369,6 +2412,10 @@ export type MoveObject = IMoveObject & IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The `0x3::staking_pool::StakedIota` objects owned by this object. */
@@ -2626,10 +2673,11 @@ export type MovePackage = IObject & IOwner & {
      * Note that objects that have been sent to a package become inaccessible.
      *
      * `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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -2648,6 +2696,10 @@ export type MovePackage = IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /**
@@ -2766,7 +2818,7 @@ export type MovePackageObjectsArgs = {
  * definitions, functions, and dependencies.
  */
 export type MovePackagePackageAtVersionArgs = {
-    version: Scalars['Int']['input'];
+    version: Scalars['UInt53']['input'];
 };
 /**
  * A MovePackage is a kind of Move object that represents code that has been
@@ -2899,15 +2951,9 @@ export type MoveStructTypeParameter = {
 /** Represents concrete types (no type parameters, no references). */
 export type MoveType = {
     __typename?: 'MoveType';
-    /**
-     * The abilities this concrete type has. Returns no abilities if the type
-     * is invalid.
-     */
+    /** The abilities this concrete type has. */
     abilities: Array<MoveAbility>;
-    /**
-     * Structured representation of the "shape" of values that match this type.
-     * May return MoveTypeLayout::InvalidType for malformed types.
-     */
+    /** Structured representation of the "shape" of values that match this type. */
     layout: Scalars['MoveTypeLayout']['output'];
     /** Flat representation of the type signature, as a displayable string. */
     repr: Scalars['String']['output'];
@@ -2978,8 +3024,8 @@ export type Mutation = {
     /**
      * Execute a transaction, committing its effects on chain.
      *
-     * - `txBytes` is a `TransactionData` struct that has been BCS-encoded and
-     * then Base64-encoded.
+     * - `txBytes` is a `Transaction` struct that has been BCS-encoded and then
+     * Base64-encoded.
      * - `signatures` are a list of `flag || signature || pubkey` bytes,
      * Base64-encoded.
      *
@@ -3099,10 +3145,11 @@ export type NameRegistration = IMoveObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -3121,6 +3168,10 @@ export type NameRegistration = IMoveObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The `0x3::staking_pool::StakedIota` objects owned by this object. */
@@ -3307,10 +3358,11 @@ export type Object = IObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -3329,6 +3381,10 @@ export type Object = IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The `0x3::staking_pool::StakedIota` objects owned by this object. */
@@ -3970,14 +4026,14 @@ export type Query = {
      * Simulate running a transaction to inspect its effects without
      * committing to them on-chain.
      *
-     * `txBytes` either a `TransactionData` struct or a `TransactionKind`
+     * `txBytes` either a `Transaction` struct or a `TransactionKind`
      * struct, BCS-encoded and then Base64-encoded.  The expected
      * type is controlled by the presence or absence of `txMeta`: If
      * present, `txBytes` is assumed to be a `TransactionKind`, if
-     * absent, then `TransactionData`.
+     * absent, then `Transaction`.
      *
      * `txMeta` the data that is missing from a `TransactionKind` to make
-     * a `TransactionData` (sender address and gas information).  All
+     * a `Transaction` (sender address and gas information).  All
      * its fields are nullable.
      *
      * `skipChecks` optional flag to disable the usual verification
@@ -4085,10 +4141,11 @@ export type Query = {
      * The transaction blocks that exist in the network.
      *
      * `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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -4108,13 +4165,30 @@ export type Query = {
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters. Transactions that don't have a checkpoint yet
      * are always omitted.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     transactionBlocks: TransactionBlockConnection;
     /**
      * Fetch multiple transaction blocks by their digests.
      * This includes all transactions, even if they are not checkpointed yet.
+     * @deprecated Use `transactionsByDigests` instead. Will be removed in v1.38.
      */
     transactionBlocksByDigests: Array<Maybe<TransactionBlock>>;
+    /**
+     * Fetch multiple transaction blocks by their digests.
+     *
+     * Unlike `transactionBlocks(filter: { transactionIds })`, this includes
+     * all transactions, even if they are not checkpointed yet.
+     *
+     * Pages keep the order of the `digests` argument and hold one node per
+     * digest, null when the transaction was not found. Only forward
+     * pagination is supported: `limit` caps the page size and `cursor`
+     * resumes after an entry of a previous page.
+     */
+    transactionsByDigests: TransactionsByDigestsPage;
     /**
      * Fetch a structured representation of a concrete type, including its
      * layout information. Fails if the type is malformed.
@@ -4223,6 +4297,11 @@ export type QueryTransactionBlocksArgs = {
 export type QueryTransactionBlocksByDigestsArgs = {
     digests: Array<Scalars['String']['input']>;
 };
+export type QueryTransactionsByDigestsArgs = {
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    digests: Array<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+};
 export type QueryTypeArgs = {
     type: Scalars['String']['input'];
 };
@@ -4587,10 +4666,11 @@ export type StakedIota = IMoveObject & IObject & IOwner & {
      * 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`.
+     * gathering a page of results. It is required for queries that apply two
+     * or more complex filters (on function, affected address, recipient, input
+     * object, changed object, or wrapped or deleted object), and can be at
+     * most `serviceConfig.maxScanLimit`. A `kind` filter cannot be
+     * combined with any of them.
      *
      * When the scan limit is reached the page will be returned even if it has
      * fewer than `first` results when paginating forward (`last` when
@@ -4609,6 +4689,10 @@ export type StakedIota = IMoveObject & IObject & IOwner & {
      * GraphQL, but it can be restricted by the `after` and `before`
      * cursors, and the `beforeCheckpoint`, `afterCheckpoint` and
      * `atCheckpoint` filters.
+     *
+     * DEPRECATION NOTICE: Support for the combination of two or more complex
+     * filters as discussed above will stop with the v1.38 release. `scanLimit`
+     * will thus become obsolete and will be removed as well.
      */
     receivedTransactionBlocks: TransactionBlockConnection;
     /** The epoch at which this object was requested to join a stake pool. */
@@ -4851,8 +4935,8 @@ export type TransactionArgument = GasCoin | Input | Result;
 export type TransactionBlock = {
     __typename?: 'TransactionBlock';
     /**
-     * Serialized form of this transaction's `SenderSignedData`, BCS serialized
-     * and Base64 encoded.
+     * Serialized form of this transaction's `SenderSignedTransaction`, BCS
+     * serialized and Base64 encoded.
      */
     bcs?: Maybe<Scalars['Base64']['output']>;
     /**
@@ -4933,6 +5017,11 @@ export type TransactionBlockEdge = {
 /** The effects representing the result of executing a transaction block. */
 export type TransactionBlockEffects = {
     __typename?: 'TransactionBlockEffects';
+    /**
+     * The error code of the Move abort, populated if this transaction failed
+     * with a Move abort.
+     */
+    abortCode?: Maybe<Scalars['BigInt']['output']>;
     /**
      * The effect this transaction had on the balances (sum of coin values per
      * coin type) of addresses and objects.
@@ -5020,6 +5109,11 @@ export type TransactionBlockEffectsUnchangedSharedObjectsArgs = {
 };
 /** Represents optional available filters for transaction blocks. */
 export type TransactionBlockFilter = {
+    /**
+     * Limit to transactions that affected the given address (the address is
+     * the sender, a recipient, or the owner of the gas payment).
+     */
+    affectedAddress?: InputMaybe<Scalars['IotaAddress']['input']>;
     /** Limit to transactions that occurred strictly after the given checkpoint. */
     afterCheckpoint?: InputMaybe<Scalars['UInt53']['input']>;
     /** Limit to transactions in the given checkpoint. */
@@ -5055,7 +5149,7 @@ export type TransactionBlockFilter = {
  * The kind of transaction block, either a programmable transaction or a system
  * transaction.
  */
-export type TransactionBlockKind = ConsensusCommitPrologueTransaction | EndOfEpochTransaction | GenesisTransaction | ProgrammableTransactionBlock | RandomnessStateUpdateTransaction;
+export type TransactionBlockKind = ConsensusCommitPrologueTransaction | EndOfEpochTransaction | GenesisTransaction | ProgrammableTransactionBlock | RandomnessStateUpdateTransaction | TransactionDenyRulesUpdateTransaction;
 /** An input filter selecting for either system or programmable transactions. */
 export declare enum TransactionBlockKindInput {
     /** The consensus commit prologue transaction block. */
@@ -5083,6 +5177,48 @@ export declare enum TransactionBlockKindInput {
  * number of lost payloads.
  */
 export type TransactionBlockSubscriptionPayload = Lagged | TransactionBlock;
+export type TransactionDenyRulesCreateTransaction = {
+    __typename?: 'TransactionDenyRulesCreateTransaction';
+    /** A workaround to define an empty variant of a GraphQL union. */
+    dummy?: Maybe<Scalars['Boolean']['output']>;
+};
+/**
+ * System transaction that applies an add/remove delta to the on-chain
+ * transaction deny rules; the switch states are absolute.
+ */
+export type TransactionDenyRulesUpdateTransaction = {
+    __typename?: 'TransactionDenyRulesUpdateTransaction';
+    /** Addresses added to the sender-or-sponsor deny list. */
+    addedAddresses: Array<Scalars['IotaAddress']['output']>;
+    /** Objects added to the input-or-receiving deny list. */
+    addedObjects: Array<Scalars['IotaAddress']['output']>;
+    /** Packages added to the dependency deny list. */
+    addedPackages: Array<Scalars['IotaAddress']['output']>;
+    /** The initial version the deny rules object was shared at. */
+    denyRulesObjInitialSharedVersion: Scalars['UInt53']['output'];
+    /** Epoch of the deny rules update transaction. */
+    epoch?: Maybe<Epoch>;
+    /** Whether transactions signed with a Move authenticator are denied. */
+    moveAuthenticatorDisabled: Scalars['Boolean']['output'];
+    /** Whether all package publishing is denied. */
+    packagePublishDisabled: Scalars['Boolean']['output'];
+    /** Whether all package upgrades are denied. */
+    packageUpgradeDisabled: Scalars['Boolean']['output'];
+    /** Whether transactions that contain receiving objects are denied. */
+    receivingObjectsDisabled: Scalars['Boolean']['output'];
+    /** Addresses removed from the sender-or-sponsor deny list. */
+    removedAddresses: Array<Scalars['IotaAddress']['output']>;
+    /** Objects removed from the input-or-receiving deny list. */
+    removedObjects: Array<Scalars['IotaAddress']['output']>;
+    /** Packages removed from the dependency deny list. */
+    removedPackages: Array<Scalars['IotaAddress']['output']>;
+    /** Consensus round of the update. */
+    round: Scalars['UInt53']['output'];
+    /** Whether transactions that use shared objects as inputs are denied. */
+    sharedObjectDisabled: Scalars['Boolean']['output'];
+    /** Whether all user transactions are denied. */
+    userTransactionDisabled: Scalars['Boolean']['output'];
+};
 export type TransactionInput = OwnedOrImmutable | Pure | Receiving | SharedInput;
 export type TransactionInputConnection = {
     __typename?: 'TransactionInputConnection';
@@ -5115,6 +5251,22 @@ export type TransactionMetadata = {
     gasSponsor?: InputMaybe<Scalars['IotaAddress']['input']>;
     sender?: InputMaybe<Scalars['IotaAddress']['input']>;
 };
+/** A page of the `transactionsByDigests` query. */
+export type TransactionsByDigestsPage = {
+    __typename?: 'TransactionsByDigestsPage';
+    /**
+     * Cursor of the last entry of this page; pass it as `cursor` to get the
+     * next page.
+     */
+    endCursor?: Maybe<Scalars['String']['output']>;
+    /** Whether there are more entries after this page. */
+    hasNextPage: Scalars['Boolean']['output'];
+    /**
+     * One entry per digest of the page, in the order of the `digests`
+     * argument, null when the transaction was not found.
+     */
+    nodes: Array<Maybe<TransactionBlock>>;
+};
 /**
  * Transfers `inputs` to `address`. All inputs must have the `store` ability
  * (allows public transfer) and must not be previously immutable or shared.
@@ -5470,6 +5622,8 @@ export type GetCheckpointQuery = {
                                     protocolVersion: any;
                                 };
                             } | null;
+                        } | {
+                            __typename: 'TransactionDenyRulesCreateTransaction';
                         }>;
                     };
                 } | {
@@ -5478,6 +5632,8 @@ export type GetCheckpointQuery = {
                     __typename: 'ProgrammableTransactionBlock';
                 } | {
                     __typename: 'RandomnessStateUpdateTransaction';
+                } | {
+                    __typename: 'TransactionDenyRulesUpdateTransaction';
                 } | null;
             }>;
         };
@@ -5589,6 +5745,8 @@ export type GetCheckpointsQuery = {
                                         protocolVersion: any;
                                     };
                                 } | null;
+                            } | {
+                                __typename: 'TransactionDenyRulesCreateTransaction';
                             }>;
                         };
                     } | {
@@ -5597,6 +5755,8 @@ export type GetCheckpointsQuery = {
                         __typename: 'ProgrammableTransactionBlock';
                     } | {
                         __typename: 'RandomnessStateUpdateTransaction';
+                    } | {
+                        __typename: 'TransactionDenyRulesUpdateTransaction';
                     } | null;
                 }>;
             };
@@ -5714,6 +5874,8 @@ export type Rpc_Checkpoint_FieldsFragment = {
                                 protocolVersion: any;
                             };
                         } | null;
+                    } | {
+                        __typename: 'TransactionDenyRulesCreateTransaction';
                     }>;
                 };
             } | {
@@ -5722,6 +5884,8 @@ export type Rpc_Checkpoint_FieldsFragment = {
                 __typename: 'ProgrammableTransactionBlock';
             } | {
                 __typename: 'RandomnessStateUpdateTransaction';
+            } | {
+                __typename: 'TransactionDenyRulesUpdateTransaction';
             } | null;
         }>;
     };
@@ -8383,6 +8547,59 @@ export type Rpc_Stake_FieldsFragment = {
         json: any;
     } | null;
 };
+export type SubscribeEventsSubscriptionVariables = Exact<{
+    filter?: InputMaybe<SubscriptionEventFilter>;
+    startAfter?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type SubscribeEventsSubscription = {
+    __typename?: 'Subscription';
+    events: {
+        __typename: 'Event';
+        json: any;
+        bcs: any;
+        timestamp?: any | null;
+        transactionBlock?: {
+            __typename?: 'TransactionBlock';
+            digest?: string | null;
+        } | null;
+        sendingModule?: {
+            __typename?: 'MoveModule';
+            name: string;
+            package: {
+                __typename?: 'MovePackage';
+                address: any;
+            };
+        } | null;
+        sender?: {
+            __typename?: 'Address';
+            address: any;
+        } | null;
+        type: {
+            __typename?: 'MoveType';
+            repr: string;
+        };
+    } | {
+        __typename: 'Lagged';
+        count: number;
+    };
+};
+export type SubscribeTransactionsSubscriptionVariables = Exact<{
+    filter?: InputMaybe<SubscriptionTransactionFilter>;
+    startAfter?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type SubscribeTransactionsSubscription = {
+    __typename?: 'Subscription';
+    transactions: {
+        __typename: 'Lagged';
+        count: number;
+    } | {
+        __typename: 'TransactionBlock';
+        effects?: {
+            __typename?: 'TransactionBlockEffects';
+            bcs: any;
+        } | null;
+    };
+};
 export type TransactionBlocksByDigestsQueryVariables = Exact<{
     digests: Array<Scalars['String']['input']> | Scalars['String']['input'];
 }>;
@@ -9268,6 +9485,8 @@ export declare const MultiGetObjectsDocument: TypedDocumentString<MultiGetObject
 export declare const QueryEventsDocument: TypedDocumentString<QueryEventsQuery, QueryEventsQueryVariables>;
 export declare const GetStakesDocument: TypedDocumentString<GetStakesQuery, GetStakesQueryVariables>;
 export declare const GetStakesByIdsDocument: TypedDocumentString<GetStakesByIdsQuery, GetStakesByIdsQueryVariables>;
+export declare const SubscribeEventsDocument: TypedDocumentString<SubscribeEventsSubscription, SubscribeEventsSubscriptionVariables>;
+export declare const SubscribeTransactionsDocument: TypedDocumentString<SubscribeTransactionsSubscription, SubscribeTransactionsSubscriptionVariables>;
 export declare const TransactionBlocksByDigestsDocument: TypedDocumentString<TransactionBlocksByDigestsQuery, TransactionBlocksByDigestsQueryVariables>;
 export declare const QueryTransactionBlocksDocument: TypedDocumentString<QueryTransactionBlocksQuery, QueryTransactionBlocksQueryVariables>;
 export declare const GetTransactionBlockDocument: TypedDocumentString<GetTransactionBlockQuery, GetTransactionBlockQueryVariables>;