@ludo.ninja/api 2.8.28 → 2.8.30

package/build/graphql_tools/__generated__/opportunitiesHost/schema.d.ts

@@ -0,0 +1,486 @@
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+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;
+    /** A 64-bit signed integer */
+    Long: any;
+};
+export type IBrand = {
+    brandId: Scalars['ID'];
+    name: Scalars['String'];
+    matchingWords?: Maybe<Array<Maybe<Scalars['String']>>>;
+    description?: Maybe<Scalars['String']>;
+    industry?: Maybe<Scalars['String']>;
+    link?: Maybe<Scalars['String']>;
+    media?: Maybe<Scalars['String']>;
+};
+export type IBrandInput = {
+    name: Scalars['String'];
+    matchingWords: Array<Maybe<Scalars['String']>>;
+    description?: Maybe<Scalars['String']>;
+    industry?: Maybe<Scalars['String']>;
+    link?: Maybe<Scalars['String']>;
+};
+export type ICategory = {
+    categoryId: Scalars['ID'];
+    matchingWords?: Maybe<Array<Maybe<Scalars['String']>>>;
+    name: Scalars['String'];
+};
+export type ICategoryInput = {
+    name: Scalars['String'];
+    matchingWords: Array<Maybe<Scalars['String']>>;
+};
+export type IMutation = {
+    setDummy: Scalars['String'];
+    createBrand: Scalars['Boolean'];
+    updateBrand: Scalars['Boolean'];
+    createCategory: Scalars['Boolean'];
+    updateCategory: Scalars['Boolean'];
+    openOpportunity: Scalars['Boolean'];
+    hideOpportunity: Scalars['Boolean'];
+    createOpportunity: Scalars['Boolean'];
+    updateOpportunity: Scalars['Boolean'];
+};
+export type IMutationCreateBrandArgs = {
+    input: IBrandInput;
+};
+export type IMutationUpdateBrandArgs = {
+    brandId: Scalars['ID'];
+    input: IBrandInput;
+};
+export type IMutationCreateCategoryArgs = {
+    input: ICategoryInput;
+};
+export type IMutationUpdateCategoryArgs = {
+    categoryId: Scalars['ID'];
+    input: ICategoryInput;
+};
+export type IMutationOpenOpportunityArgs = {
+    opportunityId: Scalars['ID'];
+};
+export type IMutationHideOpportunityArgs = {
+    opportunityId: Scalars['ID'];
+};
+export type IMutationCreateOpportunityArgs = {
+    input: IOpportunityInput;
+};
+export type IMutationUpdateOpportunityArgs = {
+    opportunityId: Scalars['ID'];
+    input: IOpportunityInput;
+};
+export type IOpportunitiesPage = {
+    currentOpportunities?: Maybe<Array<Maybe<IOpportunity>>>;
+    similarOpportunities?: Maybe<Array<Maybe<IOpportunity>>>;
+};
+export type IOpportunity = {
+    opportunityId?: Maybe<Scalars['ID']>;
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    startedAt?: Maybe<Scalars['Long']>;
+    endedAt?: Maybe<Scalars['Long']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+    category?: Maybe<Scalars['String']>;
+    media?: Maybe<Scalars['String']>;
+    links?: Maybe<Array<Maybe<Scalars['String']>>>;
+    ludoRankRequired?: Maybe<Scalars['Boolean']>;
+    ludoRankRequiredMin?: Maybe<Scalars['Int']>;
+    ludoRankRequiredMax?: Maybe<Scalars['Int']>;
+    rewardType?: Maybe<Scalars['String']>;
+    creatorId?: Maybe<Scalars['String']>;
+    creatorWallet?: Maybe<Scalars['String']>;
+    status?: Maybe<Scalars['String']>;
+    shareLink?: Maybe<Scalars['String']>;
+    notifiable?: Maybe<Scalars['Boolean']>;
+    clicks?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    brandId?: Maybe<Scalars['String']>;
+    brandName?: Maybe<Scalars['String']>;
+    brandDescription?: Maybe<Scalars['String']>;
+    brandIndustry?: Maybe<Scalars['String']>;
+    brandLink?: Maybe<Scalars['String']>;
+    brandMedia?: Maybe<Scalars['String']>;
+};
+export type IOpportunityInput = {
+    brandId: Scalars['String'];
+    categoryId: Scalars['String'];
+    opportunityStatus: Scalars['String'];
+    opportunityType: Scalars['String'];
+    notificationType: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    ludoUrl?: Maybe<Scalars['String']>;
+    projectUrl?: Maybe<Scalars['String']>;
+    activeFrom?: Maybe<Scalars['Long']>;
+    activeUntil?: Maybe<Scalars['Long']>;
+    minXpLevel?: Maybe<Scalars['Int']>;
+    maxXpLevel?: Maybe<Scalars['Int']>;
+    minRank?: Maybe<Scalars['Float']>;
+    maxRank?: Maybe<Scalars['Float']>;
+    reportLink?: Maybe<Scalars['String']>;
+    blockchain?: Maybe<Scalars['String']>;
+    collection?: Maybe<Scalars['String']>;
+    minWalletValue?: Maybe<Scalars['Float']>;
+    maxWalletValue?: Maybe<Scalars['Float']>;
+};
+export type IOpportunityV2 = {
+    opportunityId: Scalars['ID'];
+    brandId: Scalars['String'];
+    categoryId: Scalars['String'];
+    opportunityStatus: Scalars['String'];
+    opportunityType: Scalars['String'];
+    notificationType: Scalars['String'];
+    name: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    brandName?: Maybe<Scalars['String']>;
+    brandDescription?: Maybe<Scalars['String']>;
+    brandMedia?: Maybe<Scalars['String']>;
+    brandUrl?: Maybe<Scalars['String']>;
+    brandIndustry?: Maybe<Scalars['String']>;
+    categoryName?: Maybe<Scalars['String']>;
+    ludoUrl?: Maybe<Scalars['String']>;
+    projectUrl?: Maybe<Scalars['String']>;
+    activeFrom?: Maybe<Scalars['Long']>;
+    activeUntil?: Maybe<Scalars['Long']>;
+    minXpLevel?: Maybe<Scalars['Int']>;
+    maxXpLevel?: Maybe<Scalars['Int']>;
+    minRank?: Maybe<Scalars['Float']>;
+    maxRank?: Maybe<Scalars['Float']>;
+    media?: Maybe<Scalars['String']>;
+    reportLink?: Maybe<Scalars['String']>;
+    clicks?: Maybe<Scalars['Int']>;
+    views?: Maybe<Scalars['Int']>;
+    blockchain?: Maybe<Scalars['String']>;
+    collection?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['Long']>;
+    minWalletValue?: Maybe<Scalars['Float']>;
+    maxWalletValue?: Maybe<Scalars['Float']>;
+};
+/** scalar Upload */
+export type IQuery = {
+    getDummy: Scalars['String'];
+    fetchBrands?: Maybe<Array<Maybe<IBrand>>>;
+    fetchBrand: IBrand;
+    fetchCategories?: Maybe<Array<Maybe<ICategory>>>;
+    fetchCategory: ICategory;
+    fetchOpportunities: IOpportunitiesPage;
+    fetchOpportunitiesV2?: Maybe<Array<Maybe<IOpportunityV2>>>;
+    fetchOpportunity: IOpportunityV2;
+};
+/** scalar Upload */
+export type IQueryFetchBrandArgs = {
+    brandId: Scalars['ID'];
+};
+/** scalar Upload */
+export type IQueryFetchCategoryArgs = {
+    categoryId: Scalars['ID'];
+};
+/** scalar Upload */
+export type IQueryFetchOpportunitiesArgs = {
+    domain?: Maybe<Scalars['String']>;
+};
+/** scalar Upload */
+export type IQueryFetchOpportunityArgs = {
+    opportunityId: Scalars['ID'];
+};
+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 = {
+    Brand: ResolverTypeWrapper<IBrand>;
+    ID: ResolverTypeWrapper<Scalars['ID']>;
+    String: ResolverTypeWrapper<Scalars['String']>;
+    BrandInput: IBrandInput;
+    Category: ResolverTypeWrapper<ICategory>;
+    CategoryInput: ICategoryInput;
+    Long: ResolverTypeWrapper<Scalars['Long']>;
+    Mutation: ResolverTypeWrapper<{}>;
+    Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+    OpportunitiesPage: ResolverTypeWrapper<IOpportunitiesPage>;
+    Opportunity: ResolverTypeWrapper<IOpportunity>;
+    Int: ResolverTypeWrapper<Scalars['Int']>;
+    OpportunityInput: IOpportunityInput;
+    Float: ResolverTypeWrapper<Scalars['Float']>;
+    OpportunityV2: ResolverTypeWrapper<IOpportunityV2>;
+    Query: ResolverTypeWrapper<{}>;
+};
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+    Brand: IBrand;
+    ID: Scalars['ID'];
+    String: Scalars['String'];
+    BrandInput: IBrandInput;
+    Category: ICategory;
+    CategoryInput: ICategoryInput;
+    Long: Scalars['Long'];
+    Mutation: {};
+    Boolean: Scalars['Boolean'];
+    OpportunitiesPage: IOpportunitiesPage;
+    Opportunity: IOpportunity;
+    Int: Scalars['Int'];
+    OpportunityInput: IOpportunityInput;
+    Float: Scalars['Float'];
+    OpportunityV2: IOpportunityV2;
+    Query: {};
+};
+export type IOneOfDirectiveArgs = {};
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+export type IBrandResolvers<ContextType = any, ParentType extends IResolversParentTypes['Brand'] = IResolversParentTypes['Brand']> = {
+    brandId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    matchingWords?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    industry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    link?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type ICategoryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Category'] = IResolversParentTypes['Category']> = {
+    categoryId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+    matchingWords?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
+    name: 'Long';
+}
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+    setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    createBrand?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateBrandArgs, 'input'>>;
+    updateBrand?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateBrandArgs, 'brandId' | 'input'>>;
+    createCategory?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateCategoryArgs, 'input'>>;
+    updateCategory?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateCategoryArgs, 'categoryId' | 'input'>>;
+    openOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationOpenOpportunityArgs, 'opportunityId'>>;
+    hideOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationHideOpportunityArgs, 'opportunityId'>>;
+    createOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateOpportunityArgs, 'input'>>;
+    updateOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateOpportunityArgs, 'opportunityId' | 'input'>>;
+};
+export type IOpportunitiesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunitiesPage'] = IResolversParentTypes['OpportunitiesPage']> = {
+    currentOpportunities?: Resolver<Maybe<Array<Maybe<IResolversTypes['Opportunity']>>>, ParentType, ContextType>;
+    similarOpportunities?: Resolver<Maybe<Array<Maybe<IResolversTypes['Opportunity']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IOpportunityResolvers<ContextType = any, ParentType extends IResolversParentTypes['Opportunity'] = IResolversParentTypes['Opportunity']> = {
+    opportunityId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+    name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    startedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    endedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    tags?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    links?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    ludoRankRequired?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    ludoRankRequiredMin?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    ludoRankRequiredMax?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    rewardType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    creatorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    creatorWallet?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    shareLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    notifiable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    clicks?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    brandId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandIndustry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandMedia?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IOpportunityV2Resolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunityV2'] = IResolversParentTypes['OpportunityV2']> = {
+    opportunityId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+    brandId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    categoryId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    opportunityStatus?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    opportunityType?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    notificationType?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandMedia?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    brandIndustry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    categoryName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    ludoUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    projectUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    activeFrom?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    activeUntil?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    minXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    maxXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    minRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+    maxRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+    media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    reportLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    clicks?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    blockchain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    collection?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+    minWalletValue?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+    maxWalletValue?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+    getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    fetchBrands?: Resolver<Maybe<Array<Maybe<IResolversTypes['Brand']>>>, ParentType, ContextType>;
+    fetchBrand?: Resolver<IResolversTypes['Brand'], ParentType, ContextType, RequireFields<IQueryFetchBrandArgs, 'brandId'>>;
+    fetchCategories?: Resolver<Maybe<Array<Maybe<IResolversTypes['Category']>>>, ParentType, ContextType>;
+    fetchCategory?: Resolver<IResolversTypes['Category'], ParentType, ContextType, RequireFields<IQueryFetchCategoryArgs, 'categoryId'>>;
+    fetchOpportunities?: Resolver<IResolversTypes['OpportunitiesPage'], ParentType, ContextType, Partial<IQueryFetchOpportunitiesArgs>>;
+    fetchOpportunitiesV2?: Resolver<Maybe<Array<Maybe<IResolversTypes['OpportunityV2']>>>, ParentType, ContextType>;
+    fetchOpportunity?: Resolver<IResolversTypes['OpportunityV2'], ParentType, ContextType, RequireFields<IQueryFetchOpportunityArgs, 'opportunityId'>>;
+};
+export type IResolvers<ContextType = any> = {
+    Brand?: IBrandResolvers<ContextType>;
+    Category?: ICategoryResolvers<ContextType>;
+    Long?: GraphQLScalarType;
+    Mutation?: IMutationResolvers<ContextType>;
+    OpportunitiesPage?: IOpportunitiesPageResolvers<ContextType>;
+    Opportunity?: IOpportunityResolvers<ContextType>;
+    OpportunityV2?: IOpportunityV2Resolvers<ContextType>;
+    Query?: IQueryResolvers<ContextType>;
+};
+export type IDirectiveResolvers<ContextType = any> = {
+    oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+export type ICreateOpportunityMutationVariables = Exact<{
+    input: IOpportunityInput;
+}>;
+export type ICreateOpportunityMutation = Pick<IMutation, 'createOpportunity'>;
+export type IOpenOpportunityMutationVariables = Exact<{
+    opportunityId: Scalars['ID'];
+}>;
+export type IOpenOpportunityMutation = Pick<IMutation, 'openOpportunity'>;
+export type IFetchOpportunitiesQueryVariables = Exact<{
+    domain?: Maybe<Scalars['String']>;
+}>;
+export type IFetchOpportunitiesQuery = {
+    fetchOpportunities: {
+        currentOpportunities?: Maybe<Array<Maybe<Pick<IOpportunity, 'opportunityId' | 'name' | 'description' | 'startedAt' | 'endedAt' | 'createdAt' | 'tags' | 'category' | 'media' | 'links' | 'ludoRankRequired' | 'ludoRankRequiredMin' | 'ludoRankRequiredMax' | 'rewardType' | 'creatorId' | 'creatorWallet' | 'status'>>>>;
+        similarOpportunities?: Maybe<Array<Maybe<Pick<IOpportunity, 'opportunityId' | 'name' | 'description' | 'startedAt' | 'endedAt' | 'createdAt' | 'tags' | 'category' | 'media' | 'links' | 'ludoRankRequired' | 'ludoRankRequiredMin' | 'ludoRankRequiredMax' | 'rewardType' | 'creatorId' | 'creatorWallet' | 'status'>>>>;
+    };
+};
+export declare const CreateOpportunityDocument: Apollo.DocumentNode;
+export type ICreateOpportunityMutationFn = Apollo.MutationFunction<ICreateOpportunityMutation, ICreateOpportunityMutationVariables>;
+/**
+ * __useCreateOpportunityMutation__
+ *
+ * To run a mutation, you first call `useCreateOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateOpportunityMutation` 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 [createOpportunityMutation, { data, loading, error }] = useCreateOpportunityMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<ICreateOpportunityMutation, ICreateOpportunityMutationVariables>): Apollo.MutationTuple<ICreateOpportunityMutation, Exact<{
+    input: IOpportunityInput;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateOpportunityMutationHookResult = ReturnType<typeof useCreateOpportunityMutation>;
+export type CreateOpportunityMutationResult = Apollo.MutationResult<ICreateOpportunityMutation>;
+export type CreateOpportunityMutationOptions = Apollo.BaseMutationOptions<ICreateOpportunityMutation, ICreateOpportunityMutationVariables>;
+export declare const OpenOpportunityDocument: Apollo.DocumentNode;
+export type IOpenOpportunityMutationFn = Apollo.MutationFunction<IOpenOpportunityMutation, IOpenOpportunityMutationVariables>;
+/**
+ * __useOpenOpportunityMutation__
+ *
+ * To run a mutation, you first call `useOpenOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useOpenOpportunityMutation` 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 [openOpportunityMutation, { data, loading, error }] = useOpenOpportunityMutation({
+ *   variables: {
+ *      opportunityId: // value for 'opportunityId'
+ *   },
+ * });
+ */
+export declare function useOpenOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<IOpenOpportunityMutation, IOpenOpportunityMutationVariables>): Apollo.MutationTuple<IOpenOpportunityMutation, Exact<{
+    opportunityId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type OpenOpportunityMutationHookResult = ReturnType<typeof useOpenOpportunityMutation>;
+export type OpenOpportunityMutationResult = Apollo.MutationResult<IOpenOpportunityMutation>;
+export type OpenOpportunityMutationOptions = Apollo.BaseMutationOptions<IOpenOpportunityMutation, IOpenOpportunityMutationVariables>;
+export declare const FetchOpportunitiesDocument: Apollo.DocumentNode;
+/**
+ * __useFetchOpportunitiesQuery__
+ *
+ * To run a query within a React component, call `useFetchOpportunitiesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchOpportunitiesQuery` 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 } = useFetchOpportunitiesQuery({
+ *   variables: {
+ *      domain: // value for 'domain'
+ *   },
+ * });
+ */
+export declare function useFetchOpportunitiesQuery(baseOptions?: Apollo.QueryHookOptions<IFetchOpportunitiesQuery, IFetchOpportunitiesQueryVariables>): Apollo.QueryResult<IFetchOpportunitiesQuery, Exact<{
+    domain?: Maybe<string> | undefined;
+}>>;
+export declare function useFetchOpportunitiesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchOpportunitiesQuery, IFetchOpportunitiesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchOpportunitiesQuery, Exact<{
+    domain?: Maybe<string> | undefined;
+}>>;
+export type FetchOpportunitiesQueryHookResult = ReturnType<typeof useFetchOpportunitiesQuery>;
+export type FetchOpportunitiesLazyQueryHookResult = ReturnType<typeof useFetchOpportunitiesLazyQuery>;
+export type FetchOpportunitiesQueryResult = Apollo.QueryResult<IFetchOpportunitiesQuery, IFetchOpportunitiesQueryVariables>;

package/build/graphql_tools/__generated__/opportunitiesHost/schema.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchOpportunitiesLazyQuery = exports.useFetchOpportunitiesQuery = exports.FetchOpportunitiesDocument = exports.useOpenOpportunityMutation = exports.OpenOpportunityDocument = exports.useCreateOpportunityMutation = exports.CreateOpportunityDocument = void 0;
+const client_1 = require("@apollo/client");
+const Apollo = __importStar(require("@apollo/client"));
+exports.CreateOpportunityDocument = (0, client_1.gql) `
+    mutation CreateOpportunity($input: OpportunityInput!) {
+  createOpportunity(input: $input)
+}
+    `;
+/**
+ * __useCreateOpportunityMutation__
+ *
+ * To run a mutation, you first call `useCreateOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateOpportunityMutation` 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 [createOpportunityMutation, { data, loading, error }] = useCreateOpportunityMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+function useCreateOpportunityMutation(baseOptions) {
+    return Apollo.useMutation(exports.CreateOpportunityDocument, baseOptions);
+}
+exports.useCreateOpportunityMutation = useCreateOpportunityMutation;
+exports.OpenOpportunityDocument = (0, client_1.gql) `
+    mutation OpenOpportunity($opportunityId: ID!) {
+  openOpportunity(opportunityId: $opportunityId)
+}
+    `;
+/**
+ * __useOpenOpportunityMutation__
+ *
+ * To run a mutation, you first call `useOpenOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useOpenOpportunityMutation` 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 [openOpportunityMutation, { data, loading, error }] = useOpenOpportunityMutation({
+ *   variables: {
+ *      opportunityId: // value for 'opportunityId'
+ *   },
+ * });
+ */
+function useOpenOpportunityMutation(baseOptions) {
+    return Apollo.useMutation(exports.OpenOpportunityDocument, baseOptions);
+}
+exports.useOpenOpportunityMutation = useOpenOpportunityMutation;
+exports.FetchOpportunitiesDocument = (0, client_1.gql) `
+    query FetchOpportunities($domain: String) {
+  fetchOpportunities(domain: $domain) {
+    currentOpportunities {
+      opportunityId
+      name
+      description
+      startedAt
+      endedAt
+      createdAt
+      tags
+      category
+      media
+      links
+      ludoRankRequired
+      ludoRankRequiredMin
+      ludoRankRequiredMax
+      rewardType
+      creatorId
+      creatorWallet
+      status
+    }
+    similarOpportunities {
+      opportunityId
+      name
+      description
+      startedAt
+      endedAt
+      createdAt
+      tags
+      category
+      media
+      links
+      ludoRankRequired
+      ludoRankRequiredMin
+      ludoRankRequiredMax
+      rewardType
+      creatorId
+      creatorWallet
+      status
+    }
+  }
+}
+    `;
+/**
+ * __useFetchOpportunitiesQuery__
+ *
+ * To run a query within a React component, call `useFetchOpportunitiesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchOpportunitiesQuery` 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 } = useFetchOpportunitiesQuery({
+ *   variables: {
+ *      domain: // value for 'domain'
+ *   },
+ * });
+ */
+function useFetchOpportunitiesQuery(baseOptions) {
+    return Apollo.useQuery(exports.FetchOpportunitiesDocument, baseOptions);
+}
+exports.useFetchOpportunitiesQuery = useFetchOpportunitiesQuery;
+function useFetchOpportunitiesLazyQuery(baseOptions) {
+    return Apollo.useLazyQuery(exports.FetchOpportunitiesDocument, baseOptions);
+}
+exports.useFetchOpportunitiesLazyQuery = useFetchOpportunitiesLazyQuery;