@ludo.ninja/api 3.2.32 → 3.2.34

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

@@ -0,0 +1,354 @@
+/* eslint-disable */
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } 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;
+  /** A JSON scalar */
+  JSON: any;
+  /** A 64-bit signed integer */
+  Long: any;
+};
+
+
+export type IFeature = {
+  featureId: Scalars['Int'];
+  name: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  parameterized: Scalars['Boolean'];
+};
+
+export type IFeaturePack = {
+  featurePackId: Scalars['String'];
+  name: Scalars['String'];
+  price: Scalars['Float'];
+  basic: Scalars['Boolean'];
+  daysPeriod: Scalars['Int'];
+  packedFeatures?: Maybe<Array<IPackedFeature>>;
+};
+
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  buyFeaturePackForXp: Scalars['Boolean'];
+  buyProjectMonitorForXp: Scalars['Boolean'];
+  buyProjectAlertForXp: Scalars['Boolean'];
+};
+
+
+export type IMutationBuyFeaturePackForXpArgs = {
+  featurePackId: Scalars['String'];
+};
+
+export type IPackedFeature = {
+  featurePackId: Scalars['String'];
+  featureId: Scalars['String'];
+  name: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  param?: Maybe<Scalars['Int']>;
+  usageLimit?: Maybe<Scalars['Int']>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchFeatures?: Maybe<Array<IFeature>>;
+  fetchFeaturePacks?: Maybe<Array<IFeaturePack>>;
+};
+
+export type IUserFeaturePack = {
+  userId: Scalars['String'];
+  featurePackId: Scalars['String'];
+  acquiredAt: Scalars['Long'];
+};
+
+
+
+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 = {
+  Feature: ResolverTypeWrapper<IFeature>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  FeaturePack: ResolverTypeWrapper<IFeaturePack>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  JSON: ResolverTypeWrapper<Scalars['JSON']>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  PackedFeature: ResolverTypeWrapper<IPackedFeature>;
+  Query: ResolverTypeWrapper<{}>;
+  UserFeaturePack: ResolverTypeWrapper<IUserFeaturePack>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  Feature: IFeature;
+  Int: Scalars['Int'];
+  String: Scalars['String'];
+  Boolean: Scalars['Boolean'];
+  FeaturePack: IFeaturePack;
+  Float: Scalars['Float'];
+  JSON: Scalars['JSON'];
+  Long: Scalars['Long'];
+  Mutation: {};
+  PackedFeature: IPackedFeature;
+  Query: {};
+  UserFeaturePack: IUserFeaturePack;
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IFeatureResolvers<ContextType = any, ParentType extends IResolversParentTypes['Feature'] = IResolversParentTypes['Feature']> = {
+  featureId?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  parameterized?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IFeaturePackResolvers<ContextType = any, ParentType extends IResolversParentTypes['FeaturePack'] = IResolversParentTypes['FeaturePack']> = {
+  featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  price?: Resolver<IResolversTypes['Float'], ParentType, ContextType>;
+  basic?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  daysPeriod?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  packedFeatures?: Resolver<Maybe<Array<IResolversTypes['PackedFeature']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface IJsonScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
+  name: 'JSON';
+}
+
+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>;
+  buyFeaturePackForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationBuyFeaturePackForXpArgs, 'featurePackId'>>;
+  buyProjectMonitorForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  buyProjectAlertForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+};
+
+export type IPackedFeatureResolvers<ContextType = any, ParentType extends IResolversParentTypes['PackedFeature'] = IResolversParentTypes['PackedFeature']> = {
+  featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  featureId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  param?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  usageLimit?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchFeatures?: Resolver<Maybe<Array<IResolversTypes['Feature']>>, ParentType, ContextType>;
+  fetchFeaturePacks?: Resolver<Maybe<Array<IResolversTypes['FeaturePack']>>, ParentType, ContextType>;
+};
+
+export type IUserFeaturePackResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserFeaturePack'] = IResolversParentTypes['UserFeaturePack']> = {
+  userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  acquiredAt?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Feature?: IFeatureResolvers<ContextType>;
+  FeaturePack?: IFeaturePackResolvers<ContextType>;
+  JSON?: GraphQLScalarType;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  PackedFeature?: IPackedFeatureResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  UserFeaturePack?: IUserFeaturePackResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IBuyFeaturePackForXpMutationVariables = Exact<{
+  featurePackId: Scalars['String'];
+}>;
+
+
+export type IBuyFeaturePackForXpMutation = Pick<IMutation, 'buyFeaturePackForXp'>;
+
+export type IBuyProjectAlertForXpMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IBuyProjectAlertForXpMutation = Pick<IMutation, 'buyProjectAlertForXp'>;
+
+export type IBuyProjectMonitorForXpMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IBuyProjectMonitorForXpMutation = Pick<IMutation, 'buyProjectMonitorForXp'>;
+
+
+export const BuyFeaturePackForXpDocument = gql`
+    mutation BuyFeaturePackForXp($featurePackId: String!) {
+  buyFeaturePackForXp(featurePackId: $featurePackId)
+}
+    `;
+export type IBuyFeaturePackForXpMutationFn = Apollo.MutationFunction<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>;
+
+/**
+ * __useBuyFeaturePackForXpMutation__
+ *
+ * To run a mutation, you first call `useBuyFeaturePackForXpMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBuyFeaturePackForXpMutation` 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 [buyFeaturePackForXpMutation, { data, loading, error }] = useBuyFeaturePackForXpMutation({
+ *   variables: {
+ *      featurePackId: // value for 'featurePackId'
+ *   },
+ * });
+ */
+export function useBuyFeaturePackForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>) {
+        return Apollo.useMutation<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>(BuyFeaturePackForXpDocument, baseOptions);
+      }
+export type BuyFeaturePackForXpMutationHookResult = ReturnType<typeof useBuyFeaturePackForXpMutation>;
+export type BuyFeaturePackForXpMutationResult = Apollo.MutationResult<IBuyFeaturePackForXpMutation>;
+export type BuyFeaturePackForXpMutationOptions = Apollo.BaseMutationOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>;
+export const BuyProjectAlertForXpDocument = gql`
+    mutation BuyProjectAlertForXp {
+  buyProjectAlertForXp
+}
+    `;
+export type IBuyProjectAlertForXpMutationFn = Apollo.MutationFunction<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>;
+
+/**
+ * __useBuyProjectAlertForXpMutation__
+ *
+ * To run a mutation, you first call `useBuyProjectAlertForXpMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBuyProjectAlertForXpMutation` 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 [buyProjectAlertForXpMutation, { data, loading, error }] = useBuyProjectAlertForXpMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useBuyProjectAlertForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>) {
+        return Apollo.useMutation<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>(BuyProjectAlertForXpDocument, baseOptions);
+      }
+export type BuyProjectAlertForXpMutationHookResult = ReturnType<typeof useBuyProjectAlertForXpMutation>;
+export type BuyProjectAlertForXpMutationResult = Apollo.MutationResult<IBuyProjectAlertForXpMutation>;
+export type BuyProjectAlertForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>;
+export const BuyProjectMonitorForXpDocument = gql`
+    mutation BuyProjectMonitorForXp {
+  buyProjectMonitorForXp
+}
+    `;
+export type IBuyProjectMonitorForXpMutationFn = Apollo.MutationFunction<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>;
+
+/**
+ * __useBuyProjectMonitorForXpMutation__
+ *
+ * To run a mutation, you first call `useBuyProjectMonitorForXpMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBuyProjectMonitorForXpMutation` 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 [buyProjectMonitorForXpMutation, { data, loading, error }] = useBuyProjectMonitorForXpMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useBuyProjectMonitorForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>) {
+        return Apollo.useMutation<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>(BuyProjectMonitorForXpDocument, baseOptions);
+      }
+export type BuyProjectMonitorForXpMutationHookResult = ReturnType<typeof useBuyProjectMonitorForXpMutation>;
+export type BuyProjectMonitorForXpMutationResult = Apollo.MutationResult<IBuyProjectMonitorForXpMutation>;
+export type BuyProjectMonitorForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>;

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

@@ -21,6 +21,8 @@ export type Scalars = {
 
 
 
+
+
 export type IAirdropsLeaderboardFilterInput = {
   userRank?: Maybe<Scalars['Int']>;
   geolocationTerm?: Maybe<Scalars['String']>;
@@ -453,6 +455,7 @@ export type IProjectsLeaderboardSortInput = {
   sortByLudoRankDayDifference?: Maybe<ISort>;
   sortByLudoRankWeekDifference?: Maybe<ISort>;
   sortByInvestors?: Maybe<ISort>;
+  sortByFetchedAt?: Maybe<ISort>;
 };
 
 export type IProjectsPage = {
@@ -940,6 +943,17 @@ export type IRangeDirectiveArgs = {
 
 export type IRangeDirectiveResolver<Result, Parent, ContextType = any, Args = IRangeDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
 
+export type IDeferDirectiveArgs = {
+  if?: Scalars['Boolean'];
+  label?: Maybe<Scalars['String']>;
+};
+
+export type IDeferDirectiveResolver<Result, Parent, ContextType = any, Args = IDeferDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IExperimental_DisableErrorPropagationDirectiveArgs = { };
+
+export type IExperimental_DisableErrorPropagationDirectiveResolver<Result, Parent, ContextType = any, Args = IExperimental_DisableErrorPropagationDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
 export type IOneOfDirectiveArgs = { };
 
 export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
@@ -1377,6 +1391,8 @@ export type IResolvers<ContextType = any> = {
 export type IDirectiveResolvers<ContextType = any> = {
   NotBlank?: INotBlankDirectiveResolver<any, any, ContextType>;
   Range?: IRangeDirectiveResolver<any, any, ContextType>;
+  defer?: IDeferDirectiveResolver<any, any, ContextType>;
+  experimental_disableErrorPropagation?: IExperimental_DisableErrorPropagationDirectiveResolver<any, any, ContextType>;
   oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
 };
 

package/src/index.ts

@@ -14,6 +14,7 @@ import * as mintInfoSchema from "./graphql_tools/__generated__/mintInfoHost/sche
 import * as opportunitiesSchema from "./graphql_tools/__generated__/opportunitiesHost/schema";
 import * as preferencesSchema from "./graphql_tools/__generated__/preferencesHost/schema";
 import * as searchSchema from "./graphql_tools/__generated__/searchHost/schema";
+import * as featuresSchema from "./graphql_tools/__generated__/featuresHost/schema";
 import * as formsSchema from "./graphql_tools/__generated__/formsHost/schema";
 import * as tapsSchema from "./graphql_tools/__generated__/tapHost/schema";
 import * as notificationsSchema from "./graphql_tools/__generated__/notificationsHost/schema";
@@ -34,7 +35,8 @@ const schema = {
   ...formsSchema,
   ...tapsSchema,
   ...notificationsSchema,
-  ...mintInfoSchema
+  ...mintInfoSchema,
+  ...featuresSchema
 };
 
 export {
@@ -57,5 +59,6 @@ export {
   formsSchema,
   tapsSchema,
   notificationsSchema,
-  mintInfoSchema
+  mintInfoSchema,
+  featuresSchema
 };