@ludo.ninja/api 2.8.28 → 2.8.30

package/src/graphql_tools/__generated__/preferencesHost/schema.ts

@@ -0,0 +1,772 @@
+/* eslint-disable */
+import { GraphQLResolveInfo } from 'graphql';
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T | null;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+};
+
+
+export type IExpectation = {
+  name: Scalars['String'];
+  imageUrl: Scalars['String'];
+};
+
+export type IInterest = {
+  name: Scalars['String'];
+  imageUrl: Scalars['String'];
+};
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  saveUserInterests: Scalars['Boolean'];
+  saveUserExpectations: Scalars['Boolean'];
+};
+
+
+export type IMutationSaveUserInterestsArgs = {
+  interests: Array<Maybe<Scalars['String']>>;
+};
+
+
+export type IMutationSaveUserExpectationsArgs = {
+  expectations: Array<Maybe<Scalars['String']>>;
+};
+
+/**
+ * scalar Long
+ * scalar Upload
+ */
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchInterests: Array<Maybe<IInterest>>;
+  fetchExpectations: Array<Maybe<IExpectation>>;
+  fetchUserInterests: Array<Maybe<IUserInterest>>;
+  fetchUserExpectations: Array<Maybe<IUserExpectation>>;
+  fetchSortSelections: Array<Maybe<ISelection>>;
+  fetchVarietyOfAddressSelections: Array<Maybe<ISelection>>;
+  fetchCategorySelections: Array<Maybe<ISelection>>;
+  fetchBlockchainSelections: Array<Maybe<ISelection>>;
+  fetchSearchSortSelections: Array<Maybe<ISelection>>;
+  fetchSearchResultTypeSelections: Array<Maybe<ISelection>>;
+  fetchSearchResultBlockchainSelections: Array<Maybe<ISelection>>;
+  fetchSearchResultCategorySelections: Array<Maybe<ISelection>>;
+  fetchSearchResultTimeSelections: Array<Maybe<ISelection>>;
+  fetchSearchResultStatusSelections: Array<Maybe<ISelection>>;
+  fetchSetsSearchResultTypeSelections: Array<Maybe<ISelection>>;
+  fetchSearchResultSelections: ISearchResultSelectionsPage;
+};
+
+export type ISearchResultSelectionsPage = {
+  typeSelections: Array<Maybe<ISelection>>;
+  blockchainSelections: Array<Maybe<ISelection>>;
+  categorySelections: Array<Maybe<ISelection>>;
+  timeSelections: Array<Maybe<ISelection>>;
+  statusSelections: Array<Maybe<ISelection>>;
+};
+
+export type ISelection = {
+  name: Scalars['String'];
+  ordering: Scalars['Int'];
+  label: Scalars['String'];
+};
+
+export type IUserExpectation = {
+  userId: Scalars['String'];
+  name: Scalars['String'];
+  imageUrl: Scalars['String'];
+};
+
+export type IUserInterest = {
+  userId: Scalars['String'];
+  name: Scalars['String'];
+  imageUrl: Scalars['String'];
+  percents: Scalars['Int'];
+};
+
+
+
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+
+
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Promise<TResult> | TResult;
+
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+}
+
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+
+export type NextResolverFn<T> = () => Promise<T>;
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  next: NextResolverFn<TResult>,
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+/** Mapping between all available schema types and the resolvers types */
+export type IResolversTypes = {
+  Expectation: ResolverTypeWrapper<IExpectation>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Interest: ResolverTypeWrapper<IInterest>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Query: ResolverTypeWrapper<{}>;
+  SearchResultSelectionsPage: ResolverTypeWrapper<ISearchResultSelectionsPage>;
+  Selection: ResolverTypeWrapper<ISelection>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  UserExpectation: ResolverTypeWrapper<IUserExpectation>;
+  UserInterest: ResolverTypeWrapper<IUserInterest>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  Expectation: IExpectation;
+  String: Scalars['String'];
+  Interest: IInterest;
+  Mutation: {};
+  Boolean: Scalars['Boolean'];
+  Query: {};
+  SearchResultSelectionsPage: ISearchResultSelectionsPage;
+  Selection: ISelection;
+  Int: Scalars['Int'];
+  UserExpectation: IUserExpectation;
+  UserInterest: IUserInterest;
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IExpectationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Expectation'] = IResolversParentTypes['Expectation']> = {
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  imageUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IInterestResolvers<ContextType = any, ParentType extends IResolversParentTypes['Interest'] = IResolversParentTypes['Interest']> = {
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  imageUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  saveUserInterests?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSaveUserInterestsArgs, 'interests'>>;
+  saveUserExpectations?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSaveUserExpectationsArgs, 'expectations'>>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchInterests?: Resolver<Array<Maybe<IResolversTypes['Interest']>>, ParentType, ContextType>;
+  fetchExpectations?: Resolver<Array<Maybe<IResolversTypes['Expectation']>>, ParentType, ContextType>;
+  fetchUserInterests?: Resolver<Array<Maybe<IResolversTypes['UserInterest']>>, ParentType, ContextType>;
+  fetchUserExpectations?: Resolver<Array<Maybe<IResolversTypes['UserExpectation']>>, ParentType, ContextType>;
+  fetchSortSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchVarietyOfAddressSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchCategorySelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchBlockchainSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchSortSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultTypeSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultBlockchainSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultCategorySelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultTimeSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultStatusSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSetsSearchResultTypeSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  fetchSearchResultSelections?: Resolver<IResolversTypes['SearchResultSelectionsPage'], ParentType, ContextType>;
+};
+
+export type ISearchResultSelectionsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['SearchResultSelectionsPage'] = IResolversParentTypes['SearchResultSelectionsPage']> = {
+  typeSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  blockchainSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  categorySelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  timeSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  statusSelections?: Resolver<Array<Maybe<IResolversTypes['Selection']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ISelectionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Selection'] = IResolversParentTypes['Selection']> = {
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  ordering?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  label?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IUserExpectationResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserExpectation'] = IResolversParentTypes['UserExpectation']> = {
+  userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  imageUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IUserInterestResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserInterest'] = IResolversParentTypes['UserInterest']> = {
+  userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  imageUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  percents?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Expectation?: IExpectationResolvers<ContextType>;
+  Interest?: IInterestResolvers<ContextType>;
+  Mutation?: IMutationResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  SearchResultSelectionsPage?: ISearchResultSelectionsPageResolvers<ContextType>;
+  Selection?: ISelectionResolvers<ContextType>;
+  UserExpectation?: IUserExpectationResolvers<ContextType>;
+  UserInterest?: IUserInterestResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type ISaveUserExpectationsMutationVariables = Exact<{
+  expectations: Array<Maybe<Scalars['String']>>;
+}>;
+
+
+export type ISaveUserExpectationsMutation = Pick<IMutation, 'saveUserExpectations'>;
+
+export type ISaveUserInterestsMutationVariables = Exact<{
+  interests: Array<Maybe<Scalars['String']>>;
+}>;
+
+
+export type ISaveUserInterestsMutation = Pick<IMutation, 'saveUserInterests'>;
+
+export type IFetchExpectationsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchExpectationsQuery = { fetchExpectations: Array<Maybe<Pick<IExpectation, 'name' | 'imageUrl'>>> };
+
+export type IFetchInterestsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchInterestsQuery = { fetchInterests: Array<Maybe<Pick<IInterest, 'name' | 'imageUrl'>>> };
+
+export type IFetchSearchResultSelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSearchResultSelectionsQuery = { fetchSearchResultSelections: { typeSelections: Array<Maybe<(
+      Pick<ISelection, 'label'>
+      & { id: ISelection['name'] }
+    )>>, blockchainSelections: Array<Maybe<(
+      Pick<ISelection, 'label'>
+      & { id: ISelection['name'] }
+    )>>, categorySelections: Array<Maybe<(
+      Pick<ISelection, 'label'>
+      & { id: ISelection['name'] }
+    )>>, timeSelections: Array<Maybe<(
+      Pick<ISelection, 'label'>
+      & { id: ISelection['name'] }
+    )>>, statusSelections: Array<Maybe<(
+      Pick<ISelection, 'label'>
+      & { id: ISelection['name'] }
+    )>> } };
+
+export type IFetchSearchResultTimeSelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSearchResultTimeSelectionsQuery = { fetchSearchResultTimeSelections: Array<Maybe<Pick<ISelection, 'name' | 'label'>>> };
+
+export type IFetchUserExpectationsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchUserExpectationsQuery = { fetchUserExpectations: Array<Maybe<Pick<IUserExpectation, 'userId' | 'name' | 'imageUrl'>>> };
+
+export type IFetchUserInterestsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchUserInterestsQuery = { fetchUserInterests: Array<Maybe<Pick<IUserInterest, 'userId' | 'name' | 'imageUrl' | 'percents'>>> };
+
+export type IFetchSearchResultBlockchainSelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSearchResultBlockchainSelectionsQuery = { fetchSearchResultBlockchainSelections: Array<Maybe<Pick<ISelection, 'name' | 'label'>>> };
+
+export type IFetchSearchResultCategorySelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSearchResultCategorySelectionsQuery = { fetchSearchResultCategorySelections: Array<Maybe<Pick<ISelection, 'name' | 'label'>>> };
+
+export type IFetchSearchResultStatusSelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSearchResultStatusSelectionsQuery = { fetchSearchResultStatusSelections: Array<Maybe<Pick<ISelection, 'name' | 'label'>>> };
+
+export type IFetchSetsSearchResultTypeSelectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchSetsSearchResultTypeSelectionsQuery = { fetchSetsSearchResultTypeSelections: Array<Maybe<Pick<ISelection, 'name' | 'label'>>> };
+
+
+export const SaveUserExpectationsDocument = gql`
+    mutation SaveUserExpectations($expectations: [String]!) {
+  saveUserExpectations(expectations: $expectations)
+}
+    `;
+export type ISaveUserExpectationsMutationFn = Apollo.MutationFunction<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>;
+
+/**
+ * __useSaveUserExpectationsMutation__
+ *
+ * To run a mutation, you first call `useSaveUserExpectationsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveUserExpectationsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [saveUserExpectationsMutation, { data, loading, error }] = useSaveUserExpectationsMutation({
+ *   variables: {
+ *      expectations: // value for 'expectations'
+ *   },
+ * });
+ */
+export function useSaveUserExpectationsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>) {
+        return Apollo.useMutation<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>(SaveUserExpectationsDocument, baseOptions);
+      }
+export type SaveUserExpectationsMutationHookResult = ReturnType<typeof useSaveUserExpectationsMutation>;
+export type SaveUserExpectationsMutationResult = Apollo.MutationResult<ISaveUserExpectationsMutation>;
+export type SaveUserExpectationsMutationOptions = Apollo.BaseMutationOptions<ISaveUserExpectationsMutation, ISaveUserExpectationsMutationVariables>;
+export const SaveUserInterestsDocument = gql`
+    mutation SaveUserInterests($interests: [String]!) {
+  saveUserInterests(interests: $interests)
+}
+    `;
+export type ISaveUserInterestsMutationFn = Apollo.MutationFunction<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>;
+
+/**
+ * __useSaveUserInterestsMutation__
+ *
+ * To run a mutation, you first call `useSaveUserInterestsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveUserInterestsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [saveUserInterestsMutation, { data, loading, error }] = useSaveUserInterestsMutation({
+ *   variables: {
+ *      interests: // value for 'interests'
+ *   },
+ * });
+ */
+export function useSaveUserInterestsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>) {
+        return Apollo.useMutation<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>(SaveUserInterestsDocument, baseOptions);
+      }
+export type SaveUserInterestsMutationHookResult = ReturnType<typeof useSaveUserInterestsMutation>;
+export type SaveUserInterestsMutationResult = Apollo.MutationResult<ISaveUserInterestsMutation>;
+export type SaveUserInterestsMutationOptions = Apollo.BaseMutationOptions<ISaveUserInterestsMutation, ISaveUserInterestsMutationVariables>;
+export const FetchExpectationsDocument = gql`
+    query FetchExpectations {
+  fetchExpectations {
+    name
+    imageUrl
+  }
+}
+    `;
+
+/**
+ * __useFetchExpectationsQuery__
+ *
+ * To run a query within a React component, call `useFetchExpectationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchExpectationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchExpectationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchExpectationsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>) {
+        return Apollo.useQuery<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>(FetchExpectationsDocument, baseOptions);
+      }
+export function useFetchExpectationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>(FetchExpectationsDocument, baseOptions);
+        }
+export type FetchExpectationsQueryHookResult = ReturnType<typeof useFetchExpectationsQuery>;
+export type FetchExpectationsLazyQueryHookResult = ReturnType<typeof useFetchExpectationsLazyQuery>;
+export type FetchExpectationsQueryResult = Apollo.QueryResult<IFetchExpectationsQuery, IFetchExpectationsQueryVariables>;
+export const FetchInterestsDocument = gql`
+    query FetchInterests {
+  fetchInterests {
+    name
+    imageUrl
+  }
+}
+    `;
+
+/**
+ * __useFetchInterestsQuery__
+ *
+ * To run a query within a React component, call `useFetchInterestsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchInterestsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchInterestsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchInterestsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchInterestsQuery, IFetchInterestsQueryVariables>) {
+        return Apollo.useQuery<IFetchInterestsQuery, IFetchInterestsQueryVariables>(FetchInterestsDocument, baseOptions);
+      }
+export function useFetchInterestsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchInterestsQuery, IFetchInterestsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchInterestsQuery, IFetchInterestsQueryVariables>(FetchInterestsDocument, baseOptions);
+        }
+export type FetchInterestsQueryHookResult = ReturnType<typeof useFetchInterestsQuery>;
+export type FetchInterestsLazyQueryHookResult = ReturnType<typeof useFetchInterestsLazyQuery>;
+export type FetchInterestsQueryResult = Apollo.QueryResult<IFetchInterestsQuery, IFetchInterestsQueryVariables>;
+export const FetchSearchResultSelectionsDocument = gql`
+    query FetchSearchResultSelections {
+  fetchSearchResultSelections {
+    typeSelections {
+      id: name
+      label
+    }
+    blockchainSelections {
+      id: name
+      label
+    }
+    categorySelections {
+      id: name
+      label
+    }
+    timeSelections {
+      id: name
+      label
+    }
+    statusSelections {
+      id: name
+      label
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchSearchResultSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSearchResultSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultSelectionsQuery, IFetchSearchResultSelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSearchResultSelectionsQuery, IFetchSearchResultSelectionsQueryVariables>(FetchSearchResultSelectionsDocument, baseOptions);
+      }
+export function useFetchSearchResultSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultSelectionsQuery, IFetchSearchResultSelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSearchResultSelectionsQuery, IFetchSearchResultSelectionsQueryVariables>(FetchSearchResultSelectionsDocument, baseOptions);
+        }
+export type FetchSearchResultSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultSelectionsQuery>;
+export type FetchSearchResultSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultSelectionsLazyQuery>;
+export type FetchSearchResultSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultSelectionsQuery, IFetchSearchResultSelectionsQueryVariables>;
+export const FetchSearchResultTimeSelectionsDocument = gql`
+    query FetchSearchResultTimeSelections {
+  fetchSearchResultTimeSelections {
+    name
+    label
+  }
+}
+    `;
+
+/**
+ * __useFetchSearchResultTimeSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultTimeSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultTimeSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultTimeSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSearchResultTimeSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>(FetchSearchResultTimeSelectionsDocument, baseOptions);
+      }
+export function useFetchSearchResultTimeSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>(FetchSearchResultTimeSelectionsDocument, baseOptions);
+        }
+export type FetchSearchResultTimeSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultTimeSelectionsQuery>;
+export type FetchSearchResultTimeSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultTimeSelectionsLazyQuery>;
+export type FetchSearchResultTimeSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultTimeSelectionsQuery, IFetchSearchResultTimeSelectionsQueryVariables>;
+export const FetchUserExpectationsDocument = gql`
+    query FetchUserExpectations {
+  fetchUserExpectations {
+    userId
+    name
+    imageUrl
+  }
+}
+    `;
+
+/**
+ * __useFetchUserExpectationsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserExpectationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserExpectationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserExpectationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchUserExpectationsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>) {
+        return Apollo.useQuery<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>(FetchUserExpectationsDocument, baseOptions);
+      }
+export function useFetchUserExpectationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>(FetchUserExpectationsDocument, baseOptions);
+        }
+export type FetchUserExpectationsQueryHookResult = ReturnType<typeof useFetchUserExpectationsQuery>;
+export type FetchUserExpectationsLazyQueryHookResult = ReturnType<typeof useFetchUserExpectationsLazyQuery>;
+export type FetchUserExpectationsQueryResult = Apollo.QueryResult<IFetchUserExpectationsQuery, IFetchUserExpectationsQueryVariables>;
+export const FetchUserInterestsDocument = gql`
+    query FetchUserInterests {
+  fetchUserInterests {
+    userId
+    name
+    imageUrl
+    percents
+  }
+}
+    `;
+
+/**
+ * __useFetchUserInterestsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserInterestsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserInterestsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchUserInterestsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchUserInterestsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>) {
+        return Apollo.useQuery<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>(FetchUserInterestsDocument, baseOptions);
+      }
+export function useFetchUserInterestsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>(FetchUserInterestsDocument, baseOptions);
+        }
+export type FetchUserInterestsQueryHookResult = ReturnType<typeof useFetchUserInterestsQuery>;
+export type FetchUserInterestsLazyQueryHookResult = ReturnType<typeof useFetchUserInterestsLazyQuery>;
+export type FetchUserInterestsQueryResult = Apollo.QueryResult<IFetchUserInterestsQuery, IFetchUserInterestsQueryVariables>;
+export const FetchSearchResultBlockchainSelectionsDocument = gql`
+    query FetchSearchResultBlockchainSelections {
+  fetchSearchResultBlockchainSelections {
+    name
+    label
+  }
+}
+    `;
+
+/**
+ * __useFetchSearchResultBlockchainSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultBlockchainSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultBlockchainSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultBlockchainSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSearchResultBlockchainSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>(FetchSearchResultBlockchainSelectionsDocument, baseOptions);
+      }
+export function useFetchSearchResultBlockchainSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>(FetchSearchResultBlockchainSelectionsDocument, baseOptions);
+        }
+export type FetchSearchResultBlockchainSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultBlockchainSelectionsQuery>;
+export type FetchSearchResultBlockchainSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultBlockchainSelectionsLazyQuery>;
+export type FetchSearchResultBlockchainSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultBlockchainSelectionsQuery, IFetchSearchResultBlockchainSelectionsQueryVariables>;
+export const FetchSearchResultCategorySelectionsDocument = gql`
+    query FetchSearchResultCategorySelections {
+  fetchSearchResultCategorySelections {
+    name
+    label
+  }
+}
+    `;
+
+/**
+ * __useFetchSearchResultCategorySelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultCategorySelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultCategorySelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultCategorySelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSearchResultCategorySelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>(FetchSearchResultCategorySelectionsDocument, baseOptions);
+      }
+export function useFetchSearchResultCategorySelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>(FetchSearchResultCategorySelectionsDocument, baseOptions);
+        }
+export type FetchSearchResultCategorySelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultCategorySelectionsQuery>;
+export type FetchSearchResultCategorySelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultCategorySelectionsLazyQuery>;
+export type FetchSearchResultCategorySelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultCategorySelectionsQuery, IFetchSearchResultCategorySelectionsQueryVariables>;
+export const FetchSearchResultStatusSelectionsDocument = gql`
+    query FetchSearchResultStatusSelections {
+  fetchSearchResultStatusSelections {
+    name
+    label
+  }
+}
+    `;
+
+/**
+ * __useFetchSearchResultStatusSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSearchResultStatusSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSearchResultStatusSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSearchResultStatusSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSearchResultStatusSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>(FetchSearchResultStatusSelectionsDocument, baseOptions);
+      }
+export function useFetchSearchResultStatusSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>(FetchSearchResultStatusSelectionsDocument, baseOptions);
+        }
+export type FetchSearchResultStatusSelectionsQueryHookResult = ReturnType<typeof useFetchSearchResultStatusSelectionsQuery>;
+export type FetchSearchResultStatusSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSearchResultStatusSelectionsLazyQuery>;
+export type FetchSearchResultStatusSelectionsQueryResult = Apollo.QueryResult<IFetchSearchResultStatusSelectionsQuery, IFetchSearchResultStatusSelectionsQueryVariables>;
+export const FetchSetsSearchResultTypeSelectionsDocument = gql`
+    query FetchSetsSearchResultTypeSelections {
+  fetchSetsSearchResultTypeSelections {
+    name
+    label
+  }
+}
+    `;
+
+/**
+ * __useFetchSetsSearchResultTypeSelectionsQuery__
+ *
+ * To run a query within a React component, call `useFetchSetsSearchResultTypeSelectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchSetsSearchResultTypeSelectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchSetsSearchResultTypeSelectionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchSetsSearchResultTypeSelectionsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>) {
+        return Apollo.useQuery<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>(FetchSetsSearchResultTypeSelectionsDocument, baseOptions);
+      }
+export function useFetchSetsSearchResultTypeSelectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>(FetchSetsSearchResultTypeSelectionsDocument, baseOptions);
+        }
+export type FetchSetsSearchResultTypeSelectionsQueryHookResult = ReturnType<typeof useFetchSetsSearchResultTypeSelectionsQuery>;
+export type FetchSetsSearchResultTypeSelectionsLazyQueryHookResult = ReturnType<typeof useFetchSetsSearchResultTypeSelectionsLazyQuery>;
+export type FetchSetsSearchResultTypeSelectionsQueryResult = Apollo.QueryResult<IFetchSetsSearchResultTypeSelectionsQuery, IFetchSetsSearchResultTypeSelectionsQueryVariables>;