@ludo.ninja/api 3.2.17 → 3.2.19

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

@@ -25,6 +25,8 @@ export type Scalars = {
 
 
 
+
+
 export type IAuditBalanceCollection = {
   collection?: Maybe<Scalars['String']>;
   type?: Maybe<Scalars['String']>;
@@ -176,8 +178,11 @@ export type IMultiversxAudit = {
 export type IMutation = {
   setDummy: Scalars['String'];
   createNonce: Scalars['String'];
+  createAdminNonce: INonce;
   createTonNonce: Scalars['String'];
   createEvmNonce: Scalars['String'];
+  createMfaSecret: Scalars['String'];
+  verifyMfaSecret: Scalars['Boolean'];
   signInAdminMetamask: IIdentity;
   signInMetamask: IIdentity;
   signInTezos: IIdentity;
@@ -211,10 +216,23 @@ export type IMutationCreateNonceArgs = {
 };
 
 
+export type IMutationCreateAdminNonceArgs = {
+  address: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationVerifyMfaSecretArgs = {
+  mfaCode: Scalars['String'];
+};
+
+
 export type IMutationSignInAdminMetamaskArgs = {
   signature: Scalars['String'];
   address: Scalars['String'];
   chainId: Scalars['String'];
+  mfaCode?: Maybe<Scalars['String']>;
 };
 
 
@@ -391,6 +409,11 @@ export type IMyProfileV2 = {
   shareLink?: Maybe<Scalars['String']>;
 };
 
+export type INonce = {
+  nonce: Scalars['String'];
+  mfaEnabled: Scalars['Boolean'];
+};
+
 export type IProfile = {
   userId: Scalars['ID'];
   username?: Maybe<Scalars['String']>;
@@ -644,6 +667,7 @@ export type IResolversTypes = {
   MultiversxAudit: ResolverTypeWrapper<IMultiversxAudit>;
   Mutation: ResolverTypeWrapper<{}>;
   MyProfileV2: ResolverTypeWrapper<IMyProfileV2>;
+  Nonce: ResolverTypeWrapper<INonce>;
   Profile: ResolverTypeWrapper<IProfile>;
   Proof: IProof;
   Query: ResolverTypeWrapper<{}>;
@@ -682,6 +706,7 @@ export type IResolversParentTypes = {
   MultiversxAudit: IMultiversxAudit;
   Mutation: {};
   MyProfileV2: IMyProfileV2;
+  Nonce: INonce;
   Profile: IProfile;
   Proof: IProof;
   Query: {};
@@ -721,6 +746,17 @@ export type IConnectionDirectiveArgs = {
 
 export type IConnectionDirectiveResolver<Result, Parent, ContextType = any, Args = IConnectionDirectiveArgs> = 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>;
@@ -821,8 +857,11 @@ export type IMultiversxAuditResolvers<ContextType = any, ParentType extends IRes
 export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
   setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
   createNonce?: Resolver<IResolversTypes['String'], ParentType, ContextType, RequireFields<IMutationCreateNonceArgs, 'address' | 'blockchain'>>;
+  createAdminNonce?: Resolver<IResolversTypes['Nonce'], ParentType, ContextType, RequireFields<IMutationCreateAdminNonceArgs, 'address' | 'blockchain'>>;
   createTonNonce?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
   createEvmNonce?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  createMfaSecret?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  verifyMfaSecret?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationVerifyMfaSecretArgs, 'mfaCode'>>;
   signInAdminMetamask?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInAdminMetamaskArgs, 'signature' | 'address' | 'chainId'>>;
   signInMetamask?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInMetamaskArgs, 'signature' | 'address' | 'chainId'>>;
   signInTezos?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInTezosArgs, 'signature' | 'pubkey'>>;
@@ -880,6 +919,12 @@ export type IMyProfileV2Resolvers<ContextType = any, ParentType extends IResolve
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
+export type INonceResolvers<ContextType = any, ParentType extends IResolversParentTypes['Nonce'] = IResolversParentTypes['Nonce']> = {
+  nonce?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  mfaEnabled?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export type IProfileResolvers<ContextType = any, ParentType extends IResolversParentTypes['Profile'] = IResolversParentTypes['Profile']> = {
   userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
   username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -979,6 +1024,7 @@ export type IResolvers<ContextType = any> = {
   MultiversxAudit?: IMultiversxAuditResolvers<ContextType>;
   Mutation?: IMutationResolvers<ContextType>;
   MyProfileV2?: IMyProfileV2Resolvers<ContextType>;
+  Nonce?: INonceResolvers<ContextType>;
   Profile?: IProfileResolvers<ContextType>;
   Query?: IQueryResolvers<ContextType>;
   Social?: ISocialResolvers<ContextType>;
@@ -993,6 +1039,8 @@ export type IDirectiveResolvers<ContextType = any> = {
   Range?: IRangeDirectiveResolver<any, any, ContextType>;
   Size?: ISizeDirectiveResolver<any, any, ContextType>;
   connection?: IConnectionDirectiveResolver<any, any, ContextType>;
+  defer?: IDeferDirectiveResolver<any, any, ContextType>;
+  experimental_disableErrorPropagation?: IExperimental_DisableErrorPropagationDirectiveResolver<any, any, ContextType>;
   oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
 };
 
@@ -1057,11 +1105,25 @@ export type IAddWalletTonMutationVariables = Exact<{
 
 export type IAddWalletTonMutation = Pick<IMutation, 'addWalletTon'>;
 
+export type ICreateAdminNonceMutationVariables = Exact<{
+  address: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type ICreateAdminNonceMutation = { createAdminNonce: Pick<INonce, 'nonce' | 'mfaEnabled'> };
+
 export type ICreateEvmNonceMutationVariables = Exact<{ [key: string]: never; }>;
 
 
 export type ICreateEvmNonceMutation = Pick<IMutation, 'createEvmNonce'>;
 
+export type ICreateMfaSecretMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type ICreateMfaSecretMutation = Pick<IMutation, 'createMfaSecret'>;
+
 export type ICreateNonceMutationVariables = Exact<{
   address: Scalars['String'];
   blockchain: Scalars['String'];
@@ -1120,6 +1182,7 @@ export type ISignInAdminMetamaskMutationVariables = Exact<{
   signature: Scalars['String'];
   address: Scalars['String'];
   chainId: Scalars['String'];
+  mfaCode: Scalars['String'];
 }>;
 
 
@@ -1222,6 +1285,13 @@ export type IUpdateProfileMutationVariables = Exact<{
 
 export type IUpdateProfileMutation = Pick<IMutation, 'updateProfile'>;
 
+export type IVerifyMfaSecretMutationVariables = Exact<{
+  mfaCode: Scalars['String'];
+}>;
+
+
+export type IVerifyMfaSecretMutation = Pick<IMutation, 'verifyMfaSecret'>;
+
 export type IFetchAggregatedMultiversxAuditQueryVariables = Exact<{
   userId: Scalars['ID'];
 }>;
@@ -1528,6 +1598,41 @@ export function useAddWalletTonMutation(baseOptions?: Apollo.MutationHookOptions
 export type AddWalletTonMutationHookResult = ReturnType<typeof useAddWalletTonMutation>;
 export type AddWalletTonMutationResult = Apollo.MutationResult<IAddWalletTonMutation>;
 export type AddWalletTonMutationOptions = Apollo.BaseMutationOptions<IAddWalletTonMutation, IAddWalletTonMutationVariables>;
+export const CreateAdminNonceDocument = gql`
+    mutation CreateAdminNonce($address: String!, $blockchain: String!, $chainId: String) {
+  createAdminNonce(address: $address, blockchain: $blockchain, chainId: $chainId) {
+    nonce
+    mfaEnabled
+  }
+}
+    `;
+export type ICreateAdminNonceMutationFn = Apollo.MutationFunction<ICreateAdminNonceMutation, ICreateAdminNonceMutationVariables>;
+
+/**
+ * __useCreateAdminNonceMutation__
+ *
+ * To run a mutation, you first call `useCreateAdminNonceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateAdminNonceMutation` 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 [createAdminNonceMutation, { data, loading, error }] = useCreateAdminNonceMutation({
+ *   variables: {
+ *      address: // value for 'address'
+ *      blockchain: // value for 'blockchain'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useCreateAdminNonceMutation(baseOptions?: Apollo.MutationHookOptions<ICreateAdminNonceMutation, ICreateAdminNonceMutationVariables>) {
+        return Apollo.useMutation<ICreateAdminNonceMutation, ICreateAdminNonceMutationVariables>(CreateAdminNonceDocument, baseOptions);
+      }
+export type CreateAdminNonceMutationHookResult = ReturnType<typeof useCreateAdminNonceMutation>;
+export type CreateAdminNonceMutationResult = Apollo.MutationResult<ICreateAdminNonceMutation>;
+export type CreateAdminNonceMutationOptions = Apollo.BaseMutationOptions<ICreateAdminNonceMutation, ICreateAdminNonceMutationVariables>;
 export const CreateEvmNonceDocument = gql`
     mutation CreateEvmNonce {
   createEvmNonce
@@ -1557,6 +1662,35 @@ export function useCreateEvmNonceMutation(baseOptions?: Apollo.MutationHookOptio
 export type CreateEvmNonceMutationHookResult = ReturnType<typeof useCreateEvmNonceMutation>;
 export type CreateEvmNonceMutationResult = Apollo.MutationResult<ICreateEvmNonceMutation>;
 export type CreateEvmNonceMutationOptions = Apollo.BaseMutationOptions<ICreateEvmNonceMutation, ICreateEvmNonceMutationVariables>;
+export const CreateMfaSecretDocument = gql`
+    mutation CreateMfaSecret {
+  createMfaSecret
+}
+    `;
+export type ICreateMfaSecretMutationFn = Apollo.MutationFunction<ICreateMfaSecretMutation, ICreateMfaSecretMutationVariables>;
+
+/**
+ * __useCreateMfaSecretMutation__
+ *
+ * To run a mutation, you first call `useCreateMfaSecretMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateMfaSecretMutation` 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 [createMfaSecretMutation, { data, loading, error }] = useCreateMfaSecretMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useCreateMfaSecretMutation(baseOptions?: Apollo.MutationHookOptions<ICreateMfaSecretMutation, ICreateMfaSecretMutationVariables>) {
+        return Apollo.useMutation<ICreateMfaSecretMutation, ICreateMfaSecretMutationVariables>(CreateMfaSecretDocument, baseOptions);
+      }
+export type CreateMfaSecretMutationHookResult = ReturnType<typeof useCreateMfaSecretMutation>;
+export type CreateMfaSecretMutationResult = Apollo.MutationResult<ICreateMfaSecretMutation>;
+export type CreateMfaSecretMutationOptions = Apollo.BaseMutationOptions<ICreateMfaSecretMutation, ICreateMfaSecretMutationVariables>;
 export const CreateNonceDocument = gql`
     mutation CreateNonce($address: String!, $blockchain: String!, $chainId: String) {
   createNonce(address: $address, blockchain: $blockchain, chainId: $chainId)
@@ -1779,8 +1913,13 @@ export type SetMainWalletMutationHookResult = ReturnType<typeof useSetMainWallet
 export type SetMainWalletMutationResult = Apollo.MutationResult<ISetMainWalletMutation>;
 export type SetMainWalletMutationOptions = Apollo.BaseMutationOptions<ISetMainWalletMutation, ISetMainWalletMutationVariables>;
 export const SignInAdminMetamaskDocument = gql`
-    mutation SignInAdminMetamask($signature: String!, $address: String!, $chainId: String!) {
-  signInAdminMetamask(signature: $signature, address: $address, chainId: $chainId) {
+    mutation SignInAdminMetamask($signature: String!, $address: String!, $chainId: String!, $mfaCode: String!) {
+  signInAdminMetamask(
+    signature: $signature
+    address: $address
+    chainId: $chainId
+    mfaCode: $mfaCode
+  ) {
     userId
     wallets
     tokens {
@@ -1820,6 +1959,7 @@ export type ISignInAdminMetamaskMutationFn = Apollo.MutationFunction<ISignInAdmi
  *      signature: // value for 'signature'
  *      address: // value for 'address'
  *      chainId: // value for 'chainId'
+ *      mfaCode: // value for 'mfaCode'
  *   },
  * });
  */
@@ -2208,6 +2348,36 @@ export function useUpdateProfileMutation(baseOptions?: Apollo.MutationHookOption
 export type UpdateProfileMutationHookResult = ReturnType<typeof useUpdateProfileMutation>;
 export type UpdateProfileMutationResult = Apollo.MutationResult<IUpdateProfileMutation>;
 export type UpdateProfileMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+export const VerifyMfaSecretDocument = gql`
+    mutation VerifyMfaSecret($mfaCode: String!) {
+  verifyMfaSecret(mfaCode: $mfaCode)
+}
+    `;
+export type IVerifyMfaSecretMutationFn = Apollo.MutationFunction<IVerifyMfaSecretMutation, IVerifyMfaSecretMutationVariables>;
+
+/**
+ * __useVerifyMfaSecretMutation__
+ *
+ * To run a mutation, you first call `useVerifyMfaSecretMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useVerifyMfaSecretMutation` 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 [verifyMfaSecretMutation, { data, loading, error }] = useVerifyMfaSecretMutation({
+ *   variables: {
+ *      mfaCode: // value for 'mfaCode'
+ *   },
+ * });
+ */
+export function useVerifyMfaSecretMutation(baseOptions?: Apollo.MutationHookOptions<IVerifyMfaSecretMutation, IVerifyMfaSecretMutationVariables>) {
+        return Apollo.useMutation<IVerifyMfaSecretMutation, IVerifyMfaSecretMutationVariables>(VerifyMfaSecretDocument, baseOptions);
+      }
+export type VerifyMfaSecretMutationHookResult = ReturnType<typeof useVerifyMfaSecretMutation>;
+export type VerifyMfaSecretMutationResult = Apollo.MutationResult<IVerifyMfaSecretMutation>;
+export type VerifyMfaSecretMutationOptions = Apollo.BaseMutationOptions<IVerifyMfaSecretMutation, IVerifyMfaSecretMutationVariables>;
 export const FetchAggregatedMultiversxAuditDocument = gql`
     query FetchAggregatedMultiversxAudit($userId: ID!) {
   fetchAggregatedMultiversxAudit(userId: $userId) {

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

@@ -78,6 +78,11 @@ export type IHoldersGeolocation = {
   percentage: Scalars['Float'];
 };
 
+export enum ILinkType {
+  Twitter = 'TWITTER',
+  Website = 'WEBSITE'
+}
+
 
 export type ILudoRankDifference = {
   hourDifference?: Maybe<Scalars['Float']>;
@@ -125,6 +130,7 @@ export type IMutation = {
   activateMonitoring: Scalars['Boolean'];
   subscribeOnAlerts: Scalars['Boolean'];
   reconsiderProjectStatus: Scalars['Boolean'];
+  clickOnProjectLink: Scalars['Boolean'];
 };
 
 
@@ -236,6 +242,11 @@ export type IMutationReconsiderProjectStatusArgs = {
   input: IProjectReconsiderationInput;
 };
 
+
+export type IMutationClickOnProjectLinkArgs = {
+  input: IProjectLinkClickInput;
+};
+
 export type IOpportunitiesPage = {
   currentOpportunities?: Maybe<Array<Maybe<IOpportunity>>>;
   similarOpportunities?: Maybe<Array<Maybe<IOpportunity>>>;
@@ -397,6 +408,12 @@ export type IProjectCommunityVote = {
   dislikesRating?: Maybe<Scalars['Int']>;
 };
 
+export type IProjectLinkClickInput = {
+  blockchain: Scalars['String'];
+  contract: Scalars['String'];
+  linkType: ILinkType;
+};
+
 export type IProjectMonitoring = {
   userId: Scalars['String'];
   monitorsFree: Scalars['Int'];
@@ -642,6 +659,7 @@ export type IResolversTypes = {
   Int: ResolverTypeWrapper<Scalars['Int']>;
   HoldersGeolocation: ResolverTypeWrapper<IHoldersGeolocation>;
   Float: ResolverTypeWrapper<Scalars['Float']>;
+  LinkType: ILinkType;
   Long: ResolverTypeWrapper<Scalars['Long']>;
   LudoRankDifference: ResolverTypeWrapper<ILudoRankDifference>;
   Monitor: ResolverTypeWrapper<IMonitor>;
@@ -656,6 +674,7 @@ export type IResolversTypes = {
   ProfileOpportunities: ResolverTypeWrapper<IProfileOpportunities>;
   Project: ResolverTypeWrapper<IProject>;
   ProjectCommunityVote: ResolverTypeWrapper<IProjectCommunityVote>;
+  ProjectLinkClickInput: IProjectLinkClickInput;
   ProjectMonitoring: ResolverTypeWrapper<IProjectMonitoring>;
   ProjectReactionInput: IProjectReactionInput;
   ProjectReactions: ResolverTypeWrapper<IProjectReactions>;
@@ -699,6 +718,7 @@ export type IResolversParentTypes = {
   ProfileOpportunities: IProfileOpportunities;
   Project: IProject;
   ProjectCommunityVote: IProjectCommunityVote;
+  ProjectLinkClickInput: IProjectLinkClickInput;
   ProjectMonitoring: IProjectMonitoring;
   ProjectReactionInput: IProjectReactionInput;
   ProjectReactions: IProjectReactions;
@@ -809,6 +829,7 @@ export type IMutationResolvers<ContextType = any, ParentType extends IResolversP
   activateMonitoring?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationActivateMonitoringArgs, 'input'>>;
   subscribeOnAlerts?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSubscribeOnAlertsArgs, 'input'>>;
   reconsiderProjectStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationReconsiderProjectStatusArgs, 'input'>>;
+  clickOnProjectLink?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationClickOnProjectLinkArgs, 'input'>>;
 };
 
 export type IOpportunitiesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunitiesPage'] = IResolversParentTypes['OpportunitiesPage']> = {
@@ -1078,6 +1099,13 @@ export type IActivateMonitoringMutationVariables = Exact<{
 
 export type IActivateMonitoringMutation = Pick<IMutation, 'activateMonitoring'>;
 
+export type IClickOnProjectLinkMutationVariables = Exact<{
+  input: IProjectLinkClickInput;
+}>;
+
+
+export type IClickOnProjectLinkMutation = Pick<IMutation, 'clickOnProjectLink'>;
+
 export type ICopyOpportunityShareLinkMutationVariables = Exact<{
   opportunityId: Scalars['ID'];
 }>;
@@ -1330,6 +1358,36 @@ export function useActivateMonitoringMutation(baseOptions?: Apollo.MutationHookO
 export type ActivateMonitoringMutationHookResult = ReturnType<typeof useActivateMonitoringMutation>;
 export type ActivateMonitoringMutationResult = Apollo.MutationResult<IActivateMonitoringMutation>;
 export type ActivateMonitoringMutationOptions = Apollo.BaseMutationOptions<IActivateMonitoringMutation, IActivateMonitoringMutationVariables>;
+export const ClickOnProjectLinkDocument = gql`
+    mutation ClickOnProjectLink($input: ProjectLinkClickInput!) {
+  clickOnProjectLink(input: $input)
+}
+    `;
+export type IClickOnProjectLinkMutationFn = Apollo.MutationFunction<IClickOnProjectLinkMutation, IClickOnProjectLinkMutationVariables>;
+
+/**
+ * __useClickOnProjectLinkMutation__
+ *
+ * To run a mutation, you first call `useClickOnProjectLinkMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useClickOnProjectLinkMutation` 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 [clickOnProjectLinkMutation, { data, loading, error }] = useClickOnProjectLinkMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useClickOnProjectLinkMutation(baseOptions?: Apollo.MutationHookOptions<IClickOnProjectLinkMutation, IClickOnProjectLinkMutationVariables>) {
+        return Apollo.useMutation<IClickOnProjectLinkMutation, IClickOnProjectLinkMutationVariables>(ClickOnProjectLinkDocument, baseOptions);
+      }
+export type ClickOnProjectLinkMutationHookResult = ReturnType<typeof useClickOnProjectLinkMutation>;
+export type ClickOnProjectLinkMutationResult = Apollo.MutationResult<IClickOnProjectLinkMutation>;
+export type ClickOnProjectLinkMutationOptions = Apollo.BaseMutationOptions<IClickOnProjectLinkMutation, IClickOnProjectLinkMutationVariables>;
 export const CopyOpportunityShareLinkDocument = gql`
     mutation CopyOpportunityShareLink($opportunityId: ID!) {
   copyOpportunityShareLink(opportunityId: $opportunityId)