@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,356 @@
+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 IMutation = {
+    setDummy: Scalars['String'];
+};
+export type IQuery = {
+    getDummy: Scalars['String'];
+    fetchMyExperience: Scalars['Int'];
+    fetchMyExperienceV2: IUserXp;
+    fetchMyTasks: Array<Maybe<ITask>>;
+    fetchMyLatestExperienceIncrement?: Maybe<IUserXpIncrement>;
+};
+export type ISubscription = {
+    onDummy: Scalars['String'];
+    onMyExperienceUpdated: IUserXp;
+    onMyExperienceIncremented: IUserXpIncrement;
+    onInviteCodeUsed: IUsedInviteCode;
+};
+export type ISubscriptionOnMyExperienceUpdatedArgs = {
+    authToken: Scalars['String'];
+};
+export type ISubscriptionOnMyExperienceIncrementedArgs = {
+    authToken: Scalars['String'];
+};
+export type ISubscriptionOnInviteCodeUsedArgs = {
+    authToken: Scalars['String'];
+};
+export type ITask = {
+    taskId?: Maybe<Scalars['ID']>;
+    userId?: Maybe<Scalars['ID']>;
+    taskType?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    repeatable?: Maybe<Scalars['Boolean']>;
+    maxRepeats?: Maybe<Scalars['Int']>;
+    minPointsAward?: Maybe<Scalars['Int']>;
+    maxPointsAward?: Maybe<Scalars['Int']>;
+    repeatsCompleted?: Maybe<Scalars['Int']>;
+    xpPointsEarned?: Maybe<Scalars['Int']>;
+};
+export type IUsedInviteCode = {
+    userId?: Maybe<Scalars['String']>;
+    inviteCode?: Maybe<Scalars['String']>;
+    inviteeId?: Maybe<Scalars['String']>;
+};
+export type IUserXp = {
+    xps: Scalars['Int'];
+    level: Scalars['Int'];
+    levelMinXps: Scalars['Int'];
+    levelMaxXps: Scalars['Int'];
+};
+export type IUserXpIncrement = {
+    xpsIncrement: Scalars['Int'];
+    description?: Maybe<Scalars['String']>;
+    xps: Scalars['Int'];
+    level: Scalars['Int'];
+    levelMinXps: Scalars['Int'];
+    levelMaxXps: 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 = {
+    Long: ResolverTypeWrapper<Scalars['Long']>;
+    Mutation: ResolverTypeWrapper<{}>;
+    String: ResolverTypeWrapper<Scalars['String']>;
+    Query: ResolverTypeWrapper<{}>;
+    Int: ResolverTypeWrapper<Scalars['Int']>;
+    Subscription: ResolverTypeWrapper<{}>;
+    Task: ResolverTypeWrapper<ITask>;
+    ID: ResolverTypeWrapper<Scalars['ID']>;
+    Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+    UsedInviteCode: ResolverTypeWrapper<IUsedInviteCode>;
+    UserXP: ResolverTypeWrapper<IUserXp>;
+    UserXPIncrement: ResolverTypeWrapper<IUserXpIncrement>;
+};
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+    Long: Scalars['Long'];
+    Mutation: {};
+    String: Scalars['String'];
+    Query: {};
+    Int: Scalars['Int'];
+    Subscription: {};
+    Task: ITask;
+    ID: Scalars['ID'];
+    Boolean: Scalars['Boolean'];
+    UsedInviteCode: IUsedInviteCode;
+    UserXP: IUserXp;
+    UserXPIncrement: IUserXpIncrement;
+};
+export type IOneOfDirectiveArgs = {};
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+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>;
+};
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+    getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    fetchMyExperience?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    fetchMyExperienceV2?: Resolver<IResolversTypes['UserXP'], ParentType, ContextType>;
+    fetchMyTasks?: Resolver<Array<Maybe<IResolversTypes['Task']>>, ParentType, ContextType>;
+    fetchMyLatestExperienceIncrement?: Resolver<Maybe<IResolversTypes['UserXPIncrement']>, ParentType, ContextType>;
+};
+export type ISubscriptionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
+    onDummy?: SubscriptionResolver<IResolversTypes['String'], "onDummy", ParentType, ContextType>;
+    onMyExperienceUpdated?: SubscriptionResolver<IResolversTypes['UserXP'], "onMyExperienceUpdated", ParentType, ContextType, RequireFields<ISubscriptionOnMyExperienceUpdatedArgs, 'authToken'>>;
+    onMyExperienceIncremented?: SubscriptionResolver<IResolversTypes['UserXPIncrement'], "onMyExperienceIncremented", ParentType, ContextType, RequireFields<ISubscriptionOnMyExperienceIncrementedArgs, 'authToken'>>;
+    onInviteCodeUsed?: SubscriptionResolver<IResolversTypes['UsedInviteCode'], "onInviteCodeUsed", ParentType, ContextType, RequireFields<ISubscriptionOnInviteCodeUsedArgs, 'authToken'>>;
+};
+export type ITaskResolvers<ContextType = any, ParentType extends IResolversParentTypes['Task'] = IResolversParentTypes['Task']> = {
+    taskId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+    userId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+    taskType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    repeatable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    maxRepeats?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    minPointsAward?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    maxPointsAward?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    repeatsCompleted?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    xpPointsEarned?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IUsedInviteCodeResolvers<ContextType = any, ParentType extends IResolversParentTypes['UsedInviteCode'] = IResolversParentTypes['UsedInviteCode']> = {
+    userId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    inviteCode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    inviteeId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IUserXpResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserXP'] = IResolversParentTypes['UserXP']> = {
+    xps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    level?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    levelMinXps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    levelMaxXps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IUserXpIncrementResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserXPIncrement'] = IResolversParentTypes['UserXPIncrement']> = {
+    xpsIncrement?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    xps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    level?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    levelMinXps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    levelMaxXps?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type IResolvers<ContextType = any> = {
+    Long?: GraphQLScalarType;
+    Mutation?: IMutationResolvers<ContextType>;
+    Query?: IQueryResolvers<ContextType>;
+    Subscription?: ISubscriptionResolvers<ContextType>;
+    Task?: ITaskResolvers<ContextType>;
+    UsedInviteCode?: IUsedInviteCodeResolvers<ContextType>;
+    UserXP?: IUserXpResolvers<ContextType>;
+    UserXPIncrement?: IUserXpIncrementResolvers<ContextType>;
+};
+export type IDirectiveResolvers<ContextType = any> = {
+    oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+export type IFetchMyExperienceV2QueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchMyExperienceV2Query = {
+    fetchMyExperienceV2: Pick<IUserXp, 'xps' | 'level' | 'levelMaxXps' | 'levelMinXps'>;
+};
+export type IFetchMyTasksQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IFetchMyTasksQuery = {
+    fetchMyTasks: Array<Maybe<Pick<ITask, 'taskId' | 'userId' | 'taskType' | 'name' | 'description' | 'repeatable' | 'maxRepeats' | 'minPointsAward' | 'maxPointsAward' | 'repeatsCompleted'>>>;
+};
+export type IOnInviteCodeUsedSubscriptionVariables = Exact<{
+    authToken: Scalars['String'];
+}>;
+export type IOnInviteCodeUsedSubscription = {
+    onInviteCodeUsed: Pick<IUsedInviteCode, 'userId' | 'inviteCode' | 'inviteeId'>;
+};
+export type IOnMyExperienceIncrementedSubscriptionVariables = Exact<{
+    authToken: Scalars['String'];
+}>;
+export type IOnMyExperienceIncrementedSubscription = {
+    onMyExperienceIncremented: Pick<IUserXpIncrement, 'xpsIncrement' | 'description' | 'xps' | 'level' | 'levelMinXps' | 'levelMaxXps'>;
+};
+export type IOnMyExperienceUpdatedSubscriptionVariables = Exact<{
+    authToken: Scalars['String'];
+}>;
+export type IOnMyExperienceUpdatedSubscription = {
+    onMyExperienceUpdated: Pick<IUserXp, 'xps' | 'level' | 'levelMinXps' | 'levelMaxXps'>;
+};
+export declare const FetchMyExperienceV2Document: Apollo.DocumentNode;
+/**
+ * __useFetchMyExperienceV2Query__
+ *
+ * To run a query within a React component, call `useFetchMyExperienceV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyExperienceV2Query` 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 } = useFetchMyExperienceV2Query({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchMyExperienceV2Query(baseOptions?: Apollo.QueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>): Apollo.QueryResult<IFetchMyExperienceV2Query, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchMyExperienceV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>): Apollo.LazyQueryResultTuple<IFetchMyExperienceV2Query, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchMyExperienceV2QueryHookResult = ReturnType<typeof useFetchMyExperienceV2Query>;
+export type FetchMyExperienceV2LazyQueryHookResult = ReturnType<typeof useFetchMyExperienceV2LazyQuery>;
+export type FetchMyExperienceV2QueryResult = Apollo.QueryResult<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>;
+export declare const FetchMyTasksDocument: Apollo.DocumentNode;
+/**
+ * __useFetchMyTasksQuery__
+ *
+ * To run a query within a React component, call `useFetchMyTasksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyTasksQuery` 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 } = useFetchMyTasksQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useFetchMyTasksQuery(baseOptions?: Apollo.QueryHookOptions<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>): Apollo.QueryResult<IFetchMyTasksQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchMyTasksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>): Apollo.LazyQueryResultTuple<IFetchMyTasksQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchMyTasksQueryHookResult = ReturnType<typeof useFetchMyTasksQuery>;
+export type FetchMyTasksLazyQueryHookResult = ReturnType<typeof useFetchMyTasksLazyQuery>;
+export type FetchMyTasksQueryResult = Apollo.QueryResult<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>;
+export declare const OnInviteCodeUsedDocument: Apollo.DocumentNode;
+/**
+ * __useOnInviteCodeUsedSubscription__
+ *
+ * To run a query within a React component, call `useOnInviteCodeUsedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnInviteCodeUsedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnInviteCodeUsedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+export declare function useOnInviteCodeUsedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnInviteCodeUsedSubscription, IOnInviteCodeUsedSubscriptionVariables>): Apollo.SubscriptionResult<IOnInviteCodeUsedSubscription, Exact<{
+    authToken: string;
+}>>;
+export type OnInviteCodeUsedSubscriptionHookResult = ReturnType<typeof useOnInviteCodeUsedSubscription>;
+export type OnInviteCodeUsedSubscriptionResult = Apollo.SubscriptionResult<IOnInviteCodeUsedSubscription>;
+export declare const OnMyExperienceIncrementedDocument: Apollo.DocumentNode;
+/**
+ * __useOnMyExperienceIncrementedSubscription__
+ *
+ * To run a query within a React component, call `useOnMyExperienceIncrementedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnMyExperienceIncrementedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnMyExperienceIncrementedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+export declare function useOnMyExperienceIncrementedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceIncrementedSubscription, IOnMyExperienceIncrementedSubscriptionVariables>): Apollo.SubscriptionResult<IOnMyExperienceIncrementedSubscription, Exact<{
+    authToken: string;
+}>>;
+export type OnMyExperienceIncrementedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceIncrementedSubscription>;
+export type OnMyExperienceIncrementedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceIncrementedSubscription>;
+export declare const OnMyExperienceUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __useOnMyExperienceUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useOnMyExperienceUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnMyExperienceUpdatedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnMyExperienceUpdatedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+export declare function useOnMyExperienceUpdatedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceUpdatedSubscription, IOnMyExperienceUpdatedSubscriptionVariables>): Apollo.SubscriptionResult<IOnMyExperienceUpdatedSubscription, Exact<{
+    authToken: string;
+}>>;
+export type OnMyExperienceUpdatedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceUpdatedSubscription>;
+export type OnMyExperienceUpdatedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceUpdatedSubscription>;

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

@@ -0,0 +1,191 @@
+"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.useOnMyExperienceUpdatedSubscription = exports.OnMyExperienceUpdatedDocument = exports.useOnMyExperienceIncrementedSubscription = exports.OnMyExperienceIncrementedDocument = exports.useOnInviteCodeUsedSubscription = exports.OnInviteCodeUsedDocument = exports.useFetchMyTasksLazyQuery = exports.useFetchMyTasksQuery = exports.FetchMyTasksDocument = exports.useFetchMyExperienceV2LazyQuery = exports.useFetchMyExperienceV2Query = exports.FetchMyExperienceV2Document = void 0;
+const client_1 = require("@apollo/client");
+const Apollo = __importStar(require("@apollo/client"));
+exports.FetchMyExperienceV2Document = (0, client_1.gql) `
+    query FetchMyExperienceV2 {
+  fetchMyExperienceV2 {
+    xps
+    level
+    levelMaxXps
+    levelMinXps
+  }
+}
+    `;
+/**
+ * __useFetchMyExperienceV2Query__
+ *
+ * To run a query within a React component, call `useFetchMyExperienceV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyExperienceV2Query` 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 } = useFetchMyExperienceV2Query({
+ *   variables: {
+ *   },
+ * });
+ */
+function useFetchMyExperienceV2Query(baseOptions) {
+    return Apollo.useQuery(exports.FetchMyExperienceV2Document, baseOptions);
+}
+exports.useFetchMyExperienceV2Query = useFetchMyExperienceV2Query;
+function useFetchMyExperienceV2LazyQuery(baseOptions) {
+    return Apollo.useLazyQuery(exports.FetchMyExperienceV2Document, baseOptions);
+}
+exports.useFetchMyExperienceV2LazyQuery = useFetchMyExperienceV2LazyQuery;
+exports.FetchMyTasksDocument = (0, client_1.gql) `
+    query FetchMyTasks {
+  fetchMyTasks {
+    taskId
+    userId
+    taskType
+    name
+    description
+    repeatable
+    maxRepeats
+    minPointsAward
+    maxPointsAward
+    repeatsCompleted
+  }
+}
+    `;
+/**
+ * __useFetchMyTasksQuery__
+ *
+ * To run a query within a React component, call `useFetchMyTasksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyTasksQuery` 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 } = useFetchMyTasksQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+function useFetchMyTasksQuery(baseOptions) {
+    return Apollo.useQuery(exports.FetchMyTasksDocument, baseOptions);
+}
+exports.useFetchMyTasksQuery = useFetchMyTasksQuery;
+function useFetchMyTasksLazyQuery(baseOptions) {
+    return Apollo.useLazyQuery(exports.FetchMyTasksDocument, baseOptions);
+}
+exports.useFetchMyTasksLazyQuery = useFetchMyTasksLazyQuery;
+exports.OnInviteCodeUsedDocument = (0, client_1.gql) `
+    subscription onInviteCodeUsed($authToken: String!) {
+  onInviteCodeUsed(authToken: $authToken) {
+    userId
+    inviteCode
+    inviteeId
+  }
+}
+    `;
+/**
+ * __useOnInviteCodeUsedSubscription__
+ *
+ * To run a query within a React component, call `useOnInviteCodeUsedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnInviteCodeUsedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnInviteCodeUsedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+function useOnInviteCodeUsedSubscription(baseOptions) {
+    return Apollo.useSubscription(exports.OnInviteCodeUsedDocument, baseOptions);
+}
+exports.useOnInviteCodeUsedSubscription = useOnInviteCodeUsedSubscription;
+exports.OnMyExperienceIncrementedDocument = (0, client_1.gql) `
+    subscription onMyExperienceIncremented($authToken: String!) {
+  onMyExperienceIncremented(authToken: $authToken) {
+    xpsIncrement
+    description
+    xps
+    level
+    levelMinXps
+    levelMaxXps
+  }
+}
+    `;
+/**
+ * __useOnMyExperienceIncrementedSubscription__
+ *
+ * To run a query within a React component, call `useOnMyExperienceIncrementedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnMyExperienceIncrementedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnMyExperienceIncrementedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+function useOnMyExperienceIncrementedSubscription(baseOptions) {
+    return Apollo.useSubscription(exports.OnMyExperienceIncrementedDocument, baseOptions);
+}
+exports.useOnMyExperienceIncrementedSubscription = useOnMyExperienceIncrementedSubscription;
+exports.OnMyExperienceUpdatedDocument = (0, client_1.gql) `
+    subscription OnMyExperienceUpdated($authToken: String!) {
+  onMyExperienceUpdated(authToken: $authToken) {
+    xps
+    level
+    levelMinXps
+    levelMaxXps
+  }
+}
+    `;
+/**
+ * __useOnMyExperienceUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useOnMyExperienceUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnMyExperienceUpdatedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnMyExperienceUpdatedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+function useOnMyExperienceUpdatedSubscription(baseOptions) {
+    return Apollo.useSubscription(exports.OnMyExperienceUpdatedDocument, baseOptions);
+}
+exports.useOnMyExperienceUpdatedSubscription = useOnMyExperienceUpdatedSubscription;