@ludo.ninja/api 3.2.32 → 3.2.34

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

@@ -0,0 +1,274 @@
+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 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 declare const BuyFeaturePackForXpDocument: Apollo.DocumentNode;
+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 declare function useBuyFeaturePackForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>): Apollo.MutationTuple<IBuyFeaturePackForXpMutation, Exact<{
+    featurePackId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type BuyFeaturePackForXpMutationHookResult = ReturnType<typeof useBuyFeaturePackForXpMutation>;
+export type BuyFeaturePackForXpMutationResult = Apollo.MutationResult<IBuyFeaturePackForXpMutation>;
+export type BuyFeaturePackForXpMutationOptions = Apollo.BaseMutationOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>;
+export declare const BuyProjectAlertForXpDocument: Apollo.DocumentNode;
+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 declare function useBuyProjectAlertForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>): Apollo.MutationTuple<IBuyProjectAlertForXpMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type BuyProjectAlertForXpMutationHookResult = ReturnType<typeof useBuyProjectAlertForXpMutation>;
+export type BuyProjectAlertForXpMutationResult = Apollo.MutationResult<IBuyProjectAlertForXpMutation>;
+export type BuyProjectAlertForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>;
+export declare const BuyProjectMonitorForXpDocument: Apollo.DocumentNode;
+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 declare function useBuyProjectMonitorForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>): Apollo.MutationTuple<IBuyProjectMonitorForXpMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type BuyProjectMonitorForXpMutationHookResult = ReturnType<typeof useBuyProjectMonitorForXpMutation>;
+export type BuyProjectMonitorForXpMutationResult = Apollo.MutationResult<IBuyProjectMonitorForXpMutation>;
+export type BuyProjectMonitorForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>;

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

@@ -0,0 +1,104 @@
+"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.useBuyProjectMonitorForXpMutation = exports.BuyProjectMonitorForXpDocument = exports.useBuyProjectAlertForXpMutation = exports.BuyProjectAlertForXpDocument = exports.useBuyFeaturePackForXpMutation = exports.BuyFeaturePackForXpDocument = void 0;
+const client_1 = require("@apollo/client");
+const Apollo = __importStar(require("@apollo/client"));
+exports.BuyFeaturePackForXpDocument = (0, client_1.gql) `
+    mutation BuyFeaturePackForXp($featurePackId: String!) {
+  buyFeaturePackForXp(featurePackId: $featurePackId)
+}
+    `;
+/**
+ * __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'
+ *   },
+ * });
+ */
+function useBuyFeaturePackForXpMutation(baseOptions) {
+    return Apollo.useMutation(exports.BuyFeaturePackForXpDocument, baseOptions);
+}
+exports.useBuyFeaturePackForXpMutation = useBuyFeaturePackForXpMutation;
+exports.BuyProjectAlertForXpDocument = (0, client_1.gql) `
+    mutation BuyProjectAlertForXp {
+  buyProjectAlertForXp
+}
+    `;
+/**
+ * __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: {
+ *   },
+ * });
+ */
+function useBuyProjectAlertForXpMutation(baseOptions) {
+    return Apollo.useMutation(exports.BuyProjectAlertForXpDocument, baseOptions);
+}
+exports.useBuyProjectAlertForXpMutation = useBuyProjectAlertForXpMutation;
+exports.BuyProjectMonitorForXpDocument = (0, client_1.gql) `
+    mutation BuyProjectMonitorForXp {
+  buyProjectMonitorForXp
+}
+    `;
+/**
+ * __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: {
+ *   },
+ * });
+ */
+function useBuyProjectMonitorForXpMutation(baseOptions) {
+    return Apollo.useMutation(exports.BuyProjectMonitorForXpDocument, baseOptions);
+}
+exports.useBuyProjectMonitorForXpMutation = useBuyProjectMonitorForXpMutation;

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

@@ -412,6 +412,7 @@ export type IProjectsLeaderboardSortInput = {
     sortByLudoRankDayDifference?: Maybe<ISort>;
     sortByLudoRankWeekDifference?: Maybe<ISort>;
     sortByInvestors?: Maybe<ISort>;
+    sortByFetchedAt?: Maybe<ISort>;
 };
 export type IProjectsPage = {
     projects: Array<IProject>;
@@ -781,6 +782,13 @@ export type IRangeDirectiveArgs = {
     message?: Maybe<Scalars['String']>;
 };
 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>;
 export type IAssetResolvers<ContextType = any, ParentType extends IResolversParentTypes['Asset'] = IResolversParentTypes['Asset']> = {
@@ -1184,6 +1192,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>;
 };
 export type IFetchAirdropsLeaderboardQueryVariables = Exact<{

package/build/index.d.ts

@@ -14,10 +14,29 @@ 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";
 declare const schema: {
+    useBuyFeaturePackForXpMutation(baseOptions?: import("@apollo/client").MutationHookOptions<featuresSchema.IBuyFeaturePackForXpMutation, featuresSchema.Exact<{
+        featurePackId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<featuresSchema.IBuyFeaturePackForXpMutation, featuresSchema.Exact<{
+        featurePackId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
+    useBuyProjectAlertForXpMutation(baseOptions?: import("@apollo/client").MutationHookOptions<featuresSchema.IBuyProjectAlertForXpMutation, featuresSchema.Exact<{
+        [key: string]: never;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<featuresSchema.IBuyProjectAlertForXpMutation, featuresSchema.Exact<{
+        [key: string]: never;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
+    useBuyProjectMonitorForXpMutation(baseOptions?: import("@apollo/client").MutationHookOptions<featuresSchema.IBuyProjectMonitorForXpMutation, featuresSchema.Exact<{
+        [key: string]: never;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<featuresSchema.IBuyProjectMonitorForXpMutation, featuresSchema.Exact<{
+        [key: string]: never;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
+    BuyFeaturePackForXpDocument: import("graphql").DocumentNode;
+    BuyProjectAlertForXpDocument: import("graphql").DocumentNode;
+    BuyProjectMonitorForXpDocument: import("graphql").DocumentNode;
     useFetchMintingInfoQuery(baseOptions: import("@apollo/client").QueryHookOptions<mintInfoSchema.IFetchMintingInfoQuery, mintInfoSchema.Exact<{
         input: mintInfoSchema.IMintingInput;
     }>>): import("@apollo/client").QueryResult<mintInfoSchema.IFetchMintingInfoQuery, mintInfoSchema.Exact<{
@@ -2578,4 +2597,4 @@ declare const schema: {
     FetchProjectLinksClicksInfoCsvDocument: import("graphql").DocumentNode;
     FetchProjectReactionsInfoCsvDocument: import("graphql").DocumentNode;
 };
-export { hosts, schema, graphqlConfig, authCookies, adminSchema, assetSchema, authSchema, collectionsSchema, experiencesSchema, extensionSchema, galleriesSchema, identitySchema, mediasSchema, opportunitiesSchema, preferencesSchema, searchSchema, formsSchema, tapsSchema, notificationsSchema, mintInfoSchema };
+export { hosts, schema, graphqlConfig, authCookies, adminSchema, assetSchema, authSchema, collectionsSchema, experiencesSchema, extensionSchema, galleriesSchema, identitySchema, mediasSchema, opportunitiesSchema, preferencesSchema, searchSchema, formsSchema, tapsSchema, notificationsSchema, mintInfoSchema, featuresSchema };

package/build/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mintInfoSchema = exports.notificationsSchema = exports.tapsSchema = exports.formsSchema = exports.searchSchema = exports.preferencesSchema = exports.opportunitiesSchema = exports.mediasSchema = exports.identitySchema = exports.galleriesSchema = exports.extensionSchema = exports.experiencesSchema = exports.collectionsSchema = exports.authSchema = exports.assetSchema = exports.adminSchema = exports.authCookies = exports.graphqlConfig = exports.schema = exports.hosts = void 0;
+exports.featuresSchema = exports.mintInfoSchema = exports.notificationsSchema = exports.tapsSchema = exports.formsSchema = exports.searchSchema = exports.preferencesSchema = exports.opportunitiesSchema = exports.mediasSchema = exports.identitySchema = exports.galleriesSchema = exports.extensionSchema = exports.experiencesSchema = exports.collectionsSchema = exports.authSchema = exports.assetSchema = exports.adminSchema = exports.authCookies = exports.graphqlConfig = exports.schema = exports.hosts = void 0;
 const hosts = __importStar(require("./hosts"));
 exports.hosts = hosts;
 const graphqlConfig = __importStar(require("./config"));
@@ -56,6 +56,8 @@ const preferencesSchema = __importStar(require("./graphql_tools/__generated__/pr
 exports.preferencesSchema = preferencesSchema;
 const searchSchema = __importStar(require("./graphql_tools/__generated__/searchHost/schema"));
 exports.searchSchema = searchSchema;
+const featuresSchema = __importStar(require("./graphql_tools/__generated__/featuresHost/schema"));
+exports.featuresSchema = featuresSchema;
 const formsSchema = __importStar(require("./graphql_tools/__generated__/formsHost/schema"));
 exports.formsSchema = formsSchema;
 const tapsSchema = __importStar(require("./graphql_tools/__generated__/tapHost/schema"));
@@ -78,6 +80,7 @@ const schema = {
     ...formsSchema,
     ...tapsSchema,
     ...notificationsSchema,
-    ...mintInfoSchema
+    ...mintInfoSchema,
+    ...featuresSchema
 };
 exports.schema = schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ludo.ninja/api",
-  "version": "3.2.32",
+  "version": "3.2.34",
   "main": "./build/index.js",
   "scripts": {
     "test": "jest",