@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,478 @@
+/* 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 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 const FetchMyExperienceV2Document = 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: {
+ *   },
+ * });
+ */
+export function useFetchMyExperienceV2Query(baseOptions?: Apollo.QueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>) {
+        return Apollo.useQuery<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>(FetchMyExperienceV2Document, baseOptions);
+      }
+export function useFetchMyExperienceV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>) {
+          return Apollo.useLazyQuery<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>(FetchMyExperienceV2Document, baseOptions);
+        }
+export type FetchMyExperienceV2QueryHookResult = ReturnType<typeof useFetchMyExperienceV2Query>;
+export type FetchMyExperienceV2LazyQueryHookResult = ReturnType<typeof useFetchMyExperienceV2LazyQuery>;
+export type FetchMyExperienceV2QueryResult = Apollo.QueryResult<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>;
+export const FetchMyTasksDocument = 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: {
+ *   },
+ * });
+ */
+export function useFetchMyTasksQuery(baseOptions?: Apollo.QueryHookOptions<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>) {
+        return Apollo.useQuery<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>(FetchMyTasksDocument, baseOptions);
+      }
+export function useFetchMyTasksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>(FetchMyTasksDocument, baseOptions);
+        }
+export type FetchMyTasksQueryHookResult = ReturnType<typeof useFetchMyTasksQuery>;
+export type FetchMyTasksLazyQueryHookResult = ReturnType<typeof useFetchMyTasksLazyQuery>;
+export type FetchMyTasksQueryResult = Apollo.QueryResult<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>;
+export const OnInviteCodeUsedDocument = 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'
+ *   },
+ * });
+ */
+export function useOnInviteCodeUsedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnInviteCodeUsedSubscription, IOnInviteCodeUsedSubscriptionVariables>) {
+        return Apollo.useSubscription<IOnInviteCodeUsedSubscription, IOnInviteCodeUsedSubscriptionVariables>(OnInviteCodeUsedDocument, baseOptions);
+      }
+export type OnInviteCodeUsedSubscriptionHookResult = ReturnType<typeof useOnInviteCodeUsedSubscription>;
+export type OnInviteCodeUsedSubscriptionResult = Apollo.SubscriptionResult<IOnInviteCodeUsedSubscription>;
+export const OnMyExperienceIncrementedDocument = 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'
+ *   },
+ * });
+ */
+export function useOnMyExperienceIncrementedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceIncrementedSubscription, IOnMyExperienceIncrementedSubscriptionVariables>) {
+        return Apollo.useSubscription<IOnMyExperienceIncrementedSubscription, IOnMyExperienceIncrementedSubscriptionVariables>(OnMyExperienceIncrementedDocument, baseOptions);
+      }
+export type OnMyExperienceIncrementedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceIncrementedSubscription>;
+export type OnMyExperienceIncrementedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceIncrementedSubscription>;
+export const OnMyExperienceUpdatedDocument = 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'
+ *   },
+ * });
+ */
+export function useOnMyExperienceUpdatedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceUpdatedSubscription, IOnMyExperienceUpdatedSubscriptionVariables>) {
+        return Apollo.useSubscription<IOnMyExperienceUpdatedSubscription, IOnMyExperienceUpdatedSubscriptionVariables>(OnMyExperienceUpdatedDocument, baseOptions);
+      }
+export type OnMyExperienceUpdatedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceUpdatedSubscription>;
+export type OnMyExperienceUpdatedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceUpdatedSubscription>;