@polymeshassociation/polymesh-sdk 21.0.0-alpha.6 → 21.0.0-alpha.8

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']>;
@@ -6288,6 +6753,46 @@ export declare type BlockPortfolioMovementsByUpdatedBlockIdArgs = {
     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 BlockPortfoliosByAssetTransactionCreatedBlockIdAndFromPortfolioIdArgs = {
+    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>>;
+};
+/** 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 BlockPortfoliosByAssetTransactionCreatedBlockIdAndToPortfolioIdArgs = {
+    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>>;
+};
+/** 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 BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdArgs = {
+    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>>;
+};
+/** 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 BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdArgs = {
+    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>>;
+};
+/** 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 = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
@@ -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';
@@ -8584,23 +9171,105 @@ export declare type BlockBlocksByAssetHolderUpdatedBlockIdAndCreatedBlockIdManyT
     /** The `Block` at the end of the edge. */
     node?: Maybe<Block>;
 };
-/** A `Block` edge in the connection, with data from `AssetHolder`. */
-export declare type BlockBlocksByAssetHolderUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetHoldersByCreatedBlockIdArgs = {
+/** A `Block` edge in the connection, with data from `AssetHolder`. */
+export declare type BlockBlocksByAssetHolderUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetHoldersByCreatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetHolderFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetHoldersOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnection = {
+    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnection';
+    /** 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 `AssetPendingOwnershipTransfer`, and the cursor to aid in pagination. */
+    edges: Array<BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge>;
+    /** 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 `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge = {
+    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
+    assetPendingOwnershipTransfersByUpdatedBlockId: AssetPendingOwnershipTransfersConnection;
+    /** 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 `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdgeAssetPendingOwnershipTransfersByUpdatedBlockIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']>;
+    before?: InputMaybe<Scalars['Cursor']>;
+    filter?: InputMaybe<AssetPendingOwnershipTransferFilter>;
+    first?: InputMaybe<Scalars['Int']>;
+    last?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
+};
+/** A connection to a list of `Block` values, with data from `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnection = {
+    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnection';
+    /** 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 `AssetPendingOwnershipTransfer`, and the cursor to aid in pagination. */
+    edges: Array<BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge>;
+    /** 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 `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<BlocksGroupBy>;
+    having?: InputMaybe<BlocksHavingInput>;
+};
+/** A `Block` edge in the connection, with data from `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge = {
+    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge';
+    /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
+    assetPendingOwnershipTransfersByCreatedBlockId: AssetPendingOwnershipTransfersConnection;
+    /** 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 `AssetPendingOwnershipTransfer`. */
+export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetPendingOwnershipTransfersByCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetHolderFilter>;
+    filter?: InputMaybe<AssetPendingOwnershipTransferFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetHoldersOrderBy>>;
+    orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
 };
-/** A connection to a list of `Block` values, with data from `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnection = {
-    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnection';
+/** 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 `AssetPendingOwnershipTransfer`, and the cursor to aid in pagination. */
-    edges: Array<BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge>;
+    /** 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. */
@@ -8610,38 +9279,38 @@ export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndU
     /** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+/** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge = {
-    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdge';
-    /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
-    assetPendingOwnershipTransfersByUpdatedBlockId: AssetPendingOwnershipTransfersConnection;
+/** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferCreatedBlockIdAndUpdatedBlockIdManyToManyEdgeAssetPendingOwnershipTransfersByUpdatedBlockIdArgs = {
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionCreatedBlockIdAndUpdatedBlockIdManyToManyEdgeAssetTransactionsByUpdatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetPendingOwnershipTransferFilter>;
+    filter?: InputMaybe<AssetTransactionFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
 };
-/** A connection to a list of `Block` values, with data from `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnection = {
-    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnection';
+/** 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 `AssetPendingOwnershipTransfer`, and the cursor to aid in pagination. */
-    edges: Array<BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge>;
+    /** 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. */
@@ -8651,30 +9320,30 @@ export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndC
     /** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyConnectionGroupedAggregatesArgs = {
+/** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge = {
-    __typename?: 'BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdge';
-    /** Reads and enables pagination through a set of `AssetPendingOwnershipTransfer`. */
-    assetPendingOwnershipTransfersByCreatedBlockId: AssetPendingOwnershipTransfersConnection;
+/** 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 `AssetPendingOwnershipTransfer`. */
-export declare type BlockBlocksByAssetPendingOwnershipTransferUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetPendingOwnershipTransfersByCreatedBlockIdArgs = {
+/** A `Block` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockBlocksByAssetTransactionUpdatedBlockIdAndCreatedBlockIdManyToManyEdgeAssetTransactionsByCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetPendingOwnershipTransferFilter>;
+    filter?: InputMaybe<AssetTransactionFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetPendingOwnershipTransfersOrderBy>>;
+    orderBy?: InputMaybe<Array<AssetTransactionsOrderBy>>;
 };
 /** A connection to a list of `Block` values, with data from `Asset`. */
 export declare type BlockBlocksByAssetUpdatedBlockIdAndCreatedBlockIdManyToManyConnection = {
@@ -13106,6 +13775,170 @@ export declare type BlockPermissionsByAccountUpdatedBlockIdAndPermissionsIdManyT
     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* `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 BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** 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 `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndFromPortfolioIdManyToManyEdgeAssetTransactionsByFromPortfolioIdArgs = {
+    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 BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnection = {
+    __typename?: 'BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnection';
+    /** 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<BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdge>;
+    /** 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 BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyConnectionGroupedAggregatesArgs = {
+    groupBy: Array<PortfoliosGroupBy>;
+    having?: InputMaybe<PortfoliosHavingInput>;
+};
+/** 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 `Portfolio` at the end of the edge. */
+    node?: Maybe<Portfolio>;
+};
+/** A `Portfolio` edge in the connection, with data from `AssetTransaction`. */
+export declare type BlockPortfoliosByAssetTransactionUpdatedBlockIdAndToPortfolioIdManyToManyEdgeAssetTransactionsByToPortfolioIdArgs = {
+    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 BlockPortfoliosByDistributionCreatedBlockIdAndPortfolioIdManyToManyConnection = {
     __typename?: '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'];
@@ -21176,6 +22020,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 +22039,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 +22112,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 +22144,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
  *
@@ -21306,49 +22226,105 @@ export declare type PortfolioAssetsByPortfolioMovementFromIdAndAssetIdArgs = {
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+    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 PortfolioAssetsByPortfolioMovementToIdAndAssetIdArgs = {
+    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 PortfolioAssetsByStoOfferingPortfolioIdAndOfferingAssetIdArgs = {
+    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 PortfolioAssetsByStoRaisingPortfolioIdAndOfferingAssetIdArgs = {
+    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 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 PortfolioAssetsByPortfolioMovementToIdAndAssetIdArgs = {
+export declare type PortfolioBlocksByAssetTransactionFromPortfolioIdAndUpdatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetFilter>;
+    filter?: InputMaybe<BlockFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+    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 PortfolioAssetsByStoOfferingPortfolioIdAndOfferingAssetIdArgs = {
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndCreatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetFilter>;
+    filter?: InputMaybe<BlockFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+    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 PortfolioAssetsByStoRaisingPortfolioIdAndOfferingAssetIdArgs = {
+export declare type PortfolioBlocksByAssetTransactionToPortfolioIdAndUpdatedBlockIdArgs = {
     after?: InputMaybe<Scalars['Cursor']>;
     before?: InputMaybe<Scalars['Cursor']>;
-    filter?: InputMaybe<AssetFilter>;
+    filter?: InputMaybe<BlockFilter>;
     first?: InputMaybe<Scalars['Int']>;
     last?: InputMaybe<Scalars['Int']>;
     offset?: InputMaybe<Scalars['Int']>;
-    orderBy?: InputMaybe<Array<AssetsOrderBy>>;
+    orderBy?: InputMaybe<Array<BlocksOrderBy>>;
 };
 /**
  * Represents a grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
@@ -21686,6 +22662,34 @@ export declare type PortfolioPortfolioMovementsByToIdArgs = {
     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 PortfolioPortfoliosByAssetTransactionFromPortfolioIdAndToPortfolioIdArgs = {
+    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 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 PortfolioPortfoliosByAssetTransactionToPortfolioIdAndFromPortfolioIdArgs = {
+    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 grouping of Assets held by an Identity. Particular accounts maybe authorized only over certain portfolios
  *
@@ -21858,6 +22862,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 +23149,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 +24264,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 +24805,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",
@@ -25194,6 +26530,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>;
@@ -25498,6 +26839,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']>;