import * as SchemaTypes from '@adminide-stack/extension-api';
import { DocumentNode } from 'graphql';
import * as Apollo from '@apollo/client';
export declare const CopyDocument: DocumentNode;
/**
 * __useCopyMutation__
 *
 * To run a mutation, you first call `useCopyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCopyMutation` 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 [copyMutation, { data, loading, error }] = useCopyMutation({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export declare function useCopyMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ICopyMutation, SchemaTypes.ICopyMutationVariables>): Apollo.MutationTuple<SchemaTypes.ICopyMutation, SchemaTypes.Exact<{
    value?: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
export declare type CopyMutationResult = Apollo.MutationResult<SchemaTypes.ICopyMutation>;
export declare type CopyMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ICopyMutation, SchemaTypes.ICopyMutationVariables>;
export declare const RunMenuActionDocument: DocumentNode;
/**
 * __useRunMenuActionMutation__
 *
 * To run a mutation, you first call `useRunMenuActionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRunMenuActionMutation` 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 [runMenuActionMutation, { data, loading, error }] = useRunMenuActionMutation({
 *   variables: {
 *      argument: // value for 'argument'
 *   },
 * });
 */
export declare function useRunMenuActionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRunMenuActionMutation, SchemaTypes.IRunMenuActionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRunMenuActionMutation, SchemaTypes.Exact<{
    argument?: SchemaTypes.IContributionActionRunInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type RunMenuActionMutationHookResult = ReturnType<typeof useRunMenuActionMutation>;
export declare type RunMenuActionMutationResult = Apollo.MutationResult<SchemaTypes.IRunMenuActionMutation>;
export declare type RunMenuActionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRunMenuActionMutation, SchemaTypes.IRunMenuActionMutationVariables>;
export declare const HideContextMenuDocument: DocumentNode;
/**
 * __useHideContextMenuMutation__
 *
 * To run a mutation, you first call `useHideContextMenuMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideContextMenuMutation` 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 [hideContextMenuMutation, { data, loading, error }] = useHideContextMenuMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useHideContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHideContextMenuMutation, SchemaTypes.IHideContextMenuMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHideContextMenuMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type HideContextMenuMutationHookResult = ReturnType<typeof useHideContextMenuMutation>;
export declare type HideContextMenuMutationResult = Apollo.MutationResult<SchemaTypes.IHideContextMenuMutation>;
export declare type HideContextMenuMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHideContextMenuMutation, SchemaTypes.IHideContextMenuMutationVariables>;
export declare const ShowContextMenuDocument: DocumentNode;
/**
 * __useShowContextMenuMutation__
 *
 * To run a mutation, you first call `useShowContextMenuMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowContextMenuMutation` 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 [showContextMenuMutation, { data, loading, error }] = useShowContextMenuMutation({
 *   variables: {
 *      delegate: // value for 'delegate'
 *   },
 * });
 */
export declare function useShowContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IShowContextMenuMutation, SchemaTypes.IShowContextMenuMutationVariables>): Apollo.MutationTuple<SchemaTypes.IShowContextMenuMutation, SchemaTypes.Exact<{
    delegate?: SchemaTypes.IContextMenuInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type ShowContextMenuMutationHookResult = ReturnType<typeof useShowContextMenuMutation>;
export declare type ShowContextMenuMutationResult = Apollo.MutationResult<SchemaTypes.IShowContextMenuMutation>;
export declare type ShowContextMenuMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IShowContextMenuMutation, SchemaTypes.IShowContextMenuMutationVariables>;
export declare const InstallDocument: DocumentNode;
/**
 * __useInstallMutation__
 *
 * To run a mutation, you first call `useInstallMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useInstallMutation` 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 [installMutation, { data, loading, error }] = useInstallMutation({
 *   variables: {
 *      vsix: // value for 'vsix'
 *   },
 * });
 */
export declare function useInstallMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IInstallMutation, SchemaTypes.IInstallMutationVariables>): Apollo.MutationTuple<SchemaTypes.IInstallMutation, SchemaTypes.Exact<{
    vsix: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type InstallMutationHookResult = ReturnType<typeof useInstallMutation>;
export declare type InstallMutationResult = Apollo.MutationResult<SchemaTypes.IInstallMutation>;
export declare type InstallMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IInstallMutation, SchemaTypes.IInstallMutationVariables>;
export declare const ProviderDefinitionDocument: DocumentNode;
/**
 * __useProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useProviderDefinitionMutation` 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 [providerDefinitionMutation, { data, loading, error }] = useProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IProviderDefinitionMutation, SchemaTypes.IProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.ITextDocumentPositionParamsInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type ProviderDefinitionMutationHookResult = ReturnType<typeof useProviderDefinitionMutation>;
export declare type ProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IProviderDefinitionMutation>;
export declare type ProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IProviderDefinitionMutation, SchemaTypes.IProviderDefinitionMutationVariables>;
export declare const RemoveDocument: DocumentNode;
/**
 * __useRemoveMutation__
 *
 * To run a mutation, you first call `useRemoveMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveMutation` 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 [removeMutation, { data, loading, error }] = useRemoveMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useRemoveMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRemoveMutation, SchemaTypes.IRemoveMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRemoveMutation, SchemaTypes.Exact<{
    id: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type RemoveMutationHookResult = ReturnType<typeof useRemoveMutation>;
export declare type RemoveMutationResult = Apollo.MutationResult<SchemaTypes.IRemoveMutation>;
export declare type RemoveMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRemoveMutation, SchemaTypes.IRemoveMutationVariables>;
export declare const ContextMenuDocument: DocumentNode;
/**
 * __useContextMenuQuery__
 *
 * To run a query within a React component, call `useContextMenuQuery` and pass it any options that fit your needs.
 * When your component renders, `useContextMenuQuery` 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 } = useContextMenuQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useContextMenuQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IContextMenuQuery, SchemaTypes.IContextMenuQueryVariables>): Apollo.QueryResult<SchemaTypes.IContextMenuQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IContextMenuQuery, SchemaTypes.IContextMenuQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IContextMenuQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare type ContextMenuQueryHookResult = ReturnType<typeof useContextMenuQuery>;
export declare type ContextMenuLazyQueryHookResult = ReturnType<typeof useContextMenuLazyQuery>;
export declare type ContextMenuQueryResult = Apollo.QueryResult<SchemaTypes.IContextMenuQuery, SchemaTypes.IContextMenuQueryVariables>;
export declare const GalleryExtensionDocument: DocumentNode;
/**
 * __useGalleryExtensionQuery__
 *
 * To run a query within a React component, call `useGalleryExtensionQuery` and pass it any options that fit your needs.
 * When your component renders, `useGalleryExtensionQuery` 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 } = useGalleryExtensionQuery({
 *   variables: {
 *      extensionID: // value for 'extensionID'
 *   },
 * });
 */
export declare function useGalleryExtensionQuery(baseOptions: Apollo.QueryHookOptions<SchemaTypes.IGalleryExtensionQuery, SchemaTypes.IGalleryExtensionQueryVariables>): Apollo.QueryResult<SchemaTypes.IGalleryExtensionQuery, SchemaTypes.Exact<{
    extensionID: string;
}>>;
export declare function useGalleryExtensionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGalleryExtensionQuery, SchemaTypes.IGalleryExtensionQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGalleryExtensionQuery, SchemaTypes.Exact<{
    extensionID: string;
}>>;
export declare type GalleryExtensionQueryHookResult = ReturnType<typeof useGalleryExtensionQuery>;
export declare type GalleryExtensionLazyQueryHookResult = ReturnType<typeof useGalleryExtensionLazyQuery>;
export declare type GalleryExtensionQueryResult = Apollo.QueryResult<SchemaTypes.IGalleryExtensionQuery, SchemaTypes.IGalleryExtensionQueryVariables>;
export declare const ExtensionsByLimitDocument: DocumentNode;
/**
 * __useExtensionsByLimitQuery__
 *
 * To run a query within a React component, call `useExtensionsByLimitQuery` and pass it any options that fit your needs.
 * When your component renders, `useExtensionsByLimitQuery` 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 } = useExtensionsByLimitQuery({
 *   variables: {
 *      first: // value for 'first'
 *      prioritizeExtensionIDs: // value for 'prioritizeExtensionIDs'
 *   },
 * });
 */
export declare function useExtensionsByLimitQuery(baseOptions: Apollo.QueryHookOptions<SchemaTypes.IExtensionsByLimitQuery, SchemaTypes.IExtensionsByLimitQueryVariables>): Apollo.QueryResult<SchemaTypes.IExtensionsByLimitQuery, SchemaTypes.Exact<{
    first: number;
    prioritizeExtensionIDs: string | string[];
}>>;
export declare function useExtensionsByLimitLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IExtensionsByLimitQuery, SchemaTypes.IExtensionsByLimitQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IExtensionsByLimitQuery, SchemaTypes.Exact<{
    first: number;
    prioritizeExtensionIDs: string | string[];
}>>;
export declare type ExtensionsByLimitQueryHookResult = ReturnType<typeof useExtensionsByLimitQuery>;
export declare type ExtensionsByLimitLazyQueryHookResult = ReturnType<typeof useExtensionsByLimitLazyQuery>;
export declare type ExtensionsByLimitQueryResult = Apollo.QueryResult<SchemaTypes.IExtensionsByLimitQuery, SchemaTypes.IExtensionsByLimitQueryVariables>;
export declare const GalleryDocument: DocumentNode;
/**
 * __useGalleryQuery__
 *
 * To run a query within a React component, call `useGalleryQuery` and pass it any options that fit your needs.
 * When your component renders, `useGalleryQuery` 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 } = useGalleryQuery({
 *   variables: {
 *      query: // value for 'query'
 *   },
 * });
 */
export declare function useGalleryQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGalleryQuery, SchemaTypes.IGalleryQueryVariables>): Apollo.QueryResult<SchemaTypes.IGalleryQuery, SchemaTypes.Exact<{
    query?: SchemaTypes.IGalleryQueryInput;
}>>;
export declare function useGalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGalleryQuery, SchemaTypes.IGalleryQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGalleryQuery, SchemaTypes.Exact<{
    query?: SchemaTypes.IGalleryQueryInput;
}>>;
export declare type GalleryQueryHookResult = ReturnType<typeof useGalleryQuery>;
export declare type GalleryLazyQueryHookResult = ReturnType<typeof useGalleryLazyQuery>;
export declare type GalleryQueryResult = Apollo.QueryResult<SchemaTypes.IGalleryQuery, SchemaTypes.IGalleryQueryVariables>;
export declare const InstalledExtensionsDocument: DocumentNode;
/**
 * __useInstalledExtensionsQuery__
 *
 * To run a query within a React component, call `useInstalledExtensionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useInstalledExtensionsQuery` 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 } = useInstalledExtensionsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useInstalledExtensionsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IInstalledExtensionsQuery, SchemaTypes.IInstalledExtensionsQueryVariables>): Apollo.QueryResult<SchemaTypes.IInstalledExtensionsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useInstalledExtensionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IInstalledExtensionsQuery, SchemaTypes.IInstalledExtensionsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IInstalledExtensionsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare type InstalledExtensionsQueryHookResult = ReturnType<typeof useInstalledExtensionsQuery>;
export declare type InstalledExtensionsLazyQueryHookResult = ReturnType<typeof useInstalledExtensionsLazyQuery>;
export declare type InstalledExtensionsQueryResult = Apollo.QueryResult<SchemaTypes.IInstalledExtensionsQuery, SchemaTypes.IInstalledExtensionsQueryVariables>;
export declare const NotificationsDocument: DocumentNode;
/**
 * __useNotificationsQuery__
 *
 * To run a query within a React component, call `useNotificationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useNotificationsQuery` 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 } = useNotificationsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useNotificationsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.INotificationsQuery, SchemaTypes.INotificationsQueryVariables>): Apollo.QueryResult<SchemaTypes.INotificationsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.INotificationsQuery, SchemaTypes.INotificationsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.INotificationsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare type NotificationsQueryHookResult = ReturnType<typeof useNotificationsQuery>;
export declare type NotificationsLazyQueryHookResult = ReturnType<typeof useNotificationsLazyQuery>;
export declare type NotificationsQueryResult = Apollo.QueryResult<SchemaTypes.INotificationsQuery, SchemaTypes.INotificationsQueryVariables>;
export declare const ShowNotificationDocument: DocumentNode;
/**
 * __useShowNotificationQuery__
 *
 * To run a query within a React component, call `useShowNotificationQuery` and pass it any options that fit your needs.
 * When your component renders, `useShowNotificationQuery` 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 } = useShowNotificationQuery({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export declare function useShowNotificationQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IShowNotificationQuery, SchemaTypes.IShowNotificationQueryVariables>): Apollo.QueryResult<SchemaTypes.IShowNotificationQuery, SchemaTypes.Exact<{
    notification?: SchemaTypes.INotificationInput;
}>>;
export declare function useShowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IShowNotificationQuery, SchemaTypes.IShowNotificationQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IShowNotificationQuery, SchemaTypes.Exact<{
    notification?: SchemaTypes.INotificationInput;
}>>;
export declare type ShowNotificationQueryHookResult = ReturnType<typeof useShowNotificationQuery>;
export declare type ShowNotificationLazyQueryHookResult = ReturnType<typeof useShowNotificationLazyQuery>;
export declare type ShowNotificationQueryResult = Apollo.QueryResult<SchemaTypes.IShowNotificationQuery, SchemaTypes.IShowNotificationQueryVariables>;
