@requestnetwork/payment-detection 0.35.1-next.1712 → 0.35.1-next.1715

package/dist/thegraph/generated/graphql-superfluid.d.ts

@@ -24,7 +24,7 @@ export declare type Scalars = {
     Bytes: any;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type Account = {
@@ -47,7 +47,7 @@ export declare type Account = {
     accountTokenSnapshots: Array<AccountTokenSnapshot>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountInflowsArgs = {
@@ -58,7 +58,7 @@ export declare type AccountInflowsArgs = {
     where?: Maybe<Stream_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountOutflowsArgs = {
@@ -69,7 +69,7 @@ export declare type AccountOutflowsArgs = {
     where?: Maybe<Stream_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountSubscriptionsArgs = {
@@ -80,7 +80,7 @@ export declare type AccountSubscriptionsArgs = {
     where?: Maybe<IndexSubscription_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountPublishedIndexesArgs = {
@@ -91,7 +91,7 @@ export declare type AccountPublishedIndexesArgs = {
     where?: Maybe<Index_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountSentTransferEventsArgs = {
@@ -102,7 +102,7 @@ export declare type AccountSentTransferEventsArgs = {
     where?: Maybe<TransferEvent_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountReceivedTransferEventsArgs = {
@@ -113,7 +113,7 @@ export declare type AccountReceivedTransferEventsArgs = {
     where?: Maybe<TransferEvent_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountTokenUpgradedEventsArgs = {
@@ -124,7 +124,7 @@ export declare type AccountTokenUpgradedEventsArgs = {
     where?: Maybe<TokenUpgradedEvent_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountTokenDowngradedEventsArgs = {
@@ -135,7 +135,7 @@ export declare type AccountTokenDowngradedEventsArgs = {
     where?: Maybe<TokenDowngradedEvent_Filter>;
 };
 /**
- * Account: A HOL entity created for any addresses which interact with
+ * Account: A higher order entity created for any addresses which interact with
  * Superfluid contracts.
  */
 export declare type AccountAccountTokenSnapshotsArgs = {
@@ -151,7 +151,7 @@ export declare type AccountAccountTokenSnapshotsArgs = {
  */
 export declare type AccountTokenSnapshot = {
     __typename?: 'AccountTokenSnapshot';
-    /** ID composed of: accountID-tokenID */
+    /** ID composed of: accountID + keccak256("-") + tokenID */
     id: Scalars['ID'];
     updatedAtTimestamp: Scalars['BigInt'];
     updatedAtBlockNumber: Scalars['BigInt'];
@@ -165,6 +165,8 @@ export declare type AccountTokenSnapshot = {
     totalApprovedSubscriptions: Scalars['Int'];
     /** Balance of `account` as of `updatedAtTimestamp`/`updatedAtBlock`. */
     balanceUntilUpdatedAt: Scalars['BigInt'];
+    /** The total deposit this account has held by the CFA agreement for `account` active streams. */
+    totalDeposit: Scalars['BigInt'];
     /** The total net flow rate of the `account` as of `updatedAtTimestamp`/`updatedAtBlock`. */
     totalNetFlowRate: Scalars['BigInt'];
     /** The total inflow rate (receive flowRate per second) of the `account`. */
@@ -180,6 +182,18 @@ export declare type AccountTokenSnapshot = {
     totalAmountTransferredUntilUpdatedAt: Scalars['BigInt'];
     account: Account;
     token: Token;
+    flowOperators: Array<FlowOperator>;
+};
+/**
+ * AccountTokenSnapshot: An aggregate entity which aggregates data on an account's
+ * interaction with a `token`.
+ */
+export declare type AccountTokenSnapshotFlowOperatorsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperator_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperator_Filter>;
 };
 export declare type AccountTokenSnapshot_Filter = {
     id?: Maybe<Scalars['ID']>;
@@ -246,6 +260,14 @@ export declare type AccountTokenSnapshot_Filter = {
     balanceUntilUpdatedAt_lte?: Maybe<Scalars['BigInt']>;
     balanceUntilUpdatedAt_in?: Maybe<Array<Scalars['BigInt']>>;
     balanceUntilUpdatedAt_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    totalDeposit?: Maybe<Scalars['BigInt']>;
+    totalDeposit_not?: Maybe<Scalars['BigInt']>;
+    totalDeposit_gt?: Maybe<Scalars['BigInt']>;
+    totalDeposit_lt?: Maybe<Scalars['BigInt']>;
+    totalDeposit_gte?: Maybe<Scalars['BigInt']>;
+    totalDeposit_lte?: Maybe<Scalars['BigInt']>;
+    totalDeposit_in?: Maybe<Array<Scalars['BigInt']>>;
+    totalDeposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
     totalNetFlowRate?: Maybe<Scalars['BigInt']>;
     totalNetFlowRate_not?: Maybe<Scalars['BigInt']>;
     totalNetFlowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -338,13 +360,15 @@ export declare enum AccountTokenSnapshot_OrderBy {
     TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
     TotalApprovedSubscriptions = "totalApprovedSubscriptions",
     BalanceUntilUpdatedAt = "balanceUntilUpdatedAt",
+    TotalDeposit = "totalDeposit",
     TotalNetFlowRate = "totalNetFlowRate",
     TotalInflowRate = "totalInflowRate",
     TotalOutflowRate = "totalOutflowRate",
     TotalAmountStreamedUntilUpdatedAt = "totalAmountStreamedUntilUpdatedAt",
     TotalAmountTransferredUntilUpdatedAt = "totalAmountTransferredUntilUpdatedAt",
     Account = "account",
-    Token = "token"
+    Token = "token",
+    FlowOperators = "flowOperators"
 }
 export declare type Account_Filter = {
     id?: Maybe<Scalars['ID']>;
@@ -1521,6 +1545,338 @@ export declare enum Event_OrderBy {
     Timestamp = "timestamp",
     TransactionHash = "transactionHash"
 }
+/** FlowOperator: A higher order entity that of a flow operator for an `AccountTokenSnapshot`. */
+export declare type FlowOperator = {
+    __typename?: 'FlowOperator';
+    /** ID composed of: flowOperator - token - sender */
+    id: Scalars['ID'];
+    createdAtTimestamp: Scalars['BigInt'];
+    createdAtBlockNumber: Scalars['BigInt'];
+    updatedAtTimestamp: Scalars['BigInt'];
+    updatedAtBlockNumber: Scalars['BigInt'];
+    /**
+     * The permissions granted to the `flowOperator`.
+     * Octo bitmask representation.
+     */
+    permissions: Scalars['Int'];
+    /**
+     * The flow rate allowance granted to the `flowOperator`
+     * by the `sender`. This can be reset if the `sender`
+     * updates the `flowOperator` flow rate allowance.
+     */
+    flowRateAllowanceGranted: Scalars['BigInt'];
+    /**
+     * The remaining flow rate allowance the `flowOperator` has,
+     * this will go down every time when `flowOperator` uses it
+     * (if they increase flowRate or create a new flow)
+     * and can only be reset if the `sender` updates the flow
+     * rate allowance.
+     */
+    flowRateAllowanceRemaining: Scalars['BigInt'];
+    flowOperator: Scalars['Bytes'];
+    sender: Account;
+    token: Token;
+    accountTokenSnapshot: AccountTokenSnapshot;
+    flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
+};
+/** FlowOperator: A higher order entity that of a flow operator for an `AccountTokenSnapshot`. */
+export declare type FlowOperatorFlowOperatorUpdatedEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
+};
+export declare type FlowOperatorUpdatedEvent = Event & {
+    __typename?: 'FlowOperatorUpdatedEvent';
+    id: Scalars['ID'];
+    transactionHash: Scalars['Bytes'];
+    timestamp: Scalars['BigInt'];
+    name: Scalars['String'];
+    /** Holds the token, sender, and flowOperator addresses. */
+    addresses: Array<Scalars['Bytes']>;
+    blockNumber: Scalars['BigInt'];
+    /** The address of the `token` being streamed. */
+    token: Scalars['Bytes'];
+    sender: Scalars['Bytes'];
+    /**
+     * The permissions granted to the `flowOperator`.
+     * Octo bitmask representation.
+     */
+    permissions: Scalars['Int'];
+    flowRateAllowance: Scalars['BigInt'];
+    flowOperator: FlowOperator;
+};
+export declare type FlowOperatorUpdatedEvent_Filter = {
+    id?: Maybe<Scalars['ID']>;
+    id_not?: Maybe<Scalars['ID']>;
+    id_gt?: Maybe<Scalars['ID']>;
+    id_lt?: Maybe<Scalars['ID']>;
+    id_gte?: Maybe<Scalars['ID']>;
+    id_lte?: Maybe<Scalars['ID']>;
+    id_in?: Maybe<Array<Scalars['ID']>>;
+    id_not_in?: Maybe<Array<Scalars['ID']>>;
+    transactionHash?: Maybe<Scalars['Bytes']>;
+    transactionHash_not?: Maybe<Scalars['Bytes']>;
+    transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
+    transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    transactionHash_contains?: Maybe<Scalars['Bytes']>;
+    transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
+    timestamp?: Maybe<Scalars['BigInt']>;
+    timestamp_not?: Maybe<Scalars['BigInt']>;
+    timestamp_gt?: Maybe<Scalars['BigInt']>;
+    timestamp_lt?: Maybe<Scalars['BigInt']>;
+    timestamp_gte?: Maybe<Scalars['BigInt']>;
+    timestamp_lte?: Maybe<Scalars['BigInt']>;
+    timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
+    timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    name?: Maybe<Scalars['String']>;
+    name_not?: Maybe<Scalars['String']>;
+    name_gt?: Maybe<Scalars['String']>;
+    name_lt?: Maybe<Scalars['String']>;
+    name_gte?: Maybe<Scalars['String']>;
+    name_lte?: Maybe<Scalars['String']>;
+    name_in?: Maybe<Array<Scalars['String']>>;
+    name_not_in?: Maybe<Array<Scalars['String']>>;
+    name_contains?: Maybe<Scalars['String']>;
+    name_contains_nocase?: Maybe<Scalars['String']>;
+    name_not_contains?: Maybe<Scalars['String']>;
+    name_not_contains_nocase?: Maybe<Scalars['String']>;
+    name_starts_with?: Maybe<Scalars['String']>;
+    name_starts_with_nocase?: Maybe<Scalars['String']>;
+    name_not_starts_with?: Maybe<Scalars['String']>;
+    name_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    name_ends_with?: Maybe<Scalars['String']>;
+    name_ends_with_nocase?: Maybe<Scalars['String']>;
+    name_not_ends_with?: Maybe<Scalars['String']>;
+    name_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    addresses?: Maybe<Array<Scalars['Bytes']>>;
+    addresses_not?: Maybe<Array<Scalars['Bytes']>>;
+    addresses_contains?: Maybe<Array<Scalars['Bytes']>>;
+    addresses_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
+    addresses_not_contains?: Maybe<Array<Scalars['Bytes']>>;
+    addresses_not_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
+    blockNumber?: Maybe<Scalars['BigInt']>;
+    blockNumber_not?: Maybe<Scalars['BigInt']>;
+    blockNumber_gt?: Maybe<Scalars['BigInt']>;
+    blockNumber_lt?: Maybe<Scalars['BigInt']>;
+    blockNumber_gte?: Maybe<Scalars['BigInt']>;
+    blockNumber_lte?: Maybe<Scalars['BigInt']>;
+    blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
+    blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    token?: Maybe<Scalars['Bytes']>;
+    token_not?: Maybe<Scalars['Bytes']>;
+    token_in?: Maybe<Array<Scalars['Bytes']>>;
+    token_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    token_contains?: Maybe<Scalars['Bytes']>;
+    token_not_contains?: Maybe<Scalars['Bytes']>;
+    sender?: Maybe<Scalars['Bytes']>;
+    sender_not?: Maybe<Scalars['Bytes']>;
+    sender_in?: Maybe<Array<Scalars['Bytes']>>;
+    sender_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    sender_contains?: Maybe<Scalars['Bytes']>;
+    sender_not_contains?: Maybe<Scalars['Bytes']>;
+    permissions?: Maybe<Scalars['Int']>;
+    permissions_not?: Maybe<Scalars['Int']>;
+    permissions_gt?: Maybe<Scalars['Int']>;
+    permissions_lt?: Maybe<Scalars['Int']>;
+    permissions_gte?: Maybe<Scalars['Int']>;
+    permissions_lte?: Maybe<Scalars['Int']>;
+    permissions_in?: Maybe<Array<Scalars['Int']>>;
+    permissions_not_in?: Maybe<Array<Scalars['Int']>>;
+    flowRateAllowance?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_not?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_gt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_lt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_gte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_lte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowance_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowRateAllowance_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowOperator?: Maybe<Scalars['String']>;
+    flowOperator_not?: Maybe<Scalars['String']>;
+    flowOperator_gt?: Maybe<Scalars['String']>;
+    flowOperator_lt?: Maybe<Scalars['String']>;
+    flowOperator_gte?: Maybe<Scalars['String']>;
+    flowOperator_lte?: Maybe<Scalars['String']>;
+    flowOperator_in?: Maybe<Array<Scalars['String']>>;
+    flowOperator_not_in?: Maybe<Array<Scalars['String']>>;
+    flowOperator_contains?: Maybe<Scalars['String']>;
+    flowOperator_contains_nocase?: Maybe<Scalars['String']>;
+    flowOperator_not_contains?: Maybe<Scalars['String']>;
+    flowOperator_not_contains_nocase?: Maybe<Scalars['String']>;
+    flowOperator_starts_with?: Maybe<Scalars['String']>;
+    flowOperator_starts_with_nocase?: Maybe<Scalars['String']>;
+    flowOperator_not_starts_with?: Maybe<Scalars['String']>;
+    flowOperator_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    flowOperator_ends_with?: Maybe<Scalars['String']>;
+    flowOperator_ends_with_nocase?: Maybe<Scalars['String']>;
+    flowOperator_not_ends_with?: Maybe<Scalars['String']>;
+    flowOperator_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    /** Filter for the block changed event. */
+    _change_block?: Maybe<BlockChangedFilter>;
+};
+export declare enum FlowOperatorUpdatedEvent_OrderBy {
+    Id = "id",
+    TransactionHash = "transactionHash",
+    Timestamp = "timestamp",
+    Name = "name",
+    Addresses = "addresses",
+    BlockNumber = "blockNumber",
+    Token = "token",
+    Sender = "sender",
+    Permissions = "permissions",
+    FlowRateAllowance = "flowRateAllowance",
+    FlowOperator = "flowOperator"
+}
+export declare type FlowOperator_Filter = {
+    id?: Maybe<Scalars['ID']>;
+    id_not?: Maybe<Scalars['ID']>;
+    id_gt?: Maybe<Scalars['ID']>;
+    id_lt?: Maybe<Scalars['ID']>;
+    id_gte?: Maybe<Scalars['ID']>;
+    id_lte?: Maybe<Scalars['ID']>;
+    id_in?: Maybe<Array<Scalars['ID']>>;
+    id_not_in?: Maybe<Array<Scalars['ID']>>;
+    createdAtTimestamp?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_not?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
+    createdAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
+    createdAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    createdAtBlockNumber?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_not?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_gt?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_lt?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_gte?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
+    createdAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
+    createdAtBlockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    updatedAtTimestamp?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_not?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
+    updatedAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
+    updatedAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    updatedAtBlockNumber?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_not?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_gt?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_lt?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_gte?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
+    updatedAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
+    updatedAtBlockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    permissions?: Maybe<Scalars['Int']>;
+    permissions_not?: Maybe<Scalars['Int']>;
+    permissions_gt?: Maybe<Scalars['Int']>;
+    permissions_lt?: Maybe<Scalars['Int']>;
+    permissions_gte?: Maybe<Scalars['Int']>;
+    permissions_lte?: Maybe<Scalars['Int']>;
+    permissions_in?: Maybe<Array<Scalars['Int']>>;
+    permissions_not_in?: Maybe<Array<Scalars['Int']>>;
+    flowRateAllowanceGranted?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_not?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_gt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_lt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_gte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_lte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceGranted_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowRateAllowanceGranted_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowRateAllowanceRemaining?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_not?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_gt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_lt?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_gte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_lte?: Maybe<Scalars['BigInt']>;
+    flowRateAllowanceRemaining_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowRateAllowanceRemaining_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    flowOperator?: Maybe<Scalars['Bytes']>;
+    flowOperator_not?: Maybe<Scalars['Bytes']>;
+    flowOperator_in?: Maybe<Array<Scalars['Bytes']>>;
+    flowOperator_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    flowOperator_contains?: Maybe<Scalars['Bytes']>;
+    flowOperator_not_contains?: Maybe<Scalars['Bytes']>;
+    sender?: Maybe<Scalars['String']>;
+    sender_not?: Maybe<Scalars['String']>;
+    sender_gt?: Maybe<Scalars['String']>;
+    sender_lt?: Maybe<Scalars['String']>;
+    sender_gte?: Maybe<Scalars['String']>;
+    sender_lte?: Maybe<Scalars['String']>;
+    sender_in?: Maybe<Array<Scalars['String']>>;
+    sender_not_in?: Maybe<Array<Scalars['String']>>;
+    sender_contains?: Maybe<Scalars['String']>;
+    sender_contains_nocase?: Maybe<Scalars['String']>;
+    sender_not_contains?: Maybe<Scalars['String']>;
+    sender_not_contains_nocase?: Maybe<Scalars['String']>;
+    sender_starts_with?: Maybe<Scalars['String']>;
+    sender_starts_with_nocase?: Maybe<Scalars['String']>;
+    sender_not_starts_with?: Maybe<Scalars['String']>;
+    sender_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    sender_ends_with?: Maybe<Scalars['String']>;
+    sender_ends_with_nocase?: Maybe<Scalars['String']>;
+    sender_not_ends_with?: Maybe<Scalars['String']>;
+    sender_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    token?: Maybe<Scalars['String']>;
+    token_not?: Maybe<Scalars['String']>;
+    token_gt?: Maybe<Scalars['String']>;
+    token_lt?: Maybe<Scalars['String']>;
+    token_gte?: Maybe<Scalars['String']>;
+    token_lte?: Maybe<Scalars['String']>;
+    token_in?: Maybe<Array<Scalars['String']>>;
+    token_not_in?: Maybe<Array<Scalars['String']>>;
+    token_contains?: Maybe<Scalars['String']>;
+    token_contains_nocase?: Maybe<Scalars['String']>;
+    token_not_contains?: Maybe<Scalars['String']>;
+    token_not_contains_nocase?: Maybe<Scalars['String']>;
+    token_starts_with?: Maybe<Scalars['String']>;
+    token_starts_with_nocase?: Maybe<Scalars['String']>;
+    token_not_starts_with?: Maybe<Scalars['String']>;
+    token_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    token_ends_with?: Maybe<Scalars['String']>;
+    token_ends_with_nocase?: Maybe<Scalars['String']>;
+    token_not_ends_with?: Maybe<Scalars['String']>;
+    token_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_gt?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_lt?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_gte?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_lte?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_in?: Maybe<Array<Scalars['String']>>;
+    accountTokenSnapshot_not_in?: Maybe<Array<Scalars['String']>>;
+    accountTokenSnapshot_contains?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_contains_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_contains?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_contains_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_starts_with?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_starts_with_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_starts_with?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_ends_with?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_ends_with_nocase?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_ends_with?: Maybe<Scalars['String']>;
+    accountTokenSnapshot_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    /** Filter for the block changed event. */
+    _change_block?: Maybe<BlockChangedFilter>;
+};
+export declare enum FlowOperator_OrderBy {
+    Id = "id",
+    CreatedAtTimestamp = "createdAtTimestamp",
+    CreatedAtBlockNumber = "createdAtBlockNumber",
+    UpdatedAtTimestamp = "updatedAtTimestamp",
+    UpdatedAtBlockNumber = "updatedAtBlockNumber",
+    Permissions = "permissions",
+    FlowRateAllowanceGranted = "flowRateAllowanceGranted",
+    FlowRateAllowanceRemaining = "flowRateAllowanceRemaining",
+    FlowOperator = "flowOperator",
+    Sender = "sender",
+    Token = "token",
+    AccountTokenSnapshot = "accountTokenSnapshot",
+    FlowOperatorUpdatedEvents = "flowOperatorUpdatedEvents"
+}
 /**
  * FlowUpdated: An `Event` entity that is emitted
  * when a flow is created, updated, or deleted.
@@ -1538,10 +1894,17 @@ export declare type FlowUpdatedEvent = Event & {
     token: Scalars['Bytes'];
     sender: Scalars['Bytes'];
     receiver: Scalars['Bytes'];
+    /**
+     * The address that is triggering the flow update.
+     * This will be the zero address until the flowOperator
+     * feature is live.
+     */
+    flowOperator: Scalars['Bytes'];
     /** The flow rate per second. */
     flowRate: Scalars['BigInt'];
     totalSenderFlowRate: Scalars['BigInt'];
     totalReceiverFlowRate: Scalars['BigInt'];
+    deposit: Scalars['BigInt'];
     userData: Scalars['Bytes'];
     /** The previous flow rate. */
     oldFlowRate: Scalars['BigInt'];
@@ -1635,6 +1998,12 @@ export declare type FlowUpdatedEvent_Filter = {
     receiver_not_in?: Maybe<Array<Scalars['Bytes']>>;
     receiver_contains?: Maybe<Scalars['Bytes']>;
     receiver_not_contains?: Maybe<Scalars['Bytes']>;
+    flowOperator?: Maybe<Scalars['Bytes']>;
+    flowOperator_not?: Maybe<Scalars['Bytes']>;
+    flowOperator_in?: Maybe<Array<Scalars['Bytes']>>;
+    flowOperator_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    flowOperator_contains?: Maybe<Scalars['Bytes']>;
+    flowOperator_not_contains?: Maybe<Scalars['Bytes']>;
     flowRate?: Maybe<Scalars['BigInt']>;
     flowRate_not?: Maybe<Scalars['BigInt']>;
     flowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -1659,6 +2028,14 @@ export declare type FlowUpdatedEvent_Filter = {
     totalReceiverFlowRate_lte?: Maybe<Scalars['BigInt']>;
     totalReceiverFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
     totalReceiverFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit?: Maybe<Scalars['BigInt']>;
+    deposit_not?: Maybe<Scalars['BigInt']>;
+    deposit_gt?: Maybe<Scalars['BigInt']>;
+    deposit_lt?: Maybe<Scalars['BigInt']>;
+    deposit_gte?: Maybe<Scalars['BigInt']>;
+    deposit_lte?: Maybe<Scalars['BigInt']>;
+    deposit_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
     userData?: Maybe<Scalars['Bytes']>;
     userData_not?: Maybe<Scalars['Bytes']>;
     userData_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1722,9 +2099,11 @@ export declare enum FlowUpdatedEvent_OrderBy {
     Token = "token",
     Sender = "sender",
     Receiver = "receiver",
+    FlowOperator = "flowOperator",
     FlowRate = "flowRate",
     TotalSenderFlowRate = "totalSenderFlowRate",
     TotalReceiverFlowRate = "totalReceiverFlowRate",
+    Deposit = "deposit",
     UserData = "userData",
     OldFlowRate = "oldFlowRate",
     Type = "type",
@@ -1825,7 +2204,7 @@ export declare enum GovernanceReplacedEvent_OrderBy {
     OldGovernance = "oldGovernance",
     NewGovernance = "newGovernance"
 }
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type Index = {
     __typename?: 'Index';
     /** ID composed of: publisherAddress-tokenAddress-indexId */
@@ -1870,7 +2249,7 @@ export declare type Index = {
     indexUnitsUpdatedEvents: Array<IndexUnitsUpdatedEvent>;
     indexUnsubscribedEvents: Array<IndexUnsubscribedEvent>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexSubscriptionsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -1878,7 +2257,7 @@ export declare type IndexSubscriptionsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<IndexSubscription_Filter>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexIndexDistributionClaimedEventsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -1886,7 +2265,7 @@ export declare type IndexIndexDistributionClaimedEventsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<IndexDistributionClaimedEvent_Filter>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexIndexUpdatedEventsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -1894,7 +2273,7 @@ export declare type IndexIndexUpdatedEventsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<IndexUpdatedEvent_Filter>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexIndexSubscribedEventsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -1902,7 +2281,7 @@ export declare type IndexIndexSubscribedEventsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<IndexSubscribedEvent_Filter>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexIndexUnitsUpdatedEventsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -1910,7 +2289,7 @@ export declare type IndexIndexUnitsUpdatedEventsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<IndexUnitsUpdatedEvent_Filter>;
 };
-/** Index: A Index HOL entity. */
+/** Index: An Index higher order entity. */
 export declare type IndexIndexUnsubscribedEventsArgs = {
     skip?: Maybe<Scalars['Int']>;
     first?: Maybe<Scalars['Int']>;
@@ -2339,7 +2718,7 @@ export declare enum IndexSubscribedEvent_OrderBy {
     Index = "index"
 }
 /**
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
  * `Index`.
  */
 export declare type IndexSubscription = {
@@ -2380,7 +2759,7 @@ export declare type IndexSubscription = {
     subscriptionUnitsUpdatedEvents: Array<SubscriptionUnitsUpdatedEvent>;
 };
 /**
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
  * `Index`.
  */
 export declare type IndexSubscriptionSubscriptionApprovedEventsArgs = {
@@ -2391,7 +2770,7 @@ export declare type IndexSubscriptionSubscriptionApprovedEventsArgs = {
     where?: Maybe<SubscriptionApprovedEvent_Filter>;
 };
 /**
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
  * `Index`.
  */
 export declare type IndexSubscriptionSubscriptionDistributionClaimedEventsArgs = {
@@ -2402,7 +2781,7 @@ export declare type IndexSubscriptionSubscriptionDistributionClaimedEventsArgs =
     where?: Maybe<SubscriptionDistributionClaimedEvent_Filter>;
 };
 /**
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
  * `Index`.
  */
 export declare type IndexSubscriptionSubscriptionRevokedEventsArgs = {
@@ -2413,7 +2792,7 @@ export declare type IndexSubscriptionSubscriptionRevokedEventsArgs = {
     where?: Maybe<SubscriptionRevokedEvent_Filter>;
 };
 /**
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
  * `Index`.
  */
 export declare type IndexSubscriptionSubscriptionUnitsUpdatedEventsArgs = {
@@ -3558,6 +3937,8 @@ export declare type Query = {
     __typename?: 'Query';
     flowUpdatedEvent?: Maybe<FlowUpdatedEvent>;
     flowUpdatedEvents: Array<FlowUpdatedEvent>;
+    flowOperatorUpdatedEvent?: Maybe<FlowOperatorUpdatedEvent>;
+    flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
     indexCreatedEvent?: Maybe<IndexCreatedEvent>;
     indexCreatedEvents: Array<IndexCreatedEvent>;
     indexDistributionClaimedEvent?: Maybe<IndexDistributionClaimedEvent>;
@@ -3638,6 +4019,8 @@ export declare type Query = {
     indexSubscriptions: Array<IndexSubscription>;
     stream?: Maybe<Stream>;
     streams: Array<Stream>;
+    flowOperator?: Maybe<FlowOperator>;
+    flowOperators: Array<FlowOperator>;
     streamPeriod?: Maybe<StreamPeriod>;
     streamPeriods: Array<StreamPeriod>;
     streamRevision?: Maybe<StreamRevision>;
@@ -3669,6 +4052,20 @@ export declare type QueryFlowUpdatedEventsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type QueryFlowOperatorUpdatedEventArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type QueryFlowOperatorUpdatedEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type QueryIndexCreatedEventArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -4229,6 +4626,20 @@ export declare type QueryStreamsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type QueryFlowOperatorArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type QueryFlowOperatorsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperator_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperator_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type QueryStreamPeriodArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -4959,7 +5370,7 @@ export declare enum SentEvent_OrderBy {
     OperatorData = "operatorData"
 }
 /**
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
  * A account can start a stream, update the flow rate, but when they close it, it is
  * considered "dead". The next stream you create with the same `sender` and `receiver`
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -4974,6 +5385,7 @@ export declare type Stream = {
     updatedAtTimestamp: Scalars['BigInt'];
     updatedAtBlockNumber: Scalars['BigInt'];
     currentFlowRate: Scalars['BigInt'];
+    deposit: Scalars['BigInt'];
     /**
      * The amount streamed until `updatedAtTimestamp`/`updatedAtBlock`. The formula to get the current streamed
      * amount is:
@@ -4987,7 +5399,7 @@ export declare type Stream = {
     streamPeriods: Array<StreamPeriod>;
 };
 /**
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
  * A account can start a stream, update the flow rate, but when they close it, it is
  * considered "dead". The next stream you create with the same `sender` and `receiver`
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -5001,7 +5413,7 @@ export declare type StreamFlowUpdatedEventsArgs = {
     where?: Maybe<FlowUpdatedEvent_Filter>;
 };
 /**
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
  * A account can start a stream, update the flow rate, but when they close it, it is
  * considered "dead". The next stream you create with the same `sender` and `receiver`
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -5014,7 +5426,7 @@ export declare type StreamStreamPeriodsArgs = {
     orderDirection?: Maybe<OrderDirection>;
     where?: Maybe<StreamPeriod_Filter>;
 };
-/** StreamPeriod: A HOL entity that represents a period of time in a Stream with a constant flowRate. */
+/** StreamPeriod: A higher order entity that represents a period of time in a Stream with a constant flowRate. */
 export declare type StreamPeriod = {
     __typename?: 'StreamPeriod';
     /** ID composed of: streamId - periodRevisionIndex */
@@ -5024,6 +5436,7 @@ export declare type StreamPeriod = {
     receiver: Account;
     token: Token;
     flowRate: Scalars['BigInt'];
+    deposit: Scalars['BigInt'];
     startedAtTimestamp: Scalars['BigInt'];
     startedAtBlockNumber: Scalars['BigInt'];
     startedAtEvent: FlowUpdatedEvent;
@@ -5130,6 +5543,14 @@ export declare type StreamPeriod_Filter = {
     flowRate_lte?: Maybe<Scalars['BigInt']>;
     flowRate_in?: Maybe<Array<Scalars['BigInt']>>;
     flowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit?: Maybe<Scalars['BigInt']>;
+    deposit_not?: Maybe<Scalars['BigInt']>;
+    deposit_gt?: Maybe<Scalars['BigInt']>;
+    deposit_lt?: Maybe<Scalars['BigInt']>;
+    deposit_gte?: Maybe<Scalars['BigInt']>;
+    deposit_lte?: Maybe<Scalars['BigInt']>;
+    deposit_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
     startedAtTimestamp?: Maybe<Scalars['BigInt']>;
     startedAtTimestamp_not?: Maybe<Scalars['BigInt']>;
     startedAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
@@ -5220,6 +5641,7 @@ export declare enum StreamPeriod_OrderBy {
     Receiver = "receiver",
     Token = "token",
     FlowRate = "flowRate",
+    Deposit = "deposit",
     StartedAtTimestamp = "startedAtTimestamp",
     StartedAtBlockNumber = "startedAtBlockNumber",
     StartedAtEvent = "startedAtEvent",
@@ -5316,6 +5738,14 @@ export declare type Stream_Filter = {
     currentFlowRate_lte?: Maybe<Scalars['BigInt']>;
     currentFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
     currentFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit?: Maybe<Scalars['BigInt']>;
+    deposit_not?: Maybe<Scalars['BigInt']>;
+    deposit_gt?: Maybe<Scalars['BigInt']>;
+    deposit_lt?: Maybe<Scalars['BigInt']>;
+    deposit_gte?: Maybe<Scalars['BigInt']>;
+    deposit_lte?: Maybe<Scalars['BigInt']>;
+    deposit_in?: Maybe<Array<Scalars['BigInt']>>;
+    deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
     streamedUntilUpdatedAt?: Maybe<Scalars['BigInt']>;
     streamedUntilUpdatedAt_not?: Maybe<Scalars['BigInt']>;
     streamedUntilUpdatedAt_gt?: Maybe<Scalars['BigInt']>;
@@ -5394,6 +5824,7 @@ export declare enum Stream_OrderBy {
     UpdatedAtTimestamp = "updatedAtTimestamp",
     UpdatedAtBlockNumber = "updatedAtBlockNumber",
     CurrentFlowRate = "currentFlowRate",
+    Deposit = "deposit",
     StreamedUntilUpdatedAt = "streamedUntilUpdatedAt",
     Token = "token",
     Sender = "sender",
@@ -5405,6 +5836,8 @@ export declare type Subscription = {
     __typename?: 'Subscription';
     flowUpdatedEvent?: Maybe<FlowUpdatedEvent>;
     flowUpdatedEvents: Array<FlowUpdatedEvent>;
+    flowOperatorUpdatedEvent?: Maybe<FlowOperatorUpdatedEvent>;
+    flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
     indexCreatedEvent?: Maybe<IndexCreatedEvent>;
     indexCreatedEvents: Array<IndexCreatedEvent>;
     indexDistributionClaimedEvent?: Maybe<IndexDistributionClaimedEvent>;
@@ -5485,6 +5918,8 @@ export declare type Subscription = {
     indexSubscriptions: Array<IndexSubscription>;
     stream?: Maybe<Stream>;
     streams: Array<Stream>;
+    flowOperator?: Maybe<FlowOperator>;
+    flowOperators: Array<FlowOperator>;
     streamPeriod?: Maybe<StreamPeriod>;
     streamPeriods: Array<StreamPeriod>;
     streamRevision?: Maybe<StreamRevision>;
@@ -5516,6 +5951,20 @@ export declare type SubscriptionFlowUpdatedEventsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type SubscriptionFlowOperatorUpdatedEventArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type SubscriptionFlowOperatorUpdatedEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type SubscriptionIndexCreatedEventArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -6076,6 +6525,20 @@ export declare type SubscriptionStreamsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type SubscriptionFlowOperatorArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type SubscriptionFlowOperatorsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<FlowOperator_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<FlowOperator_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type SubscriptionStreamPeriodArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -7120,7 +7583,7 @@ export declare enum SuperTokenLogicUpdatedEvent_OrderBy {
     Code = "code"
 }
 /**
- * Token: A HOL entity created for super tokens that are "valid" (tokens that have
+ * Token: A higher order entity created for super tokens that are "valid" (tokens that have
  * Superfluid's host contract address set as the host).
  */
 export declare type Token = {
@@ -7264,7 +7727,7 @@ export declare enum TokenDowngradedEvent_OrderBy {
 /** TokenStatistic: An aggregate entity which aggregates data of a single `token`. */
 export declare type TokenStatistic = {
     __typename?: 'TokenStatistic';
-    /** ID: tokenID */
+    /** id: token address */
     id: Scalars['ID'];
     updatedAtTimestamp: Scalars['BigInt'];
     updatedAtBlockNumber: Scalars['BigInt'];
@@ -7286,6 +7749,8 @@ export declare type TokenStatistic = {
     totalSubscriptionsWithUnits: Scalars['Int'];
     /** Counts all approved subscriptions whether or not they have units. */
     totalApprovedSubscriptions: Scalars['Int'];
+    /** The total deposit held by the CFA agreement for this particular `token`. */
+    totalDeposit: Scalars['BigInt'];
     /** The total outflow rate of the `token` (how much value is being moved). */
     totalOutflowRate: Scalars['BigInt'];
     /** The all-time total amount streamed until the `updatedAtTimestamp`/`updatedAtBlock`. */
@@ -7374,6 +7839,14 @@ export declare type TokenStatistic_Filter = {
     totalApprovedSubscriptions_lte?: Maybe<Scalars['Int']>;
     totalApprovedSubscriptions_in?: Maybe<Array<Scalars['Int']>>;
     totalApprovedSubscriptions_not_in?: Maybe<Array<Scalars['Int']>>;
+    totalDeposit?: Maybe<Scalars['BigInt']>;
+    totalDeposit_not?: Maybe<Scalars['BigInt']>;
+    totalDeposit_gt?: Maybe<Scalars['BigInt']>;
+    totalDeposit_lt?: Maybe<Scalars['BigInt']>;
+    totalDeposit_gte?: Maybe<Scalars['BigInt']>;
+    totalDeposit_lte?: Maybe<Scalars['BigInt']>;
+    totalDeposit_in?: Maybe<Array<Scalars['BigInt']>>;
+    totalDeposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
     totalOutflowRate?: Maybe<Scalars['BigInt']>;
     totalOutflowRate_not?: Maybe<Scalars['BigInt']>;
     totalOutflowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -7447,6 +7920,7 @@ export declare enum TokenStatistic_OrderBy {
     TotalNumberOfActiveIndexes = "totalNumberOfActiveIndexes",
     TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
     TotalApprovedSubscriptions = "totalApprovedSubscriptions",
+    TotalDeposit = "totalDeposit",
     TotalOutflowRate = "totalOutflowRate",
     TotalAmountStreamedUntilUpdatedAt = "totalAmountStreamedUntilUpdatedAt",
     TotalAmountTransferredUntilUpdatedAt = "totalAmountTransferredUntilUpdatedAt",