@ludo.ninja/api 2.8.34 → 2.8.35

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

@@ -0,0 +1,550 @@
+/* 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 IContactSupportInput = {
+  userId?: Maybe<Scalars['ID']>;
+  email: Scalars['String'];
+  walletAddress: Scalars['String'];
+  category?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  priority?: Maybe<Scalars['String']>;
+};
+
+export type IContentReportInput = {
+  userId?: Maybe<Scalars['ID']>;
+  email: Scalars['String'];
+  nameOfSubject?: Maybe<Scalars['String']>;
+  contentType?: Maybe<Scalars['String']>;
+  contentId?: Maybe<Scalars['String']>;
+  reportReason?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  evidenceFileUrl?: Maybe<Scalars['String']>;
+};
+
+export type IInvestorInquiryInput = {
+  userId?: Maybe<Scalars['ID']>;
+  email: Scalars['String'];
+  name: Scalars['String'];
+  phoneNumber: Scalars['String'];
+  telegramId?: Maybe<Scalars['String']>;
+  investorType: Scalars['String'];
+  investmentAmount?: Maybe<Scalars['Float']>;
+  investmentExperience: Scalars['String'];
+  assistanceRequest: Scalars['String'];
+  ludoReferrerInfo?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  submitOpportunity: Scalars['Boolean'];
+  submitContactSupport: Scalars['Boolean'];
+  submitRegistrationInvite: Scalars['Boolean'];
+  submitContentReport: Scalars['Boolean'];
+  submitPartnershipInquiry: Scalars['Boolean'];
+  submitUserFeedback: Scalars['Boolean'];
+  submitInvestorInquiry: Scalars['Boolean'];
+};
+
+
+export type IMutationSubmitOpportunityArgs = {
+  input: IOpportunityInput;
+};
+
+
+export type IMutationSubmitContactSupportArgs = {
+  input: IContactSupportInput;
+};
+
+
+export type IMutationSubmitRegistrationInviteArgs = {
+  input: IRegistrationInviteInput;
+};
+
+
+export type IMutationSubmitContentReportArgs = {
+  input: IContentReportInput;
+};
+
+
+export type IMutationSubmitPartnershipInquiryArgs = {
+  input: IPartnershipInquiryInput;
+};
+
+
+export type IMutationSubmitUserFeedbackArgs = {
+  input: IUserFeedbackInput;
+};
+
+
+export type IMutationSubmitInvestorInquiryArgs = {
+  input: IInvestorInquiryInput;
+};
+
+export type IOpportunityInput = {
+  userId?: Maybe<Scalars['ID']>;
+  submitterEmail: Scalars['String'];
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  registrationLink?: Maybe<Scalars['String']>;
+  startDate?: Maybe<Scalars['Long']>;
+  endDate?: Maybe<Scalars['Long']>;
+};
+
+export type IPartnershipInquiryInput = {
+  userId?: Maybe<Scalars['ID']>;
+  name: Scalars['String'];
+  email: Scalars['String'];
+  projectName: Scalars['String'];
+  website: Scalars['String'];
+  aboutProject: Scalars['String'];
+  partnershipType: Scalars['String'];
+  ludoReferrerInfo?: Maybe<Scalars['String']>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+};
+
+export type IRegistrationInviteInput = {
+  userId?: Maybe<Scalars['ID']>;
+  ludoIdOrAddress: Scalars['String'];
+  reason: Scalars['String'];
+};
+
+export type IUserFeedbackInput = {
+  userId?: Maybe<Scalars['ID']>;
+  email: Scalars['String'];
+  satisfactionScore: Scalars['Int'];
+  missedFeature?: Maybe<Scalars['String']>;
+  howEasyToUseScore?: Maybe<Scalars['String']>;
+  performanceScore?: Maybe<Scalars['Int']>;
+  whatToImprove?: Maybe<Scalars['String']>;
+  comments?: Maybe<Scalars['String']>;
+};
+
+
+
+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 = {
+  ContactSupportInput: IContactSupportInput;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  ContentReportInput: IContentReportInput;
+  InvestorInquiryInput: IInvestorInquiryInput;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  OpportunityInput: IOpportunityInput;
+  PartnershipInquiryInput: IPartnershipInquiryInput;
+  Query: ResolverTypeWrapper<{}>;
+  RegistrationInviteInput: IRegistrationInviteInput;
+  UserFeedbackInput: IUserFeedbackInput;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  ContactSupportInput: IContactSupportInput;
+  ID: Scalars['ID'];
+  String: Scalars['String'];
+  ContentReportInput: IContentReportInput;
+  InvestorInquiryInput: IInvestorInquiryInput;
+  Float: Scalars['Float'];
+  Long: Scalars['Long'];
+  Mutation: {};
+  Boolean: Scalars['Boolean'];
+  OpportunityInput: IOpportunityInput;
+  PartnershipInquiryInput: IPartnershipInquiryInput;
+  Query: {};
+  RegistrationInviteInput: IRegistrationInviteInput;
+  UserFeedbackInput: IUserFeedbackInput;
+  Int: Scalars['Int'];
+};
+
+export type IPatternDirectiveArgs = {
+  regexp: Scalars['String'];
+  message?: Maybe<Scalars['String']>;
+};
+
+export type IPatternDirectiveResolver<Result, Parent, ContextType = any, Args = IPatternDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+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>;
+  submitOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitOpportunityArgs, 'input'>>;
+  submitContactSupport?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitContactSupportArgs, 'input'>>;
+  submitRegistrationInvite?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitRegistrationInviteArgs, 'input'>>;
+  submitContentReport?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitContentReportArgs, 'input'>>;
+  submitPartnershipInquiry?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitPartnershipInquiryArgs, 'input'>>;
+  submitUserFeedback?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitUserFeedbackArgs, 'input'>>;
+  submitInvestorInquiry?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubmitInvestorInquiryArgs, 'input'>>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  Pattern?: IPatternDirectiveResolver<any, any, ContextType>;
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type ISubmitContactSupportMutationVariables = Exact<{
+  input: IContactSupportInput;
+}>;
+
+
+export type ISubmitContactSupportMutation = Pick<IMutation, 'submitContactSupport'>;
+
+export type ISubmitContentReportMutationVariables = Exact<{
+  input: IContentReportInput;
+}>;
+
+
+export type ISubmitContentReportMutation = Pick<IMutation, 'submitContentReport'>;
+
+export type ISubmitInvestorInquiryMutationVariables = Exact<{
+  input: IInvestorInquiryInput;
+}>;
+
+
+export type ISubmitInvestorInquiryMutation = Pick<IMutation, 'submitInvestorInquiry'>;
+
+export type ISubmitOpportunityMutationVariables = Exact<{
+  input: IOpportunityInput;
+}>;
+
+
+export type ISubmitOpportunityMutation = Pick<IMutation, 'submitOpportunity'>;
+
+export type ISubmitPartnershipInquiryMutationVariables = Exact<{
+  input: IPartnershipInquiryInput;
+}>;
+
+
+export type ISubmitPartnershipInquiryMutation = Pick<IMutation, 'submitPartnershipInquiry'>;
+
+export type ISubmitRegistrationInviteMutationVariables = Exact<{
+  input: IRegistrationInviteInput;
+}>;
+
+
+export type ISubmitRegistrationInviteMutation = Pick<IMutation, 'submitRegistrationInvite'>;
+
+export type ISubmitUserFeedbackMutationVariables = Exact<{
+  input: IUserFeedbackInput;
+}>;
+
+
+export type ISubmitUserFeedbackMutation = Pick<IMutation, 'submitUserFeedback'>;
+
+
+export const SubmitContactSupportDocument = gql`
+    mutation SubmitContactSupport($input: ContactSupportInput!) {
+  submitContactSupport(input: $input)
+}
+    `;
+export type ISubmitContactSupportMutationFn = Apollo.MutationFunction<ISubmitContactSupportMutation, ISubmitContactSupportMutationVariables>;
+
+/**
+ * __useSubmitContactSupportMutation__
+ *
+ * To run a mutation, you first call `useSubmitContactSupportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitContactSupportMutation` 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 [submitContactSupportMutation, { data, loading, error }] = useSubmitContactSupportMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitContactSupportMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitContactSupportMutation, ISubmitContactSupportMutationVariables>) {
+        return Apollo.useMutation<ISubmitContactSupportMutation, ISubmitContactSupportMutationVariables>(SubmitContactSupportDocument, baseOptions);
+      }
+export type SubmitContactSupportMutationHookResult = ReturnType<typeof useSubmitContactSupportMutation>;
+export type SubmitContactSupportMutationResult = Apollo.MutationResult<ISubmitContactSupportMutation>;
+export type SubmitContactSupportMutationOptions = Apollo.BaseMutationOptions<ISubmitContactSupportMutation, ISubmitContactSupportMutationVariables>;
+export const SubmitContentReportDocument = gql`
+    mutation SubmitContentReport($input: ContentReportInput!) {
+  submitContentReport(input: $input)
+}
+    `;
+export type ISubmitContentReportMutationFn = Apollo.MutationFunction<ISubmitContentReportMutation, ISubmitContentReportMutationVariables>;
+
+/**
+ * __useSubmitContentReportMutation__
+ *
+ * To run a mutation, you first call `useSubmitContentReportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitContentReportMutation` 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 [submitContentReportMutation, { data, loading, error }] = useSubmitContentReportMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitContentReportMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitContentReportMutation, ISubmitContentReportMutationVariables>) {
+        return Apollo.useMutation<ISubmitContentReportMutation, ISubmitContentReportMutationVariables>(SubmitContentReportDocument, baseOptions);
+      }
+export type SubmitContentReportMutationHookResult = ReturnType<typeof useSubmitContentReportMutation>;
+export type SubmitContentReportMutationResult = Apollo.MutationResult<ISubmitContentReportMutation>;
+export type SubmitContentReportMutationOptions = Apollo.BaseMutationOptions<ISubmitContentReportMutation, ISubmitContentReportMutationVariables>;
+export const SubmitInvestorInquiryDocument = gql`
+    mutation SubmitInvestorInquiry($input: InvestorInquiryInput!) {
+  submitInvestorInquiry(input: $input)
+}
+    `;
+export type ISubmitInvestorInquiryMutationFn = Apollo.MutationFunction<ISubmitInvestorInquiryMutation, ISubmitInvestorInquiryMutationVariables>;
+
+/**
+ * __useSubmitInvestorInquiryMutation__
+ *
+ * To run a mutation, you first call `useSubmitInvestorInquiryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitInvestorInquiryMutation` 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 [submitInvestorInquiryMutation, { data, loading, error }] = useSubmitInvestorInquiryMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitInvestorInquiryMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitInvestorInquiryMutation, ISubmitInvestorInquiryMutationVariables>) {
+        return Apollo.useMutation<ISubmitInvestorInquiryMutation, ISubmitInvestorInquiryMutationVariables>(SubmitInvestorInquiryDocument, baseOptions);
+      }
+export type SubmitInvestorInquiryMutationHookResult = ReturnType<typeof useSubmitInvestorInquiryMutation>;
+export type SubmitInvestorInquiryMutationResult = Apollo.MutationResult<ISubmitInvestorInquiryMutation>;
+export type SubmitInvestorInquiryMutationOptions = Apollo.BaseMutationOptions<ISubmitInvestorInquiryMutation, ISubmitInvestorInquiryMutationVariables>;
+export const SubmitOpportunityDocument = gql`
+    mutation SubmitOpportunity($input: OpportunityInput!) {
+  submitOpportunity(input: $input)
+}
+    `;
+export type ISubmitOpportunityMutationFn = Apollo.MutationFunction<ISubmitOpportunityMutation, ISubmitOpportunityMutationVariables>;
+
+/**
+ * __useSubmitOpportunityMutation__
+ *
+ * To run a mutation, you first call `useSubmitOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitOpportunityMutation` 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 [submitOpportunityMutation, { data, loading, error }] = useSubmitOpportunityMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitOpportunityMutation, ISubmitOpportunityMutationVariables>) {
+        return Apollo.useMutation<ISubmitOpportunityMutation, ISubmitOpportunityMutationVariables>(SubmitOpportunityDocument, baseOptions);
+      }
+export type SubmitOpportunityMutationHookResult = ReturnType<typeof useSubmitOpportunityMutation>;
+export type SubmitOpportunityMutationResult = Apollo.MutationResult<ISubmitOpportunityMutation>;
+export type SubmitOpportunityMutationOptions = Apollo.BaseMutationOptions<ISubmitOpportunityMutation, ISubmitOpportunityMutationVariables>;
+export const SubmitPartnershipInquiryDocument = gql`
+    mutation SubmitPartnershipInquiry($input: PartnershipInquiryInput!) {
+  submitPartnershipInquiry(input: $input)
+}
+    `;
+export type ISubmitPartnershipInquiryMutationFn = Apollo.MutationFunction<ISubmitPartnershipInquiryMutation, ISubmitPartnershipInquiryMutationVariables>;
+
+/**
+ * __useSubmitPartnershipInquiryMutation__
+ *
+ * To run a mutation, you first call `useSubmitPartnershipInquiryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitPartnershipInquiryMutation` 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 [submitPartnershipInquiryMutation, { data, loading, error }] = useSubmitPartnershipInquiryMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitPartnershipInquiryMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitPartnershipInquiryMutation, ISubmitPartnershipInquiryMutationVariables>) {
+        return Apollo.useMutation<ISubmitPartnershipInquiryMutation, ISubmitPartnershipInquiryMutationVariables>(SubmitPartnershipInquiryDocument, baseOptions);
+      }
+export type SubmitPartnershipInquiryMutationHookResult = ReturnType<typeof useSubmitPartnershipInquiryMutation>;
+export type SubmitPartnershipInquiryMutationResult = Apollo.MutationResult<ISubmitPartnershipInquiryMutation>;
+export type SubmitPartnershipInquiryMutationOptions = Apollo.BaseMutationOptions<ISubmitPartnershipInquiryMutation, ISubmitPartnershipInquiryMutationVariables>;
+export const SubmitRegistrationInviteDocument = gql`
+    mutation SubmitRegistrationInvite($input: RegistrationInviteInput!) {
+  submitRegistrationInvite(input: $input)
+}
+    `;
+export type ISubmitRegistrationInviteMutationFn = Apollo.MutationFunction<ISubmitRegistrationInviteMutation, ISubmitRegistrationInviteMutationVariables>;
+
+/**
+ * __useSubmitRegistrationInviteMutation__
+ *
+ * To run a mutation, you first call `useSubmitRegistrationInviteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitRegistrationInviteMutation` 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 [submitRegistrationInviteMutation, { data, loading, error }] = useSubmitRegistrationInviteMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitRegistrationInviteMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitRegistrationInviteMutation, ISubmitRegistrationInviteMutationVariables>) {
+        return Apollo.useMutation<ISubmitRegistrationInviteMutation, ISubmitRegistrationInviteMutationVariables>(SubmitRegistrationInviteDocument, baseOptions);
+      }
+export type SubmitRegistrationInviteMutationHookResult = ReturnType<typeof useSubmitRegistrationInviteMutation>;
+export type SubmitRegistrationInviteMutationResult = Apollo.MutationResult<ISubmitRegistrationInviteMutation>;
+export type SubmitRegistrationInviteMutationOptions = Apollo.BaseMutationOptions<ISubmitRegistrationInviteMutation, ISubmitRegistrationInviteMutationVariables>;
+export const SubmitUserFeedbackDocument = gql`
+    mutation SubmitUserFeedback($input: UserFeedbackInput!) {
+  submitUserFeedback(input: $input)
+}
+    `;
+export type ISubmitUserFeedbackMutationFn = Apollo.MutationFunction<ISubmitUserFeedbackMutation, ISubmitUserFeedbackMutationVariables>;
+
+/**
+ * __useSubmitUserFeedbackMutation__
+ *
+ * To run a mutation, you first call `useSubmitUserFeedbackMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSubmitUserFeedbackMutation` 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 [submitUserFeedbackMutation, { data, loading, error }] = useSubmitUserFeedbackMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useSubmitUserFeedbackMutation(baseOptions?: Apollo.MutationHookOptions<ISubmitUserFeedbackMutation, ISubmitUserFeedbackMutationVariables>) {
+        return Apollo.useMutation<ISubmitUserFeedbackMutation, ISubmitUserFeedbackMutationVariables>(SubmitUserFeedbackDocument, baseOptions);
+      }
+export type SubmitUserFeedbackMutationHookResult = ReturnType<typeof useSubmitUserFeedbackMutation>;
+export type SubmitUserFeedbackMutationResult = Apollo.MutationResult<ISubmitUserFeedbackMutation>;
+export type SubmitUserFeedbackMutationOptions = Apollo.BaseMutationOptions<ISubmitUserFeedbackMutation, ISubmitUserFeedbackMutationVariables>;