import * as SchemaTypes from '@workbench-stack/core';
import { DocumentNode } from 'graphql';
import * as Apollo from '@apollo/client/index.js';
export declare const DefaultSettingFragmentDoc: DocumentNode;
export declare const SettingRangeFragmentDoc: DocumentNode;
export declare const TerminalConfigurationFragmentDoc: DocumentNode;
export declare const SearchConfigurationFragmentDoc: DocumentNode;
export declare const LanguagesConfigurationFragmentDoc: DocumentNode;
export declare const FilesConfigurationFragmentDoc: DocumentNode;
export declare const GitConfigurationFragmentDoc: DocumentNode;
export declare const WorkspaceConfigurationFragmentDoc: DocumentNode;
export declare const ViewerSettingsFragmentDoc: DocumentNode;
export declare const AllContextFragmentDoc: DocumentNode;
export declare const FinalConfigurationFragmentDoc: DocumentNode;
export declare const KeybindingItemFragmentDoc: DocumentNode;
export declare const KeybindingsFragmentDoc: DocumentNode;
export declare const PickItemFragmentDoc: DocumentNode;
export declare const SelectedFragmentDoc: DocumentNode;
export declare const ResourceContextFragmentDoc: DocumentNode;
export declare const StatusbarItemFragmentDoc: DocumentNode;
export declare const GetConfigurationDataFragmentDoc: DocumentNode;
export declare const INotificationMessageFragmentDoc: DocumentNode;
export declare const NotificationMessageFragmentDoc: DocumentNode;
export declare const NotifyActionFragmentDoc: DocumentNode;
export declare const NotificationFragmentDoc: DocumentNode;
export declare const WorkspaceFolderFragmentDoc: DocumentNode;
export declare const GetConfigurationTargetDocument: DocumentNode;
/**
 * __useGetConfigurationTargetMutation__
 *
 * To run a mutation, you first call `useGetConfigurationTargetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGetConfigurationTargetMutation` 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 [getConfigurationTargetMutation, { data, loading, error }] = useGetConfigurationTargetMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *   },
 * });
 */
export declare function useGetConfigurationTargetMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IGetConfigurationTargetMutation, SchemaTypes.IGetConfigurationTargetMutationVariables>): Apollo.MutationTuple<SchemaTypes.IGetConfigurationTargetMutation, SchemaTypes.Exact<{
    resource?: SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type GetConfigurationTargetMutationHookResult = ReturnType<typeof useGetConfigurationTargetMutation>;
export type GetConfigurationTargetMutationResult = Apollo.MutationResult<SchemaTypes.IGetConfigurationTargetMutation>;
export type GetConfigurationTargetMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IGetConfigurationTargetMutation, SchemaTypes.IGetConfigurationTargetMutationVariables>;
export declare const OpenGlobalKeybindingsSettingsDocument: DocumentNode;
/**
 * __useOpenGlobalKeybindingsSettingsMutation__
 *
 * To run a mutation, you first call `useOpenGlobalKeybindingsSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenGlobalKeybindingsSettingsMutation` 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 [openGlobalKeybindingsSettingsMutation, { data, loading, error }] = useOpenGlobalKeybindingsSettingsMutation({
 *   variables: {
 *      textual: // value for 'textual'
 *   },
 * });
 */
export declare function useOpenGlobalKeybindingsSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenGlobalKeybindingsSettingsMutation, SchemaTypes.IOpenGlobalKeybindingsSettingsMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenGlobalKeybindingsSettingsMutation, SchemaTypes.Exact<{
    textual?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenGlobalKeybindingsSettingsMutationHookResult = ReturnType<typeof useOpenGlobalKeybindingsSettingsMutation>;
export type OpenGlobalKeybindingsSettingsMutationResult = Apollo.MutationResult<SchemaTypes.IOpenGlobalKeybindingsSettingsMutation>;
export type OpenGlobalKeybindingsSettingsMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenGlobalKeybindingsSettingsMutation, SchemaTypes.IOpenGlobalKeybindingsSettingsMutationVariables>;
export declare const OpenPreferenceSettingsDocument: DocumentNode;
/**
 * __useOpenPreferenceSettingsMutation__
 *
 * To run a mutation, you first call `useOpenPreferenceSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenPreferenceSettingsMutation` 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 [openPreferenceSettingsMutation, { data, loading, error }] = useOpenPreferenceSettingsMutation({
 *   variables: {
 *      jsonEditor: // value for 'jsonEditor'
 *      query: // value for 'query'
 *   },
 * });
 */
export declare function useOpenPreferenceSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenPreferenceSettingsMutation, SchemaTypes.IOpenPreferenceSettingsMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenPreferenceSettingsMutation, SchemaTypes.Exact<{
    jsonEditor?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
    query?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenPreferenceSettingsMutationHookResult = ReturnType<typeof useOpenPreferenceSettingsMutation>;
export type OpenPreferenceSettingsMutationResult = Apollo.MutationResult<SchemaTypes.IOpenPreferenceSettingsMutation>;
export type OpenPreferenceSettingsMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenPreferenceSettingsMutation, SchemaTypes.IOpenPreferenceSettingsMutationVariables>;
export declare const ResetSettingDocument: DocumentNode;
/**
 * __useResetSettingMutation__
 *
 * To run a mutation, you first call `useResetSettingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResetSettingMutation` 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 [resetSettingMutation, { data, loading, error }] = useResetSettingMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *      settingKey: // value for 'settingKey'
 *   },
 * });
 */
export declare function useResetSettingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IResetSettingMutation, SchemaTypes.IResetSettingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IResetSettingMutation, SchemaTypes.Exact<{
    resource?: SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>;
    settingKey?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ResetSettingMutationHookResult = ReturnType<typeof useResetSettingMutation>;
export type ResetSettingMutationResult = Apollo.MutationResult<SchemaTypes.IResetSettingMutation>;
export type ResetSettingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IResetSettingMutation, SchemaTypes.IResetSettingMutationVariables>;
export declare const SaveUserSettingsDocument: DocumentNode;
/**
 * __useSaveUserSettingsMutation__
 *
 * To run a mutation, you first call `useSaveUserSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSaveUserSettingsMutation` 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 [saveUserSettingsMutation, { data, loading, error }] = useSaveUserSettingsMutation({
 *   variables: {
 *      content: // value for 'content'
 *   },
 * });
 */
export declare function useSaveUserSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISaveUserSettingsMutation, SchemaTypes.ISaveUserSettingsMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISaveUserSettingsMutation, SchemaTypes.Exact<{
    content?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SaveUserSettingsMutationHookResult = ReturnType<typeof useSaveUserSettingsMutation>;
export type SaveUserSettingsMutationResult = Apollo.MutationResult<SchemaTypes.ISaveUserSettingsMutation>;
export type SaveUserSettingsMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISaveUserSettingsMutation, SchemaTypes.ISaveUserSettingsMutationVariables>;
export declare const SaveWorkspaceSettingsDocument: DocumentNode;
/**
 * __useSaveWorkspaceSettingsMutation__
 *
 * To run a mutation, you first call `useSaveWorkspaceSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSaveWorkspaceSettingsMutation` 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 [saveWorkspaceSettingsMutation, { data, loading, error }] = useSaveWorkspaceSettingsMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useSaveWorkspaceSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISaveWorkspaceSettingsMutation, SchemaTypes.ISaveWorkspaceSettingsMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISaveWorkspaceSettingsMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SaveWorkspaceSettingsMutationHookResult = ReturnType<typeof useSaveWorkspaceSettingsMutation>;
export type SaveWorkspaceSettingsMutationResult = Apollo.MutationResult<SchemaTypes.ISaveWorkspaceSettingsMutation>;
export type SaveWorkspaceSettingsMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISaveWorkspaceSettingsMutation, SchemaTypes.ISaveWorkspaceSettingsMutationVariables>;
export declare const SwitchSettingsDocument: DocumentNode;
/**
 * __useSwitchSettingsMutation__
 *
 * To run a mutation, you first call `useSwitchSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSwitchSettingsMutation` 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 [switchSettingsMutation, { data, loading, error }] = useSwitchSettingsMutation({
 *   variables: {
 *      target: // value for 'target'
 *      editorId: // value for 'editorId'
 *      resource: // value for 'resource'
 *      jsonEditor: // value for 'jsonEditor'
 *   },
 * });
 */
export declare function useSwitchSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISwitchSettingsMutation, SchemaTypes.ISwitchSettingsMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISwitchSettingsMutation, SchemaTypes.Exact<{
    target?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
    editorId?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
    resource?: SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>;
    jsonEditor?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SwitchSettingsMutationHookResult = ReturnType<typeof useSwitchSettingsMutation>;
export type SwitchSettingsMutationResult = Apollo.MutationResult<SchemaTypes.ISwitchSettingsMutation>;
export type SwitchSettingsMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISwitchSettingsMutation, SchemaTypes.ISwitchSettingsMutationVariables>;
export declare const DefaultPreferencesDocument: DocumentNode;
/**
 * __useDefaultPreferencesQuery__
 *
 * To run a query within a React component, call `useDefaultPreferencesQuery` and pass it any options that fit your needs.
 * When your component renders, `useDefaultPreferencesQuery` 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 } = useDefaultPreferencesQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useDefaultPreferencesQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IDefaultPreferencesQuery, SchemaTypes.IDefaultPreferencesQueryVariables>): Apollo.QueryResult<SchemaTypes.IDefaultPreferencesQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useDefaultPreferencesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IDefaultPreferencesQuery, SchemaTypes.IDefaultPreferencesQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IDefaultPreferencesQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type DefaultPreferencesQueryHookResult = ReturnType<typeof useDefaultPreferencesQuery>;
export type DefaultPreferencesLazyQueryHookResult = ReturnType<typeof useDefaultPreferencesLazyQuery>;
export type DefaultPreferencesQueryResult = Apollo.QueryResult<SchemaTypes.IDefaultPreferencesQuery, SchemaTypes.IDefaultPreferencesQueryVariables>;
export declare const DefaultSettingsDocument: DocumentNode;
/**
 * __useDefaultSettingsQuery__
 *
 * To run a query within a React component, call `useDefaultSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useDefaultSettingsQuery` 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 } = useDefaultSettingsQuery({
 *   variables: {
 *      target: // value for 'target'
 *   },
 * });
 */
export declare function useDefaultSettingsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IDefaultSettingsQuery, SchemaTypes.IDefaultSettingsQueryVariables>): Apollo.QueryResult<SchemaTypes.IDefaultSettingsQuery, SchemaTypes.Exact<{
    target?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>>;
export declare function useDefaultSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IDefaultSettingsQuery, SchemaTypes.IDefaultSettingsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IDefaultSettingsQuery, SchemaTypes.Exact<{
    target?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>>;
export type DefaultSettingsQueryHookResult = ReturnType<typeof useDefaultSettingsQuery>;
export type DefaultSettingsLazyQueryHookResult = ReturnType<typeof useDefaultSettingsLazyQuery>;
export type DefaultSettingsQueryResult = Apollo.QueryResult<SchemaTypes.IDefaultSettingsQuery, SchemaTypes.IDefaultSettingsQueryVariables>;
export declare const FullConfigurationDocument: DocumentNode;
/**
 * __useFullConfigurationQuery__
 *
 * To run a query within a React component, call `useFullConfigurationQuery` and pass it any options that fit your needs.
 * When your component renders, `useFullConfigurationQuery` 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 } = useFullConfigurationQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useFullConfigurationQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IFullConfigurationQuery, SchemaTypes.IFullConfigurationQueryVariables>): Apollo.QueryResult<SchemaTypes.IFullConfigurationQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useFullConfigurationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IFullConfigurationQuery, SchemaTypes.IFullConfigurationQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IFullConfigurationQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type FullConfigurationQueryHookResult = ReturnType<typeof useFullConfigurationQuery>;
export type FullConfigurationLazyQueryHookResult = ReturnType<typeof useFullConfigurationLazyQuery>;
export type FullConfigurationQueryResult = Apollo.QueryResult<SchemaTypes.IFullConfigurationQuery, SchemaTypes.IFullConfigurationQueryVariables>;
export declare const GetMostCommonlyUsedSettingsDocument: DocumentNode;
/**
 * __useGetMostCommonlyUsedSettingsQuery__
 *
 * To run a query within a React component, call `useGetMostCommonlyUsedSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMostCommonlyUsedSettingsQuery` 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 } = useGetMostCommonlyUsedSettingsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetMostCommonlyUsedSettingsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetMostCommonlyUsedSettingsQuery, SchemaTypes.IGetMostCommonlyUsedSettingsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetMostCommonlyUsedSettingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetMostCommonlyUsedSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetMostCommonlyUsedSettingsQuery, SchemaTypes.IGetMostCommonlyUsedSettingsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetMostCommonlyUsedSettingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetMostCommonlyUsedSettingsQueryHookResult = ReturnType<typeof useGetMostCommonlyUsedSettingsQuery>;
export type GetMostCommonlyUsedSettingsLazyQueryHookResult = ReturnType<typeof useGetMostCommonlyUsedSettingsLazyQuery>;
export type GetMostCommonlyUsedSettingsQueryResult = Apollo.QueryResult<SchemaTypes.IGetMostCommonlyUsedSettingsQuery, SchemaTypes.IGetMostCommonlyUsedSettingsQueryVariables>;
export declare const WorkspacesDocument: DocumentNode;
/**
 * __useWorkspacesQuery__
 *
 * To run a query within a React component, call `useWorkspacesQuery` and pass it any options that fit your needs.
 * When your component renders, `useWorkspacesQuery` 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 } = useWorkspacesQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useWorkspacesQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IWorkspacesQuery, SchemaTypes.IWorkspacesQueryVariables>): Apollo.QueryResult<SchemaTypes.IWorkspacesQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useWorkspacesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IWorkspacesQuery, SchemaTypes.IWorkspacesQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IWorkspacesQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type WorkspacesQueryHookResult = ReturnType<typeof useWorkspacesQuery>;
export type WorkspacesLazyQueryHookResult = ReturnType<typeof useWorkspacesLazyQuery>;
export type WorkspacesQueryResult = Apollo.QueryResult<SchemaTypes.IWorkspacesQuery, SchemaTypes.IWorkspacesQueryVariables>;
export declare const UpdateConfigurationValueDocument: DocumentNode;
/**
 * __useUpdateConfigurationValueMutation__
 *
 * To run a mutation, you first call `useUpdateConfigurationValueMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateConfigurationValueMutation` 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 [updateConfigurationValueMutation, { data, loading, error }] = useUpdateConfigurationValueMutation({
 *   variables: {
 *      key: // value for 'key'
 *      value: // value for 'value'
 *      overrides: // value for 'overrides'
 *      target: // value for 'target'
 *      donotNotifyError: // value for 'donotNotifyError'
 *   },
 * });
 */
export declare function useUpdateConfigurationValueMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateConfigurationValueMutation, SchemaTypes.IUpdateConfigurationValueMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateConfigurationValueMutation, SchemaTypes.Exact<{
    key: SchemaTypes.Scalars["String"];
    value: SchemaTypes.Scalars["AnyObject"];
    overrides: SchemaTypes.IConfigurationOverrides_Input;
    target?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
    donotNotifyError?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateConfigurationValueMutationHookResult = ReturnType<typeof useUpdateConfigurationValueMutation>;
export type UpdateConfigurationValueMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateConfigurationValueMutation>;
export type UpdateConfigurationValueMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateConfigurationValueMutation, SchemaTypes.IUpdateConfigurationValueMutationVariables>;
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?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
export type CopyMutationResult = Apollo.MutationResult<SchemaTypes.ICopyMutation>;
export 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.Maybe<SchemaTypes.IActionRunInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RunMenuActionMutationHookResult = ReturnType<typeof useRunMenuActionMutation>;
export type RunMenuActionMutationResult = Apollo.MutationResult<SchemaTypes.IRunMenuActionMutation>;
export 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 type HideContextMenuMutationHookResult = ReturnType<typeof useHideContextMenuMutation>;
export type HideContextMenuMutationResult = Apollo.MutationResult<SchemaTypes.IHideContextMenuMutation>;
export 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.Maybe<SchemaTypes.IContextMenuInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ShowContextMenuMutationHookResult = ReturnType<typeof useShowContextMenuMutation>;
export type ShowContextMenuMutationResult = Apollo.MutationResult<SchemaTypes.IShowContextMenuMutation>;
export type ShowContextMenuMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IShowContextMenuMutation, SchemaTypes.IShowContextMenuMutationVariables>;
export declare const CloseDialogDocument: DocumentNode;
/**
 * __useCloseDialogMutation__
 *
 * To run a mutation, you first call `useCloseDialogMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCloseDialogMutation` 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 [closeDialogMutation, { data, loading, error }] = useCloseDialogMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useCloseDialogMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ICloseDialogMutation, SchemaTypes.ICloseDialogMutationVariables>): Apollo.MutationTuple<SchemaTypes.ICloseDialogMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CloseDialogMutationHookResult = ReturnType<typeof useCloseDialogMutation>;
export type CloseDialogMutationResult = Apollo.MutationResult<SchemaTypes.ICloseDialogMutation>;
export type CloseDialogMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ICloseDialogMutation, SchemaTypes.ICloseDialogMutationVariables>;
export declare const ShowDocument: DocumentNode;
/**
 * __useShowMutation__
 *
 * To run a mutation, you first call `useShowMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowMutation` 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 [showMutation, { data, loading, error }] = useShowMutation({
 *   variables: {
 *      dialog: // value for 'dialog'
 *   },
 * });
 */
export declare function useShowMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IShowMutation, SchemaTypes.IShowMutationVariables>): Apollo.MutationTuple<SchemaTypes.IShowMutation, SchemaTypes.Exact<{
    dialog?: SchemaTypes.Maybe<SchemaTypes.IDialogInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ShowMutationHookResult = ReturnType<typeof useShowMutation>;
export type ShowMutationResult = Apollo.MutationResult<SchemaTypes.IShowMutation>;
export type ShowMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IShowMutation, SchemaTypes.IShowMutationVariables>;
export declare const OpenEditorResourceInputDocument: DocumentNode;
/**
 * __useOpenEditorResourceInputMutation__
 *
 * To run a mutation, you first call `useOpenEditorResourceInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorResourceInputMutation` 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 [openEditorResourceInputMutation, { data, loading, error }] = useOpenEditorResourceInputMutation({
 *   variables: {
 *      editor: // value for 'editor'
 *      group: // value for 'group'
 *   },
 * });
 */
export declare function useOpenEditorResourceInputMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenEditorResourceInputMutation, SchemaTypes.IOpenEditorResourceInputMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenEditorResourceInputMutation, SchemaTypes.Exact<{
    editor: SchemaTypes.IResource_Input;
    group?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenEditorResourceInputMutationHookResult = ReturnType<typeof useOpenEditorResourceInputMutation>;
export type OpenEditorResourceInputMutationResult = Apollo.MutationResult<SchemaTypes.IOpenEditorResourceInputMutation>;
export type OpenEditorResourceInputMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenEditorResourceInputMutation, SchemaTypes.IOpenEditorResourceInputMutationVariables>;
export declare const OpenEditorDocument: DocumentNode;
/**
 * __useOpenEditorMutation__
 *
 * To run a mutation, you first call `useOpenEditorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorMutation` 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 [openEditorMutation, { data, loading, error }] = useOpenEditorMutation({
 *   variables: {
 *      content: // value for 'content'
 *      options: // value for 'options'
 *   },
 * });
 */
export declare function useOpenEditorMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenEditorMutation, SchemaTypes.IOpenEditorMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenEditorMutation, SchemaTypes.Exact<{
    content: SchemaTypes.IOpenEditor_Input;
    options?: SchemaTypes.Maybe<SchemaTypes.IEditorOpenOptions_Input>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenEditorMutationHookResult = ReturnType<typeof useOpenEditorMutation>;
export type OpenEditorMutationResult = Apollo.MutationResult<SchemaTypes.IOpenEditorMutation>;
export type OpenEditorMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenEditorMutation, SchemaTypes.IOpenEditorMutationVariables>;
export declare const GoToLineDocument: DocumentNode;
/**
 * __useGoToLineMutation__
 *
 * To run a mutation, you first call `useGoToLineMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGoToLineMutation` 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 [goToLineMutation, { data, loading, error }] = useGoToLineMutation({
 *   variables: {
 *      range: // value for 'range'
 *   },
 * });
 */
export declare function useGoToLineMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IGoToLineMutation, SchemaTypes.IGoToLineMutationVariables>): Apollo.MutationTuple<SchemaTypes.IGoToLineMutation, SchemaTypes.Exact<{
    range?: SchemaTypes.Maybe<SchemaTypes.ILineRangeInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type GoToLineMutationHookResult = ReturnType<typeof useGoToLineMutation>;
export type GoToLineMutationResult = Apollo.MutationResult<SchemaTypes.IGoToLineMutation>;
export type GoToLineMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IGoToLineMutation, SchemaTypes.IGoToLineMutationVariables>;
export declare const HighlightLineDocument: DocumentNode;
/**
 * __useHighlightLineMutation__
 *
 * To run a mutation, you first call `useHighlightLineMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHighlightLineMutation` 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 [highlightLineMutation, { data, loading, error }] = useHighlightLineMutation({
 *   variables: {
 *      range: // value for 'range'
 *   },
 * });
 */
export declare function useHighlightLineMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHighlightLineMutation, SchemaTypes.IHighlightLineMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHighlightLineMutation, SchemaTypes.Exact<{
    range?: SchemaTypes.Maybe<SchemaTypes.ILineRangeInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type HighlightLineMutationHookResult = ReturnType<typeof useHighlightLineMutation>;
export type HighlightLineMutationResult = Apollo.MutationResult<SchemaTypes.IHighlightLineMutation>;
export type HighlightLineMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHighlightLineMutation, SchemaTypes.IHighlightLineMutationVariables>;
export declare const JsonEditingWriteDocument: DocumentNode;
/**
 * __useJsonEditingWriteMutation__
 *
 * To run a mutation, you first call `useJsonEditingWriteMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useJsonEditingWriteMutation` 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 [jsonEditingWriteMutation, { data, loading, error }] = useJsonEditingWriteMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *      value: // value for 'value'
 *      save: // value for 'save'
 *   },
 * });
 */
export declare function useJsonEditingWriteMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IJsonEditingWriteMutation, SchemaTypes.IJsonEditingWriteMutationVariables>): Apollo.MutationTuple<SchemaTypes.IJsonEditingWriteMutation, SchemaTypes.Exact<{
    resource?: SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>;
    value?: SchemaTypes.Maybe<SchemaTypes.IIjsonValueInput>;
    save?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type JsonEditingWriteMutationHookResult = ReturnType<typeof useJsonEditingWriteMutation>;
export type JsonEditingWriteMutationResult = Apollo.MutationResult<SchemaTypes.IJsonEditingWriteMutation>;
export type JsonEditingWriteMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IJsonEditingWriteMutation, SchemaTypes.IJsonEditingWriteMutationVariables>;
export declare const ChangeKeybindingDocument: DocumentNode;
/**
 * __useChangeKeybindingMutation__
 *
 * To run a mutation, you first call `useChangeKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeKeybindingMutation` 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 [changeKeybindingMutation, { data, loading, error }] = useChangeKeybindingMutation({
 *   variables: {
 *      editItem: // value for 'editItem'
 *      selectedIndex: // value for 'selectedIndex'
 *      isOpenDialog: // value for 'isOpenDialog'
 *   },
 * });
 */
export declare function useChangeKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IChangeKeybindingMutation, SchemaTypes.IChangeKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IChangeKeybindingMutation, SchemaTypes.Exact<{
    editItem?: SchemaTypes.Maybe<SchemaTypes.IKeybindingItemInput>;
    selectedIndex?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
    isOpenDialog?: SchemaTypes.Maybe<SchemaTypes.Scalars["Boolean"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ChangeKeybindingMutationHookResult = ReturnType<typeof useChangeKeybindingMutation>;
export type ChangeKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.IChangeKeybindingMutation>;
export type ChangeKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IChangeKeybindingMutation, SchemaTypes.IChangeKeybindingMutationVariables>;
export declare const ChangeWhenExpressionDocument: DocumentNode;
/**
 * __useChangeWhenExpressionMutation__
 *
 * To run a mutation, you first call `useChangeWhenExpressionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeWhenExpressionMutation` 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 [changeWhenExpressionMutation, { data, loading, error }] = useChangeWhenExpressionMutation({
 *   variables: {
 *      editItem: // value for 'editItem'
 *      editWhenIndex: // value for 'editWhenIndex'
 *      newWhen: // value for 'newWhen'
 *   },
 * });
 */
export declare function useChangeWhenExpressionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IChangeWhenExpressionMutation, SchemaTypes.IChangeWhenExpressionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IChangeWhenExpressionMutation, SchemaTypes.Exact<{
    editItem?: SchemaTypes.Maybe<SchemaTypes.IKeybindingItemInput>;
    editWhenIndex?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
    newWhen?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ChangeWhenExpressionMutationHookResult = ReturnType<typeof useChangeWhenExpressionMutation>;
export type ChangeWhenExpressionMutationResult = Apollo.MutationResult<SchemaTypes.IChangeWhenExpressionMutation>;
export type ChangeWhenExpressionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IChangeWhenExpressionMutation, SchemaTypes.IChangeWhenExpressionMutationVariables>;
export declare const EditKeybindingDocument: DocumentNode;
/**
 * __useEditKeybindingMutation__
 *
 * To run a mutation, you first call `useEditKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditKeybindingMutation` 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 [editKeybindingMutation, { data, loading, error }] = useEditKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *      key: // value for 'key'
 *      when: // value for 'when'
 *   },
 * });
 */
export declare function useEditKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IEditKeybindingMutation, SchemaTypes.IEditKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IEditKeybindingMutation, SchemaTypes.Exact<{
    keybindingItem?: SchemaTypes.Maybe<SchemaTypes.IKeybindingItemInput>;
    key?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
    when?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type EditKeybindingMutationHookResult = ReturnType<typeof useEditKeybindingMutation>;
export type EditKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.IEditKeybindingMutation>;
export type EditKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IEditKeybindingMutation, SchemaTypes.IEditKeybindingMutationVariables>;
export declare const HideKeybindingDialogDocument: DocumentNode;
/**
 * __useHideKeybindingDialogMutation__
 *
 * To run a mutation, you first call `useHideKeybindingDialogMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideKeybindingDialogMutation` 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 [hideKeybindingDialogMutation, { data, loading, error }] = useHideKeybindingDialogMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useHideKeybindingDialogMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHideKeybindingDialogMutation, SchemaTypes.IHideKeybindingDialogMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHideKeybindingDialogMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type HideKeybindingDialogMutationHookResult = ReturnType<typeof useHideKeybindingDialogMutation>;
export type HideKeybindingDialogMutationResult = Apollo.MutationResult<SchemaTypes.IHideKeybindingDialogMutation>;
export type HideKeybindingDialogMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHideKeybindingDialogMutation, SchemaTypes.IHideKeybindingDialogMutationVariables>;
export declare const LookupKeybindingDocument: DocumentNode;
/**
 * __useLookupKeybindingMutation__
 *
 * To run a mutation, you first call `useLookupKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useLookupKeybindingMutation` 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 [lookupKeybindingMutation, { data, loading, error }] = useLookupKeybindingMutation({
 *   variables: {
 *      commandId: // value for 'commandId'
 *   },
 * });
 */
export declare function useLookupKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ILookupKeybindingMutation, SchemaTypes.ILookupKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.ILookupKeybindingMutation, SchemaTypes.Exact<{
    commandId?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type LookupKeybindingMutationHookResult = ReturnType<typeof useLookupKeybindingMutation>;
export type LookupKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.ILookupKeybindingMutation>;
export type LookupKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ILookupKeybindingMutation, SchemaTypes.ILookupKeybindingMutationVariables>;
export declare const RegisterKeybindingDocument: DocumentNode;
/**
 * __useRegisterKeybindingMutation__
 *
 * To run a mutation, you first call `useRegisterKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRegisterKeybindingMutation` 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 [registerKeybindingMutation, { data, loading, error }] = useRegisterKeybindingMutation({
 *   variables: {
 *      keybinding: // value for 'keybinding'
 *   },
 * });
 */
export declare function useRegisterKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRegisterKeybindingMutation, SchemaTypes.IRegisterKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRegisterKeybindingMutation, SchemaTypes.Exact<{
    keybinding?: SchemaTypes.Maybe<SchemaTypes.IKeybindingInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RegisterKeybindingMutationHookResult = ReturnType<typeof useRegisterKeybindingMutation>;
export type RegisterKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.IRegisterKeybindingMutation>;
export type RegisterKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRegisterKeybindingMutation, SchemaTypes.IRegisterKeybindingMutationVariables>;
export declare const RemoveKeybindingDocument: DocumentNode;
/**
 * __useRemoveKeybindingMutation__
 *
 * To run a mutation, you first call `useRemoveKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveKeybindingMutation` 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 [removeKeybindingMutation, { data, loading, error }] = useRemoveKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *   },
 * });
 */
export declare function useRemoveKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRemoveKeybindingMutation, SchemaTypes.IRemoveKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRemoveKeybindingMutation, SchemaTypes.Exact<{
    keybindingItem?: SchemaTypes.Maybe<SchemaTypes.IKeybindingItemInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RemoveKeybindingMutationHookResult = ReturnType<typeof useRemoveKeybindingMutation>;
export type RemoveKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.IRemoveKeybindingMutation>;
export type RemoveKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRemoveKeybindingMutation, SchemaTypes.IRemoveKeybindingMutationVariables>;
export declare const ResetKeybindingDocument: DocumentNode;
/**
 * __useResetKeybindingMutation__
 *
 * To run a mutation, you first call `useResetKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResetKeybindingMutation` 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 [resetKeybindingMutation, { data, loading, error }] = useResetKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *   },
 * });
 */
export declare function useResetKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IResetKeybindingMutation, SchemaTypes.IResetKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.IResetKeybindingMutation, SchemaTypes.Exact<{
    keybindingItem?: SchemaTypes.Maybe<SchemaTypes.IKeybindingItemInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ResetKeybindingMutationHookResult = ReturnType<typeof useResetKeybindingMutation>;
export type ResetKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.IResetKeybindingMutation>;
export type ResetKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IResetKeybindingMutation, SchemaTypes.IResetKeybindingMutationVariables>;
export declare const ResolveKeyboardEventDocument: DocumentNode;
/**
 * __useResolveKeyboardEventMutation__
 *
 * To run a mutation, you first call `useResolveKeyboardEventMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResolveKeyboardEventMutation` 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 [resolveKeyboardEventMutation, { data, loading, error }] = useResolveKeyboardEventMutation({
 *   variables: {
 *      keyboardEvent: // value for 'keyboardEvent'
 *   },
 * });
 */
export declare function useResolveKeyboardEventMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IResolveKeyboardEventMutation, SchemaTypes.IResolveKeyboardEventMutationVariables>): Apollo.MutationTuple<SchemaTypes.IResolveKeyboardEventMutation, SchemaTypes.Exact<{
    keyboardEvent?: SchemaTypes.Maybe<SchemaTypes.IKeyboardEventInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ResolveKeyboardEventMutationHookResult = ReturnType<typeof useResolveKeyboardEventMutation>;
export type ResolveKeyboardEventMutationResult = Apollo.MutationResult<SchemaTypes.IResolveKeyboardEventMutation>;
export type ResolveKeyboardEventMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IResolveKeyboardEventMutation, SchemaTypes.IResolveKeyboardEventMutationVariables>;
export declare const SearchKeybindingDocument: DocumentNode;
/**
 * __useSearchKeybindingMutation__
 *
 * To run a mutation, you first call `useSearchKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSearchKeybindingMutation` 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 [searchKeybindingMutation, { data, loading, error }] = useSearchKeybindingMutation({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export declare function useSearchKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISearchKeybindingMutation, SchemaTypes.ISearchKeybindingMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISearchKeybindingMutation, SchemaTypes.Exact<{
    value?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SearchKeybindingMutationHookResult = ReturnType<typeof useSearchKeybindingMutation>;
export type SearchKeybindingMutationResult = Apollo.MutationResult<SchemaTypes.ISearchKeybindingMutation>;
export type SearchKeybindingMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISearchKeybindingMutation, SchemaTypes.ISearchKeybindingMutationVariables>;
export declare const SetSelectedKeybindingIndexDocument: DocumentNode;
/**
 * __useSetSelectedKeybindingIndexMutation__
 *
 * To run a mutation, you first call `useSetSelectedKeybindingIndexMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetSelectedKeybindingIndexMutation` 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 [setSelectedKeybindingIndexMutation, { data, loading, error }] = useSetSelectedKeybindingIndexMutation({
 *   variables: {
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useSetSelectedKeybindingIndexMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISetSelectedKeybindingIndexMutation, SchemaTypes.ISetSelectedKeybindingIndexMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISetSelectedKeybindingIndexMutation, SchemaTypes.Exact<{
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SetSelectedKeybindingIndexMutationHookResult = ReturnType<typeof useSetSelectedKeybindingIndexMutation>;
export type SetSelectedKeybindingIndexMutationResult = Apollo.MutationResult<SchemaTypes.ISetSelectedKeybindingIndexMutation>;
export type SetSelectedKeybindingIndexMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISetSelectedKeybindingIndexMutation, SchemaTypes.ISetSelectedKeybindingIndexMutationVariables>;
export declare const StopEditWhenExpressionDocument: DocumentNode;
/**
 * __useStopEditWhenExpressionMutation__
 *
 * To run a mutation, you first call `useStopEditWhenExpressionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStopEditWhenExpressionMutation` 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 [stopEditWhenExpressionMutation, { data, loading, error }] = useStopEditWhenExpressionMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useStopEditWhenExpressionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IStopEditWhenExpressionMutation, SchemaTypes.IStopEditWhenExpressionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IStopEditWhenExpressionMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type StopEditWhenExpressionMutationHookResult = ReturnType<typeof useStopEditWhenExpressionMutation>;
export type StopEditWhenExpressionMutationResult = Apollo.MutationResult<SchemaTypes.IStopEditWhenExpressionMutation>;
export type StopEditWhenExpressionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IStopEditWhenExpressionMutation, SchemaTypes.IStopEditWhenExpressionMutationVariables>;
export declare const AddNotificationDocument: DocumentNode;
/**
 * __useAddNotificationMutation__
 *
 * To run a mutation, you first call `useAddNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddNotificationMutation` 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 [addNotificationMutation, { data, loading, error }] = useAddNotificationMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export declare function useAddNotificationMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IAddNotificationMutation, SchemaTypes.IAddNotificationMutationVariables>): Apollo.MutationTuple<SchemaTypes.IAddNotificationMutation, SchemaTypes.Exact<{
    notification?: SchemaTypes.Maybe<SchemaTypes.INotificationInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type AddNotificationMutationHookResult = ReturnType<typeof useAddNotificationMutation>;
export type AddNotificationMutationResult = Apollo.MutationResult<SchemaTypes.IAddNotificationMutation>;
export type AddNotificationMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IAddNotificationMutation, SchemaTypes.IAddNotificationMutationVariables>;
export declare const CloseNotificationDocument: DocumentNode;
/**
 * __useCloseNotificationMutation__
 *
 * To run a mutation, you first call `useCloseNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCloseNotificationMutation` 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 [closeNotificationMutation, { data, loading, error }] = useCloseNotificationMutation({
 *   variables: {
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useCloseNotificationMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ICloseNotificationMutation, SchemaTypes.ICloseNotificationMutationVariables>): Apollo.MutationTuple<SchemaTypes.ICloseNotificationMutation, SchemaTypes.Exact<{
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CloseNotificationMutationHookResult = ReturnType<typeof useCloseNotificationMutation>;
export type CloseNotificationMutationResult = Apollo.MutationResult<SchemaTypes.ICloseNotificationMutation>;
export type CloseNotificationMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ICloseNotificationMutation, SchemaTypes.ICloseNotificationMutationVariables>;
export declare const HandlerDocument: DocumentNode;
/**
 * __useHandlerMutation__
 *
 * To run a mutation, you first call `useHandlerMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHandlerMutation` 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 [handlerMutation, { data, loading, error }] = useHandlerMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export declare function useHandlerMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHandlerMutation, SchemaTypes.IHandlerMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHandlerMutation, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.IActionRunInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type HandlerMutationHookResult = ReturnType<typeof useHandlerMutation>;
export type HandlerMutationResult = Apollo.MutationResult<SchemaTypes.IHandlerMutation>;
export type HandlerMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHandlerMutation, SchemaTypes.IHandlerMutationVariables>;
export declare const OpenEditorFileDocument: DocumentNode;
/**
 * __useOpenEditorFileMutation__
 *
 * To run a mutation, you first call `useOpenEditorFileMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorFileMutation` 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 [openEditorFileMutation, { data, loading, error }] = useOpenEditorFileMutation({
 *   variables: {
 *      content: // value for 'content'
 *      options: // value for 'options'
 *   },
 * });
 */
export declare function useOpenEditorFileMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenEditorFileMutation, SchemaTypes.IOpenEditorFileMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenEditorFileMutation, SchemaTypes.Exact<{
    content: SchemaTypes.IOpenEditor_Input;
    options?: SchemaTypes.Maybe<SchemaTypes.IEditorOpenOptions_Input>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenEditorFileMutationHookResult = ReturnType<typeof useOpenEditorFileMutation>;
export type OpenEditorFileMutationResult = Apollo.MutationResult<SchemaTypes.IOpenEditorFileMutation>;
export type OpenEditorFileMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenEditorFileMutation, SchemaTypes.IOpenEditorFileMutationVariables>;
export declare const HideInputModelDocument: DocumentNode;
/**
 * __useHideInputModelMutation__
 *
 * To run a mutation, you first call `useHideInputModelMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideInputModelMutation` 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 [hideInputModelMutation, { data, loading, error }] = useHideInputModelMutation({
 *   variables: {
 *   },
 * });
 */
export declare function useHideInputModelMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHideInputModelMutation, SchemaTypes.IHideInputModelMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHideInputModelMutation, SchemaTypes.Exact<{
    [key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type HideInputModelMutationHookResult = ReturnType<typeof useHideInputModelMutation>;
export type HideInputModelMutationResult = Apollo.MutationResult<SchemaTypes.IHideInputModelMutation>;
export type HideInputModelMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHideInputModelMutation, SchemaTypes.IHideInputModelMutationVariables>;
export declare const SetSelectedDocument: DocumentNode;
/**
 * __useSetSelectedMutation__
 *
 * To run a mutation, you first call `useSetSelectedMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetSelectedMutation` 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 [setSelectedMutation, { data, loading, error }] = useSetSelectedMutation({
 *   variables: {
 *      selectedValue: // value for 'selectedValue'
 *      inputValue: // value for 'inputValue'
 *   },
 * });
 */
export declare function useSetSelectedMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISetSelectedMutation, SchemaTypes.ISetSelectedMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISetSelectedMutation, SchemaTypes.Exact<{
    selectedValue?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IPickItem>> | SchemaTypes.Maybe<SchemaTypes.IPickItem>>;
    inputValue?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SetSelectedMutationHookResult = ReturnType<typeof useSetSelectedMutation>;
export type SetSelectedMutationResult = Apollo.MutationResult<SchemaTypes.ISetSelectedMutation>;
export type SetSelectedMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISetSelectedMutation, SchemaTypes.ISetSelectedMutationVariables>;
export declare const ShowInputDocument: DocumentNode;
/**
 * __useShowInputMutation__
 *
 * To run a mutation, you first call `useShowInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowInputMutation` 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 [showInputMutation, { data, loading, error }] = useShowInputMutation({
 *   variables: {
 *      options: // value for 'options'
 *   },
 * });
 */
export declare function useShowInputMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IShowInputMutation, SchemaTypes.IShowInputMutationVariables>): Apollo.MutationTuple<SchemaTypes.IShowInputMutation, SchemaTypes.Exact<{
    options?: SchemaTypes.Maybe<SchemaTypes.IInputOptions>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ShowInputMutationHookResult = ReturnType<typeof useShowInputMutation>;
export type ShowInputMutationResult = Apollo.MutationResult<SchemaTypes.IShowInputMutation>;
export type ShowInputMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IShowInputMutation, SchemaTypes.IShowInputMutationVariables>;
export declare const ShowPickInputDocument: DocumentNode;
/**
 * __useShowPickInputMutation__
 *
 * To run a mutation, you first call `useShowPickInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowPickInputMutation` 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 [showPickInputMutation, { data, loading, error }] = useShowPickInputMutation({
 *   variables: {
 *      items: // value for 'items'
 *      options: // value for 'options'
 *   },
 * });
 */
export declare function useShowPickInputMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IShowPickInputMutation, SchemaTypes.IShowPickInputMutationVariables>): Apollo.MutationTuple<SchemaTypes.IShowPickInputMutation, SchemaTypes.Exact<{
    items?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IPickItem>> | SchemaTypes.Maybe<SchemaTypes.IPickItem>>;
    options?: SchemaTypes.Maybe<SchemaTypes.IPickInputOptions>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ShowPickInputMutationHookResult = ReturnType<typeof useShowPickInputMutation>;
export type ShowPickInputMutationResult = Apollo.MutationResult<SchemaTypes.IShowPickInputMutation>;
export type ShowPickInputMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IShowPickInputMutation, SchemaTypes.IShowPickInputMutationVariables>;
export declare const AddEntryDocument: DocumentNode;
/**
 * __useAddEntryMutation__
 *
 * To run a mutation, you first call `useAddEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddEntryMutation` 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 [addEntryMutation, { data, loading, error }] = useAddEntryMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export declare function useAddEntryMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IAddEntryMutation, SchemaTypes.IAddEntryMutationVariables>): Apollo.MutationTuple<SchemaTypes.IAddEntryMutation, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.IAddEntryInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type AddEntryMutationHookResult = ReturnType<typeof useAddEntryMutation>;
export type AddEntryMutationResult = Apollo.MutationResult<SchemaTypes.IAddEntryMutation>;
export type AddEntryMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IAddEntryMutation, SchemaTypes.IAddEntryMutationVariables>;
export declare const RemoveStatusbarEntryDocument: DocumentNode;
/**
 * __useRemoveStatusbarEntryMutation__
 *
 * To run a mutation, you first call `useRemoveStatusbarEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveStatusbarEntryMutation` 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 [removeStatusbarEntryMutation, { data, loading, error }] = useRemoveStatusbarEntryMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useRemoveStatusbarEntryMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRemoveStatusbarEntryMutation, SchemaTypes.IRemoveStatusbarEntryMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRemoveStatusbarEntryMutation, SchemaTypes.Exact<{
    id: SchemaTypes.Scalars["ID"];
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RemoveStatusbarEntryMutationHookResult = ReturnType<typeof useRemoveStatusbarEntryMutation>;
export type RemoveStatusbarEntryMutationResult = Apollo.MutationResult<SchemaTypes.IRemoveStatusbarEntryMutation>;
export type RemoveStatusbarEntryMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRemoveStatusbarEntryMutation, SchemaTypes.IRemoveStatusbarEntryMutationVariables>;
export declare const SetStatusMessageDocument: DocumentNode;
/**
 * __useSetStatusMessageMutation__
 *
 * To run a mutation, you first call `useSetStatusMessageMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetStatusMessageMutation` 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 [setStatusMessageMutation, { data, loading, error }] = useSetStatusMessageMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export declare function useSetStatusMessageMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ISetStatusMessageMutation, SchemaTypes.ISetStatusMessageMutationVariables>): Apollo.MutationTuple<SchemaTypes.ISetStatusMessageMutation, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.ISetStatusMsgInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SetStatusMessageMutationHookResult = ReturnType<typeof useSetStatusMessageMutation>;
export type SetStatusMessageMutationResult = Apollo.MutationResult<SchemaTypes.ISetStatusMessageMutation>;
export type SetStatusMessageMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ISetStatusMessageMutation, SchemaTypes.ISetStatusMessageMutationVariables>;
export declare const UpdateStatusbarEntryDocument: DocumentNode;
/**
 * __useUpdateStatusbarEntryMutation__
 *
 * To run a mutation, you first call `useUpdateStatusbarEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateStatusbarEntryMutation` 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 [updateStatusbarEntryMutation, { data, loading, error }] = useUpdateStatusbarEntryMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export declare function useUpdateStatusbarEntryMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateStatusbarEntryMutation, SchemaTypes.IUpdateStatusbarEntryMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateStatusbarEntryMutation, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.IUpdateEntryInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateStatusbarEntryMutationHookResult = ReturnType<typeof useUpdateStatusbarEntryMutation>;
export type UpdateStatusbarEntryMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateStatusbarEntryMutation>;
export type UpdateStatusbarEntryMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateStatusbarEntryMutation, SchemaTypes.IUpdateStatusbarEntryMutationVariables>;
export declare const AddFoldersDocument: DocumentNode;
/**
 * __useAddFoldersMutation__
 *
 * To run a mutation, you first call `useAddFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddFoldersMutation` 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 [addFoldersMutation, { data, loading, error }] = useAddFoldersMutation({
 *   variables: {
 *      folders: // value for 'folders'
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useAddFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IAddFoldersMutation, SchemaTypes.IAddFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IAddFoldersMutation, SchemaTypes.Exact<{
    folders?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IFolderInput>> | SchemaTypes.Maybe<SchemaTypes.IFolderInput>>;
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type AddFoldersMutationHookResult = ReturnType<typeof useAddFoldersMutation>;
export type AddFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IAddFoldersMutation>;
export type AddFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IAddFoldersMutation, SchemaTypes.IAddFoldersMutationVariables>;
export declare const ChangeWorkspaceDocument: DocumentNode;
/**
 * __useChangeWorkspaceMutation__
 *
 * To run a mutation, you first call `useChangeWorkspaceMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeWorkspaceMutation` 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 [changeWorkspaceMutation, { data, loading, error }] = useChangeWorkspaceMutation({
 *   variables: {
 *      args: // value for 'args'
 *   },
 * });
 */
export declare function useChangeWorkspaceMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IChangeWorkspaceMutation, SchemaTypes.IChangeWorkspaceMutationVariables>): Apollo.MutationTuple<SchemaTypes.IChangeWorkspaceMutation, SchemaTypes.Exact<{
    args?: SchemaTypes.Maybe<SchemaTypes.IArgsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ChangeWorkspaceMutationHookResult = ReturnType<typeof useChangeWorkspaceMutation>;
export type ChangeWorkspaceMutationResult = Apollo.MutationResult<SchemaTypes.IChangeWorkspaceMutation>;
export type ChangeWorkspaceMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IChangeWorkspaceMutation, SchemaTypes.IChangeWorkspaceMutationVariables>;
export declare const RemoveFoldersDocument: DocumentNode;
/**
 * __useRemoveFoldersMutation__
 *
 * To run a mutation, you first call `useRemoveFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveFoldersMutation` 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 [removeFoldersMutation, { data, loading, error }] = useRemoveFoldersMutation({
 *   variables: {
 *      folders: // value for 'folders'
 *   },
 * });
 */
export declare function useRemoveFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRemoveFoldersMutation, SchemaTypes.IRemoveFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRemoveFoldersMutation, SchemaTypes.Exact<{
    folders?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>> | SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RemoveFoldersMutationHookResult = ReturnType<typeof useRemoveFoldersMutation>;
export type RemoveFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IRemoveFoldersMutation>;
export type RemoveFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRemoveFoldersMutation, SchemaTypes.IRemoveFoldersMutationVariables>;
export declare const UpdateFoldersDocument: DocumentNode;
/**
 * __useUpdateFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateFoldersMutation` 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 [updateFoldersMutation, { data, loading, error }] = useUpdateFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      foldersToRemove: // value for 'foldersToRemove'
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useUpdateFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateFoldersMutation, SchemaTypes.IUpdateFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateFoldersMutation, SchemaTypes.Exact<{
    foldersToAdd?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IFolderInput>> | SchemaTypes.Maybe<SchemaTypes.IFolderInput>>;
    foldersToRemove?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>> | SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>>;
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateFoldersMutationHookResult = ReturnType<typeof useUpdateFoldersMutation>;
export type UpdateFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateFoldersMutation>;
export type UpdateFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateFoldersMutation, SchemaTypes.IUpdateFoldersMutationVariables>;
export declare const FinalConfiguration_WsDocument: DocumentNode;
/**
 * __useFinalConfiguration_WsQuery__
 *
 * To run a query within a React component, call `useFinalConfiguration_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFinalConfiguration_WsQuery` 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 } = useFinalConfiguration_WsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useFinalConfiguration_WsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IFinalConfiguration_WsQuery, SchemaTypes.IFinalConfiguration_WsQueryVariables>): Apollo.QueryResult<SchemaTypes.IFinalConfiguration_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useFinalConfiguration_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IFinalConfiguration_WsQuery, SchemaTypes.IFinalConfiguration_WsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IFinalConfiguration_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type FinalConfiguration_WsQueryHookResult = ReturnType<typeof useFinalConfiguration_WsQuery>;
export type FinalConfiguration_WsLazyQueryHookResult = ReturnType<typeof useFinalConfiguration_WsLazyQuery>;
export type FinalConfiguration_WsQueryResult = Apollo.QueryResult<SchemaTypes.IFinalConfiguration_WsQuery, SchemaTypes.IFinalConfiguration_WsQueryVariables>;
export declare const GetContextDocument: DocumentNode;
/**
 * __useGetContextQuery__
 *
 * To run a query within a React component, call `useGetContextQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetContextQuery` 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 } = useGetContextQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetContextQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetContextQuery, SchemaTypes.IGetContextQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetContextQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetContextLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetContextQuery, SchemaTypes.IGetContextQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetContextQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetContextQueryHookResult = ReturnType<typeof useGetContextQuery>;
export type GetContextLazyQueryHookResult = ReturnType<typeof useGetContextLazyQuery>;
export type GetContextQueryResult = Apollo.QueryResult<SchemaTypes.IGetContextQuery, SchemaTypes.IGetContextQueryVariables>;
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 type ContextMenuQueryHookResult = ReturnType<typeof useContextMenuQuery>;
export type ContextMenuLazyQueryHookResult = ReturnType<typeof useContextMenuLazyQuery>;
export type ContextMenuQueryResult = Apollo.QueryResult<SchemaTypes.IContextMenuQuery, SchemaTypes.IContextMenuQueryVariables>;
export declare const DialogDocument: DocumentNode;
/**
 * __useDialogQuery__
 *
 * To run a query within a React component, call `useDialogQuery` and pass it any options that fit your needs.
 * When your component renders, `useDialogQuery` 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 } = useDialogQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useDialogQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IDialogQuery, SchemaTypes.IDialogQueryVariables>): Apollo.QueryResult<SchemaTypes.IDialogQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useDialogLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IDialogQuery, SchemaTypes.IDialogQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IDialogQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type DialogQueryHookResult = ReturnType<typeof useDialogQuery>;
export type DialogLazyQueryHookResult = ReturnType<typeof useDialogLazyQuery>;
export type DialogQueryResult = Apollo.QueryResult<SchemaTypes.IDialogQuery, SchemaTypes.IDialogQueryVariables>;
export declare const ShowDialogDocument: DocumentNode;
/**
 * __useShowDialogQuery__
 *
 * To run a query within a React component, call `useShowDialogQuery` and pass it any options that fit your needs.
 * When your component renders, `useShowDialogQuery` 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 } = useShowDialogQuery({
 *   variables: {
 *      dialog: // value for 'dialog'
 *   },
 * });
 */
export declare function useShowDialogQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IShowDialogQuery, SchemaTypes.IShowDialogQueryVariables>): Apollo.QueryResult<SchemaTypes.IShowDialogQuery, SchemaTypes.Exact<{
    dialog?: SchemaTypes.Maybe<SchemaTypes.IDialogInput>;
}>>;
export declare function useShowDialogLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IShowDialogQuery, SchemaTypes.IShowDialogQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IShowDialogQuery, SchemaTypes.Exact<{
    dialog?: SchemaTypes.Maybe<SchemaTypes.IDialogInput>;
}>>;
export type ShowDialogQueryHookResult = ReturnType<typeof useShowDialogQuery>;
export type ShowDialogLazyQueryHookResult = ReturnType<typeof useShowDialogLazyQuery>;
export type ShowDialogQueryResult = Apollo.QueryResult<SchemaTypes.IShowDialogQuery, SchemaTypes.IShowDialogQueryVariables>;
export declare const GoToLineQuickAccessDocument: DocumentNode;
/**
 * __useGoToLineQuickAccessQuery__
 *
 * To run a query within a React component, call `useGoToLineQuickAccessQuery` and pass it any options that fit your needs.
 * When your component renders, `useGoToLineQuickAccessQuery` 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 } = useGoToLineQuickAccessQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGoToLineQuickAccessQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGoToLineQuickAccessQuery, SchemaTypes.IGoToLineQuickAccessQueryVariables>): Apollo.QueryResult<SchemaTypes.IGoToLineQuickAccessQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGoToLineQuickAccessLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGoToLineQuickAccessQuery, SchemaTypes.IGoToLineQuickAccessQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGoToLineQuickAccessQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GoToLineQuickAccessQueryHookResult = ReturnType<typeof useGoToLineQuickAccessQuery>;
export type GoToLineQuickAccessLazyQueryHookResult = ReturnType<typeof useGoToLineQuickAccessLazyQuery>;
export type GoToLineQuickAccessQueryResult = Apollo.QueryResult<SchemaTypes.IGoToLineQuickAccessQuery, SchemaTypes.IGoToLineQuickAccessQueryVariables>;
export declare const GetKeybindingsDocument: DocumentNode;
/**
 * __useGetKeybindingsQuery__
 *
 * To run a query within a React component, call `useGetKeybindingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetKeybindingsQuery` 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 } = useGetKeybindingsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetKeybindingsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetKeybindingsQuery, SchemaTypes.IGetKeybindingsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetKeybindingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetKeybindingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetKeybindingsQuery, SchemaTypes.IGetKeybindingsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetKeybindingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetKeybindingsQueryHookResult = ReturnType<typeof useGetKeybindingsQuery>;
export type GetKeybindingsLazyQueryHookResult = ReturnType<typeof useGetKeybindingsLazyQuery>;
export type GetKeybindingsQueryResult = Apollo.QueryResult<SchemaTypes.IGetKeybindingsQuery, SchemaTypes.IGetKeybindingsQueryVariables>;
export declare const KeybindingContextMenuDocument: DocumentNode;
/**
 * __useKeybindingContextMenuQuery__
 *
 * To run a query within a React component, call `useKeybindingContextMenuQuery` and pass it any options that fit your needs.
 * When your component renders, `useKeybindingContextMenuQuery` 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 } = useKeybindingContextMenuQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useKeybindingContextMenuQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IKeybindingContextMenuQuery, SchemaTypes.IKeybindingContextMenuQueryVariables>): Apollo.QueryResult<SchemaTypes.IKeybindingContextMenuQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useKeybindingContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IKeybindingContextMenuQuery, SchemaTypes.IKeybindingContextMenuQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IKeybindingContextMenuQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type KeybindingContextMenuQueryHookResult = ReturnType<typeof useKeybindingContextMenuQuery>;
export type KeybindingContextMenuLazyQueryHookResult = ReturnType<typeof useKeybindingContextMenuLazyQuery>;
export type KeybindingContextMenuQueryResult = Apollo.QueryResult<SchemaTypes.IKeybindingContextMenuQuery, SchemaTypes.IKeybindingContextMenuQueryVariables>;
export declare const KeybindingsDocument: DocumentNode;
/**
 * __useKeybindingsQuery__
 *
 * To run a query within a React component, call `useKeybindingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useKeybindingsQuery` 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 } = useKeybindingsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useKeybindingsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IKeybindingsQuery, SchemaTypes.IKeybindingsQueryVariables>): Apollo.QueryResult<SchemaTypes.IKeybindingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useKeybindingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IKeybindingsQuery, SchemaTypes.IKeybindingsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IKeybindingsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type KeybindingsQueryHookResult = ReturnType<typeof useKeybindingsQuery>;
export type KeybindingsLazyQueryHookResult = ReturnType<typeof useKeybindingsLazyQuery>;
export type KeybindingsQueryResult = Apollo.QueryResult<SchemaTypes.IKeybindingsQuery, SchemaTypes.IKeybindingsQueryVariables>;
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 type NotificationsQueryHookResult = ReturnType<typeof useNotificationsQuery>;
export type NotificationsLazyQueryHookResult = ReturnType<typeof useNotificationsLazyQuery>;
export 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.Maybe<SchemaTypes.INotificationInput>;
}>>;
export declare function useShowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IShowNotificationQuery, SchemaTypes.IShowNotificationQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IShowNotificationQuery, SchemaTypes.Exact<{
    notification?: SchemaTypes.Maybe<SchemaTypes.INotificationInput>;
}>>;
export type ShowNotificationQueryHookResult = ReturnType<typeof useShowNotificationQuery>;
export type ShowNotificationLazyQueryHookResult = ReturnType<typeof useShowNotificationLazyQuery>;
export type ShowNotificationQueryResult = Apollo.QueryResult<SchemaTypes.IShowNotificationQuery, SchemaTypes.IShowNotificationQueryVariables>;
export declare const GetSelectedValueDocument: DocumentNode;
/**
 * __useGetSelectedValueQuery__
 *
 * To run a query within a React component, call `useGetSelectedValueQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSelectedValueQuery` 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 } = useGetSelectedValueQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetSelectedValueQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetSelectedValueQuery, SchemaTypes.IGetSelectedValueQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetSelectedValueQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetSelectedValueLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetSelectedValueQuery, SchemaTypes.IGetSelectedValueQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetSelectedValueQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetSelectedValueQueryHookResult = ReturnType<typeof useGetSelectedValueQuery>;
export type GetSelectedValueLazyQueryHookResult = ReturnType<typeof useGetSelectedValueLazyQuery>;
export type GetSelectedValueQueryResult = Apollo.QueryResult<SchemaTypes.IGetSelectedValueQuery, SchemaTypes.IGetSelectedValueQueryVariables>;
export declare const QuickInputModelDocument: DocumentNode;
/**
 * __useQuickInputModelQuery__
 *
 * To run a query within a React component, call `useQuickInputModelQuery` and pass it any options that fit your needs.
 * When your component renders, `useQuickInputModelQuery` 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 } = useQuickInputModelQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useQuickInputModelQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IQuickInputModelQuery, SchemaTypes.IQuickInputModelQueryVariables>): Apollo.QueryResult<SchemaTypes.IQuickInputModelQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useQuickInputModelLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IQuickInputModelQuery, SchemaTypes.IQuickInputModelQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IQuickInputModelQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type QuickInputModelQueryHookResult = ReturnType<typeof useQuickInputModelQuery>;
export type QuickInputModelLazyQueryHookResult = ReturnType<typeof useQuickInputModelLazyQuery>;
export type QuickInputModelQueryResult = Apollo.QueryResult<SchemaTypes.IQuickInputModelQuery, SchemaTypes.IQuickInputModelQueryVariables>;
export declare const StatusbarDocument: DocumentNode;
/**
 * __useStatusbarQuery__
 *
 * To run a query within a React component, call `useStatusbarQuery` and pass it any options that fit your needs.
 * When your component renders, `useStatusbarQuery` 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 } = useStatusbarQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useStatusbarQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IStatusbarQuery, SchemaTypes.IStatusbarQueryVariables>): Apollo.QueryResult<SchemaTypes.IStatusbarQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useStatusbarLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IStatusbarQuery, SchemaTypes.IStatusbarQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IStatusbarQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type StatusbarQueryHookResult = ReturnType<typeof useStatusbarQuery>;
export type StatusbarLazyQueryHookResult = ReturnType<typeof useStatusbarLazyQuery>;
export type StatusbarQueryResult = Apollo.QueryResult<SchemaTypes.IStatusbarQuery, SchemaTypes.IStatusbarQueryVariables>;
export declare const StatusbarItemDocument: DocumentNode;
/**
 * __useStatusbarItemQuery__
 *
 * To run a query within a React component, call `useStatusbarItemQuery` and pass it any options that fit your needs.
 * When your component renders, `useStatusbarItemQuery` 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 } = useStatusbarItemQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useStatusbarItemQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IStatusbarItemQuery, SchemaTypes.IStatusbarItemQueryVariables>): Apollo.QueryResult<SchemaTypes.IStatusbarItemQuery, SchemaTypes.Exact<{
    id?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>>;
export declare function useStatusbarItemLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IStatusbarItemQuery, SchemaTypes.IStatusbarItemQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IStatusbarItemQuery, SchemaTypes.Exact<{
    id?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
}>>;
export type StatusbarItemQueryHookResult = ReturnType<typeof useStatusbarItemQuery>;
export type StatusbarItemLazyQueryHookResult = ReturnType<typeof useStatusbarItemLazyQuery>;
export type StatusbarItemQueryResult = Apollo.QueryResult<SchemaTypes.IStatusbarItemQuery, SchemaTypes.IStatusbarItemQueryVariables>;
export declare const GetViewsDocument: DocumentNode;
/**
 * __useGetViewsQuery__
 *
 * To run a query within a React component, call `useGetViewsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetViewsQuery` 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 } = useGetViewsQuery({
 *   variables: {
 *      containerId: // value for 'containerId'
 *   },
 * });
 */
export declare function useGetViewsQuery(baseOptions: Apollo.QueryHookOptions<SchemaTypes.IGetViewsQuery, SchemaTypes.IGetViewsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetViewsQuery, SchemaTypes.Exact<{
    containerId: SchemaTypes.Scalars["String"];
}>>;
export declare function useGetViewsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetViewsQuery, SchemaTypes.IGetViewsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetViewsQuery, SchemaTypes.Exact<{
    containerId: SchemaTypes.Scalars["String"];
}>>;
export type GetViewsQueryHookResult = ReturnType<typeof useGetViewsQuery>;
export type GetViewsLazyQueryHookResult = ReturnType<typeof useGetViewsLazyQuery>;
export type GetViewsQueryResult = Apollo.QueryResult<SchemaTypes.IGetViewsQuery, SchemaTypes.IGetViewsQueryVariables>;
export declare const GetWorkspaceDocument: DocumentNode;
/**
 * __useGetWorkspaceQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceQuery` 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 } = useGetWorkspaceQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetWorkspaceQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetWorkspaceQuery, SchemaTypes.IGetWorkspaceQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetWorkspaceQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetWorkspaceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetWorkspaceQuery, SchemaTypes.IGetWorkspaceQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetWorkspaceQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetWorkspaceQueryHookResult = ReturnType<typeof useGetWorkspaceQuery>;
export type GetWorkspaceLazyQueryHookResult = ReturnType<typeof useGetWorkspaceLazyQuery>;
export type GetWorkspaceQueryResult = Apollo.QueryResult<SchemaTypes.IGetWorkspaceQuery, SchemaTypes.IGetWorkspaceQueryVariables>;
export declare const NotifyErrorDocument: DocumentNode;
/**
 * __useNotifyErrorMutation__
 *
 * To run a mutation, you first call `useNotifyErrorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyErrorMutation` 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 [notifyErrorMutation, { data, loading, error }] = useNotifyErrorMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export declare function useNotifyErrorMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.INotifyErrorMutation, SchemaTypes.INotifyErrorMutationVariables>): Apollo.MutationTuple<SchemaTypes.INotifyErrorMutation, SchemaTypes.Exact<{
    message?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>> | SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type NotifyErrorMutationHookResult = ReturnType<typeof useNotifyErrorMutation>;
export type NotifyErrorMutationResult = Apollo.MutationResult<SchemaTypes.INotifyErrorMutation>;
export type NotifyErrorMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.INotifyErrorMutation, SchemaTypes.INotifyErrorMutationVariables>;
export declare const NotifyInfoDocument: DocumentNode;
/**
 * __useNotifyInfoMutation__
 *
 * To run a mutation, you first call `useNotifyInfoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyInfoMutation` 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 [notifyInfoMutation, { data, loading, error }] = useNotifyInfoMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export declare function useNotifyInfoMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.INotifyInfoMutation, SchemaTypes.INotifyInfoMutationVariables>): Apollo.MutationTuple<SchemaTypes.INotifyInfoMutation, SchemaTypes.Exact<{
    message?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>> | SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type NotifyInfoMutationHookResult = ReturnType<typeof useNotifyInfoMutation>;
export type NotifyInfoMutationResult = Apollo.MutationResult<SchemaTypes.INotifyInfoMutation>;
export type NotifyInfoMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.INotifyInfoMutation, SchemaTypes.INotifyInfoMutationVariables>;
export declare const NotifyPromptDocument: DocumentNode;
/**
 * __useNotifyPromptMutation__
 *
 * To run a mutation, you first call `useNotifyPromptMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyPromptMutation` 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 [notifyPromptMutation, { data, loading, error }] = useNotifyPromptMutation({
 *   variables: {
 *      severity: // value for 'severity'
 *      message: // value for 'message'
 *      choices: // value for 'choices'
 *      options: // value for 'options'
 *   },
 * });
 */
export declare function useNotifyPromptMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.INotifyPromptMutation, SchemaTypes.INotifyPromptMutationVariables>): Apollo.MutationTuple<SchemaTypes.INotifyPromptMutation, SchemaTypes.Exact<{
    severity?: SchemaTypes.Maybe<SchemaTypes.NotificationSeverity>;
    message?: SchemaTypes.Maybe<SchemaTypes.Scalars["String"]>;
    choices?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IPromptChoiceInput>> | SchemaTypes.Maybe<SchemaTypes.IPromptChoiceInput>>;
    options?: SchemaTypes.Maybe<SchemaTypes.IPromptOptionsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type NotifyPromptMutationHookResult = ReturnType<typeof useNotifyPromptMutation>;
export type NotifyPromptMutationResult = Apollo.MutationResult<SchemaTypes.INotifyPromptMutation>;
export type NotifyPromptMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.INotifyPromptMutation, SchemaTypes.INotifyPromptMutationVariables>;
export declare const NotifyWarnDocument: DocumentNode;
/**
 * __useNotifyWarnMutation__
 *
 * To run a mutation, you first call `useNotifyWarnMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyWarnMutation` 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 [notifyWarnMutation, { data, loading, error }] = useNotifyWarnMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export declare function useNotifyWarnMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.INotifyWarnMutation, SchemaTypes.INotifyWarnMutationVariables>): Apollo.MutationTuple<SchemaTypes.INotifyWarnMutation, SchemaTypes.Exact<{
    message?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>> | SchemaTypes.Maybe<SchemaTypes.INotificationMessageInput>>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type NotifyWarnMutationHookResult = ReturnType<typeof useNotifyWarnMutation>;
export type NotifyWarnMutationResult = Apollo.MutationResult<SchemaTypes.INotifyWarnMutation>;
export type NotifyWarnMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.INotifyWarnMutation, SchemaTypes.INotifyWarnMutationVariables>;
export declare const NotifyDocument: DocumentNode;
/**
 * __useNotifyMutation__
 *
 * To run a mutation, you first call `useNotifyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyMutation` 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 [notifyMutation, { data, loading, error }] = useNotifyMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export declare function useNotifyMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.INotifyMutation, SchemaTypes.INotifyMutationVariables>): Apollo.MutationTuple<SchemaTypes.INotifyMutation, SchemaTypes.Exact<{
    notification?: SchemaTypes.Maybe<SchemaTypes.INotificationInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type NotifyMutationHookResult = ReturnType<typeof useNotifyMutation>;
export type NotifyMutationResult = Apollo.MutationResult<SchemaTypes.INotifyMutation>;
export type NotifyMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.INotifyMutation, SchemaTypes.INotifyMutationVariables>;
export declare const UpdateWorkspaceContextAddFoldersDocument: DocumentNode;
/**
 * __useUpdateWorkspaceContextAddFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextAddFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextAddFoldersMutation` 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 [updateWorkspaceContextAddFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextAddFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useUpdateWorkspaceContextAddFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateWorkspaceContextAddFoldersMutation, SchemaTypes.IUpdateWorkspaceContextAddFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateWorkspaceContextAddFoldersMutation, SchemaTypes.Exact<{
    foldersToAdd?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IFoldersToAdd_Input>> | SchemaTypes.Maybe<SchemaTypes.IFoldersToAdd_Input>>;
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateWorkspaceContextAddFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextAddFoldersMutation>;
export type UpdateWorkspaceContextAddFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateWorkspaceContextAddFoldersMutation>;
export type UpdateWorkspaceContextAddFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateWorkspaceContextAddFoldersMutation, SchemaTypes.IUpdateWorkspaceContextAddFoldersMutationVariables>;
export declare const UpdateWorkspaceContextRemoveFoldersDocument: DocumentNode;
/**
 * __useUpdateWorkspaceContextRemoveFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextRemoveFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextRemoveFoldersMutation` 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 [updateWorkspaceContextRemoveFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextRemoveFoldersMutation({
 *   variables: {
 *      foldersToRemove: // value for 'foldersToRemove'
 *   },
 * });
 */
export declare function useUpdateWorkspaceContextRemoveFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutation, SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutation, SchemaTypes.Exact<{
    foldersToRemove?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>> | SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateWorkspaceContextRemoveFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextRemoveFoldersMutation>;
export type UpdateWorkspaceContextRemoveFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutation>;
export type UpdateWorkspaceContextRemoveFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutation, SchemaTypes.IUpdateWorkspaceContextRemoveFoldersMutationVariables>;
export declare const UpdateWorkspaceContextUpdateFoldersDocument: DocumentNode;
/**
 * __useUpdateWorkspaceContextUpdateFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextUpdateFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextUpdateFoldersMutation` 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 [updateWorkspaceContextUpdateFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextUpdateFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      foldersToRemove: // value for 'foldersToRemove'
 *      index: // value for 'index'
 *   },
 * });
 */
export declare function useUpdateWorkspaceContextUpdateFoldersMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutation, SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutation, SchemaTypes.Exact<{
    foldersToAdd?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.IFoldersToAdd_Input>> | SchemaTypes.Maybe<SchemaTypes.IFoldersToAdd_Input>>;
    foldersToRemove?: SchemaTypes.Maybe<Array<SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>> | SchemaTypes.Maybe<SchemaTypes.Scalars["URI"]>>;
    index?: SchemaTypes.Maybe<SchemaTypes.Scalars["Int"]>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateWorkspaceContextUpdateFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextUpdateFoldersMutation>;
export type UpdateWorkspaceContextUpdateFoldersMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutation>;
export type UpdateWorkspaceContextUpdateFoldersMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutation, SchemaTypes.IUpdateWorkspaceContextUpdateFoldersMutationVariables>;
export declare const GetConfiguration_WsDocument: DocumentNode;
/**
 * __useGetConfiguration_WsQuery__
 *
 * To run a query within a React component, call `useGetConfiguration_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetConfiguration_WsQuery` 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 } = useGetConfiguration_WsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetConfiguration_WsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetConfiguration_WsQuery, SchemaTypes.IGetConfiguration_WsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetConfiguration_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetConfiguration_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetConfiguration_WsQuery, SchemaTypes.IGetConfiguration_WsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetConfiguration_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetConfiguration_WsQueryHookResult = ReturnType<typeof useGetConfiguration_WsQuery>;
export type GetConfiguration_WsLazyQueryHookResult = ReturnType<typeof useGetConfiguration_WsLazyQuery>;
export type GetConfiguration_WsQueryResult = Apollo.QueryResult<SchemaTypes.IGetConfiguration_WsQuery, SchemaTypes.IGetConfiguration_WsQueryVariables>;
export declare const GetEnvironment_WsDocument: DocumentNode;
/**
 * __useGetEnvironment_WsQuery__
 *
 * To run a query within a React component, call `useGetEnvironment_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetEnvironment_WsQuery` 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 } = useGetEnvironment_WsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetEnvironment_WsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetEnvironment_WsQuery, SchemaTypes.IGetEnvironment_WsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetEnvironment_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetEnvironment_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetEnvironment_WsQuery, SchemaTypes.IGetEnvironment_WsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetEnvironment_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetEnvironment_WsQueryHookResult = ReturnType<typeof useGetEnvironment_WsQuery>;
export type GetEnvironment_WsLazyQueryHookResult = ReturnType<typeof useGetEnvironment_WsLazyQuery>;
export type GetEnvironment_WsQueryResult = Apollo.QueryResult<SchemaTypes.IGetEnvironment_WsQuery, SchemaTypes.IGetEnvironment_WsQueryVariables>;
export declare const GetWorkspace_WsDocument: DocumentNode;
/**
 * __useGetWorkspace_WsQuery__
 *
 * To run a query within a React component, call `useGetWorkspace_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspace_WsQuery` 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 } = useGetWorkspace_WsQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetWorkspace_WsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetWorkspace_WsQuery, SchemaTypes.IGetWorkspace_WsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetWorkspace_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export declare function useGetWorkspace_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetWorkspace_WsQuery, SchemaTypes.IGetWorkspace_WsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetWorkspace_WsQuery, SchemaTypes.Exact<{
    [key: string]: never;
}>>;
export type GetWorkspace_WsQueryHookResult = ReturnType<typeof useGetWorkspace_WsQuery>;
export type GetWorkspace_WsLazyQueryHookResult = ReturnType<typeof useGetWorkspace_WsLazyQuery>;
export type GetWorkspace_WsQueryResult = Apollo.QueryResult<SchemaTypes.IGetWorkspace_WsQuery, SchemaTypes.IGetWorkspace_WsQueryVariables>;
export declare const GetWorkspaceValue_WsDocument: DocumentNode;
/**
 * __useGetWorkspaceValue_WsQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceValue_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceValue_WsQuery` 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 } = useGetWorkspaceValue_WsQuery({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export declare function useGetWorkspaceValue_WsQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetWorkspaceValue_WsQuery, SchemaTypes.IGetWorkspaceValue_WsQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetWorkspaceValue_WsQuery, SchemaTypes.Exact<{
    value?: SchemaTypes.Maybe<SchemaTypes.IWorkspaceValue_Input>;
}>>;
export declare function useGetWorkspaceValue_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetWorkspaceValue_WsQuery, SchemaTypes.IGetWorkspaceValue_WsQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetWorkspaceValue_WsQuery, SchemaTypes.Exact<{
    value?: SchemaTypes.Maybe<SchemaTypes.IWorkspaceValue_Input>;
}>>;
export type GetWorkspaceValue_WsQueryHookResult = ReturnType<typeof useGetWorkspaceValue_WsQuery>;
export type GetWorkspaceValue_WsLazyQueryHookResult = ReturnType<typeof useGetWorkspaceValue_WsLazyQuery>;
export type GetWorkspaceValue_WsQueryResult = Apollo.QueryResult<SchemaTypes.IGetWorkspaceValue_WsQuery, SchemaTypes.IGetWorkspaceValue_WsQueryVariables>;
export declare const AddServerNotificationDocument: DocumentNode;
/**
 * __useAddServerNotificationMutation__
 *
 * To run a mutation, you first call `useAddServerNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddServerNotificationMutation` 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 [addServerNotificationMutation, { data, loading, error }] = useAddServerNotificationMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export declare function useAddServerNotificationMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IAddServerNotificationMutation, SchemaTypes.IAddServerNotificationMutationVariables>): Apollo.MutationTuple<SchemaTypes.IAddServerNotificationMutation, SchemaTypes.Exact<{
    notification?: SchemaTypes.Maybe<SchemaTypes.INotificationInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type AddServerNotificationMutationHookResult = ReturnType<typeof useAddServerNotificationMutation>;
export type AddServerNotificationMutationResult = Apollo.MutationResult<SchemaTypes.IAddServerNotificationMutation>;
export type AddServerNotificationMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IAddServerNotificationMutation, SchemaTypes.IAddServerNotificationMutationVariables>;
export declare const GetWorkspaceFolderContextDocument: DocumentNode;
/**
 * __useGetWorkspaceFolderContextQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceFolderContextQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceFolderContextQuery` 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 } = useGetWorkspaceFolderContextQuery({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export declare function useGetWorkspaceFolderContextQuery(baseOptions?: Apollo.QueryHookOptions<SchemaTypes.IGetWorkspaceFolderContextQuery, SchemaTypes.IGetWorkspaceFolderContextQueryVariables>): Apollo.QueryResult<SchemaTypes.IGetWorkspaceFolderContextQuery, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.IArg_Input>;
}>>;
export declare function useGetWorkspaceFolderContextLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SchemaTypes.IGetWorkspaceFolderContextQuery, SchemaTypes.IGetWorkspaceFolderContextQueryVariables>): Apollo.LazyQueryResultTuple<SchemaTypes.IGetWorkspaceFolderContextQuery, SchemaTypes.Exact<{
    arg?: SchemaTypes.Maybe<SchemaTypes.IArg_Input>;
}>>;
export type GetWorkspaceFolderContextQueryHookResult = ReturnType<typeof useGetWorkspaceFolderContextQuery>;
export type GetWorkspaceFolderContextLazyQueryHookResult = ReturnType<typeof useGetWorkspaceFolderContextLazyQuery>;
export type GetWorkspaceFolderContextQueryResult = Apollo.QueryResult<SchemaTypes.IGetWorkspaceFolderContextQuery, SchemaTypes.IGetWorkspaceFolderContextQueryVariables>;
export declare const CodeLenseProviderDefinitionDocument: DocumentNode;
/**
 * __useCodeLenseProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useCodeLenseProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCodeLenseProviderDefinitionMutation` 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 [codeLenseProviderDefinitionMutation, { data, loading, error }] = useCodeLenseProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useCodeLenseProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ICodeLenseProviderDefinitionMutation, SchemaTypes.ICodeLenseProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.ICodeLenseProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CodeLenseProviderDefinitionMutationHookResult = ReturnType<typeof useCodeLenseProviderDefinitionMutation>;
export type CodeLenseProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.ICodeLenseProviderDefinitionMutation>;
export type CodeLenseProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ICodeLenseProviderDefinitionMutation, SchemaTypes.ICodeLenseProviderDefinitionMutationVariables>;
export declare const CompletionProviderDefinitionDocument: DocumentNode;
/**
 * __useCompletionProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useCompletionProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCompletionProviderDefinitionMutation` 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 [completionProviderDefinitionMutation, { data, loading, error }] = useCompletionProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useCompletionProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.ICompletionProviderDefinitionMutation, SchemaTypes.ICompletionProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.ICompletionProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CompletionProviderDefinitionMutationHookResult = ReturnType<typeof useCompletionProviderDefinitionMutation>;
export type CompletionProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.ICompletionProviderDefinitionMutation>;
export type CompletionProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.ICompletionProviderDefinitionMutation, SchemaTypes.ICompletionProviderDefinitionMutationVariables>;
export declare const DefinitionDefinitionDocument: DocumentNode;
/**
 * __useDefinitionDefinitionMutation__
 *
 * To run a mutation, you first call `useDefinitionDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDefinitionDefinitionMutation` 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 [definitionDefinitionMutation, { data, loading, error }] = useDefinitionDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useDefinitionDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IDefinitionDefinitionMutation, SchemaTypes.IDefinitionDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IDefinitionDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type DefinitionDefinitionMutationHookResult = ReturnType<typeof useDefinitionDefinitionMutation>;
export type DefinitionDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IDefinitionDefinitionMutation>;
export type DefinitionDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IDefinitionDefinitionMutation, SchemaTypes.IDefinitionDefinitionMutationVariables>;
export declare const DocumentHighLightProviderDefinitionDocument: DocumentNode;
/**
 * __useDocumentHighLightProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentHighLightProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentHighLightProviderDefinitionMutation` 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 [documentHighLightProviderDefinitionMutation, { data, loading, error }] = useDocumentHighLightProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useDocumentHighLightProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IDocumentHighLightProviderDefinitionMutation, SchemaTypes.IDocumentHighLightProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IDocumentHighLightProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type DocumentHighLightProviderDefinitionMutationHookResult = ReturnType<typeof useDocumentHighLightProviderDefinitionMutation>;
export type DocumentHighLightProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IDocumentHighLightProviderDefinitionMutation>;
export type DocumentHighLightProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IDocumentHighLightProviderDefinitionMutation, SchemaTypes.IDocumentHighLightProviderDefinitionMutationVariables>;
export declare const DocumentFormattingProviderDefinitionDocument: DocumentNode;
/**
 * __useDocumentFormattingProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentFormattingProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentFormattingProviderDefinitionMutation` 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 [documentFormattingProviderDefinitionMutation, { data, loading, error }] = useDocumentFormattingProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useDocumentFormattingProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IDocumentFormattingProviderDefinitionMutation, SchemaTypes.IDocumentFormattingProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IDocumentFormattingProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type DocumentFormattingProviderDefinitionMutationHookResult = ReturnType<typeof useDocumentFormattingProviderDefinitionMutation>;
export type DocumentFormattingProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IDocumentFormattingProviderDefinitionMutation>;
export type DocumentFormattingProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IDocumentFormattingProviderDefinitionMutation, SchemaTypes.IDocumentFormattingProviderDefinitionMutationVariables>;
export declare const HoverProviderDefinitionDocument: DocumentNode;
/**
 * __useHoverProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useHoverProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHoverProviderDefinitionMutation` 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 [hoverProviderDefinitionMutation, { data, loading, error }] = useHoverProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useHoverProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IHoverProviderDefinitionMutation, SchemaTypes.IHoverProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IHoverProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type HoverProviderDefinitionMutationHookResult = ReturnType<typeof useHoverProviderDefinitionMutation>;
export type HoverProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IHoverProviderDefinitionMutation>;
export type HoverProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IHoverProviderDefinitionMutation, SchemaTypes.IHoverProviderDefinitionMutationVariables>;
export declare const OpenLanguageDocumentDocument: DocumentNode;
/**
 * __useOpenLanguageDocumentMutation__
 *
 * To run a mutation, you first call `useOpenLanguageDocumentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenLanguageDocumentMutation` 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 [openLanguageDocumentMutation, { data, loading, error }] = useOpenLanguageDocumentMutation({
 *   variables: {
 *      document: // value for 'document'
 *   },
 * });
 */
export declare function useOpenLanguageDocumentMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IOpenLanguageDocumentMutation, SchemaTypes.IOpenLanguageDocumentMutationVariables>): Apollo.MutationTuple<SchemaTypes.IOpenLanguageDocumentMutation, SchemaTypes.Exact<{
    document?: SchemaTypes.Maybe<SchemaTypes.IOpenDocumentParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OpenLanguageDocumentMutationHookResult = ReturnType<typeof useOpenLanguageDocumentMutation>;
export type OpenLanguageDocumentMutationResult = Apollo.MutationResult<SchemaTypes.IOpenLanguageDocumentMutation>;
export type OpenLanguageDocumentMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IOpenLanguageDocumentMutation, SchemaTypes.IOpenLanguageDocumentMutationVariables>;
export declare const ReferenceProviderDefinitionDocument: DocumentNode;
/**
 * __useReferenceProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useReferenceProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReferenceProviderDefinitionMutation` 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 [referenceProviderDefinitionMutation, { data, loading, error }] = useReferenceProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useReferenceProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IReferenceProviderDefinitionMutation, SchemaTypes.IReferenceProviderDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IReferenceProviderDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type ReferenceProviderDefinitionMutationHookResult = ReturnType<typeof useReferenceProviderDefinitionMutation>;
export type ReferenceProviderDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IReferenceProviderDefinitionMutation>;
export type ReferenceProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IReferenceProviderDefinitionMutation, SchemaTypes.IReferenceProviderDefinitionMutationVariables>;
export declare const RenameDefinitionDocument: DocumentNode;
/**
 * __useRenameDefinitionMutation__
 *
 * To run a mutation, you first call `useRenameDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRenameDefinitionMutation` 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 [renameDefinitionMutation, { data, loading, error }] = useRenameDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useRenameDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IRenameDefinitionMutation, SchemaTypes.IRenameDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IRenameDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RenameDefinitionMutationHookResult = ReturnType<typeof useRenameDefinitionMutation>;
export type RenameDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IRenameDefinitionMutation>;
export type RenameDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IRenameDefinitionMutation, SchemaTypes.IRenameDefinitionMutationVariables>;
export declare const DocumentSymbolDefinitionDocument: DocumentNode;
/**
 * __useDocumentSymbolDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentSymbolDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentSymbolDefinitionMutation` 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 [documentSymbolDefinitionMutation, { data, loading, error }] = useDocumentSymbolDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export declare function useDocumentSymbolDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IDocumentSymbolDefinitionMutation, SchemaTypes.IDocumentSymbolDefinitionMutationVariables>): Apollo.MutationTuple<SchemaTypes.IDocumentSymbolDefinitionMutation, SchemaTypes.Exact<{
    params?: SchemaTypes.Maybe<SchemaTypes.ITextDocumentPositionParamsInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type DocumentSymbolDefinitionMutationHookResult = ReturnType<typeof useDocumentSymbolDefinitionMutation>;
export type DocumentSymbolDefinitionMutationResult = Apollo.MutationResult<SchemaTypes.IDocumentSymbolDefinitionMutation>;
export type DocumentSymbolDefinitionMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IDocumentSymbolDefinitionMutation, SchemaTypes.IDocumentSymbolDefinitionMutationVariables>;
export declare const UpdateModelDocument: DocumentNode;
/**
 * __useUpdateModelMutation__
 *
 * To run a mutation, you first call `useUpdateModelMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateModelMutation` 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 [updateModelMutation, { data, loading, error }] = useUpdateModelMutation({
 *   variables: {
 *      model: // value for 'model'
 *   },
 * });
 */
export declare function useUpdateModelMutation(baseOptions?: Apollo.MutationHookOptions<SchemaTypes.IUpdateModelMutation, SchemaTypes.IUpdateModelMutationVariables>): Apollo.MutationTuple<SchemaTypes.IUpdateModelMutation, SchemaTypes.Exact<{
    model?: SchemaTypes.Maybe<SchemaTypes.IIModelInput>;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateModelMutationHookResult = ReturnType<typeof useUpdateModelMutation>;
export type UpdateModelMutationResult = Apollo.MutationResult<SchemaTypes.IUpdateModelMutation>;
export type UpdateModelMutationOptions = Apollo.BaseMutationOptions<SchemaTypes.IUpdateModelMutation, SchemaTypes.IUpdateModelMutationVariables>;