@requestnetwork/payment-detection 0.35.1-next.1741 → 0.35.1-next.1742

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

@@ -5115,6 +5115,8 @@ export declare type Query = {
     roleGrantedEvents: Array<RoleGrantedEvent>;
     roleRevokedEvent?: Maybe<RoleRevokedEvent>;
     roleRevokedEvents: Array<RoleRevokedEvent>;
+    setEvent?: Maybe<SetEvent>;
+    setEvents: Array<SetEvent>;
     cfav1LiquidationPeriodChangedEvent?: Maybe<CfAv1LiquidationPeriodChangedEvent>;
     cfav1LiquidationPeriodChangedEvents: Array<CfAv1LiquidationPeriodChangedEvent>;
     configChangedEvent?: Maybe<ConfigChangedEvent>;
@@ -5163,6 +5165,8 @@ export declare type Query = {
     streamRevisions: Array<StreamRevision>;
     token?: Maybe<Token>;
     tokens: Array<Token>;
+    resolverEntry?: Maybe<ResolverEntry>;
+    resolverEntries: Array<ResolverEntry>;
     accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
     accountTokenSnapshots: Array<AccountTokenSnapshot>;
     accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
@@ -5486,6 +5490,20 @@ export declare type QueryRoleRevokedEventsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type QuerySetEventArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type QuerySetEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<SetEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<SetEvent_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type QueryCfav1LiquidationPeriodChangedEventArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -5822,6 +5840,20 @@ export declare type QueryTokensArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type QueryResolverEntryArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type QueryResolverEntriesArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<ResolverEntry_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<ResolverEntry_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type QueryAccountTokenSnapshotArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -5909,6 +5941,96 @@ export declare type QueryEventsArgs = {
 export declare type Query_MetaArgs = {
     block?: Maybe<Block_Height>;
 };
+export declare type ResolverEntry = {
+    __typename?: 'ResolverEntry';
+    /** ID: the keccak256 hash of the set name */
+    id: Scalars['ID'];
+    createdAtTimestamp: Scalars['BigInt'];
+    createdAtBlockNumber: Scalars['BigInt'];
+    updatedAtTimestamp: Scalars['BigInt'];
+    updatedAtBlockNumber: Scalars['BigInt'];
+    targetAddress: Scalars['Bytes'];
+    isToken: Scalars['Boolean'];
+    isListed: Scalars['Boolean'];
+    setEvents: Array<SetEvent>;
+};
+export declare type ResolverEntrySetEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<SetEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<SetEvent_Filter>;
+};
+export declare type ResolverEntry_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']>>;
+    targetAddress?: Maybe<Scalars['Bytes']>;
+    targetAddress_not?: Maybe<Scalars['Bytes']>;
+    targetAddress_in?: Maybe<Array<Scalars['Bytes']>>;
+    targetAddress_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    targetAddress_contains?: Maybe<Scalars['Bytes']>;
+    targetAddress_not_contains?: Maybe<Scalars['Bytes']>;
+    isToken?: Maybe<Scalars['Boolean']>;
+    isToken_not?: Maybe<Scalars['Boolean']>;
+    isToken_in?: Maybe<Array<Scalars['Boolean']>>;
+    isToken_not_in?: Maybe<Array<Scalars['Boolean']>>;
+    isListed?: Maybe<Scalars['Boolean']>;
+    isListed_not?: Maybe<Scalars['Boolean']>;
+    isListed_in?: Maybe<Array<Scalars['Boolean']>>;
+    isListed_not_in?: Maybe<Array<Scalars['Boolean']>>;
+    setEvents_?: Maybe<SetEvent_Filter>;
+    /** Filter for the block changed event. */
+    _change_block?: Maybe<BlockChangedFilter>;
+};
+export declare enum ResolverEntry_OrderBy {
+    Id = "id",
+    CreatedAtTimestamp = "createdAtTimestamp",
+    CreatedAtBlockNumber = "createdAtBlockNumber",
+    UpdatedAtTimestamp = "updatedAtTimestamp",
+    UpdatedAtBlockNumber = "updatedAtBlockNumber",
+    TargetAddress = "targetAddress",
+    IsToken = "isToken",
+    IsListed = "isListed",
+    SetEvents = "setEvents"
+}
 export declare type RewardAddressChangedEvent = Event & {
     __typename?: 'RewardAddressChangedEvent';
     id: Scalars['ID'];
@@ -6704,6 +6826,158 @@ export declare enum SentEvent_OrderBy {
     Data = "data",
     OperatorData = "operatorData"
 }
+export declare type SetEvent = Event & {
+    __typename?: 'SetEvent';
+    id: Scalars['ID'];
+    transactionHash: Scalars['Bytes'];
+    gasPrice: Scalars['BigInt'];
+    timestamp: Scalars['BigInt'];
+    name: Scalars['String'];
+    /** Empty addresses array. */
+    addresses: Array<Scalars['Bytes']>;
+    blockNumber: Scalars['BigInt'];
+    logIndex: Scalars['BigInt'];
+    order: Scalars['BigInt'];
+    /**
+     * Because the name property is indexed, the
+     * returned value will be a keccak256 hash
+     * of the string.
+     */
+    hashedName: Scalars['Bytes'];
+    target: Scalars['Bytes'];
+    resolverEntry: ResolverEntry;
+};
+export declare type SetEvent_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']>;
+    gasPrice?: Maybe<Scalars['BigInt']>;
+    gasPrice_not?: Maybe<Scalars['BigInt']>;
+    gasPrice_gt?: Maybe<Scalars['BigInt']>;
+    gasPrice_lt?: Maybe<Scalars['BigInt']>;
+    gasPrice_gte?: Maybe<Scalars['BigInt']>;
+    gasPrice_lte?: Maybe<Scalars['BigInt']>;
+    gasPrice_in?: Maybe<Array<Scalars['BigInt']>>;
+    gasPrice_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    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']>>;
+    logIndex?: Maybe<Scalars['BigInt']>;
+    logIndex_not?: Maybe<Scalars['BigInt']>;
+    logIndex_gt?: Maybe<Scalars['BigInt']>;
+    logIndex_lt?: Maybe<Scalars['BigInt']>;
+    logIndex_gte?: Maybe<Scalars['BigInt']>;
+    logIndex_lte?: Maybe<Scalars['BigInt']>;
+    logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
+    logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    order?: Maybe<Scalars['BigInt']>;
+    order_not?: Maybe<Scalars['BigInt']>;
+    order_gt?: Maybe<Scalars['BigInt']>;
+    order_lt?: Maybe<Scalars['BigInt']>;
+    order_gte?: Maybe<Scalars['BigInt']>;
+    order_lte?: Maybe<Scalars['BigInt']>;
+    order_in?: Maybe<Array<Scalars['BigInt']>>;
+    order_not_in?: Maybe<Array<Scalars['BigInt']>>;
+    hashedName?: Maybe<Scalars['Bytes']>;
+    hashedName_not?: Maybe<Scalars['Bytes']>;
+    hashedName_in?: Maybe<Array<Scalars['Bytes']>>;
+    hashedName_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    hashedName_contains?: Maybe<Scalars['Bytes']>;
+    hashedName_not_contains?: Maybe<Scalars['Bytes']>;
+    target?: Maybe<Scalars['Bytes']>;
+    target_not?: Maybe<Scalars['Bytes']>;
+    target_in?: Maybe<Array<Scalars['Bytes']>>;
+    target_not_in?: Maybe<Array<Scalars['Bytes']>>;
+    target_contains?: Maybe<Scalars['Bytes']>;
+    target_not_contains?: Maybe<Scalars['Bytes']>;
+    resolverEntry?: Maybe<Scalars['String']>;
+    resolverEntry_not?: Maybe<Scalars['String']>;
+    resolverEntry_gt?: Maybe<Scalars['String']>;
+    resolverEntry_lt?: Maybe<Scalars['String']>;
+    resolverEntry_gte?: Maybe<Scalars['String']>;
+    resolverEntry_lte?: Maybe<Scalars['String']>;
+    resolverEntry_in?: Maybe<Array<Scalars['String']>>;
+    resolverEntry_not_in?: Maybe<Array<Scalars['String']>>;
+    resolverEntry_contains?: Maybe<Scalars['String']>;
+    resolverEntry_contains_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_not_contains?: Maybe<Scalars['String']>;
+    resolverEntry_not_contains_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_starts_with?: Maybe<Scalars['String']>;
+    resolverEntry_starts_with_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_not_starts_with?: Maybe<Scalars['String']>;
+    resolverEntry_not_starts_with_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_ends_with?: Maybe<Scalars['String']>;
+    resolverEntry_ends_with_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_not_ends_with?: Maybe<Scalars['String']>;
+    resolverEntry_not_ends_with_nocase?: Maybe<Scalars['String']>;
+    resolverEntry_?: Maybe<ResolverEntry_Filter>;
+    /** Filter for the block changed event. */
+    _change_block?: Maybe<BlockChangedFilter>;
+};
+export declare enum SetEvent_OrderBy {
+    Id = "id",
+    TransactionHash = "transactionHash",
+    GasPrice = "gasPrice",
+    Timestamp = "timestamp",
+    Name = "name",
+    Addresses = "addresses",
+    BlockNumber = "blockNumber",
+    LogIndex = "logIndex",
+    Order = "order",
+    HashedName = "hashedName",
+    Target = "target",
+    ResolverEntry = "resolverEntry"
+}
 /**
  * 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
@@ -7224,6 +7498,8 @@ export declare type Subscription = {
     roleGrantedEvents: Array<RoleGrantedEvent>;
     roleRevokedEvent?: Maybe<RoleRevokedEvent>;
     roleRevokedEvents: Array<RoleRevokedEvent>;
+    setEvent?: Maybe<SetEvent>;
+    setEvents: Array<SetEvent>;
     cfav1LiquidationPeriodChangedEvent?: Maybe<CfAv1LiquidationPeriodChangedEvent>;
     cfav1LiquidationPeriodChangedEvents: Array<CfAv1LiquidationPeriodChangedEvent>;
     configChangedEvent?: Maybe<ConfigChangedEvent>;
@@ -7272,6 +7548,8 @@ export declare type Subscription = {
     streamRevisions: Array<StreamRevision>;
     token?: Maybe<Token>;
     tokens: Array<Token>;
+    resolverEntry?: Maybe<ResolverEntry>;
+    resolverEntries: Array<ResolverEntry>;
     accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
     accountTokenSnapshots: Array<AccountTokenSnapshot>;
     accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
@@ -7595,6 +7873,20 @@ export declare type SubscriptionRoleRevokedEventsArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type SubscriptionSetEventArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type SubscriptionSetEventsArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<SetEvent_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<SetEvent_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type SubscriptionCfav1LiquidationPeriodChangedEventArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;
@@ -7931,6 +8223,20 @@ export declare type SubscriptionTokensArgs = {
     block?: Maybe<Block_Height>;
     subgraphError?: _SubgraphErrorPolicy_;
 };
+export declare type SubscriptionResolverEntryArgs = {
+    id: Scalars['ID'];
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+export declare type SubscriptionResolverEntriesArgs = {
+    skip?: Maybe<Scalars['Int']>;
+    first?: Maybe<Scalars['Int']>;
+    orderBy?: Maybe<ResolverEntry_OrderBy>;
+    orderDirection?: Maybe<OrderDirection>;
+    where?: Maybe<ResolverEntry_Filter>;
+    block?: Maybe<Block_Height>;
+    subgraphError?: _SubgraphErrorPolicy_;
+};
 export declare type SubscriptionAccountTokenSnapshotArgs = {
     id: Scalars['ID'];
     block?: Maybe<Block_Height>;