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;
}>>;
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.IContributionActionRun_input;
}>>;
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;
}>>;
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.IContextMenu_input;
}>>;
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;
}>>;
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;
}>>;
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;
}>>;
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.QueryTuple<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.QueryTuple<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.QueryTuple<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.IGalleryQuery;
}>>;
export declare function usegalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IgalleryQuery, SchemaTypes.IgalleryQueryVariables>): Apollo.QueryTuple<SchemaTypes.IgalleryQuery, SchemaTypes.Exact<{
    query?: SchemaTypes.IGalleryQuery;
}>>;
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.QueryTuple<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.QueryTuple<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.INotification_input;
}>>;
export declare function useshowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IshowNotificationQuery, SchemaTypes.IshowNotificationQueryVariables>): Apollo.QueryTuple<SchemaTypes.IshowNotificationQuery, SchemaTypes.Exact<{
    notification?: SchemaTypes.INotification_input;
}>>;
export declare type showNotificationQueryHookResult = ReturnType<typeof useshowNotificationQuery>;
export declare type showNotificationLazyQueryHookResult = ReturnType<typeof useshowNotificationLazyQuery>;
export declare type showNotificationQueryResult = Apollo.QueryResult<SchemaTypes.IshowNotificationQuery, SchemaTypes.IshowNotificationQueryVariables>;
