@polymeshassociation/polymesh-sdk 20.2.0-beta.5 → 21.0.0-alpha.10

package/middleware/typesV2.d.ts

@@ -489,6 +489,8 @@ export declare enum AgentGroupsOrderBy {
 /** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
 export declare type Asset = Node & {
     __typename?: 'Asset';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions: AssetTransactionsConnection;
     /** Reads and enables pagination through a set of `Block`. */
     blocksByAssetDocumentAssetIdAndCreatedBlockId: AssetBlocksByAssetDocumentAssetIdAndCreatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
@@ -498,6 +500,10 @@ export declare type Asset = Node & {
     /** Reads and enables pagination through a set of `Block`. */
     blocksByAssetHolderAssetIdAndUpdatedBlockId: AssetBlocksByAssetHolderAssetIdAndUpdatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionAssetIdAndCreatedBlockId: AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionAssetIdAndUpdatedBlockId: AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
     blocksByComplianceAssetIdAndCreatedBlockId: AssetBlocksByComplianceAssetIdAndCreatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
     blocksByComplianceAssetIdAndUpdatedBlockId: AssetBlocksByComplianceAssetIdAndUpdatedBlockIdManyToManyConnection;
@@ -596,6 +602,10 @@ export declare type Asset = Node & {
     /** Reads and enables pagination through a set of `PortfolioMovement`. */
     portfolioMovements: PortfolioMovementsConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionAssetIdAndFromPortfolioId: AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionAssetIdAndToPortfolioId: AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByDistributionAssetIdAndPortfolioId: AssetPortfoliosByDistributionAssetIdAndPortfolioIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByPortfolioMovementAssetIdAndFromId: AssetPortfoliosByPortfolioMovementAssetIdAndFromIdManyToManyConnection;
@@ -637,6 +647,16 @@ export declare type Asset = Node & {
     venuesByStoOfferingAssetIdAndVenueId: AssetVenuesByStoOfferingAssetIdAndVenueIdManyToManyConnection;
 };
 /** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
+export declare type AssetAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
 export declare type AssetBlocksByAssetDocumentAssetIdAndCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -677,6 +697,26 @@ export declare type AssetBlocksByAssetHolderAssetIdAndUpdatedBlockIdArgs = {
     orderBy?: InputMaybe<Array<BlocksOrderBy>>;
 };
 /** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
+export declare type AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
+export declare type AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
 export declare type AssetBlocksByComplianceAssetIdAndCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -1077,6 +1117,26 @@ export declare type AssetPortfolioMovementsArgs = {
     orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
 };
 /** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PortfolioFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
+};
+/** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PortfolioFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
+};
+/** Represents a tokenized Asset on the Polymesh chain. The central data structure for the ecosystem */
 export declare type AssetPortfoliosByDistributionAssetIdAndPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -1404,6 +1464,88 @@ export declare type AssetBlocksByAssetHolderAssetIdAndUpdatedBlockIdManyToManyEd
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<AssetHoldersOrderBy>>;
 };
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyConnection = {
+    __typename?: 'AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyEdge = {
+    __typename?: 'AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByCreatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndCreatedBlockIdManyToManyEdgeAssetTransactionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyConnection = {
+    __typename?: 'AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyEdge = {
+    __typename?: 'AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByUpdatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetBlocksByAssetTransactionAssetIdAndUpdatedBlockIdManyToManyEdgeAssetTransactionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Block` values, with data from `Compliance`. */
 export declare type AssetBlocksByComplianceAssetIdAndCreatedBlockIdManyToManyConnection = {
     __typename?: 'AssetBlocksByComplianceAssetIdAndCreatedBlockIdManyToManyConnection';
@@ -3228,6 +3370,88 @@ export declare enum AssetPendingOwnershipTransfersOrderBy {
     UpdatedBlockIdAsc = "UPDATED_BLOCK_ID_ASC",
     UpdatedBlockIdDesc = "UPDATED_BLOCK_ID_DESC"
 }
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyConnection = {
+    __typename?: 'AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyEdge = {
+    __typename?: 'AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByFromPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndFromPortfolioIdManyToManyEdgeAssetTransactionsByFromPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyConnection = {
+    __typename?: 'AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyEdge = {
+    __typename?: 'AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByToPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type AssetPortfoliosByAssetTransactionAssetIdAndToPortfolioIdManyToManyEdgeAssetTransactionsByToPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Portfolio` values, with data from `Distribution`. */
 export declare type AssetPortfoliosByDistributionAssetIdAndPortfolioIdManyToManyConnection = {
     __typename?: 'AssetPortfoliosByDistributionAssetIdAndPortfolioIdManyToManyConnection';
@@ -3474,6 +3698,165 @@ export declare type AssetStatTypesByTransferComplianceAssetIdAndStatTypeIdManyTo
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<TransferCompliancesOrderBy>>;
 };
+/** Represents all the transactions related to an Asset */
+export declare type AssetTransaction = Node & {
+    __typename?: 'AssetTransaction';
+    amount: Scalars['BigFloat'];
+    /** Reads a single `Asset` that is related to this `AssetTransaction`. */
+    asset?: Maybe<Asset>;
+    assetId: Scalars['String'];
+    createdAt: Scalars['Datetime'];
+    /** Reads a single `Block` that is related to this `AssetTransaction`. */
+    createdBlock?: Maybe<Block>;
+    createdBlockId: Scalars['String'];
+    datetime: Scalars['Datetime'];
+    eventId: PublicEnum8F5A39C8Ee;
+    eventIdx: Scalars['Int'];
+    /** `extrinsicIdx` will be null for scheduled transactions */
+    extrinsicIdx?: Maybe<Scalars['Int']>;
+    /** Reads a single `Portfolio` that is related to this `AssetTransaction`. */
+    fromPortfolio?: Maybe<Portfolio>;
+    /** `fromPortfolioId` will be null in transactions where the Asset was issued */
+    fromPortfolioId?: Maybe<Scalars['String']>;
+    /** `fundingRound` will only be present for the cases where Assets are issued with a fundingRound name */
+    fundingRound?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
+    nodeId: Scalars['ID'];
+    /** Reads a single `Portfolio` that is related to this `AssetTransaction`. */
+    toPortfolio?: Maybe<Portfolio>;
+    /** `toPortfolioId` will be null in transactions where the Asset was redeemed */
+    toPortfolioId?: Maybe<Scalars['String']>;
+    updatedAt: Scalars['Datetime'];
+    /** Reads a single `Block` that is related to this `AssetTransaction`. */
+    updatedBlock?: Maybe<Block>;
+    updatedBlockId: Scalars['String'];
+};
+export declare type AssetTransactionAggregates = {
+    __typename?: 'AssetTransactionAggregates';
+    keys?: Maybe<Array<Scalars['String']>>;
+};
+/** A filter to be used against `AssetTransaction` object types. All fields are combined with a logical ‘and.’ */
+export declare type AssetTransactionFilter = {
+    /** Filter by the object’s `amount` field. */
+    amount?: InputMaybe<BigFloatFilter>;
+    /** Checks for all expressions in this list. */
+    and?: InputMaybe<Array<AssetTransactionFilter>>;
+    /** Filter by the object’s `assetId` field. */
+    assetId?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `createdAt` field. */
+    createdAt?: InputMaybe<DatetimeFilter>;
+    /** Filter by the object’s `createdBlockId` field. */
+    createdBlockId?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `datetime` field. */
+    datetime?: InputMaybe<DatetimeFilter>;
+    /** Filter by the object’s `eventId` field. */
+    eventId?: InputMaybe<PublicEnum8F5A39C8EeFilter>;
+    /** Filter by the object’s `eventIdx` field. */
+    eventIdx?: InputMaybe<IntFilter>;
+    /** Filter by the object’s `extrinsicIdx` field. */
+    extrinsicIdx?: InputMaybe<IntFilter>;
+    /** Filter by the object’s `fromPortfolioId` field. */
+    fromPortfolioId?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `fundingRound` field. */
+    fundingRound?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `id` field. */
+    id?: InputMaybe<StringFilter>;
+    /** Negates the expression. */
+    not?: InputMaybe<AssetTransactionFilter>;
+    /** Checks for any expressions in this list. */
+    or?: InputMaybe<Array<AssetTransactionFilter>>;
+    /** Filter by the object’s `toPortfolioId` field. */
+    toPortfolioId?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `updatedAt` field. */
+    updatedAt?: InputMaybe<DatetimeFilter>;
+    /** Filter by the object’s `updatedBlockId` field. */
+    updatedBlockId?: InputMaybe<StringFilter>;
+};
+/** A connection to a list of `AssetTransaction` values. */
+export declare type AssetTransactionsConnection = {
+    __typename?: 'AssetTransactionsConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<AssetTransactionAggregates>;
+    /** A list of edges which contains the `AssetTransaction` and cursor to aid in pagination. */
+    edges: Array<AssetTransactionsEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<AssetTransactionAggregates>>;
+    /** A list of `AssetTransaction` objects. */
+    nodes: Array<Maybe<AssetTransaction>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `AssetTransaction` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `AssetTransaction` values. */
+export declare type AssetTransactionsConnectionGroupedAggregatesArgs = {
+    groupBy: Array<AssetTransactionsGroupBy>;
+    having?: InputMaybe<AssetTransactionsHavingInput>;
+};
+/** A `AssetTransaction` edge in the connection. */
+export declare type AssetTransactionsEdge = {
+    __typename?: 'AssetTransactionsEdge';
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `AssetTransaction` at the end of the edge. */
+    node?: Maybe<AssetTransaction>;
+};
+/** Grouping methods for `AssetTransaction` for usage during aggregation. */
+export declare enum AssetTransactionsGroupBy {
+    Amount = "AMOUNT",
+    AssetId = "ASSET_ID",
+    CreatedAt = "CREATED_AT",
+    CreatedBlockId = "CREATED_BLOCK_ID",
+    Datetime = "DATETIME",
+    EventId = "EVENT_ID",
+    EventIdx = "EVENT_IDX",
+    ExtrinsicIdx = "EXTRINSIC_IDX",
+    FromPortfolioId = "FROM_PORTFOLIO_ID",
+    FundingRound = "FUNDING_ROUND",
+    ToPortfolioId = "TO_PORTFOLIO_ID",
+    UpdatedAt = "UPDATED_AT",
+    UpdatedBlockId = "UPDATED_BLOCK_ID"
+}
+/** Conditions for `AssetTransaction` aggregates. */
+export declare type AssetTransactionsHavingInput = {
+    AND?: InputMaybe<Array<AssetTransactionsHavingInput>>;
+    OR?: InputMaybe<Array<AssetTransactionsHavingInput>>;
+};
+/** Methods to use when ordering `AssetTransaction`. */
+export declare enum AssetTransactionsOrderBy {
+    AmountAsc = "AMOUNT_ASC",
+    AmountDesc = "AMOUNT_DESC",
+    AssetIdAsc = "ASSET_ID_ASC",
+    AssetIdDesc = "ASSET_ID_DESC",
+    CreatedAtAsc = "CREATED_AT_ASC",
+    CreatedAtDesc = "CREATED_AT_DESC",
+    CreatedBlockIdAsc = "CREATED_BLOCK_ID_ASC",
+    CreatedBlockIdDesc = "CREATED_BLOCK_ID_DESC",
+    DatetimeAsc = "DATETIME_ASC",
+    DatetimeDesc = "DATETIME_DESC",
+    EventIdxAsc = "EVENT_IDX_ASC",
+    EventIdxDesc = "EVENT_IDX_DESC",
+    EventIdAsc = "EVENT_ID_ASC",
+    EventIdDesc = "EVENT_ID_DESC",
+    ExtrinsicIdxAsc = "EXTRINSIC_IDX_ASC",
+    ExtrinsicIdxDesc = "EXTRINSIC_IDX_DESC",
+    FromPortfolioIdAsc = "FROM_PORTFOLIO_ID_ASC",
+    FromPortfolioIdDesc = "FROM_PORTFOLIO_ID_DESC",
+    FundingRoundAsc = "FUNDING_ROUND_ASC",
+    FundingRoundDesc = "FUNDING_ROUND_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToPortfolioIdAsc = "TO_PORTFOLIO_ID_ASC",
+    ToPortfolioIdDesc = "TO_PORTFOLIO_ID_DESC",
+    UpdatedAtAsc = "UPDATED_AT_ASC",
+    UpdatedAtDesc = "UPDATED_AT_DESC",
+    UpdatedBlockIdAsc = "UPDATED_BLOCK_ID_ASC",
+    UpdatedBlockIdDesc = "UPDATED_BLOCK_ID_DESC"
+}
 /** A connection to a list of `Venue` values, with data from `Sto`. */
 export declare type AssetVenuesByStoOfferingAssetIdAndVenueIdManyToManyConnection = {
     __typename?: 'AssetVenuesByStoOfferingAssetIdAndVenueIdManyToManyConnection';
@@ -3570,6 +3953,8 @@ export declare type AssetsHavingInput = {
 };
 /** Methods to use when ordering `Asset`. */
 export declare enum AssetsOrderBy {
+    AssetTransactionsCountAsc = "ASSET_TRANSACTIONS_COUNT_ASC",
+    AssetTransactionsCountDesc = "ASSET_TRANSACTIONS_COUNT_DESC",
     ComplianceCountAsc = "COMPLIANCE_COUNT_ASC",
     ComplianceCountDesc = "COMPLIANCE_COUNT_DESC",
     CreatedAtAsc = "CREATED_AT_ASC",
@@ -3835,6 +4220,10 @@ export declare type Block = Node & {
     assetPendingOwnershipTransfersByCreatedBlockId: AssetPendingOwnershipTransfersConnection;
     /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
     assetPendingOwnershipTransfersByUpdatedBlockId: AssetPendingOwnershipTransfersConnection;
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByCreatedBlockId: AssetTransactionsConnection;
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByUpdatedBlockId: AssetTransactionsConnection;
     /** Reads and enables pagination through a set of `Asset`. */
     assetsByAssetDocumentCreatedBlockIdAndAssetId: BlockAssetsByAssetDocumentCreatedBlockIdAndAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Asset`. */
@@ -3844,6 +4233,10 @@ export declare type Block = Node & {
     /** Reads and enables pagination through a set of `Asset`. */
     assetsByAssetHolderUpdatedBlockIdAndAssetId: BlockAssetsByAssetHolderUpdatedBlockIdAndAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Asset`. */
+    assetsByAssetTransactionCreatedBlockIdAndAssetId: BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Asset`. */
+    assetsByAssetTransactionUpdatedBlockIdAndAssetId: BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Asset`. */
     assetsByComplianceCreatedBlockIdAndAssetId: BlockAssetsByComplianceCreatedBlockIdAndAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Asset`. */
     assetsByComplianceUpdatedBlockIdAndAssetId: BlockAssetsByComplianceUpdatedBlockIdAndAssetIdManyToManyConnection;
@@ -3931,6 +4324,10 @@ export declare type Block = Node & {
     /** Reads and enables pagination through a set of `Block`. */
     blocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockId: BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionCreatedBlockIdAndUpdatedBlockId: BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionUpdatedBlockIdAndCreatedBlockId: BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
     blocksByAssetUpdatedBlockIdAndCreatedBlockId: BlockBlocksByAssetUpdatedBlockIdAndCreatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
     blocksByAuthorizationCreatedBlockIdAndUpdatedBlockId: BlockBlocksByAuthorizationCreatedBlockIdAndUpdatedBlockIdManyToManyConnection;
@@ -4216,6 +4613,14 @@ export declare type Block = Node & {
     /** Reads and enables pagination through a set of `PortfolioMovement`. */
     portfolioMovementsByUpdatedBlockId: PortfolioMovementsConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioId: BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionCreatedBlockIdAndToPortfolioId: BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioId: BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioId: BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByCreatedBlockId: PortfoliosConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByDistributionCreatedBlockIdAndPortfolioId: BlockPortfoliosByDistributionCreatedBlockIdAndPortfolioIdManyToManyConnection;
@@ -4468,6 +4873,26 @@ export declare type BlockAssetPendingOwnershipTransfersByUpdatedBlockIdArgs = {
     orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockAssetTransactionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockAssetTransactionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
 export declare type BlockAssetsByAssetDocumentCreatedBlockIdAndAssetIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -4508,6 +4933,26 @@ export declare type BlockAssetsByAssetHolderUpdatedBlockIdAndAssetIdArgs = {
     orderBy?: InputMaybe<Array<AssetsOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
 export declare type BlockAssetsByComplianceCreatedBlockIdAndAssetIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -4938,6 +5383,26 @@ export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndC
     orderBy?: InputMaybe<Array<BlocksOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
 export declare type BlockBlocksByAssetUpdatedBlockIdAndCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -6228,64 +6693,104 @@ export declare type BlockLegsByUpdatedBlockIdArgs = {
     orderBy?: InputMaybe<Array<LegsOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdArgs = {
+export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PermissionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PermissionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockPermissionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PermissionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockPermissionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PermissionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+};
+/** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
+export declare type BlockPortfolioMovementsByCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PermissionFilter>;
+    filter?: InputMaybe<PortfolioMovementFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdArgs = {
+export declare type BlockPortfolioMovementsByUpdatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PermissionFilter>;
+    filter?: InputMaybe<PortfolioMovementFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPermissionsByCreatedBlockIdArgs = {
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PermissionFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPermissionsByUpdatedBlockIdArgs = {
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PermissionFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PermissionsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPortfolioMovementsByCreatedBlockIdArgs = {
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PortfolioMovementFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
-export declare type BlockPortfolioMovementsByUpdatedBlockIdArgs = {
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PortfolioMovementFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /** A set of transactions that were executed together. Includes a reference to its parent, which reference its parent, this forms a chain to the genesis block */
 export declare type BlockPortfoliosByCreatedBlockIdArgs = {
@@ -7077,6 +7582,88 @@ export declare type BlockAssetsByAssetHolderUpdatedBlockIdAndAssetIdManyToManyEd
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<AssetHoldersOrderBy>>;
 };
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyConnection = {
+    __typename?: 'BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<AssetAggregates>;
+    /** A list of edges which contains the `Asset`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<AssetAggregates>>;
+    /** A list of `Asset` objects. */
+    nodes: Array<Maybe<Asset>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Asset` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<AssetsGroupBy>;
+    having?: InputMaybe<AssetsHavingInput>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyEdge = {
+    __typename?: 'BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Asset` at the end of the edge. */
+    node?: Maybe<Asset>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionCreatedBlockIdAndAssetIdManyToManyEdgeAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyConnection = {
+    __typename?: 'BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<AssetAggregates>;
+    /** A list of edges which contains the `Asset`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<AssetAggregates>>;
+    /** A list of `Asset` objects. */
+    nodes: Array<Maybe<Asset>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Asset` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<AssetsGroupBy>;
+    having?: InputMaybe<AssetsHavingInput>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyEdge = {
+    __typename?: 'BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Asset` at the end of the edge. */
+    node?: Maybe<Asset>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockAssetsByAssetTransactionUpdatedBlockIdAndAssetIdManyToManyEdgeAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Asset` values, with data from `Compliance`. */
 export declare type BlockAssetsByComplianceCreatedBlockIdAndAssetIdManyToManyConnection = {
     __typename?: 'BlockAssetsByComplianceCreatedBlockIdAndAssetIdManyToManyConnection';
@@ -8676,6 +9263,88 @@ export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndC
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
 };
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyConnection = {
+    __typename?: 'BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyEdge = {
+    __typename?: 'BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByUpdatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyEdgeAssetTransactionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyConnection = {
+    __typename?: 'BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyEdge = {
+    __typename?: 'BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByCreatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetTransactionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Block` values, with data from `Asset`. */
 export declare type BlockBlocksByAssetUpdatedBlockIdAndCreatedBlockIdManyToManyConnection = {
     __typename?: 'BlockBlocksByAssetUpdatedBlockIdAndCreatedBlockIdManyToManyConnection';
@@ -13032,79 +13701,243 @@ export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyT
     /** A list of edges which contains the `Permission`, info from the `Account`, and the cursor to aid in pagination. */
     edges: Array<BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdge>;
     /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
-    groupedAggregates?: Maybe<Array<PermissionAggregates>>;
-    /** A list of `Permission` objects. */
-    nodes: Array<Maybe<Permission>>;
+    groupedAggregates?: Maybe<Array<PermissionAggregates>>;
+    /** A list of `Permission` objects. */
+    nodes: Array<Maybe<Permission>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Permission` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Permission` values, with data from `Account`. */
+export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PermissionsGroupBy>;
+    having?: InputMaybe<PermissionsHavingInput>;
+};
+/** A `Permission` edge in the connection, with data from `Account`. */
+export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdge = {
+    __typename?: 'BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `Account`. */
+    accountsByPermissionsId: AccountsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Permission` at the end of the edge. */
+    node?: Maybe<Permission>;
+};
+/** A `Permission` edge in the connection, with data from `Account`. */
+export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdgeAccountsByPermissionsIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AccountFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AccountsOrderBy>>;
+};
+/** A connection to a list of `Permission` values, with data from `Account`. */
+export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnection = {
+    __typename?: 'BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PermissionAggregates>;
+    /** A list of edges which contains the `Permission`, info from the `Account`, and the cursor to aid in pagination. */
+    edges: Array<BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PermissionAggregates>>;
+    /** A list of `Permission` objects. */
+    nodes: Array<Maybe<Permission>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Permission` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Permission` values, with data from `Account`. */
+export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PermissionsGroupBy>;
+    having?: InputMaybe<PermissionsHavingInput>;
+};
+/** A `Permission` edge in the connection, with data from `Account`. */
+export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge = {
+    __typename?: 'BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `Account`. */
+    accountsByPermissionsId: AccountsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Permission` at the end of the edge. */
+    node?: Maybe<Permission>;
+};
+/** A `Permission` edge in the connection, with data from `Account`. */
+export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdgeAccountsByPermissionsIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AccountFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AccountsOrderBy>>;
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyConnection = {
+    __typename?: 'BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyEdge = {
+    __typename?: 'BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByFromPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdManyToManyEdgeAssetTransactionsByFromPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyConnection = {
+    __typename?: 'BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyEdge = {
+    __typename?: 'BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByToPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdManyToManyEdgeAssetTransactionsByToPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyConnection = {
+    __typename?: 'BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
     /** Information to aid in pagination. */
     pageInfo: PageInfo;
-    /** The count of *all* `Permission` you could get from the connection. */
+    /** The count of *all* `Portfolio` you could get from the connection. */
     totalCount: Scalars['Int'];
 };
-/** A connection to a list of `Permission` values, with data from `Account`. */
-export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyConnectionGroupedAggregatesArgs = {
-    groupBy: Array<PermissionsGroupBy>;
-    having?: InputMaybe<PermissionsHavingInput>;
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
 };
-/** A `Permission` edge in the connection, with data from `Account`. */
-export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdge = {
-    __typename?: 'BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdge';
-    /** Reads and enables pagination through a set of `Account`. */
-    accountsByPermissionsId: AccountsConnection;
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyEdge = {
+    __typename?: 'BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByFromPortfolioId: AssetTransactionsConnection;
     /** A cursor for use in pagination. */
     cursor?: Maybe<Scalars['Cursor']>;
-    /** The `Permission` at the end of the edge. */
-    node?: Maybe<Permission>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
 };
-/** A `Permission` edge in the connection, with data from `Account`. */
-export declare type BlockPermissionsByAccountCreatedBlockIdAndPermissionsIdManyToManyEdgeAccountsByPermissionsIdArgs = {
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyEdgeAssetTransactionsByFromPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AccountFilter>;
+    filter?: InputMaybe<AssetTransactionFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AccountsOrderBy>>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
 };
-/** A connection to a list of `Permission` values, with data from `Account`. */
-export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnection = {
-    __typename?: 'BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnection';
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnection = {
+    __typename?: 'BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnection';
     /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
-    aggregates?: Maybe<PermissionAggregates>;
-    /** A list of edges which contains the `Permission`, info from the `Account`, and the cursor to aid in pagination. */
-    edges: Array<BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge>;
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdge>;
     /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
-    groupedAggregates?: Maybe<Array<PermissionAggregates>>;
-    /** A list of `Permission` objects. */
-    nodes: Array<Maybe<Permission>>;
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
     /** Information to aid in pagination. */
     pageInfo: PageInfo;
-    /** The count of *all* `Permission` you could get from the connection. */
+    /** The count of *all* `Portfolio` you could get from the connection. */
     totalCount: Scalars['Int'];
 };
-/** A connection to a list of `Permission` values, with data from `Account`. */
-export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyConnectionGroupedAggregatesArgs = {
-    groupBy: Array<PermissionsGroupBy>;
-    having?: InputMaybe<PermissionsHavingInput>;
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
 };
-/** A `Permission` edge in the connection, with data from `Account`. */
-export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge = {
-    __typename?: 'BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdge';
-    /** Reads and enables pagination through a set of `Account`. */
-    accountsByPermissionsId: AccountsConnection;
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdge = {
+    __typename?: 'BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByToPortfolioId: AssetTransactionsConnection;
     /** A cursor for use in pagination. */
     cursor?: Maybe<Scalars['Cursor']>;
-    /** The `Permission` at the end of the edge. */
-    node?: Maybe<Permission>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
 };
-/** A `Permission` edge in the connection, with data from `Account`. */
-export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyToManyEdgeAccountsByPermissionsIdArgs = {
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdgeAssetTransactionsByToPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AccountFilter>;
+    filter?: InputMaybe<AssetTransactionFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AccountsOrderBy>>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
 };
 /** A connection to a list of `Portfolio` values, with data from `Distribution`. */
 export declare type BlockPortfoliosByDistributionCreatedBlockIdAndPortfolioIdManyToManyConnection = {
@@ -14171,6 +15004,10 @@ export declare enum BlocksOrderBy {
     AssetPendingOwnershipTransfersByCreatedBlockIdCountDesc = "ASSET_PENDING_OWNERSHIP_TRANSFERS_BY_CREATED_BLOCK_ID_COUNT_DESC",
     AssetPendingOwnershipTransfersByUpdatedBlockIdCountAsc = "ASSET_PENDING_OWNERSHIP_TRANSFERS_BY_UPDATED_BLOCK_ID_COUNT_ASC",
     AssetPendingOwnershipTransfersByUpdatedBlockIdCountDesc = "ASSET_PENDING_OWNERSHIP_TRANSFERS_BY_UPDATED_BLOCK_ID_COUNT_DESC",
+    AssetTransactionsByCreatedBlockIdCountAsc = "ASSET_TRANSACTIONS_BY_CREATED_BLOCK_ID_COUNT_ASC",
+    AssetTransactionsByCreatedBlockIdCountDesc = "ASSET_TRANSACTIONS_BY_CREATED_BLOCK_ID_COUNT_DESC",
+    AssetTransactionsByUpdatedBlockIdCountAsc = "ASSET_TRANSACTIONS_BY_UPDATED_BLOCK_ID_COUNT_ASC",
+    AssetTransactionsByUpdatedBlockIdCountDesc = "ASSET_TRANSACTIONS_BY_UPDATED_BLOCK_ID_COUNT_DESC",
     AuthorizationsByCreatedBlockIdCountAsc = "AUTHORIZATIONS_BY_CREATED_BLOCK_ID_COUNT_ASC",
     AuthorizationsByCreatedBlockIdCountDesc = "AUTHORIZATIONS_BY_CREATED_BLOCK_ID_COUNT_DESC",
     AuthorizationsByUpdatedBlockIdCountAsc = "AUTHORIZATIONS_BY_UPDATED_BLOCK_ID_COUNT_ASC",
@@ -15265,6 +16102,7 @@ export declare type DistributionIdentitiesByDistributionPaymentDistributionIdAnd
 export declare type DistributionPayment = Node & {
     __typename?: 'DistributionPayment';
     amount: Scalars['BigFloat'];
+    amountAfterTax: Scalars['BigFloat'];
     createdAt: Scalars['Datetime'];
     /** Reads a single `Block` that is related to this `DistributionPayment`. */
     createdBlock?: Maybe<Block>;
@@ -15295,6 +16133,8 @@ export declare type DistributionPaymentAggregates = {
 export declare type DistributionPaymentFilter = {
     /** Filter by the object’s `amount` field. */
     amount?: InputMaybe<BigFloatFilter>;
+    /** Filter by the object’s `amountAfterTax` field. */
+    amountAfterTax?: InputMaybe<BigFloatFilter>;
     /** Checks for all expressions in this list. */
     and?: InputMaybe<Array<DistributionPaymentFilter>>;
     /** Filter by the object’s `createdAt` field. */
@@ -15356,6 +16196,7 @@ export declare type DistributionPaymentsEdge = {
 /** Grouping methods for `DistributionPayment` for usage during aggregation. */
 export declare enum DistributionPaymentsGroupBy {
     Amount = "AMOUNT",
+    AmountAfterTax = "AMOUNT_AFTER_TAX",
     CreatedAt = "CREATED_AT",
     CreatedBlockId = "CREATED_BLOCK_ID",
     Datetime = "DATETIME",
@@ -15374,6 +16215,8 @@ export declare type DistributionPaymentsHavingInput = {
 };
 /** Methods to use when ordering `DistributionPayment`. */
 export declare enum DistributionPaymentsOrderBy {
+    AmountAfterTaxAsc = "AMOUNT_AFTER_TAX_ASC",
+    AmountAfterTaxDesc = "AMOUNT_AFTER_TAX_DESC",
     AmountAsc = "AMOUNT_ASC",
     AmountDesc = "AMOUNT_DESC",
     CreatedAtAsc = "CREATED_AT_ASC",
@@ -15713,6 +16556,7 @@ export declare type Extrinsic = Node & {
     params?: Maybe<Scalars['JSON']>;
     paramsTxt: Scalars['String'];
     signed: Scalars['Int'];
+    /** `signedbyAddress` is now deprecated in favour of `signed` */
     signedbyAddress: Scalars['Int'];
     specVersionId: Scalars['Int'];
     success: Scalars['Int'];
@@ -20713,7 +21557,8 @@ export declare type JsonFilter = {
 export declare type Leg = Node & {
     __typename?: 'Leg';
     addresses: Scalars['JSON'];
-    amount: Scalars['BigFloat'];
+    /** `amount` can be null for non-fungible tokens */
+    amount?: Maybe<Scalars['BigFloat']>;
     assetId: Scalars['String'];
     createdAt: Scalars['Datetime'];
     /** Reads a single `Block` that is related to this `Leg`. */
@@ -20726,6 +21571,7 @@ export declare type Leg = Node & {
     /** Reads a single `Instruction` that is related to this `Leg`. */
     instruction?: Maybe<Instruction>;
     instructionId?: Maybe<Scalars['String']>;
+    legType: PublicEnum2792Cc24Ad;
     /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
     nodeId: Scalars['ID'];
     /** Reads a single `Settlement` that is related to this `Leg`. */
@@ -20763,6 +21609,8 @@ export declare type LegFilter = {
     id?: InputMaybe<StringFilter>;
     /** Filter by the object’s `instructionId` field. */
     instructionId?: InputMaybe<StringFilter>;
+    /** Filter by the object’s `legType` field. */
+    legType?: InputMaybe<PublicEnum2792Cc24AdFilter>;
     /** Negates the expression. */
     not?: InputMaybe<LegFilter>;
     /** Checks for any expressions in this list. */
@@ -20814,6 +21662,7 @@ export declare enum LegsGroupBy {
     CreatedBlockId = "CREATED_BLOCK_ID",
     FromId = "FROM_ID",
     InstructionId = "INSTRUCTION_ID",
+    LegType = "LEG_TYPE",
     SettlementId = "SETTLEMENT_ID",
     ToId = "TO_ID",
     UpdatedAt = "UPDATED_AT",
@@ -20842,6 +21691,8 @@ export declare enum LegsOrderBy {
     IdDesc = "ID_DESC",
     InstructionIdAsc = "INSTRUCTION_ID_ASC",
     InstructionIdDesc = "INSTRUCTION_ID_DESC",
+    LegTypeAsc = "LEG_TYPE_ASC",
+    LegTypeDesc = "LEG_TYPE_DESC",
     Natural = "NATURAL",
     PrimaryKeyAsc = "PRIMARY_KEY_ASC",
     PrimaryKeyDesc = "PRIMARY_KEY_DESC",
@@ -20854,6 +21705,97 @@ export declare enum LegsOrderBy {
     UpdatedBlockIdAsc = "UPDATED_BLOCK_ID_ASC",
     UpdatedBlockIdDesc = "UPDATED_BLOCK_ID_DESC"
 }
+/** Represents the list of migrations executed */
+export declare type Migration = Node & {
+    __typename?: 'Migration';
+    createdAt: Scalars['Datetime'];
+    id: Scalars['String'];
+    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
+    nodeId: Scalars['ID'];
+    number: Scalars['Int'];
+    updatedAt: Scalars['Datetime'];
+    version: Scalars['String'];
+};
+export declare type MigrationAggregates = {
+    __typename?: 'MigrationAggregates';
+    keys?: Maybe<Array<Scalars['String']>>;
+};
+/** A filter to be used against `Migration` object types. All fields are combined with a logical ‘and.’ */
+export declare type MigrationFilter = {
+    /** Checks for all expressions in this list. */
+    and?: InputMaybe<Array<MigrationFilter>>;
+    /** Filter by the object’s `createdAt` field. */
+    createdAt?: InputMaybe<DatetimeFilter>;
+    /** Filter by the object’s `id` field. */
+    id?: InputMaybe<StringFilter>;
+    /** Negates the expression. */
+    not?: InputMaybe<MigrationFilter>;
+    /** Filter by the object’s `number` field. */
+    number?: InputMaybe<IntFilter>;
+    /** Checks for any expressions in this list. */
+    or?: InputMaybe<Array<MigrationFilter>>;
+    /** Filter by the object’s `updatedAt` field. */
+    updatedAt?: InputMaybe<DatetimeFilter>;
+    /** Filter by the object’s `version` field. */
+    version?: InputMaybe<StringFilter>;
+};
+/** A connection to a list of `Migration` values. */
+export declare type MigrationsConnection = {
+    __typename?: 'MigrationsConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<MigrationAggregates>;
+    /** A list of edges which contains the `Migration` and cursor to aid in pagination. */
+    edges: Array<MigrationsEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<MigrationAggregates>>;
+    /** A list of `Migration` objects. */
+    nodes: Array<Maybe<Migration>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Migration` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Migration` values. */
+export declare type MigrationsConnectionGroupedAggregatesArgs = {
+    groupBy: Array<MigrationsGroupBy>;
+    having?: InputMaybe<MigrationsHavingInput>;
+};
+/** A `Migration` edge in the connection. */
+export declare type MigrationsEdge = {
+    __typename?: 'MigrationsEdge';
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Migration` at the end of the edge. */
+    node?: Maybe<Migration>;
+};
+/** Grouping methods for `Migration` for usage during aggregation. */
+export declare enum MigrationsGroupBy {
+    CreatedAt = "CREATED_AT",
+    Number = "NUMBER",
+    UpdatedAt = "UPDATED_AT",
+    Version = "VERSION"
+}
+/** Conditions for `Migration` aggregates. */
+export declare type MigrationsHavingInput = {
+    AND?: InputMaybe<Array<MigrationsHavingInput>>;
+    OR?: InputMaybe<Array<MigrationsHavingInput>>;
+};
+/** Methods to use when ordering `Migration`. */
+export declare enum MigrationsOrderBy {
+    CreatedAtAsc = "CREATED_AT_ASC",
+    CreatedAtDesc = "CREATED_AT_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    NumberAsc = "NUMBER_ASC",
+    NumberDesc = "NUMBER_DESC",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UpdatedAtAsc = "UPDATED_AT_ASC",
+    UpdatedAtDesc = "UPDATED_AT_DESC",
+    VersionAsc = "VERSION_ASC",
+    VersionDesc = "VERSION_DESC"
+}
 /** An object with a globally unique `ID`. */
 export declare type Node = {
     /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
@@ -21176,6 +22118,14 @@ export declare enum PermissionsOrderBy {
  */
 export declare type Portfolio = Node & {
     __typename?: 'Portfolio';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByFromPortfolioId: AssetTransactionsConnection;
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByToPortfolioId: AssetTransactionsConnection;
+    /** Reads and enables pagination through a set of `Asset`. */
+    assetsByAssetTransactionFromPortfolioIdAndAssetId: PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Asset`. */
+    assetsByAssetTransactionToPortfolioIdAndAssetId: PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Asset`. */
     assetsByDistributionPortfolioIdAndAssetId: PortfolioAssetsByDistributionPortfolioIdAndAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Asset`. */
@@ -21187,6 +22137,14 @@ export declare type Portfolio = Node & {
     /** Reads and enables pagination through a set of `Asset`. */
     assetsByStoRaisingPortfolioIdAndOfferingAssetId: PortfolioAssetsByStoRaisingPortfolioIdAndOfferingAssetIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionFromPortfolioIdAndCreatedBlockId: PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionFromPortfolioIdAndUpdatedBlockId: PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionToPortfolioIdAndCreatedBlockId: PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
+    blocksByAssetTransactionToPortfolioIdAndUpdatedBlockId: PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Block`. */
     blocksByDistributionPortfolioIdAndCreatedBlockId: PortfolioBlocksByDistributionPortfolioIdAndCreatedBlockIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Block`. */
     blocksByDistributionPortfolioIdAndUpdatedBlockId: PortfolioBlocksByDistributionPortfolioIdAndUpdatedBlockIdManyToManyConnection;
@@ -21252,6 +22210,10 @@ export declare type Portfolio = Node & {
     /** Reads and enables pagination through a set of `PortfolioMovement`. */
     portfolioMovementsByToId: PortfolioMovementsConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionFromPortfolioIdAndToPortfolioId: PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
+    portfoliosByAssetTransactionToPortfolioIdAndFromPortfolioId: PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyConnection;
+    /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByLegFromIdAndToId: PortfolioPortfoliosByLegFromIdAndToIdManyToManyConnection;
     /** Reads and enables pagination through a set of `Portfolio`. */
     portfoliosByLegToIdAndFromId: PortfolioPortfoliosByLegToIdAndFromIdManyToManyConnection;
@@ -21280,6 +22242,62 @@ export declare type Portfolio = Node & {
     /** Reads and enables pagination through a set of `Venue`. */
     venuesByStoRaisingPortfolioIdAndVenueId: PortfolioVenuesByStoRaisingPortfolioIdAndVenueIdManyToManyConnection;
 };
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioAssetTransactionsByFromPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioAssetTransactionsByToPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+};
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
  *
@@ -21350,6 +22368,62 @@ export declare type PortfolioAssetsByStoRaisingPortfolioIdAndOfferingAssetIdArgs
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<AssetsOrderBy>>;
 };
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<BlockFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
+};
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
  *
@@ -21652,39 +22726,67 @@ export declare type PortfolioLegsByFromIdArgs = {
 export declare type PortfolioLegsByToIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<LegFilter>;
+    filter?: InputMaybe<LegFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<LegsOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioPortfolioMovementsByFromIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PortfolioMovementFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
+};
+/**
+ * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
+ *
+ * Note: identities will always have a default Portfolio (id = 0)
+ */
+export declare type PortfolioPortfolioMovementsByToIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<PortfolioMovementFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<LegsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
 };
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
  *
  * Note: identities will always have a default Portfolio (id = 0)
  */
-export declare type PortfolioPortfolioMovementsByFromIdArgs = {
+export declare type PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PortfolioMovementFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
  *
  * Note: identities will always have a default Portfolio (id = 0)
  */
-export declare type PortfolioPortfolioMovementsByToIdArgs = {
+export declare type PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<PortfolioMovementFilter>;
+    filter?: InputMaybe<PortfolioFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<PortfolioMovementsOrderBy>>;
+    orderBy?: InputMaybe<Array<PortfoliosOrderBy>>;
 };
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
@@ -21858,6 +22960,88 @@ export declare type PortfolioAggregates = {
     __typename?: 'PortfolioAggregates';
     keys?: Maybe<Array<Scalars['String']>>;
 };
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyConnection = {
+    __typename?: 'PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<AssetAggregates>;
+    /** A list of edges which contains the `Asset`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<AssetAggregates>>;
+    /** A list of `Asset` objects. */
+    nodes: Array<Maybe<Asset>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Asset` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<AssetsGroupBy>;
+    having?: InputMaybe<AssetsHavingInput>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyEdge = {
+    __typename?: 'PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Asset` at the end of the edge. */
+    node?: Maybe<Asset>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionFromPortfolioIdAndAssetIdManyToManyEdgeAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyConnection = {
+    __typename?: 'PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<AssetAggregates>;
+    /** A list of edges which contains the `Asset`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<AssetAggregates>>;
+    /** A list of `Asset` objects. */
+    nodes: Array<Maybe<Asset>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Asset` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Asset` values, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<AssetsGroupBy>;
+    having?: InputMaybe<AssetsHavingInput>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyEdge = {
+    __typename?: 'PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Asset` at the end of the edge. */
+    node?: Maybe<Asset>;
+};
+/** A `Asset` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioAssetsByAssetTransactionToPortfolioIdAndAssetIdManyToManyEdgeAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Asset` values, with data from `Distribution`. */
 export declare type PortfolioAssetsByDistributionPortfolioIdAndAssetIdManyToManyConnection = {
     __typename?: 'PortfolioAssetsByDistributionPortfolioIdAndAssetIdManyToManyConnection';
@@ -22063,6 +23247,170 @@ export declare type PortfolioAssetsByStoRaisingPortfolioIdAndOfferingAssetIdMany
     offset?: InputMaybe<Scalars['Int']>;
     orderBy?: InputMaybe<Array<StosOrderBy>>;
 };
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyConnection = {
+    __typename?: 'PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyEdge = {
+    __typename?: 'PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByCreatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndCreatedBlockIdManyToManyEdgeAssetTransactionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyConnection = {
+    __typename?: 'PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyEdge = {
+    __typename?: 'PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByUpdatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdManyToManyEdgeAssetTransactionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyConnection = {
+    __typename?: 'PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyEdge = {
+    __typename?: 'PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByCreatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdManyToManyEdgeAssetTransactionsByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyConnection = {
+    __typename?: 'PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<BlockAggregates>;
+    /** A list of edges which contains the `Block`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<BlockAggregates>>;
+    /** A list of `Block` objects. */
+    nodes: Array<Maybe<Block>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Block` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Block` values, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyEdge = {
+    __typename?: 'PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByUpdatedBlockId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Block` at the end of the edge. */
+    node?: Maybe<Block>;
+};
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdManyToManyEdgeAssetTransactionsByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Block` values, with data from `Distribution`. */
 export declare type PortfolioBlocksByDistributionPortfolioIdAndCreatedBlockIdManyToManyConnection = {
     __typename?: 'PortfolioBlocksByDistributionPortfolioIdAndCreatedBlockIdManyToManyConnection';
@@ -23014,6 +24362,88 @@ export declare enum PortfolioMovementsOrderBy {
     UpdatedBlockIdAsc = "UPDATED_BLOCK_ID_ASC",
     UpdatedBlockIdDesc = "UPDATED_BLOCK_ID_DESC"
 }
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyConnection = {
+    __typename?: 'PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyEdge = {
+    __typename?: 'PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByToPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdManyToManyEdgeAssetTransactionsByToPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyConnection = {
+    __typename?: 'PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyConnection';
+    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    aggregates?: Maybe<PortfolioAggregates>;
+    /** A list of edges which contains the `Portfolio`, info from the `AssetTransaction`, and the cursor to aid in pagination. */
+    edges: Array<PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyEdge>;
+    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
+    groupedAggregates?: Maybe<Array<PortfolioAggregates>>;
+    /** A list of `Portfolio` objects. */
+    nodes: Array<Maybe<Portfolio>>;
+    /** Information to aid in pagination. */
+    pageInfo: PageInfo;
+    /** The count of *all* `Portfolio` you could get from the connection. */
+    totalCount: Scalars['Int'];
+};
+/** A connection to a list of `Portfolio` values, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyEdge = {
+    __typename?: 'PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactionsByFromPortfolioId: AssetTransactionsConnection;
+    /** A cursor for use in pagination. */
+    cursor?: Maybe<Scalars['Cursor']>;
+    /** The `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdManyToManyEdgeAssetTransactionsByFromPortfolioIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
 /** A connection to a list of `Portfolio` values, with data from `Leg`. */
 export declare type PortfolioPortfoliosByLegFromIdAndToIdManyToManyConnection = {
     __typename?: 'PortfolioPortfoliosByLegFromIdAndToIdManyToManyConnection';
@@ -23473,6 +24903,10 @@ export declare type PortfoliosHavingInput = {
 };
 /** Methods to use when ordering `Portfolio`. */
 export declare enum PortfoliosOrderBy {
+    AssetTransactionsByFromPortfolioIdCountAsc = "ASSET_TRANSACTIONS_BY_FROM_PORTFOLIO_ID_COUNT_ASC",
+    AssetTransactionsByFromPortfolioIdCountDesc = "ASSET_TRANSACTIONS_BY_FROM_PORTFOLIO_ID_COUNT_DESC",
+    AssetTransactionsByToPortfolioIdCountAsc = "ASSET_TRANSACTIONS_BY_TO_PORTFOLIO_ID_COUNT_ASC",
+    AssetTransactionsByToPortfolioIdCountDesc = "ASSET_TRANSACTIONS_BY_TO_PORTFOLIO_ID_COUNT_DESC",
     CreatedAtAsc = "CREATED_AT_ASC",
     CreatedAtDesc = "CREATED_AT_DESC",
     CreatedBlockIdAsc = "CREATED_BLOCK_ID_ASC",
@@ -24037,6 +25471,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     BatchAddDocument = "batch_add_document",
     BatchAddSecondaryKeyWithAuthorization = "batch_add_secondary_key_with_authorization",
     BatchAddSigningKeyWithAuthorization = "batch_add_signing_key_with_authorization",
+    BatchAll = "batch_all",
     BatchAtomic = "batch_atomic",
     BatchChangeAssetRule = "batch_change_asset_rule",
     BatchChangeComplianceRequirement = "batch_change_compliance_requirement",
@@ -24044,6 +25479,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     BatchFreezeTx = "batch_freeze_tx",
     BatchHandleBridgeTx = "batch_handle_bridge_tx",
     BatchIssue = "batch_issue",
+    BatchOld = "batch_old",
     BatchOptimistic = "batch_optimistic",
     BatchProposeBridgeTx = "batch_propose_bridge_tx",
     BatchRemoveAuthorization = "batch_remove_authorization",
@@ -24083,6 +25519,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     ChangeReceiptValidity = "change_receipt_validity",
     ChangeRecordDate = "change_record_date",
     ChangeSigsRequired = "change_sigs_required",
+    ChangeSigsRequiredViaCreator = "change_sigs_required_via_creator",
     ChangeSlashingAllowedFor = "change_slashing_allowed_for",
     ChangeTemplateFees = "change_template_fees",
     ChangeTemplateMetaUrl = "change_template_meta_url",
@@ -24104,6 +25541,8 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     CreateAssetAndMint = "create_asset_and_mint",
     CreateAssetWithCustomType = "create_asset_with_custom_type",
     CreateCheckpoint = "create_checkpoint",
+    CreateChildIdentities = "create_child_identities",
+    CreateChildIdentity = "create_child_identity",
     CreateFundraiser = "create_fundraiser",
     CreateGroup = "create_group",
     CreateGroupAndAddAuth = "create_group_and_add_auth",
@@ -24122,6 +25561,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     DisableMember = "disable_member",
     DisallowVenues = "disallow_venues",
     Disbursement = "disbursement",
+    DispatchAs = "dispatch_as",
     Distribute = "distribute",
     EmergencyReferendum = "emergency_referendum",
     EnableIndividualCommissions = "enable_individual_commissions",
@@ -24130,12 +25570,15 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     ExecuteManualInstruction = "execute_manual_instruction",
     ExecuteScheduledInstruction = "execute_scheduled_instruction",
     ExecuteScheduledInstructionV2 = "execute_scheduled_instruction_v2",
+    ExecuteScheduledInstructionV3 = "execute_scheduled_instruction_v3",
     ExecuteScheduledPip = "execute_scheduled_pip",
     ExecuteScheduledProposal = "execute_scheduled_proposal",
+    ExemptTickerAffirmation = "exempt_ticker_affirmation",
     ExpireScheduledPip = "expire_scheduled_pip",
     FastTrackProposal = "fast_track_proposal",
     FillBlock = "fill_block",
     FinalHint = "final_hint",
+    ForceBatch = "force_batch",
     ForceHandleBridgeTx = "force_handle_bridge_tx",
     ForceNewEra = "force_new_era",
     ForceNewEraAlways = "force_new_era_always",
@@ -24203,11 +25646,20 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     PauseSto = "pause_sto",
     PayoutStakers = "payout_stakers",
     PayoutStakersBySystem = "payout_stakers_by_system",
+    PlaceholderAddAndAffirmInstruction = "placeholder_add_and_affirm_instruction",
+    PlaceholderAddAndAffirmInstructionWithMemo = "placeholder_add_and_affirm_instruction_with_memo",
+    PlaceholderAddInstruction = "placeholder_add_instruction",
+    PlaceholderAddInstructionWithMemo = "placeholder_add_instruction_with_memo",
+    PlaceholderAffirmInstruction = "placeholder_affirm_instruction",
     PlaceholderClaimReceipt = "placeholder_claim_receipt",
     PlaceholderFillBlock = "placeholder_fill_block",
     PlaceholderLegacySetPermissionToSigner = "placeholder_legacy_set_permission_to_signer",
+    PlaceholderRejectInstruction = "placeholder_reject_instruction",
     PlaceholderUnclaimReceipt = "placeholder_unclaim_receipt",
+    PlaceholderWithdrawAffirmation = "placeholder_withdraw_affirmation",
     PlanConfigChange = "plan_config_change",
+    PreApprovePortfolio = "pre_approve_portfolio",
+    PreApproveTicker = "pre_approve_ticker",
     Propose = "propose",
     ProposeBridgeTx = "propose_bridge_tx",
     PruneProposal = "prune_proposal",
@@ -24246,6 +25698,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     RemoveCa = "remove_ca",
     RemoveCode = "remove_code",
     RemoveComplianceRequirement = "remove_compliance_requirement",
+    RemoveCreatorControls = "remove_creator_controls",
     RemoveDefaultTrustedClaimIssuer = "remove_default_trusted_claim_issuer",
     RemoveDistribution = "remove_distribution",
     RemoveDocuments = "remove_documents",
@@ -24258,12 +25711,15 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     RemoveMultisigSignersViaCreator = "remove_multisig_signers_via_creator",
     RemovePayingKey = "remove_paying_key",
     RemovePermissionedValidator = "remove_permissioned_validator",
+    RemovePortfolioPreApproval = "remove_portfolio_pre_approval",
     RemovePrimaryIssuanceAgent = "remove_primary_issuance_agent",
     RemoveSchedule = "remove_schedule",
     RemoveSecondaryKeys = "remove_secondary_keys",
     RemoveSecondaryKeysOld = "remove_secondary_keys_old",
     RemoveSigningKeys = "remove_signing_keys",
     RemoveSmartExtension = "remove_smart_extension",
+    RemoveTickerAffirmationExemption = "remove_ticker_affirmation_exemption",
+    RemoveTickerPreApproval = "remove_ticker_pre_approval",
     RemoveTransferManager = "remove_transfer_manager",
     RemoveTxs = "remove_txs",
     RenameAsset = "rename_asset",
@@ -24356,6 +25812,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     UnfreezeFundraiser = "unfreeze_fundraiser",
     UnfreezeSecondaryKeys = "unfreeze_secondary_keys",
     UnfreezeTxs = "unfreeze_txs",
+    UnlinkChildIdentity = "unlink_child_identity",
     UnnotePreimage = "unnote_preimage",
     UnrequestPreimage = "unrequest_preimage",
     UpdateAssetType = "update_asset_type",
@@ -24371,6 +25828,7 @@ export declare enum PublicEnum0Bf3C7D4Ef {
     ValidateCddExpiryNominators = "validate_cdd_expiry_nominators",
     Vote = "vote",
     VoteOrPropose = "vote_or_propose",
+    WithWeight = "with_weight",
     WithdrawAffirmation = "withdraw_affirmation",
     WithdrawAffirmationV2 = "withdraw_affirmation_v2",
     WithdrawUnbonded = "withdraw_unbonded"
@@ -24538,6 +25996,7 @@ export declare enum PublicEnum8F5A39C8Ee {
     AllGood = "AllGood",
     Approval = "Approval",
     Approved = "Approved",
+    AssetBalanceUpdated = "AssetBalanceUpdated",
     AssetCompliancePaused = "AssetCompliancePaused",
     AssetComplianceReplaced = "AssetComplianceReplaced",
     AssetComplianceReset = "AssetComplianceReset",
@@ -24567,7 +26026,10 @@ export declare enum PublicEnum8F5A39C8Ee {
     BallotCancelled = "BallotCancelled",
     BallotCreated = "BallotCreated",
     BatchCompleted = "BatchCompleted",
+    BatchCompletedOld = "BatchCompletedOld",
+    BatchCompletedWithErrors = "BatchCompletedWithErrors",
     BatchInterrupted = "BatchInterrupted",
+    BatchInterruptedOld = "BatchInterruptedOld",
     BatchOptimisticFailed = "BatchOptimisticFailed",
     BenefitClaimed = "BenefitClaimed",
     Bonded = "Bonded",
@@ -24589,6 +26051,8 @@ export declare enum PublicEnum8F5A39C8Ee {
     CddRequirementForPrimaryKeyUpdated = "CddRequirementForPrimaryKeyUpdated",
     CddStatus = "CddStatus",
     CheckpointCreated = "CheckpointCreated",
+    ChildDidCreated = "ChildDidCreated",
+    ChildDidUnlinked = "ChildDidUnlinked",
     ClaimAdded = "ClaimAdded",
     ClaimRevoked = "ClaimRevoked",
     ClassicTickerClaimed = "ClassicTickerClaimed",
@@ -24622,6 +26086,7 @@ export declare enum PublicEnum8F5A39C8Ee {
     DidStatus = "DidStatus",
     DidWithholdingTaxChanged = "DidWithholdingTaxChanged",
     Dispatched = "Dispatched",
+    DispatchedAs = "DispatchedAs",
     DividendCanceled = "DividendCanceled",
     DividendCreated = "DividendCreated",
     DividendPaidOutToUser = "DividendPaidOutToUser",
@@ -24665,6 +26130,7 @@ export declare enum PublicEnum8F5A39C8Ee {
     FundraiserUnfrozen = "FundraiserUnfrozen",
     FundraiserWindowModifed = "FundraiserWindowModifed",
     FundraiserWindowModified = "FundraiserWindowModified",
+    FundsMovedBetweenPortfolios = "FundsMovedBetweenPortfolios",
     FundsRaised = "FundsRaised",
     FungibleTokensMovedBetweenPortfolios = "FungibleTokensMovedBetweenPortfolios",
     GlobalCommissionUpdated = "GlobalCommissionUpdated",
@@ -24697,6 +26163,8 @@ export declare enum PublicEnum8F5A39C8Ee {
     IsIssuable = "IsIssuable",
     Issued = "Issued",
     IssuedNft = "IssuedNFT",
+    ItemCompleted = "ItemCompleted",
+    ItemFailed = "ItemFailed",
     ItnRewardClaimed = "ItnRewardClaimed",
     KeyChanged = "KeyChanged",
     KilledAccount = "KilledAccount",
@@ -24722,6 +26190,7 @@ export declare enum PublicEnum8F5A39C8Ee {
     MultiSigSignerAdded = "MultiSigSignerAdded",
     MultiSigSignerAuthorized = "MultiSigSignerAuthorized",
     MultiSigSignerRemoved = "MultiSigSignerRemoved",
+    NftPortfolioUpdated = "NFTPortfolioUpdated",
     NfTsMovedBetweenPortfolios = "NFTsMovedBetweenPortfolios",
     NewAccount = "NewAccount",
     NewAssetRuleCreated = "NewAssetRuleCreated",
@@ -24785,6 +26254,7 @@ export declare enum PublicEnum8F5A39C8Ee {
     RegisterAssetMetadataGlobalType = "RegisterAssetMetadataGlobalType",
     RegisterAssetMetadataLocalType = "RegisterAssetMetadataLocalType",
     Rejected = "Rejected",
+    RelayedTx = "RelayedTx",
     ReleaseCoordinatorUpdated = "ReleaseCoordinatorUpdated",
     Remarked = "Remarked",
     Removed = "Removed",
@@ -25003,6 +26473,39 @@ export declare type PublicEnum72Fc336BfeFilter = {
     /** Not included in the specified list. */
     notIn?: InputMaybe<Array<PublicEnum72Fc336Bfe>>;
 };
+/** @enum
+ * @enumName LegTypeEnum
+ *  Represents all possible states of an Instruction */
+export declare enum PublicEnum2792Cc24Ad {
+    Fungible = "Fungible",
+    NonFungible = "NonFungible",
+    OffChain = "OffChain"
+}
+/** A filter to be used against PublicEnum2792Cc24Ad fields. All fields are combined with a logical ‘and.’ */
+export declare type PublicEnum2792Cc24AdFilter = {
+    /** Not equal to the specified value, treating null like an ordinary value. */
+    distinctFrom?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Equal to the specified value. */
+    equalTo?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Greater than the specified value. */
+    greaterThan?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Greater than or equal to the specified value. */
+    greaterThanOrEqualTo?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Included in the specified list. */
+    in?: InputMaybe<Array<PublicEnum2792Cc24Ad>>;
+    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
+    isNull?: InputMaybe<Scalars['Boolean']>;
+    /** Less than the specified value. */
+    lessThan?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Less than or equal to the specified value. */
+    lessThanOrEqualTo?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Equal to the specified value, treating null like an ordinary value. */
+    notDistinctFrom?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Not equal to the specified value. */
+    notEqualTo?: InputMaybe<PublicEnum2792Cc24Ad>;
+    /** Not included in the specified list. */
+    notIn?: InputMaybe<Array<PublicEnum2792Cc24Ad>>;
+};
 /** @enum
  * @enumName AuthorizationStatusEnum
  *  Represents all possible authorization statuses */
@@ -25194,6 +26697,11 @@ export declare type Query = Node & {
     assetPendingOwnershipTransferByNodeId?: Maybe<AssetPendingOwnershipTransfer>;
     /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
     assetPendingOwnershipTransfers?: Maybe<AssetPendingOwnershipTransfersConnection>;
+    assetTransaction?: Maybe<AssetTransaction>;
+    /** Reads a single `AssetTransaction` using its globally unique `ID`. */
+    assetTransactionByNodeId?: Maybe<AssetTransaction>;
+    /** Reads and enables pagination through a set of `AssetTransaction`. */
+    assetTransactions?: Maybe<AssetTransactionsConnection>;
     /** Reads and enables pagination through a set of `Asset`. */
     assets?: Maybe<AssetsConnection>;
     authorization?: Maybe<Authorization>;
@@ -25281,6 +26789,11 @@ export declare type Query = Node & {
     legByNodeId?: Maybe<Leg>;
     /** Reads and enables pagination through a set of `Leg`. */
     legs?: Maybe<LegsConnection>;
+    migration?: Maybe<Migration>;
+    /** Reads a single `Migration` using its globally unique `ID`. */
+    migrationByNodeId?: Maybe<Migration>;
+    /** Reads and enables pagination through a set of `Migration`. */
+    migrations?: Maybe<MigrationsConnection>;
     /** Fetches an object given its globally unique `ID`. */
     node?: Maybe<Node>;
     /** The root query type must be a `Node` to work well with Relay 1 mutations. This just resolves to `query`. */
@@ -25498,6 +27011,24 @@ export declare type QueryAssetPendingOwnershipTransfersArgs = {
     orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
 };
 /** The root query type which gives access points into the data universe. */
+export declare type QueryAssetTransactionArgs = {
+    id: Scalars['String'];
+};
+/** The root query type which gives access points into the data universe. */
+export declare type QueryAssetTransactionByNodeIdArgs = {
+    nodeId: Scalars['ID'];
+};
+/** The root query type which gives access points into the data universe. */
+export declare type QueryAssetTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetTransactionFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
+};
+/** The root query type which gives access points into the data universe. */
 export declare type QueryAssetsArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -25814,6 +27345,24 @@ export declare type QueryLegsArgs = {
     orderBy?: InputMaybe<Array<LegsOrderBy>>;
 };
 /** The root query type which gives access points into the data universe. */
+export declare type QueryMigrationArgs = {
+    id: Scalars['String'];
+};
+/** The root query type which gives access points into the data universe. */
+export declare type QueryMigrationByNodeIdArgs = {
+    nodeId: Scalars['ID'];
+};
+/** The root query type which gives access points into the data universe. */
+export declare type QueryMigrationsArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<MigrationFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<MigrationsOrderBy>>;
+};
+/** The root query type which gives access points into the data universe. */
 export declare type QueryNodeArgs = {
     nodeId: Scalars['ID'];
 };