@adminide-stack/extension-api 0.0.20-alpha.97 → 1.0.201-alpha.1

package/lib/interfaces/generated-models.d.ts

@@ -1,8 +1,19 @@
 import { URI, UriComponents } from '@vscode-alt/monaco-editor/esm/vs/base/common/uri';
 import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
 import { MyContext } from '@adminide-stack/core';
-import * as ApolloReactCommon from '@apollo/react-common';
+import * as Apollo from '@apollo/client';
 export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
 export declare type RequireFields<T, K extends keyof T> = {
     [X in Exclude<keyof T, K>]?: T[X];
 } & {
@@ -20,10 +31,10 @@ export declare type Scalars = {
     URI: URI;
     Observable: any;
     Date: any;
-    Time: any;
     DateTime: any;
-    URIInput: URI | UriComponents;
     JSONObject: any;
+    Time: any;
+    URIInput: URI | UriComponents;
 };
 export declare type IAdminIdeSettings = {
     __typename?: 'AdminIdeSettings';
@@ -75,6 +86,9 @@ export declare const enum ICacheControlScope {
     PUBLIC = "PUBLIC",
     PRIVATE = "PRIVATE"
 }
+export declare const enum IClientContainerService {
+    ExtensionController = "ExtensionController"
+}
 export declare type ICommandHandlerDescriptionType = {
     __typename?: 'CommandHandlerDescriptionType';
     description?: Maybe<Scalars['String']>;
@@ -962,6 +976,10 @@ export declare type IGalleryQuery = {
     sortOrder?: Maybe<Scalars['Int']>;
     source?: Maybe<Scalars['String']>;
 };
+export declare type IGeoLocation = {
+    __typename?: 'GeoLocation';
+    coordinates?: Maybe<Array<Maybe<Scalars['Float']>>>;
+};
 export declare type IGrammar = {
     __typename?: 'Grammar';
     language?: Maybe<Scalars['String']>;
@@ -970,6 +988,10 @@ export declare const enum IGraphqlCallType {
     mutation = "mutation",
     query = "query"
 }
+export declare type IHover = {
+    contents?: Maybe<IMarkupContent>;
+    range?: Maybe<IRange>;
+};
 export declare type IIActivationRequest = {
     env?: Maybe<Array<Maybe<Scalars['String']>>>;
     extensionID: Scalars['ID'];
@@ -1032,6 +1054,10 @@ export declare type IIObservableResult = {
     thrownError?: Maybe<Scalars['String']>;
     _isScalar?: Maybe<Scalars['Boolean']>;
 };
+export declare type IIResourceUtilizationSettings = {
+    subTopic?: Maybe<Scalars['String']>;
+    adminApiNamespace?: Maybe<Scalars['String']>;
+};
 export declare type IISourceAnonymousSubject = {
     __typename?: 'ISourceAnonymousSubject';
     closed?: Maybe<Scalars['Boolean']>;
@@ -1103,6 +1129,10 @@ export declare type ILocation = {
     range?: Maybe<IPosition>;
     uri?: Maybe<Scalars['String']>;
 };
+export declare type IMarkupContent = {
+    value?: Maybe<Scalars['String']>;
+    kind?: Maybe<IMarkupKind>;
+};
 export declare const enum IMarkupKind {
     plaintext = "plaintext",
     markdown = "markdown"
@@ -1885,31 +1915,33 @@ export declare type IViewContainer = {
     id?: Maybe<Scalars['ID']>;
     title?: Maybe<Scalars['String']>;
 };
-export declare type ICopyMutationVariables = {
+export declare type ICopyMutationVariables = Exact<{
     value?: Maybe<Scalars['String']>;
-};
+}>;
 export declare type ICopyMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'copy'>);
-export declare type IRunMenuActionMutationVariables = {
+export declare type IRunMenuActionMutationVariables = Exact<{
     argument?: Maybe<IContributionActionRun_input>;
-};
+}>;
 export declare type IRunMenuActionMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'runMenuAction'>);
-export declare type IHideContextMenuMutationVariables = {};
+export declare type IHideContextMenuMutationVariables = Exact<{
+    [key: string]: never;
+}>;
 export declare type IHideContextMenuMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'hideContextMenu'>);
-export declare type IShowContextMenuMutationVariables = {
+export declare type IShowContextMenuMutationVariables = Exact<{
     delegate?: Maybe<IContextMenu_input>;
-};
+}>;
 export declare type IShowContextMenuMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'showContextMenu'>);
-export declare type IinstallMutationVariables = {
+export declare type IinstallMutationVariables = Exact<{
     vsix: Scalars['String'];
-};
+}>;
 export declare type IinstallMutation = ({
     __typename?: 'Mutation';
 } & {
@@ -1917,19 +1949,21 @@ export declare type IinstallMutation = ({
         __typename?: 'ExtensionIdentifier';
     } & Pick<IExtensionIdentifier, 'id' | 'uuid'>)>;
 });
-export declare type IproviderDefinitionMutationVariables = {
+export declare type IproviderDefinitionMutationVariables = Exact<{
     params?: Maybe<ITextDocumentPositionParamsInput>;
-};
+}>;
 export declare type IproviderDefinitionMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'hoverProviderDefinition'>);
-export declare type IremoveMutationVariables = {
+export declare type IremoveMutationVariables = Exact<{
     id: Scalars['String'];
-};
+}>;
 export declare type IremoveMutation = ({
     __typename?: 'Mutation';
 } & Pick<IMutation, 'removeExtension'>);
-export declare type IContextMenuQueryVariables = {};
+export declare type IContextMenuQueryVariables = Exact<{
+    [key: string]: never;
+}>;
 export declare type IContextMenuQuery = ({
     __typename?: 'Query';
 } & {
@@ -1948,9 +1982,9 @@ export declare type IContextMenuQuery = ({
         })>>>;
     })>;
 });
-export declare type IgalleryExtensionQueryVariables = {
+export declare type IgalleryExtensionQueryVariables = Exact<{
     extensionID: Scalars['String'];
-};
+}>;
 export declare type IgalleryExtensionQuery = ({
     __typename?: 'Query';
 } & {
@@ -1969,10 +2003,10 @@ export declare type IgalleryExtensionQuery = ({
         } & Pick<IGalleryExtensionResources, 'icon' | 'readme' | 'manifest' | 'changelog'>)>;
     })>;
 });
-export declare type IExtensionsByLimitQueryVariables = {
+export declare type IExtensionsByLimitQueryVariables = Exact<{
     first: Scalars['Int'];
-    prioritizeExtensionIDs: Array<Scalars['String']>;
-};
+    prioritizeExtensionIDs: Array<Scalars['String']> | Scalars['String'];
+}>;
 export declare type IExtensionsByLimitQuery = ({
     __typename?: 'Query';
 } & {
@@ -1988,9 +2022,9 @@ export declare type IExtensionsByLimitQuery = ({
         })>;
     });
 });
-export declare type IgalleryQueryVariables = {
+export declare type IgalleryQueryVariables = Exact<{
     query?: Maybe<IGalleryQuery>;
-};
+}>;
 export declare type IgalleryQuery = ({
     __typename?: 'Query';
 } & {
@@ -2010,7 +2044,9 @@ export declare type IgalleryQuery = ({
         })>>>;
     })>;
 });
-export declare type IinstalledExtensionsQueryVariables = {};
+export declare type IinstalledExtensionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
 export declare type IinstalledExtensionsQuery = ({
     __typename?: 'Query';
 } & {
@@ -2032,7 +2068,9 @@ export declare type IinstalledExtensionsQuery = ({
         })>;
     })>>>;
 });
-export declare type INotificationsQueryVariables = {};
+export declare type INotificationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
 export declare type INotificationsQuery = ({
     __typename?: 'Query';
 } & {
@@ -2063,53 +2101,375 @@ export declare type INotificationsQuery = ({
         })>>>;
     })>;
 });
-export declare type IshowNotificationQueryVariables = {
+export declare type IshowNotificationQueryVariables = Exact<{
     notification?: Maybe<INotification_input>;
-};
+}>;
 export declare type IshowNotificationQuery = ({
     __typename?: 'Query';
 } & Pick<IQuery, 'showNotification'>);
-export declare const CopyDocument: import("graphql").DocumentNode;
-export declare type CopyMutationResult = ApolloReactCommon.MutationResult<ICopyMutation>;
-export declare type CopyMutationOptions = ApolloReactCommon.BaseMutationOptions<ICopyMutation, ICopyMutationVariables>;
-export declare const RunMenuActionDocument: import("graphql").DocumentNode;
-export declare type RunMenuActionMutationResult = ApolloReactCommon.MutationResult<IRunMenuActionMutation>;
-export declare type RunMenuActionMutationOptions = ApolloReactCommon.BaseMutationOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>;
-export declare const HideContextMenuDocument: import("graphql").DocumentNode;
-export declare type HideContextMenuMutationResult = ApolloReactCommon.MutationResult<IHideContextMenuMutation>;
-export declare type HideContextMenuMutationOptions = ApolloReactCommon.BaseMutationOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>;
-export declare const ShowContextMenuDocument: import("graphql").DocumentNode;
-export declare type ShowContextMenuMutationResult = ApolloReactCommon.MutationResult<IShowContextMenuMutation>;
-export declare type ShowContextMenuMutationOptions = ApolloReactCommon.BaseMutationOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>;
-export declare const installDocument: import("graphql").DocumentNode;
-export declare type installMutationResult = ApolloReactCommon.MutationResult<IinstallMutation>;
-export declare type installMutationOptions = ApolloReactCommon.BaseMutationOptions<IinstallMutation, IinstallMutationVariables>;
-export declare const providerDefinitionDocument: import("graphql").DocumentNode;
-export declare type providerDefinitionMutationResult = ApolloReactCommon.MutationResult<IproviderDefinitionMutation>;
-export declare type providerDefinitionMutationOptions = ApolloReactCommon.BaseMutationOptions<IproviderDefinitionMutation, IproviderDefinitionMutationVariables>;
-export declare const removeDocument: import("graphql").DocumentNode;
-export declare type removeMutationResult = ApolloReactCommon.MutationResult<IremoveMutation>;
-export declare type removeMutationOptions = ApolloReactCommon.BaseMutationOptions<IremoveMutation, IremoveMutationVariables>;
-export declare const ContextMenuDocument: import("graphql").DocumentNode;
-export declare type ContextMenuQueryResult = ApolloReactCommon.QueryResult<IContextMenuQuery, IContextMenuQueryVariables>;
-export declare const galleryExtensionDocument: import("graphql").DocumentNode;
-export declare type galleryExtensionQueryResult = ApolloReactCommon.QueryResult<IgalleryExtensionQuery, IgalleryExtensionQueryVariables>;
-export declare const ExtensionsByLimitDocument: import("graphql").DocumentNode;
-export declare type ExtensionsByLimitQueryResult = ApolloReactCommon.QueryResult<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>;
-export declare const galleryDocument: import("graphql").DocumentNode;
-export declare type galleryQueryResult = ApolloReactCommon.QueryResult<IgalleryQuery, IgalleryQueryVariables>;
-export declare const installedExtensionsDocument: import("graphql").DocumentNode;
-export declare type installedExtensionsQueryResult = ApolloReactCommon.QueryResult<IinstalledExtensionsQuery, IinstalledExtensionsQueryVariables>;
-export declare const NotificationsDocument: import("graphql").DocumentNode;
-export declare type NotificationsQueryResult = ApolloReactCommon.QueryResult<INotificationsQuery, INotificationsQueryVariables>;
-export declare const showNotificationDocument: import("graphql").DocumentNode;
-export declare type showNotificationQueryResult = ApolloReactCommon.QueryResult<IshowNotificationQuery, IshowNotificationQueryVariables>;
+export declare const CopyDocument: Apollo.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<ICopyMutation, ICopyMutationVariables>): Apollo.MutationTuple<ICopyMutation, Exact<{
+    value?: string;
+}>>;
+export declare type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
+export declare type CopyMutationResult = Apollo.MutationResult<ICopyMutation>;
+export declare type CopyMutationOptions = Apollo.BaseMutationOptions<ICopyMutation, ICopyMutationVariables>;
+export declare const RunMenuActionDocument: Apollo.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<IRunMenuActionMutation, IRunMenuActionMutationVariables>): Apollo.MutationTuple<IRunMenuActionMutation, Exact<{
+    argument?: IContributionActionRun_input;
+}>>;
+export declare type RunMenuActionMutationHookResult = ReturnType<typeof useRunMenuActionMutation>;
+export declare type RunMenuActionMutationResult = Apollo.MutationResult<IRunMenuActionMutation>;
+export declare type RunMenuActionMutationOptions = Apollo.BaseMutationOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>;
+export declare const HideContextMenuDocument: Apollo.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<IHideContextMenuMutation, IHideContextMenuMutationVariables>): Apollo.MutationTuple<IHideContextMenuMutation, Exact<{
+    [key: string]: never;
+}>>;
+export declare type HideContextMenuMutationHookResult = ReturnType<typeof useHideContextMenuMutation>;
+export declare type HideContextMenuMutationResult = Apollo.MutationResult<IHideContextMenuMutation>;
+export declare type HideContextMenuMutationOptions = Apollo.BaseMutationOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>;
+export declare const ShowContextMenuDocument: Apollo.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<IShowContextMenuMutation, IShowContextMenuMutationVariables>): Apollo.MutationTuple<IShowContextMenuMutation, Exact<{
+    delegate?: IContextMenu_input;
+}>>;
+export declare type ShowContextMenuMutationHookResult = ReturnType<typeof useShowContextMenuMutation>;
+export declare type ShowContextMenuMutationResult = Apollo.MutationResult<IShowContextMenuMutation>;
+export declare type ShowContextMenuMutationOptions = Apollo.BaseMutationOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>;
+export declare const installDocument: Apollo.DocumentNode;
+/**
+ * __useinstallMutation__
+ *
+ * To run a mutation, you first call `useinstallMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useinstallMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [installMutation, { data, loading, error }] = useinstallMutation({
+ *   variables: {
+ *      vsix: // value for 'vsix'
+ *   },
+ * });
+ */
+export declare function useinstallMutation(baseOptions?: Apollo.MutationHookOptions<IinstallMutation, IinstallMutationVariables>): Apollo.MutationTuple<IinstallMutation, Exact<{
+    vsix: string;
+}>>;
+export declare type installMutationHookResult = ReturnType<typeof useinstallMutation>;
+export declare type installMutationResult = Apollo.MutationResult<IinstallMutation>;
+export declare type installMutationOptions = Apollo.BaseMutationOptions<IinstallMutation, IinstallMutationVariables>;
+export declare const providerDefinitionDocument: Apollo.DocumentNode;
+/**
+ * __useproviderDefinitionMutation__
+ *
+ * To run a mutation, you first call `useproviderDefinitionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useproviderDefinitionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [providerDefinitionMutation, { data, loading, error }] = useproviderDefinitionMutation({
+ *   variables: {
+ *      params: // value for 'params'
+ *   },
+ * });
+ */
+export declare function useproviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IproviderDefinitionMutation, IproviderDefinitionMutationVariables>): Apollo.MutationTuple<IproviderDefinitionMutation, Exact<{
+    params?: ITextDocumentPositionParamsInput;
+}>>;
+export declare type providerDefinitionMutationHookResult = ReturnType<typeof useproviderDefinitionMutation>;
+export declare type providerDefinitionMutationResult = Apollo.MutationResult<IproviderDefinitionMutation>;
+export declare type providerDefinitionMutationOptions = Apollo.BaseMutationOptions<IproviderDefinitionMutation, IproviderDefinitionMutationVariables>;
+export declare const removeDocument: Apollo.DocumentNode;
+/**
+ * __useremoveMutation__
+ *
+ * To run a mutation, you first call `useremoveMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useremoveMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeMutation, { data, loading, error }] = useremoveMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useremoveMutation(baseOptions?: Apollo.MutationHookOptions<IremoveMutation, IremoveMutationVariables>): Apollo.MutationTuple<IremoveMutation, Exact<{
+    id: string;
+}>>;
+export declare type removeMutationHookResult = ReturnType<typeof useremoveMutation>;
+export declare type removeMutationResult = Apollo.MutationResult<IremoveMutation>;
+export declare type removeMutationOptions = Apollo.BaseMutationOptions<IremoveMutation, IremoveMutationVariables>;
+export declare const ContextMenuDocument: Apollo.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<IContextMenuQuery, IContextMenuQueryVariables>): Apollo.QueryResult<IContextMenuQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IContextMenuQuery, IContextMenuQueryVariables>): Apollo.QueryTuple<IContextMenuQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type ContextMenuQueryHookResult = ReturnType<typeof useContextMenuQuery>;
+export declare type ContextMenuLazyQueryHookResult = ReturnType<typeof useContextMenuLazyQuery>;
+export declare type ContextMenuQueryResult = Apollo.QueryResult<IContextMenuQuery, IContextMenuQueryVariables>;
+export declare const galleryExtensionDocument: Apollo.DocumentNode;
+/**
+ * __usegalleryExtensionQuery__
+ *
+ * To run a query within a React component, call `usegalleryExtensionQuery` and pass it any options that fit your needs.
+ * When your component renders, `usegalleryExtensionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = usegalleryExtensionQuery({
+ *   variables: {
+ *      extensionID: // value for 'extensionID'
+ *   },
+ * });
+ */
+export declare function usegalleryExtensionQuery(baseOptions: Apollo.QueryHookOptions<IgalleryExtensionQuery, IgalleryExtensionQueryVariables>): Apollo.QueryResult<IgalleryExtensionQuery, Exact<{
+    extensionID: string;
+}>>;
+export declare function usegalleryExtensionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IgalleryExtensionQuery, IgalleryExtensionQueryVariables>): Apollo.QueryTuple<IgalleryExtensionQuery, Exact<{
+    extensionID: string;
+}>>;
+export declare type galleryExtensionQueryHookResult = ReturnType<typeof usegalleryExtensionQuery>;
+export declare type galleryExtensionLazyQueryHookResult = ReturnType<typeof usegalleryExtensionLazyQuery>;
+export declare type galleryExtensionQueryResult = Apollo.QueryResult<IgalleryExtensionQuery, IgalleryExtensionQueryVariables>;
+export declare const ExtensionsByLimitDocument: Apollo.DocumentNode;
+/**
+ * __useExtensionsByLimitQuery__
+ *
+ * To run a query within a React component, call `useExtensionsByLimitQuery` and pass it any options that fit your needs.
+ * When your component renders, `useExtensionsByLimitQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useExtensionsByLimitQuery({
+ *   variables: {
+ *      first: // value for 'first'
+ *      prioritizeExtensionIDs: // value for 'prioritizeExtensionIDs'
+ *   },
+ * });
+ */
+export declare function useExtensionsByLimitQuery(baseOptions: Apollo.QueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>): Apollo.QueryResult<IExtensionsByLimitQuery, Exact<{
+    first: number;
+    prioritizeExtensionIDs: string | string[];
+}>>;
+export declare function useExtensionsByLimitLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>): Apollo.QueryTuple<IExtensionsByLimitQuery, Exact<{
+    first: number;
+    prioritizeExtensionIDs: string | string[];
+}>>;
+export declare type ExtensionsByLimitQueryHookResult = ReturnType<typeof useExtensionsByLimitQuery>;
+export declare type ExtensionsByLimitLazyQueryHookResult = ReturnType<typeof useExtensionsByLimitLazyQuery>;
+export declare type ExtensionsByLimitQueryResult = Apollo.QueryResult<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>;
+export declare const galleryDocument: Apollo.DocumentNode;
+/**
+ * __usegalleryQuery__
+ *
+ * To run a query within a React component, call `usegalleryQuery` and pass it any options that fit your needs.
+ * When your component renders, `usegalleryQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = usegalleryQuery({
+ *   variables: {
+ *      query: // value for 'query'
+ *   },
+ * });
+ */
+export declare function usegalleryQuery(baseOptions?: Apollo.QueryHookOptions<IgalleryQuery, IgalleryQueryVariables>): Apollo.QueryResult<IgalleryQuery, Exact<{
+    query?: IGalleryQuery;
+}>>;
+export declare function usegalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IgalleryQuery, IgalleryQueryVariables>): Apollo.QueryTuple<IgalleryQuery, Exact<{
+    query?: IGalleryQuery;
+}>>;
+export declare type galleryQueryHookResult = ReturnType<typeof usegalleryQuery>;
+export declare type galleryLazyQueryHookResult = ReturnType<typeof usegalleryLazyQuery>;
+export declare type galleryQueryResult = Apollo.QueryResult<IgalleryQuery, IgalleryQueryVariables>;
+export declare const installedExtensionsDocument: Apollo.DocumentNode;
+/**
+ * __useinstalledExtensionsQuery__
+ *
+ * To run a query within a React component, call `useinstalledExtensionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useinstalledExtensionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useinstalledExtensionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useinstalledExtensionsQuery(baseOptions?: Apollo.QueryHookOptions<IinstalledExtensionsQuery, IinstalledExtensionsQueryVariables>): Apollo.QueryResult<IinstalledExtensionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useinstalledExtensionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IinstalledExtensionsQuery, IinstalledExtensionsQueryVariables>): Apollo.QueryTuple<IinstalledExtensionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type installedExtensionsQueryHookResult = ReturnType<typeof useinstalledExtensionsQuery>;
+export declare type installedExtensionsLazyQueryHookResult = ReturnType<typeof useinstalledExtensionsLazyQuery>;
+export declare type installedExtensionsQueryResult = Apollo.QueryResult<IinstalledExtensionsQuery, IinstalledExtensionsQueryVariables>;
+export declare const NotificationsDocument: Apollo.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<INotificationsQuery, INotificationsQueryVariables>): Apollo.QueryResult<INotificationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<INotificationsQuery, INotificationsQueryVariables>): Apollo.QueryTuple<INotificationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type NotificationsQueryHookResult = ReturnType<typeof useNotificationsQuery>;
+export declare type NotificationsLazyQueryHookResult = ReturnType<typeof useNotificationsLazyQuery>;
+export declare type NotificationsQueryResult = Apollo.QueryResult<INotificationsQuery, INotificationsQueryVariables>;
+export declare const showNotificationDocument: Apollo.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<IshowNotificationQuery, IshowNotificationQueryVariables>): Apollo.QueryResult<IshowNotificationQuery, Exact<{
+    notification?: INotification_input;
+}>>;
+export declare function useshowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IshowNotificationQuery, IshowNotificationQueryVariables>): Apollo.QueryTuple<IshowNotificationQuery, Exact<{
+    notification?: INotification_input;
+}>>;
+export declare type showNotificationQueryHookResult = ReturnType<typeof useshowNotificationQuery>;
+export declare type showNotificationLazyQueryHookResult = ReturnType<typeof useshowNotificationLazyQuery>;
+export declare type showNotificationQueryResult = Apollo.QueryResult<IshowNotificationQuery, IshowNotificationQueryVariables>;
 export declare type ResolverTypeWrapper<T> = Promise<T> | T;
-export declare type StitchingResolver<TResult, TParent, TContext, TArgs> = {
+export declare type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export declare type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
     fragment: string;
     resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-export declare type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | StitchingResolver<TResult, TParent, TContext, TArgs>;
+export declare type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
+    selectionSet: string;
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export declare type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
+export declare type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs> | StitchingResolver<TResult, TParent, TContext, TArgs>;
 export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
 export declare type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;
 export declare type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
@@ -2128,7 +2488,7 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
 export declare type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
 export declare type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
 export declare type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
-export declare type isTypeOfResolverFn<T = {}> = (obj: T, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export declare type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
 export declare type NextResolverFn<T> = () => Promise<T>;
 export declare type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
 /** Mapping between all available schema types and the resolvers types */
@@ -2237,63 +2597,68 @@ export declare type IResolversTypes = {
     IViewComponentDataInput: IIViewComponentDataInput;
     TextDocumentItemInput: ITextDocumentItemInput;
     Subscription: ResolverTypeWrapper<{}>;
-    CommandType: ResolverTypeWrapper<ICommandType>;
-    CommandHandlerDescriptionType: ResolverTypeWrapper<ICommandHandlerDescriptionType>;
+    AdminIdeSettings: ResolverTypeWrapper<IAdminIdeSettings>;
     ArgsType: ResolverTypeWrapper<IArgsType>;
+    BaseExtension: ResolverTypeWrapper<IBaseExtension>;
+    ExtensionType: IExtensionType;
+    CacheControlScope: ICacheControlScope;
+    ClientContainerService: IClientContainerService;
+    CommandHandlerDescriptionType: ResolverTypeWrapper<ICommandHandlerDescriptionType>;
+    CommandType: ResolverTypeWrapper<ICommandType>;
     CommandsType: ResolverTypeWrapper<ICommandsType>;
-    RegistryEntry: ResolverTypeWrapper<IRegistryEntry>;
-    TextDocumentRegistrationOptions: ResolverTypeWrapper<ITextDocumentRegistrationOptions>;
+    Contributes: ResolverTypeWrapper<IContributes>;
+    ContributionView: ResolverTypeWrapper<IContributionView>;
+    Date: ResolverTypeWrapper<Scalars['Date']>;
+    DateTime: ResolverTypeWrapper<Scalars['DateTime']>;
     DocumentFilter: ResolverTypeWrapper<IDocumentFilter>;
-    ITextDocumentIdentifier: IResolversTypes['TextDocumentIdentifier'] | IResolversTypes['TextDocumentItem'];
-    TextDocumentIdentifier: ResolverTypeWrapper<ITextDocumentIdentifier>;
-    ProvideTextDocumentLocationSignature: ResolverTypeWrapper<IProvideTextDocumentLocationSignature>;
-    TextDocumentPositionParams: IResolversTypes['ProvideTextDocumentLocationSignature'];
-    Position: ResolverTypeWrapper<IPosition>;
-    Location: IResolversTypes['ProvideTextDocumentLocationSignature'];
-    MarkupKind: IMarkupKind;
-    Range: ResolverTypeWrapper<IRange>;
-    IViewComponentData: ResolverTypeWrapper<IIViewComponentData>;
-    TextDocumentItem: ResolverTypeWrapper<ITextDocumentItem>;
-    IWorkspaceRoot: ResolverTypeWrapper<IIWorkspaceRoot>;
-    IModel: ResolverTypeWrapper<IIModel>;
-    ISwitchMapOperator: ResolverTypeWrapper<IISwitchMapOperator>;
-    IDocumentSelector: ResolverTypeWrapper<IIDocumentSelector>;
-    IBehaviorSubjectValue: ResolverTypeWrapper<IIBehaviorSubjectValue>;
-    IBehaviorSubject: ResolverTypeWrapper<IIBehaviorSubject>;
-    IDestinationAnonymousSubject: ResolverTypeWrapper<IIDestinationAnonymousSubject>;
-    ISourceAnonymousSubject: ResolverTypeWrapper<IISourceAnonymousSubject>;
-    IObservableResult: ResolverTypeWrapper<IIObservableResult>;
     Environment: ResolverTypeWrapper<IEnvironment>;
     EnvironmentSync: IEnvironmentSync;
     EnvironmentPayload: IEnvironmentPayload;
-    ViewContainer: ResolverTypeWrapper<IViewContainer>;
-    ContributionView: ResolverTypeWrapper<IContributionView>;
-    RangeInput: IRangeInput;
-    ExtensionType: IExtensionType;
-    BaseExtension: ResolverTypeWrapper<IBaseExtension>;
     ExtensionConfigurationProperty: ResolverTypeWrapper<IExtensionConfigurationProperty>;
-    Contributes: ResolverTypeWrapper<IContributes>;
+    ExtensionRegistryCreateExtensionResult: ResolverTypeWrapper<IExtensionRegistryCreateExtensionResult>;
+    ExtensionRegistryUpdateExtensionResult: ResolverTypeWrapper<IExtensionRegistryUpdateExtensionResult>;
+    FieldError: ResolverTypeWrapper<IFieldError>;
     GalleryFilter: IGalleryFilter;
+    GeoLocation: ResolverTypeWrapper<IGeoLocation>;
+    Hover: never;
+    MarkupContent: never;
+    MarkupKind: IMarkupKind;
+    Range: ResolverTypeWrapper<IRange>;
+    Position: ResolverTypeWrapper<IPosition>;
+    IBehaviorSubject: ResolverTypeWrapper<IIBehaviorSubject>;
+    IBehaviorSubjectValue: ResolverTypeWrapper<IIBehaviorSubjectValue>;
+    IDocumentSelector: ResolverTypeWrapper<IIDocumentSelector>;
+    IDestinationAnonymousSubject: ResolverTypeWrapper<IIDestinationAnonymousSubject>;
+    ISwitchMapOperator: ResolverTypeWrapper<IISwitchMapOperator>;
+    IModel: ResolverTypeWrapper<IIModel>;
+    IWorkspaceRoot: ResolverTypeWrapper<IIWorkspaceRoot>;
+    IViewComponentData: ResolverTypeWrapper<IIViewComponentData>;
+    TextDocumentItem: ResolverTypeWrapper<ITextDocumentItem>;
+    ITextDocumentIdentifier: IResolversTypes['TextDocumentItem'] | IResolversTypes['TextDocumentIdentifier'];
+    IObservableResult: ResolverTypeWrapper<IIObservableResult>;
+    ISourceAnonymousSubject: ResolverTypeWrapper<IISourceAnonymousSubject>;
+    IResourceUtilizationSettings: never;
+    JSONObject: ResolverTypeWrapper<Scalars['JSONObject']>;
+    Location: IResolversTypes['ProvideTextDocumentLocationSignature'];
     MenuId: IMenuId;
     MessageLink: ResolverTypeWrapper<IMessageLink>;
-    NotificationChangeType: INotificationChangeType;
+    MoleculerServiceName: IMoleculerServiceName;
     NotificationChangeEvent: ResolverTypeWrapper<INotificationChangeEvent>;
     NotificationViewItem: ResolverTypeWrapper<INotificationViewItem>;
     NotificationMessage: ResolverTypeWrapper<INotificationMessage>;
     NotificationViewItemProgress: ResolverTypeWrapper<INotificationViewItemProgress>;
     NotificationViewItemProgressState: ResolverTypeWrapper<INotificationViewItemProgressState>;
+    NotificationChangeType: INotificationChangeType;
     NotificationViewItemLabelKind: INotificationViewItemLabelKind;
-    ExtensionRegistryCreateExtensionResult: ResolverTypeWrapper<IExtensionRegistryCreateExtensionResult>;
-    ExtensionRegistryUpdateExtensionResult: ResolverTypeWrapper<IExtensionRegistryUpdateExtensionResult>;
-    Date: ResolverTypeWrapper<Scalars['Date']>;
+    ProvideTextDocumentLocationSignature: ResolverTypeWrapper<IProvideTextDocumentLocationSignature>;
+    TextDocumentPositionParams: IResolversTypes['ProvideTextDocumentLocationSignature'];
+    TextDocumentIdentifier: ResolverTypeWrapper<ITextDocumentIdentifier>;
+    RangeInput: IRangeInput;
+    RegistryEntry: ResolverTypeWrapper<IRegistryEntry>;
+    TextDocumentRegistrationOptions: ResolverTypeWrapper<ITextDocumentRegistrationOptions>;
     Time: ResolverTypeWrapper<Scalars['Time']>;
-    DateTime: ResolverTypeWrapper<Scalars['DateTime']>;
     URIInput: ResolverTypeWrapper<Scalars['URIInput']>;
-    JSONObject: ResolverTypeWrapper<Scalars['JSONObject']>;
-    CacheControlScope: ICacheControlScope;
-    FieldError: ResolverTypeWrapper<IFieldError>;
-    AdminIdeSettings: ResolverTypeWrapper<IAdminIdeSettings>;
-    MoleculerServiceName: IMoleculerServiceName;
+    ViewContainer: ResolverTypeWrapper<IViewContainer>;
 };
 /** Mapping between all available schema types and the resolvers parents */
 export declare type IResolversParentTypes = {
@@ -2305,7 +2670,6 @@ export declare type IResolversParentTypes = {
     Int: Scalars['Int'];
     MenuItem: IMenuItem;
     ContributionActionRun: IContributionActionRun;
-    GraphqlCallType: IGraphqlCallType;
     AnyObject: Scalars['AnyObject'];
     DocSitePage: IDocSitePage;
     RegistryExtension: IRegistryExtension;
@@ -2314,7 +2678,6 @@ export declare type IResolversParentTypes = {
     RegistryPublisher: IRegistryPublisher;
     ExtensionManifest: IExtensionManifest;
     JSON: Scalars['JSON'];
-    ExtensionKind: IExtensionKind;
     Assets: IAssets;
     Scripts: IScripts;
     Bundles: IBundles;
@@ -2367,7 +2730,6 @@ export declare type IResolversParentTypes = {
     ProcessMonitoring: IProcessMonitoring;
     Notifications: INotifications;
     Notification: INotification;
-    NotificationSeverity: INotificationSeverity;
     NotificationActions: INotificationActions;
     ContributionAction: IContributionAction;
     TextDocumentRegistrationOptionsInput: ITextDocumentRegistrationOptionsInput;
@@ -2401,63 +2763,59 @@ export declare type IResolversParentTypes = {
     IViewComponentDataInput: IIViewComponentDataInput;
     TextDocumentItemInput: ITextDocumentItemInput;
     Subscription: {};
-    CommandType: ICommandType;
-    CommandHandlerDescriptionType: ICommandHandlerDescriptionType;
+    AdminIdeSettings: IAdminIdeSettings;
     ArgsType: IArgsType;
+    BaseExtension: IBaseExtension;
+    CommandHandlerDescriptionType: ICommandHandlerDescriptionType;
+    CommandType: ICommandType;
     CommandsType: ICommandsType;
-    RegistryEntry: IRegistryEntry;
-    TextDocumentRegistrationOptions: ITextDocumentRegistrationOptions;
+    Contributes: IContributes;
+    ContributionView: IContributionView;
+    Date: Scalars['Date'];
+    DateTime: Scalars['DateTime'];
     DocumentFilter: IDocumentFilter;
-    ITextDocumentIdentifier: IResolversParentTypes['TextDocumentIdentifier'] | IResolversParentTypes['TextDocumentItem'];
-    TextDocumentIdentifier: ITextDocumentIdentifier;
-    ProvideTextDocumentLocationSignature: IProvideTextDocumentLocationSignature;
-    TextDocumentPositionParams: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
-    Position: IPosition;
-    Location: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
-    MarkupKind: IMarkupKind;
-    Range: IRange;
-    IViewComponentData: IIViewComponentData;
-    TextDocumentItem: ITextDocumentItem;
-    IWorkspaceRoot: IIWorkspaceRoot;
-    IModel: IIModel;
-    ISwitchMapOperator: IISwitchMapOperator;
-    IDocumentSelector: IIDocumentSelector;
-    IBehaviorSubjectValue: IIBehaviorSubjectValue;
-    IBehaviorSubject: IIBehaviorSubject;
-    IDestinationAnonymousSubject: IIDestinationAnonymousSubject;
-    ISourceAnonymousSubject: IISourceAnonymousSubject;
-    IObservableResult: IIObservableResult;
     Environment: IEnvironment;
-    EnvironmentSync: IEnvironmentSync;
     EnvironmentPayload: IEnvironmentPayload;
-    ViewContainer: IViewContainer;
-    ContributionView: IContributionView;
-    RangeInput: IRangeInput;
-    ExtensionType: IExtensionType;
-    BaseExtension: IBaseExtension;
     ExtensionConfigurationProperty: IExtensionConfigurationProperty;
-    Contributes: IContributes;
+    ExtensionRegistryCreateExtensionResult: IExtensionRegistryCreateExtensionResult;
+    ExtensionRegistryUpdateExtensionResult: IExtensionRegistryUpdateExtensionResult;
+    FieldError: IFieldError;
     GalleryFilter: IGalleryFilter;
-    MenuId: IMenuId;
+    GeoLocation: IGeoLocation;
+    Hover: never;
+    MarkupContent: never;
+    Range: IRange;
+    Position: IPosition;
+    IBehaviorSubject: IIBehaviorSubject;
+    IBehaviorSubjectValue: IIBehaviorSubjectValue;
+    IDocumentSelector: IIDocumentSelector;
+    IDestinationAnonymousSubject: IIDestinationAnonymousSubject;
+    ISwitchMapOperator: IISwitchMapOperator;
+    IModel: IIModel;
+    IWorkspaceRoot: IIWorkspaceRoot;
+    IViewComponentData: IIViewComponentData;
+    TextDocumentItem: ITextDocumentItem;
+    ITextDocumentIdentifier: IResolversParentTypes['TextDocumentItem'] | IResolversParentTypes['TextDocumentIdentifier'];
+    IObservableResult: IIObservableResult;
+    ISourceAnonymousSubject: IISourceAnonymousSubject;
+    IResourceUtilizationSettings: never;
+    JSONObject: Scalars['JSONObject'];
+    Location: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
     MessageLink: IMessageLink;
-    NotificationChangeType: INotificationChangeType;
     NotificationChangeEvent: INotificationChangeEvent;
     NotificationViewItem: INotificationViewItem;
     NotificationMessage: INotificationMessage;
     NotificationViewItemProgress: INotificationViewItemProgress;
     NotificationViewItemProgressState: INotificationViewItemProgressState;
-    NotificationViewItemLabelKind: INotificationViewItemLabelKind;
-    ExtensionRegistryCreateExtensionResult: IExtensionRegistryCreateExtensionResult;
-    ExtensionRegistryUpdateExtensionResult: IExtensionRegistryUpdateExtensionResult;
-    Date: Scalars['Date'];
+    ProvideTextDocumentLocationSignature: IProvideTextDocumentLocationSignature;
+    TextDocumentPositionParams: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
+    TextDocumentIdentifier: ITextDocumentIdentifier;
+    RangeInput: IRangeInput;
+    RegistryEntry: IRegistryEntry;
+    TextDocumentRegistrationOptions: ITextDocumentRegistrationOptions;
     Time: Scalars['Time'];
-    DateTime: Scalars['DateTime'];
     URIInput: Scalars['URIInput'];
-    JSONObject: Scalars['JSONObject'];
-    CacheControlScope: ICacheControlScope;
-    FieldError: IFieldError;
-    AdminIdeSettings: IAdminIdeSettings;
-    MoleculerServiceName: IMoleculerServiceName;
+    ViewContainer: IViewContainer;
 };
 export declare type IcacheControlDirectiveArgs = {
     maxAge?: Maybe<Scalars['Int']>;
@@ -2466,14 +2824,14 @@ export declare type IcacheControlDirectiveArgs = {
 export declare type IcacheControlDirectiveResolver<Result, Parent, ContextType = MyContext, Args = IcacheControlDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
 export declare type IAdminIdeSettingsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['AdminIdeSettings'] = IResolversParentTypes['AdminIdeSettings']> = {
     dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IAnchorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Anchor'] = IResolversParentTypes['Anchor']> = {
     x?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     y?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     height?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     width?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export interface IAnyObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['AnyObject'], any> {
     name: 'AnyObject';
@@ -2482,16 +2840,16 @@ export declare type IArgsTypeResolvers<ContextType = MyContext, ParentType exten
     name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     constraint?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IAssetsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Assets'] = IResolversParentTypes['Assets']> = {
     Type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     Content?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IAuthorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Author'] = IResolversParentTypes['Author']> = {
     name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IBaseExtensionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['BaseExtension'] = IResolversParentTypes['BaseExtension']> = {
     type?: Resolver<Maybe<IResolversTypes['ExtensionType']>, ParentType, ContextType>;
@@ -2499,40 +2857,40 @@ export declare type IBaseExtensionResolvers<ContextType = MyContext, ParentType
     galleryIdentifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
     manifest?: Resolver<Maybe<IResolversTypes['ExtensionManifest']>, ParentType, ContextType>;
     location?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IBundlesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Bundles'] = IResolversParentTypes['Bundles']> = {
     server?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     browser?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ICommandHandlerDescriptionTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['CommandHandlerDescriptionType'] = IResolversParentTypes['CommandHandlerDescriptionType']> = {
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     args?: Resolver<Maybe<Array<Maybe<IResolversTypes['ArgsType']>>>, ParentType, ContextType>;
     returns?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ICommandsTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['CommandsType'] = IResolversParentTypes['CommandsType']> = {
     commands?: Resolver<Maybe<Array<Maybe<IResolversTypes['CommandType']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ICommandTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['CommandType'] = IResolversParentTypes['CommandType']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     handler?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
     description?: Resolver<Maybe<IResolversTypes['CommandHandlerDescriptionType']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContextMenuResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContextMenu'] = IResolversParentTypes['ContextMenu']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     isShow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     anchor?: Resolver<Maybe<IResolversTypes['Anchor']>, ParentType, ContextType>;
     menuItems?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItem']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Contributes'] = IResolversParentTypes['Contributes']> = {
     menus?: Resolver<Maybe<IResolversTypes['Menus']>, ParentType, ContextType>;
     actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionActions']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributionActionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionAction'] = IResolversParentTypes['ContributionAction']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2543,18 +2901,18 @@ export declare type IContributionActionResolvers<ContextType = MyContext, Parent
     checked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     radio?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     run?: Resolver<Maybe<IResolversTypes['ContributionActionRun']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributionActionItemResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActionItem'] = IResolversParentTypes['ContributionActionItem']> = {
     label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributionActionRunResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActionRun'] = IResolversParentTypes['ContributionActionRun']> = {
     type?: Resolver<Maybe<IResolversTypes['GraphqlCallType']>, ParentType, ContextType>;
     document?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
     variables?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributionActionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActions'] = IResolversParentTypes['ContributionActions']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2562,12 +2920,12 @@ export declare type IContributionActionsResolvers<ContextType = MyContext, Paren
     title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     actionItem?: Resolver<Maybe<IResolversTypes['ContributionActionItem']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IContributionViewResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionView'] = IResolversParentTypes['ContributionView']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export interface IDateScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Date'], any> {
     name: 'Date';
@@ -2579,29 +2937,29 @@ export declare type IDebuggerResolvers<ContextType = MyContext, ParentType exten
     label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     runtime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IDocSitePageResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['DocSitePage'] = IResolversParentTypes['DocSitePage']> = {
     title?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     contentHTML?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     indexHTML?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     filePath?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IDocumentFilterResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['DocumentFilter'] = IResolversParentTypes['DocumentFilter']> = {
     language?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     schema?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     pattern?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IEmptyResponseResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['EmptyResponse'] = IResolversParentTypes['EmptyResponse']> = {
     alwaysNil?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IEnginesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Engines'] = IResolversParentTypes['Engines']> = {
     node?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     vscode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IEnvironmentResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Environment'] = IResolversParentTypes['Environment']> = {
     extHostLogsPath?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
@@ -2620,29 +2978,29 @@ export declare type IEnvironmentResolvers<ContextType = MyContext, ParentType ex
     webviewCspSource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     webviewExternalEndpoint?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     webviewResourceRoot?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionColorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionColor'] = IResolversParentTypes['ExtensionColor']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     defaults?: Resolver<Maybe<IResolversTypes['ExtensionColorTypes']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionColorTypesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionColorTypes'] = IResolversParentTypes['ExtensionColorTypes']> = {
     light?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     dark?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     highContrast?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionConfigurationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionConfiguration'] = IResolversParentTypes['ExtensionConfiguration']> = {
     properties?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionConfigurationPropertyResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionConfigurationProperty'] = IResolversParentTypes['ExtensionConfigurationProperty']> = {
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     type?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
     defaults?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionContributionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionContributions'] = IResolversParentTypes['ExtensionContributions']> = {
     actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionActions']>>>, ParentType, ContextType>;
@@ -2661,12 +3019,12 @@ export declare type IExtensionContributionsResolvers<ContextType = MyContext, Pa
     views?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
     colors?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionColor']>>>, ParentType, ContextType>;
     localizations?: Resolver<Maybe<Array<Maybe<IResolversTypes['Localization']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionIdentifierResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionIdentifier'] = IResolversParentTypes['ExtensionIdentifier']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     uuid?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionInstanceResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionInstance'] = IResolversParentTypes['ExtensionInstance']> = {
     pid?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2676,18 +3034,18 @@ export declare type IExtensionInstanceResolvers<ContextType = MyContext, ParentT
     status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     extensionID?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     monit?: Resolver<Maybe<IResolversTypes['ProcessMonitoring']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionJSONValidationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionJSONValidation'] = IResolversParentTypes['ExtensionJSONValidation']> = {
     fileMatch?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionLanguageResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionLanguage'] = IResolversParentTypes['ExtensionLanguage']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     extensions?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
     aliases?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionManifestResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionManifest'] = IResolversParentTypes['ExtensionManifest']> = {
     name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2730,21 +3088,21 @@ export declare type IExtensionManifestResolvers<ContextType = MyContext, ParentT
     repository?: Resolver<Maybe<IResolversTypes['ExtensionManifestRepository']>, ParentType, ContextType>;
     enableProposedApi?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     api?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionManifestBugsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionManifestBugs'] = IResolversParentTypes['ExtensionManifestBugs']> = {
     url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     email?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionManifestRepositoryResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionManifestRepository'] = IResolversParentTypes['ExtensionManifestRepository']> = {
     type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionPackageTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionPackageType'] = IResolversParentTypes['ExtensionPackageType']> = {
     type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionRegistryResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistry'] = IResolversParentTypes['ExtensionRegistry']> = {
     extension?: Resolver<Maybe<IResolversTypes['RegistryExtension']>, ParentType, ContextType, RequireFields<IExtensionRegistryextensionArgs, 'extensionID'>>;
@@ -2753,19 +3111,19 @@ export declare type IExtensionRegistryResolvers<ContextType = MyContext, ParentT
     publishers?: Resolver<IResolversTypes['RegistryPublisherConnection'], ParentType, ContextType, RequireFields<IExtensionRegistrypublishersArgs, never>>;
     viewerPublishers?: Resolver<Array<IResolversTypes['RegistryPublisher']>, ParentType, ContextType>;
     localExtensionIDPrefix?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionRegistryCreateExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryCreateExtensionResult'] = IResolversParentTypes['ExtensionRegistryCreateExtensionResult']> = {
     extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionRegistryPublishExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryPublishExtensionResult'] = IResolversParentTypes['ExtensionRegistryPublishExtensionResult']> = {
     extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionRegistryUpdateExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryUpdateExtensionResult'] = IResolversParentTypes['ExtensionRegistryUpdateExtensionResult']> = {
     extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IExtensionReleaseResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRelease'] = IResolversParentTypes['ExtensionRelease']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
@@ -2778,17 +3136,17 @@ export declare type IExtensionReleaseResolvers<ContextType = MyContext, ParentTy
     creatorUserId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     releaseVersion?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     activationEvents?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IFieldErrorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['FieldError'] = IResolversParentTypes['FieldError']> = {
     field?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     message?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryBannerResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryBanner'] = IResolversParentTypes['GalleryBanner']> = {
     color?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     theme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryExtensionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryExtension'] = IResolversParentTypes['GalleryExtension']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2809,12 +3167,12 @@ export declare type IGalleryExtensionResolvers<ContextType = MyContext, ParentTy
     properties?: Resolver<Maybe<IResolversTypes['GalleryExtensionProperties']>, ParentType, ContextType>;
     preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     resources?: Resolver<Maybe<IResolversTypes['GalleryExtensionResources']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryExtensionAssetResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryExtensionAsset'] = IResolversParentTypes['GalleryExtensionAsset']> = {
     uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     fallbackUri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryExtensionAssetsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryExtensionAssets'] = IResolversParentTypes['GalleryExtensionAssets']> = {
     manifest?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
@@ -2825,14 +3183,14 @@ export declare type IGalleryExtensionAssetsResolvers<ContextType = MyContext, Pa
     license?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
     repository?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
     coreTranslations?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryExtensionPropertiesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryExtensionProperties'] = IResolversParentTypes['GalleryExtensionProperties']> = {
     engine?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     dependencies?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
     extensionPack?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
     localizedLanguages?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryExtensionResourcesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryExtensionResources'] = IResolversParentTypes['GalleryExtensionResources']> = {
     manifest?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2842,18 +3200,27 @@ export declare type IGalleryExtensionResourcesResolvers<ContextType = MyContext,
     icon?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     license?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     repository?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGalleryPagerResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GalleryPager'] = IResolversParentTypes['GalleryPager']> = {
     page?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     pageSize?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     firstPage?: Resolver<Maybe<Array<Maybe<IResolversTypes['GalleryExtension']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IGeoLocationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GeoLocation'] = IResolversParentTypes['GeoLocation']> = {
+    coordinates?: Resolver<Maybe<Array<Maybe<IResolversTypes['Float']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IGrammarResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Grammar'] = IResolversParentTypes['Grammar']> = {
     language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IHoverResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Hover'] = IResolversParentTypes['Hover']> = {
+    __resolveType: TypeResolveFn<null, ParentType, ContextType>;
+    contents?: Resolver<Maybe<IResolversTypes['MarkupContent']>, ParentType, ContextType>;
+    range?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
 };
 export declare type IIBehaviorSubjectResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IBehaviorSubject'] = IResolversParentTypes['IBehaviorSubject']> = {
     closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
@@ -2863,12 +3230,12 @@ export declare type IIBehaviorSubjectResolvers<ContextType = MyContext, ParentTy
     thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     value?: Resolver<Maybe<Array<Maybe<IResolversTypes['IBehaviorSubjectValue']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIBehaviorSubjectValueResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IBehaviorSubjectValue'] = IResolversParentTypes['IBehaviorSubjectValue']> = {
     provider?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     registrationOptions?: Resolver<Maybe<IResolversTypes['IDocumentSelector']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIDestinationAnonymousSubjectResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IDestinationAnonymousSubject'] = IResolversParentTypes['IDestinationAnonymousSubject']> = {
     closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
@@ -2880,22 +3247,22 @@ export declare type IIDestinationAnonymousSubjectResolvers<ContextType = MyConte
     source?: Resolver<Maybe<IResolversTypes['IBehaviorSubject']>, ParentType, ContextType>;
     thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIDocumentSelectorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IDocumentSelector'] = IResolversParentTypes['IDocumentSelector']> = {
     documentSelector?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIModelResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IModel'] = IResolversParentTypes['IModel']> = {
     roots?: Resolver<Maybe<IResolversTypes['IWorkspaceRoot']>, ParentType, ContextType>;
     visibleViewComponents?: Resolver<Maybe<Array<Maybe<IResolversTypes['IViewComponentData']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IInstalledExtensionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['InstalledExtension'] = IResolversParentTypes['InstalledExtension']> = {
     extension?: Resolver<Maybe<IResolversTypes['GalleryExtension']>, ParentType, ContextType>;
     identifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
     galleryIdentifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIObservableResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IObservableResult'] = IResolversParentTypes['IObservableResult']> = {
     closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
@@ -2907,7 +3274,12 @@ export declare type IIObservableResultResolvers<ContextType = MyContext, ParentT
     source?: Resolver<Maybe<IResolversTypes['ISourceAnonymousSubject']>, ParentType, ContextType>;
     thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IIResourceUtilizationSettingsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IResourceUtilizationSettings'] = IResolversParentTypes['IResourceUtilizationSettings']> = {
+    __resolveType: TypeResolveFn<null, ParentType, ContextType>;
+    subTopic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    adminApiNamespace?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
 };
 export declare type IISourceAnonymousSubjectResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ISourceAnonymousSubject'] = IResolversParentTypes['ISourceAnonymousSubject']> = {
     closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
@@ -2919,14 +3291,14 @@ export declare type IISourceAnonymousSubjectResolvers<ContextType = MyContext, P
     source?: Resolver<Maybe<IResolversTypes['IBehaviorSubject']>, ParentType, ContextType>;
     thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IISwitchMapOperatorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ISwitchMapOperator'] = IResolversParentTypes['ISwitchMapOperator']> = {
     project?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IITextDocumentIdentifierResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ITextDocumentIdentifier'] = IResolversParentTypes['ITextDocumentIdentifier']> = {
-    __resolveType: TypeResolveFn<'TextDocumentIdentifier' | 'TextDocumentItem', ParentType, ContextType>;
+    __resolveType: TypeResolveFn<'TextDocumentItem' | 'TextDocumentIdentifier', ParentType, ContextType>;
     uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
     languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
 };
@@ -2934,11 +3306,11 @@ export declare type IIViewComponentDataResolvers<ContextType = MyContext, Parent
     type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     item?: Resolver<Maybe<IResolversTypes['TextDocumentItem']>, ParentType, ContextType>;
     isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IIWorkspaceRootResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IWorkspaceRoot'] = IResolversParentTypes['IWorkspaceRoot']> = {
     url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export interface IJSONScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
     name: 'JSON';
@@ -2953,7 +3325,7 @@ export declare type IKeyBindingResolvers<ContextType = MyContext, ParentType ext
     mac?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     linux?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     win?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ILocalizationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Localization'] = IResolversParentTypes['Localization']> = {
     languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
@@ -2961,12 +3333,12 @@ export declare type ILocalizationResolvers<ContextType = MyContext, ParentType e
     localizedLanguageName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     translations?: Resolver<Maybe<Array<Maybe<IResolversTypes['LocalizationTranslation']>>>, ParentType, ContextType>;
     minimalTranslations?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ILocalizationTranslationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['LocalizationTranslation'] = IResolversParentTypes['LocalizationTranslation']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ILocationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Location'] = IResolversParentTypes['Location']> = {
     __resolveType: TypeResolveFn<'ProvideTextDocumentLocationSignature', ParentType, ContextType>;
@@ -2975,52 +3347,57 @@ export declare type ILocationResolvers<ContextType = MyContext, ParentType exten
     range?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
     uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
 };
+export declare type IMarkupContentResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MarkupContent'] = IResolversParentTypes['MarkupContent']> = {
+    __resolveType: TypeResolveFn<null, ParentType, ContextType>;
+    value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    kind?: Resolver<Maybe<IResolversTypes['MarkupKind']>, ParentType, ContextType>;
+};
 export declare type IMenuItemResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItem'] = IResolversParentTypes['MenuItem']> = {
     id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     run?: Resolver<Maybe<IResolversTypes['ContributionActionRun']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemAction'] = IResolversParentTypes['MenuItemAction']> = {
     action?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionContextResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionContext'] = IResolversParentTypes['MenuItemActionContext']> = {
     context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionDebugResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionDebug'] = IResolversParentTypes['MenuItemActionDebug']> = {
     callstack?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
     toolbar?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionEditorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionEditor'] = IResolversParentTypes['MenuItemActionEditor']> = {
     context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
     title?: Resolver<Maybe<IResolversTypes['MenuItemActionEditorTitle']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionEditorTitleResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionEditorTitle'] = IResolversParentTypes['MenuItemActionEditorTitle']> = {
     own?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
     context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionScmResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionScm'] = IResolversParentTypes['MenuItemActionScm']> = {
     title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
     resourceGroup?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
     resource?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
     change?: Resolver<Maybe<IResolversTypes['MenuItemActionScmChange']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionScmChangeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionScmChange'] = IResolversParentTypes['MenuItemActionScmChange']> = {
     title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenuItemActionViewResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionView'] = IResolversParentTypes['MenuItemActionView']> = {
     title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
     item?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMenusResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Menus'] = IResolversParentTypes['Menus']> = {
     commandPalette?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
@@ -3030,14 +3407,14 @@ export declare type IMenusResolvers<ContextType = MyContext, ParentType extends
     scm?: Resolver<Maybe<IResolversTypes['MenuItemActionScm']>, ParentType, ContextType>;
     view?: Resolver<Maybe<IResolversTypes['MenuItemActionView']>, ParentType, ContextType>;
     touchBar?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMessageLinkResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MessageLink'] = IResolversParentTypes['MessageLink']> = {
     name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     href?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     offset?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     length?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IMutationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
     activate?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationactivateArgs, 'request'>>;
@@ -3084,29 +3461,29 @@ export declare type INotificationResolvers<ContextType = MyContext, ParentType e
     source?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     actions?: Resolver<Maybe<IResolversTypes['NotificationActions']>, ParentType, ContextType>;
     sticky?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationActionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationActions'] = IResolversParentTypes['NotificationActions']> = {
     primary?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionAction']>>>, ParentType, ContextType>;
     secondary?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionAction']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationChangeEventResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationChangeEvent'] = IResolversParentTypes['NotificationChangeEvent']> = {
     index?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     item?: Resolver<Maybe<IResolversTypes['NotificationViewItem']>, ParentType, ContextType>;
     kind?: Resolver<Maybe<IResolversTypes['NotificationChangeType']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationMessageResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationMessage'] = IResolversParentTypes['NotificationMessage']> = {
     raw?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     original?: Resolver<Maybe<IResolversTypes['NotificationMessage']>, ParentType, ContextType>;
     value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     links?: Resolver<Maybe<Array<Maybe<IResolversTypes['MessageLink']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Notifications'] = IResolversParentTypes['Notifications']> = {
     notifications?: Resolver<Maybe<Array<Maybe<IResolversTypes['Notification']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationViewItemResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationViewItem'] = IResolversParentTypes['NotificationViewItem']> = {
     severity?: Resolver<Maybe<IResolversTypes['NotificationSeverity']>, ParentType, ContextType>;
@@ -3118,37 +3495,37 @@ export declare type INotificationViewItemResolvers<ContextType = MyContext, Pare
     progress?: Resolver<Maybe<IResolversTypes['NotificationViewItemProgress']>, ParentType, ContextType>;
     expanded?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     canCollapse?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationViewItemProgressResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationViewItemProgress'] = IResolversParentTypes['NotificationViewItemProgress']> = {
     state?: Resolver<Maybe<IResolversTypes['NotificationViewItemProgressState']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type INotificationViewItemProgressStateResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationViewItemProgressState'] = IResolversParentTypes['NotificationViewItemProgressState']> = {
     infinite?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     worked?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     done?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export interface IObservableScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Observable'], any> {
     name: 'Observable';
 }
 export declare type IPageInfoResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['PageInfo'] = IResolversParentTypes['PageInfo']> = {
     hasNextPage?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IPositionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Position'] = IResolversParentTypes['Position']> = {
     lineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     column?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     line?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     character?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IProcessMonitoringResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ProcessMonitoring'] = IResolversParentTypes['ProcessMonitoring']> = {
     cpu?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
     memory?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IProvideTextDocumentLocationSignatureResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ProvideTextDocumentLocationSignature'] = IResolversParentTypes['ProvideTextDocumentLocationSignature']> = {
     textDocument?: Resolver<Maybe<IResolversTypes['TextDocumentIdentifier']>, ParentType, ContextType>;
@@ -3157,7 +3534,7 @@ export declare type IProvideTextDocumentLocationSignatureResolvers<ContextType =
     uriRangeOrPosition?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     range?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
     uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IQueryResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
     contextMenu?: Resolver<Maybe<IResolversTypes['ContextMenu']>, ParentType, ContextType>;
@@ -3182,12 +3559,12 @@ export declare type IRangeResolvers<ContextType = MyContext, ParentType extends
     startColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     endLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
     endColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IRegistryEntryResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryEntry'] = IResolversParentTypes['RegistryEntry']> = {
     registrationOptions?: Resolver<Maybe<IResolversTypes['TextDocumentRegistrationOptions']>, ParentType, ContextType>;
     provider?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IRegistryExtensionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryExtension'] = IResolversParentTypes['RegistryExtension']> = {
     id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
@@ -3205,7 +3582,7 @@ export declare type IRegistryExtensionResolvers<ContextType = MyContext, ParentT
     isLocal?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     viewerCanAdminister?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     releases?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionRelease']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IRegistryExtensionConnectionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryExtensionConnection'] = IResolversParentTypes['RegistryExtensionConnection']> = {
     nodes?: Resolver<Array<IResolversTypes['RegistryExtension']>, ParentType, ContextType>;
@@ -3213,26 +3590,26 @@ export declare type IRegistryExtensionConnectionResolvers<ContextType = MyContex
     pageInfo?: Resolver<IResolversTypes['PageInfo'], ParentType, ContextType>;
     url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     error?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IRegistryPublisherResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryPublisher'] = IResolversParentTypes['RegistryPublisher']> = {
     UserId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IRegistryPublisherConnectionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryPublisherConnection'] = IResolversParentTypes['RegistryPublisherConnection']> = {
     nodes?: Resolver<Array<IResolversTypes['RegistryPublisher']>, ParentType, ContextType>;
     totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
     pageInfo?: Resolver<IResolversTypes['PageInfo'], ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IScriptsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Scripts'] = IResolversParentTypes['Scripts']> = {
     cdebasebuild?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     cdebasepublish?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ISnippetResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Snippet'] = IResolversParentTypes['Snippet']> = {
     language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ISubscriptionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
     dummy?: SubscriptionResolver<Maybe<IResolversTypes['Int']>, "dummy", ParentType, ContextType>;
@@ -3240,13 +3617,13 @@ export declare type ISubscriptionResolvers<ContextType = MyContext, ParentType e
 export declare type ITextDocumentIdentifierResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['TextDocumentIdentifier'] = IResolversParentTypes['TextDocumentIdentifier']> = {
     uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
     languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ITextDocumentItemResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['TextDocumentItem'] = IResolversParentTypes['TextDocumentItem']> = {
     uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
     languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     text?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type ITextDocumentPositionParamsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['TextDocumentPositionParams'] = IResolversParentTypes['TextDocumentPositionParams']> = {
     __resolveType: TypeResolveFn<'ProvideTextDocumentLocationSignature', ParentType, ContextType>;
@@ -3255,13 +3632,13 @@ export declare type ITextDocumentPositionParamsResolvers<ContextType = MyContext
 };
 export declare type ITextDocumentRegistrationOptionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['TextDocumentRegistrationOptions'] = IResolversParentTypes['TextDocumentRegistrationOptions']> = {
     documentSelector?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IThemeLabelResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ThemeLabel'] = IResolversParentTypes['ThemeLabel']> = {
     label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     uiTheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export interface ITimeScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Time'], any> {
     name: 'Time';
@@ -3275,7 +3652,7 @@ export interface IURIInputScalarConfig extends GraphQLScalarTypeConfig<IResolver
 export declare type IViewContainerResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ViewContainer'] = IResolversParentTypes['ViewContainer']> = {
     id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
     title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: isTypeOfResolverFn<ParentType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export declare type IResolvers<ContextType = MyContext> = {
     AdminIdeSettings?: IAdminIdeSettingsResolvers<ContextType>;
@@ -3330,7 +3707,9 @@ export declare type IResolvers<ContextType = MyContext> = {
     GalleryExtensionProperties?: IGalleryExtensionPropertiesResolvers<ContextType>;
     GalleryExtensionResources?: IGalleryExtensionResourcesResolvers<ContextType>;
     GalleryPager?: IGalleryPagerResolvers<ContextType>;
+    GeoLocation?: IGeoLocationResolvers<ContextType>;
     Grammar?: IGrammarResolvers<ContextType>;
+    Hover?: IHoverResolvers<ContextType>;
     IBehaviorSubject?: IIBehaviorSubjectResolvers<ContextType>;
     IBehaviorSubjectValue?: IIBehaviorSubjectValueResolvers<ContextType>;
     IDestinationAnonymousSubject?: IIDestinationAnonymousSubjectResolvers<ContextType>;
@@ -3338,9 +3717,10 @@ export declare type IResolvers<ContextType = MyContext> = {
     IModel?: IIModelResolvers<ContextType>;
     InstalledExtension?: IInstalledExtensionResolvers<ContextType>;
     IObservableResult?: IIObservableResultResolvers<ContextType>;
+    IResourceUtilizationSettings?: IIResourceUtilizationSettingsResolvers<ContextType>;
     ISourceAnonymousSubject?: IISourceAnonymousSubjectResolvers<ContextType>;
     ISwitchMapOperator?: IISwitchMapOperatorResolvers<ContextType>;
-    ITextDocumentIdentifier?: IITextDocumentIdentifierResolvers;
+    ITextDocumentIdentifier?: IITextDocumentIdentifierResolvers<ContextType>;
     IViewComponentData?: IIViewComponentDataResolvers<ContextType>;
     IWorkspaceRoot?: IIWorkspaceRootResolvers<ContextType>;
     JSON?: GraphQLScalarType;
@@ -3348,7 +3728,8 @@ export declare type IResolvers<ContextType = MyContext> = {
     KeyBinding?: IKeyBindingResolvers<ContextType>;
     Localization?: ILocalizationResolvers<ContextType>;
     LocalizationTranslation?: ILocalizationTranslationResolvers<ContextType>;
-    Location?: ILocationResolvers;
+    Location?: ILocationResolvers<ContextType>;
+    MarkupContent?: IMarkupContentResolvers<ContextType>;
     MenuItem?: IMenuItemResolvers<ContextType>;
     MenuItemAction?: IMenuItemActionResolvers<ContextType>;
     MenuItemActionContext?: IMenuItemActionContextResolvers<ContextType>;
@@ -3361,7 +3742,7 @@ export declare type IResolvers<ContextType = MyContext> = {
     Menus?: IMenusResolvers<ContextType>;
     MessageLink?: IMessageLinkResolvers<ContextType>;
     Mutation?: IMutationResolvers<ContextType>;
-    Node?: INodeResolvers;
+    Node?: INodeResolvers<ContextType>;
     Notification?: INotificationResolvers<ContextType>;
     NotificationActions?: INotificationActionsResolvers<ContextType>;
     NotificationChangeEvent?: INotificationChangeEventResolvers<ContextType>;
@@ -3387,7 +3768,7 @@ export declare type IResolvers<ContextType = MyContext> = {
     Subscription?: ISubscriptionResolvers<ContextType>;
     TextDocumentIdentifier?: ITextDocumentIdentifierResolvers<ContextType>;
     TextDocumentItem?: ITextDocumentItemResolvers<ContextType>;
-    TextDocumentPositionParams?: ITextDocumentPositionParamsResolvers;
+    TextDocumentPositionParams?: ITextDocumentPositionParamsResolvers<ContextType>;
     TextDocumentRegistrationOptions?: ITextDocumentRegistrationOptionsResolvers<ContextType>;
     ThemeLabel?: IThemeLabelResolvers<ContextType>;
     Time?: GraphQLScalarType;