1
>
/*---------------------------------------------------------------------------------------------
extHost.protocol.ts
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { VSBuffer } from '../../../base/common/buffer.js';
7
>
import { CancellationToken } from '../../../base/common/cancellation.js';
8
>
import { IRemoteConsoleLog } from '../../../base/common/console.js';
9
>
import { SerializedError } from '../../../base/common/errors.js';
10
>
import { IRelativePattern } from '../../../base/common/glob.js';
11
>
import { IMarkdownString } from '../../../base/common/htmlContent.js';
12
>
import { IJSONSchema } from '../../../base/common/jsonSchema.js';
13
>
import { IDisposable } from '../../../base/common/lifecycle.js';
14
>
import { IAuthorizationProtectedResourceMetadata, IAuthorizationServerMetadata, IAuthorizationTokenResponse } from '../../../base/common/oauth.js';
15
>
import * as performance from '../../../base/common/performance.js';
16
>
import Severity from '../../../base/common/severity.js';
17
>
import { ThemeColor, ThemeIcon } from '../../../base/common/themables.js';
18
>
import { URI, UriComponents, UriDto } from '../../../base/common/uri.js';
19
>
import { RenderLineNumbersType, TextEditorCursorStyle } from '../../../editor/common/config/editorOptions.js';
20
>
import { ISingleEditOperation } from '../../../editor/common/core/editOperation.js';
21
>
import { IPosition } from '../../../editor/common/core/position.js';
22
>
import { IRange } from '../../../editor/common/core/range.js';
23
>
import { ISelection, Selection } from '../../../editor/common/core/selection.js';
24
>
import { IChange } from '../../../editor/common/diff/legacyLinesDiffComputer.js';
25
>
import * as editorCommon from '../../../editor/common/editorCommon.js';
26
>
import { StandardTokenType } from '../../../editor/common/encodedTokenAttributes.js';
27
>
import * as languages from '../../../editor/common/languages.js';
28
>
import { CompletionItemLabel } from '../../../editor/common/languages.js';
29
>
import { CharacterPair, CommentRule, EnterAction } from '../../../editor/common/languages/languageConfiguration.js';
30
>
import { EndOfLineSequence } from '../../../editor/common/model.js';
31
>
import { EditSuggestionId } from '../../../editor/common/textModelEditSource.js';
32
>
import { ISerializedModelContentChangedEvent } from '../../../editor/common/textModelEvents.js';
33
>
import { IAccessibilityInformation } from '../../../platform/accessibility/common/accessibility.js';
34
>
import { ILocalizedString } from '../../../platform/action/common/action.js';
35
>
import { ConfigurationTarget, IConfigurationChange, IConfigurationData, IConfigurationOverrides } from '../../../platform/configuration/common/configuration.js';
36
>
import { ConfigurationScope } from '../../../platform/configuration/common/configurationRegistry.js';
37
>
import { IEditorOptions } from '../../../platform/editor/common/editor.js';
38
>
import { IExtensionIdWithVersion } from '../../../platform/extensionManagement/common/extensionStorage.js';
39
>
import { ExtensionIdentifier, IExtensionDescription } from '../../../platform/extensions/common/extensions.js';
40
>
import * as files from '../../../platform/files/common/files.js';
41
>
import { ResourceLabelFormatter } from '../../../platform/label/common/label.js';
42
>
import { ILoggerOptions, ILoggerResource, LogLevel } from '../../../platform/log/common/log.js';
43
>
import { IMarkerData } from '../../../platform/markers/common/markers.js';
44
>
import { IProgressOptions, IProgressStep } from '../../../platform/progress/common/progress.js';
45
>
import * as quickInput from '../../../platform/quickinput/common/quickInput.js';
46
>
import { IRemoteConnectionData, TunnelDescription } from '../../../platform/remote/common/remoteAuthorityResolver.js';
47
>
import { AuthInfo, Credentials } from '../../../platform/request/common/request.js';
48
>
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from '../../../platform/telemetry/common/gdprTypings.js';
49
>
import { TelemetryLevel } from '../../../platform/telemetry/common/telemetry.js';
50
>
import { ISerializableEnvironmentDescriptionMap, ISerializableEnvironmentVariableCollection } from '../../../platform/terminal/common/environmentVariable.js';
51
>
import { ICreateContributedTerminalProfileOptions, IProcessProperty, IProcessReadyWindowsPty, IShellLaunchConfigDto, ITerminalEnvironment, ITerminalLaunchError, ITerminalProfile, TerminalExitReason, TerminalLocation, TerminalShellType } from '../../../platform/terminal/common/terminal.js';
52
>
import { ProvidedPortAttributes, TunnelCreationOptions, TunnelOptions, TunnelPrivacyId, TunnelProviderFeatures } from '../../../platform/tunnel/common/tunnel.js';
53
>
import { ITunnelProxyInfo } from '../../../platform/tunnel/common/tunnelProxy.js';
54
>
import { EditSessionIdentityMatch } from '../../../platform/workspace/common/editSessions.js';
55
>
import { WorkspaceTrustRequestOptions } from '../../../platform/workspace/common/workspaceTrust.js';
56
>
import { SaveReason } from '../../common/editor.js';
57
>
import { IRevealOptions, ITreeItem, IViewBadge } from '../../common/views.js';
58
>
import { CallHierarchyItem } from '../../contrib/callHierarchy/common/callHierarchy.js';
59
>
import { IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, UserSelectedTools } from '../../contrib/chat/common/participants/chatAgents.js';
60
>
import { ICodeMapperRequest, ICodeMapperResult } from '../../contrib/chat/common/editing/chatCodeMapperService.js';
61
>
import { IChatContextItem } from '../../contrib/chat/common/contextContrib/chatContext.js';
62
>
import { IChatProgressHistoryResponseContent, IChatRequestModeInstructions, IChatRequestVariableData } from '../../contrib/chat/common/model/chatModel.js';
63
>
import { ChatResponseClearToPreviousToolInvocationReason, IChatContentInlineReference, IChatExternalEditsDto, IChatFollowup, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatTask, IChatTaskDto, IChatUserActionEvent, IChatVoteAction } from '../../contrib/chat/common/chatService/chatService.js';
64
>
import { IChatSessionItem, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from '../../contrib/chat/common/chatSessionsService.js';
65
>
import { IChatRequestVariableValue } from '../../contrib/chat/common/attachments/chatVariables.js';
66
>
import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
67
>
import { IChatMessage, IChatResponsePart, ILanguageModelChatInfoOptions, ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatRequestOptions, ILanguageModelChatSelector } from '../../contrib/chat/common/languageModels.js';
68
>
import { IPreparedToolInvocation, IStreamedToolInvocation, IToolInvocation, IToolInvocationPreparationContext, IToolInvocationStreamContext, IToolProgressStep, IToolResult, ToolDataSource } from '../../contrib/chat/common/tools/languageModelToolsService.js';
69
>
import { IPromptFileContext, IPromptFileResource } from '../../contrib/chat/common/promptSyntax/service/promptsService.js';
70
>
import { DebugConfigurationProviderTriggerKind, IAdapterDescriptor, IConfig, IDebugSessionReplMode, IDebugTestRunReference, IDebugVisualization, IDebugVisualizationContext, IDebugVisualizationTreeItem, MainThreadDebugVisualization } from '../../contrib/debug/common/debug.js';
71
>
import { McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from '../../contrib/mcp/common/mcpTypes.js';
72
>
import * as notebookCommon from '../../contrib/notebook/common/notebookCommon.js';
73
>
import { CellExecutionUpdateType } from '../../contrib/notebook/common/notebookExecutionService.js';
74
>
import { ICellExecutionComplete, ICellExecutionStateUpdate } from '../../contrib/notebook/common/notebookExecutionStateService.js';
75
>
import { ICellRange } from '../../contrib/notebook/common/notebookRange.js';
76
>
import { ISCMHistoryOptions } from '../../contrib/scm/common/history.js';
77
>
import { InputValidationType } from '../../contrib/scm/common/scm.js';
78
>
import { IWorkspaceSymbol, NotebookPriorityInfo } from '../../contrib/search/common/search.js';
79
>
import { IRawClosedNotebookFileMatch } from '../../contrib/search/common/searchNotebookHelpers.js';
80
>
import { IKeywordRecognitionEvent, ISpeechProviderMetadata, ISpeechToTextEvent, ITextToSpeechEvent } from '../../contrib/speech/common/speechService.js';
81
>
import { CoverageDetails, ExtensionRunTestsRequest, ICallProfileRunHandler, IFileCoverage, ISerializedTestResults, IStartControllerTests, ITestItem, ITestMessage, ITestRunProfile, ITestRunTask, ResolvedTestRunRequest, TestControllerCapability, TestMessageFollowupRequest, TestMessageFollowupResponse, TestResultState, TestsDiffOp } from '../../contrib/testing/common/testTypes.js';
82
>
import { Timeline, TimelineChangeEvent, TimelineOptions, TimelineProviderDescriptor } from '../../contrib/timeline/common/timeline.js';
83
>
import { TypeHierarchyItem } from '../../contrib/typeHierarchy/common/typeHierarchy.js';
84
>
import { RelatedInformationResult, RelatedInformationType } from '../../services/aiRelatedInformation/common/aiRelatedInformation.js';
85
>
import { AiSettingsSearchProviderOptions, AiSettingsSearchResult } from '../../services/aiSettingsSearch/common/aiSettingsSearch.js';
86
>
import { AuthenticationSession, AuthenticationSessionAccount, AuthenticationSessionsChangeEvent, IAuthenticationConstraint, IAuthenticationCreateSessionOptions, IAuthenticationGetSessionsOptions, IAuthenticationWwwAuthenticateRequest } from '../../services/authentication/common/authentication.js';
87
>
import { EditorGroupColumn } from '../../services/editor/common/editorGroupColumn.js';
88
>
import { IExtensionDescriptionDelta, IStaticWorkspaceData } from '../../services/extensions/common/extensionHostProtocol.js';
89
>
import { IResolveAuthorityResult } from '../../services/extensions/common/extensionHostProxy.js';
90
>
import { ActivationKind, ExtensionActivationReason, MissingExtensionDependency } from '../../services/extensions/common/extensions.js';
91
>
import { Dto, IRPCProtocol, SerializableObjectWithBuffers, createProxyIdentifier } from '../../services/extensions/common/proxyIdentifier.js';
92
>
import { IInlineCompletionsUnificationState } from '../../services/inlineCompletions/common/inlineCompletionsUnification.js';
93
>
import { ILanguageStatus } from '../../services/languageStatus/common/languageStatusService.js';
94
>
import { OutputChannelUpdateMode } from '../../services/output/common/output.js';
95
>
import { CandidatePort } from '../../services/remote/common/tunnelModel.js';
96
>
import { IFileQueryBuilderOptions, ITextQueryBuilderOptions } from '../../services/search/common/queryBuilder.js';
97
>
import * as search from '../../services/search/common/search.js';
98
>
import { AISearchKeyword, TextSearchCompleteMessage } from '../../services/search/common/searchExtTypes.js';
99
>
import { ISaveProfileResult } from '../../services/userDataProfile/common/userDataProfile.js';
100
>
import { IExtHostDocumentSaveDelegate } from './extHostDocumentData.js';
101
>
import { TerminalShellExecutionCommandLineConfidence } from './extHostTypes.js';
102
>
import * as tasks from './shared/tasks.js';
103
>
import { PromptsType } from '../../contrib/chat/common/promptSyntax/promptTypes.js';
104
>
import { CDPEvent, CDPRequest, CDPResponse } from '../../../platform/browserView/common/cdp/types.js';
105
>
106
>
export type IconPathDto =
107
>
| UriComponents
108
>
| { light: UriComponents; dark: UriComponents }
109
>
| ThemeIcon;
110
>
111
>
export interface IWorkspaceData extends IStaticWorkspaceData {
112
>
folders: { uri: UriComponents; name: string; index: number }[];
113
>
}
114
>
115
>
export interface IConfigurationInitData extends IConfigurationData {
116
>
configurationScopes: [string, ConfigurationScope | undefined][];
117
>
}
118
>
119
>
export interface IMainContext extends IRPCProtocol {
120
>
}
121
>
122
>
// --- main thread
123
>
124
>
export interface MainThreadGitExtensionShape extends IDisposable {
125
>
$onDidChangeRepository(handle: number): Promise<void>;
126
>
}
127
>
128
>
export interface MainThreadClipboardShape extends IDisposable {
129
>
$readText(): Promise<string>;
130
>
$writeText(value: string): Promise<void>;
131
>
}
132
>
133
>
export interface MainThreadCommandsShape extends IDisposable {
134
>
$registerCommand(id: string): void;
135
>
$unregisterCommand(id: string): void;
136
>
$fireCommandActivationEvent(id: string): void;
137
>
$executeCommand(id: string, args: unknown[] | SerializableObjectWithBuffers<unknown[]>, retry: boolean): Promise<unknown | undefined>;
138
>
$getCommands(): Promise<string[]>;
139
>
}
140
>
141
>
export interface CommentProviderFeatures {
142
>
reactionGroup?: languages.CommentReaction[];
143
>
reactionHandler?: boolean;
144
>
options?: languages.CommentOptions;
145
>
}
146
>
147
>
export interface CommentChanges {
148
>
readonly uniqueIdInThread: number;
149
>
readonly body: string | IMarkdownString;
150
>
readonly userName: string;
151
>
readonly userIconPath?: UriComponents;
152
>
readonly contextValue?: string;
153
>
readonly commentReactions?: languages.CommentReaction[];
154
>
readonly label?: string;
155
>
readonly mode?: languages.CommentMode;
156
>
readonly state?: languages.CommentState;
157
>
readonly timestamp?: string;
158
>
}
159
>
160
>
export type CommentThreadChanges<T = IRange> = Partial<{
161
>
range: T | undefined;
162
>
label: string;
163
>
contextValue: string | null;
164
>
comments: CommentChanges[];
165
>
collapseState: languages.CommentThreadCollapsibleState;
166
>
canReply: boolean | languages.CommentAuthorInformation;
167
>
state: languages.CommentThreadState;
168
>
applicability: languages.CommentThreadApplicability;
169
>
isTemplate: boolean;
170
>
}>;
171
>
172
>
export interface MainThreadCommentsShape extends IDisposable {
173
>
$registerCommentController(handle: number, id: string, label: string, extensionId: string): void;
174
>
$unregisterCommentController(handle: number): void;
175
>
$updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void;
176
>
$createCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, range: IRange | ICellRange | undefined, comments: languages.Comment[], extensionId: ExtensionIdentifier, isTemplate: boolean, editorId?: string): languages.CommentThread<IRange | ICellRange> | undefined;
177
>
$updateCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, changes: CommentThreadChanges): void;
178
>
$deleteCommentThread(handle: number, commentThreadHandle: number): void;
179
>
$updateCommentingRanges(handle: number, resourceHints?: languages.CommentingRangeResourceHint): void;
180
>
$revealCommentThread(handle: number, commentThreadHandle: number, commentUniqueIdInThread: number, options: languages.CommentThreadRevealOptions): Promise<void>;
181
>
$hideCommentThread(handle: number, commentThreadHandle: number): void;
182
>
}
183
>
184
>
export interface AuthenticationForceNewSessionOptions {
185
>
detail?: string;
186
>
sessionToRecreate?: AuthenticationSession;
187
>
}
188
>
189
>
export interface AuthenticationInteractiveOptions {
190
>
detail?: string;
191
>
learnMore?: UriComponents;
192
>
sessionToRecreate?: AuthenticationSession;
193
>
}
194
>
195
>
export interface AuthenticationGetSessionOptions {
196
>
clearSessionPreference?: boolean;
197
>
createIfNone?: boolean | AuthenticationInteractiveOptions;
198
>
forceNewSession?: boolean | AuthenticationInteractiveOptions;
199
>
silent?: boolean;
200
>
account?: AuthenticationSessionAccount;
201
>
}
202
>
export interface IRegisterAuthenticationProviderDetails {
203
>
id: string;
204
>
label: string;
205
>
supportsMultipleAccounts: boolean;
206
>
supportedAuthorizationServers?: UriComponents[];
207
>
supportsChallenges?: boolean;
208
>
resourceServer?: UriComponents;
209
>
}
210
>
211
>
export interface IRegisterDynamicAuthenticationProviderDetails extends IRegisterAuthenticationProviderDetails {
212
>
clientId: string;
213
>
clientSecret?: string;
214
>
authorizationServer: UriComponents;
215
>
}
216
>
217
>
export interface IXaaProviderDiscovery {
218
>
issuer: UriComponents;
219
>
serverMetadata: IAuthorizationServerMetadata;
220
>
clientId?: string;
221
>
}
222
>
223
>
export interface MainThreadAuthenticationShape extends IDisposable {
224
>
$registerAuthenticationProvider(details: IRegisterAuthenticationProviderDetails): Promise<void>;
225
>
$unregisterAuthenticationProvider(id: string): Promise<void>;
226
>
$ensureProvider(id: string): Promise<void>;
227
>
$sendDidChangeSessions(providerId: string, event: AuthenticationSessionsChangeEvent): Promise<void>;
228
>
$getSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, extensionId: string, extensionName: string, options: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined>;
229
>
$getAccounts(providerId: string): Promise<ReadonlyArray<AuthenticationSessionAccount>>;
230
>
$removeSession(providerId: string, sessionId: string): Promise<void>;
231
>
$waitForUriHandler(expectedUri: UriComponents): Promise<UriComponents>;
232
>
$showContinueNotification(message: string): Promise<boolean>;
233
>
$showDeviceCodeModal(userCode: string, verificationUri: string): Promise<boolean>;
234
>
$promptForClientRegistration(authorizationServerUrl: string): Promise<{ clientId: string; clientSecret?: string } | undefined>;
235
>
$promptForResourceClientSecret(resourceClientId: string, resource: string): Promise<string | undefined>;
236
>
$registerDynamicAuthenticationProvider(details: IRegisterDynamicAuthenticationProviderDetails): Promise<void>;
237
>
$setSessionsForDynamicAuthProvider(authProviderId: string, clientId: string, sessions: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<void>;
238
>
$sendDidChangeDynamicProviderInfo({ providerId, clientId, authorizationServer, label, clientSecret }: { providerId: string; clientId?: string; authorizationServer?: UriComponents; label?: string; clientSecret?: string }): Promise<void>;
239
>
}
240
>
241
>
export interface MainThreadSecretStateShape extends IDisposable {
242
>
$getPassword(extensionId: string, key: string): Promise<string | undefined>;
243
>
$setPassword(extensionId: string, key: string, value: string): Promise<void>;
244
>
$deletePassword(extensionId: string, key: string): Promise<void>;
245
>
$getKeys(extensionId: string): Promise<string[]>;
246
>
}
247
>
248
>
export interface MainThreadConfigurationShape extends IDisposable {
249
>
$updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: unknown, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
250
>
$removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
251
>
}
252
>
253
>
export interface MainThreadDiagnosticsShape extends IDisposable {
254
>
$changeMany(owner: string, entries: [UriComponents, IMarkerData[] | undefined][]): void;
255
>
$clear(owner: string): void;
256
>
}
257
>
258
>
export interface MainThreadDialogOpenOptions {
259
>
defaultUri?: UriComponents;
260
>
openLabel?: string;
261
>
canSelectFiles?: boolean;
262
>
canSelectFolders?: boolean;
263
>
canSelectMany?: boolean;
264
>
filters?: { [name: string]: string[] };
265
>
title?: string;
266
>
allowUIResources?: boolean;
267
>
}
268
>
269
>
export interface MainThreadDialogSaveOptions {
270
>
defaultUri?: UriComponents;
271
>
saveLabel?: string;
272
>
filters?: { [name: string]: string[] };
273
>
title?: string;
274
>
}
275
>
276
>
export interface MainThreadDiaglogsShape extends IDisposable {
277
>
$showOpenDialog(options?: MainThreadDialogOpenOptions): Promise<UriComponents[] | undefined>;
278
>
$showSaveDialog(options?: MainThreadDialogSaveOptions): Promise<UriComponents | undefined>;
279
>
}
280
>
281
>
export interface MainThreadDecorationsShape extends IDisposable {
282
>
$registerDecorationProvider(handle: number, label: string): void;
283
>
$unregisterDecorationProvider(handle: number): void;
284
>
$onDidChange(handle: number, resources: UriComponents[] | null): void;
285
>
}
286
>
287
>
export interface MainThreadDocumentContentProvidersShape extends IDisposable {
288
>
$registerTextContentProvider(handle: number, scheme: string): void;
289
>
$unregisterTextContentProvider(handle: number): void;
290
>
$onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void>;
291
>
}
292
>
293
>
export interface MainThreadDocumentsShape extends IDisposable, IExtHostDocumentSaveDelegate {
294
>
$tryCreateDocument(options?: { language?: string; content?: string; encoding?: string }): Promise<UriComponents>;
295
>
$tryOpenDocument(uri: UriComponents, options?: { encoding?: string }): Promise<UriComponents>;
296
>
$trySaveDocument(uri: UriComponents): Promise<boolean>;
297
>
}
298
>
299
>
export interface ITextEditorConfigurationUpdate {
300
>
tabSize?: number | 'auto';
301
>
indentSize?: number | 'tabSize';
302
>
insertSpaces?: boolean | 'auto';
303
>
cursorStyle?: TextEditorCursorStyle;
304
>
lineNumbers?: RenderLineNumbersType;
305
>
}
306
>
307
>
export interface IResolvedTextEditorConfiguration {
308
>
tabSize: number;
309
>
indentSize: number;
310
>
originalIndentSize: number | 'tabSize';
311
>
insertSpaces: boolean;
312
>
cursorStyle: TextEditorCursorStyle;
313
>
lineNumbers: RenderLineNumbersType;
314
>
}
315
>
316
>
export enum TextEditorRevealType {
317
>
Default = 0,
318
>
InCenter = 1,
319
>
InCenterIfOutsideViewport = 2,
320
>
AtTop = 3
321
>
}
322
>
323
>
export interface IUndoStopOptions {
324
>
undoStopBefore: boolean;
325
>
undoStopAfter: boolean;
326
>
}
327
>
328
>
export interface IApplyEditsOptions extends IUndoStopOptions {
329
>
setEndOfLine?: EndOfLineSequence;
330
>
}
331
>
332
>
export interface ISnippetOptions extends IUndoStopOptions {
333
>
keepWhitespace?: boolean;
334
>
}
335
>
export interface ITextDocumentShowOptions {
336
>
position?: EditorGroupColumn;
337
>
preserveFocus?: boolean;
338
>
pinned?: boolean;
339
>
selection?: IRange;
340
>
}
341
>
342
>
export interface MainThreadBulkEditsShape extends IDisposable {
343
>
$tryApplyWorkspaceEdit(workspaceEditDto: SerializableObjectWithBuffers<IWorkspaceEditDto>, undoRedoGroupId?: number, respectAutoSaveConfig?: boolean): Promise<boolean>;
344
>
}
345
>
346
>
export interface MainThreadTextEditorsShape extends IDisposable {
347
>
$tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Promise<string | undefined>;
348
>
$registerTextEditorDecorationType(extensionId: ExtensionIdentifier, key: string, options: editorCommon.IDecorationRenderOptions): void;
349
>
$removeTextEditorDecorationType(key: string): void;
350
>
$tryShowEditor(id: string, position: EditorGroupColumn): Promise<void>;
351
>
$tryHideEditor(id: string): Promise<void>;
352
>
$trySetOptions(id: string, options: ITextEditorConfigurationUpdate): Promise<void>;
353
>
$trySetDecorations(id: string, key: string, ranges: editorCommon.IDecorationOptions[]): Promise<void>;
354
>
$trySetDecorationsFast(id: string, key: string, ranges: number[]): Promise<void>;
355
>
$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Promise<void>;
356
>
$trySetSelections(id: string, selections: ISelection[]): Promise<void>;
357
>
$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): Promise<boolean>;
358
>
$tryInsertSnippet(id: string, modelVersionId: number, template: string, selections: readonly IRange[], opts: IUndoStopOptions): Promise<boolean>;
359
>
$getDiffInformation(id: string): Promise<IChange[]>;
360
>
}
361
>
362
>
export interface MainThreadTreeViewsShape extends IDisposable {
363
>
$registerTreeViewDataProvider(treeViewId: string, options: { showCollapseAll: boolean; canSelectMany: boolean; dropMimeTypes: readonly string[]; dragMimeTypes: readonly string[]; hasHandleDrag: boolean; hasHandleDrop: boolean; manuallyManageCheckboxes: boolean }): Promise<void>;
364
>
$refresh(treeViewId: string, itemsToRefresh?: { [treeItemHandle: string]: ITreeItem }): Promise<void>;
365
>
$reveal(treeViewId: string, itemInfo: { item: ITreeItem; parentChain: ITreeItem[] } | undefined, options: IRevealOptions): Promise<void>;
366
>
$setMessage(treeViewId: string, message: string | IMarkdownString): void;
367
>
$setTitle(treeViewId: string, title: string, description: string | undefined): void;
368
>
$setBadge(treeViewId: string, badge: IViewBadge | undefined): void;
369
>
$resolveDropFileData(destinationViewId: string, requestId: number, dataItemId: string): Promise<VSBuffer>;
370
>
$disposeTree(treeViewId: string): Promise<void>;
371
>
$logResolveTreeNodeFailure(extensionId: string): void;
372
>
}
373
>
374
>
export interface MainThreadDownloadServiceShape extends IDisposable {
375
>
$download(uri: UriComponents, to: UriComponents): Promise<void>;
376
>
}
377
>
378
>
export interface MainThreadErrorsShape extends IDisposable {
379
>
$onUnexpectedError(err: any | SerializedError): void;
380
>
}
381
>
382
>
export interface MainThreadConsoleShape extends IDisposable {
383
>
$logExtensionHostMessage(msg: IRemoteConsoleLog): void;
384
>
}
385
>
386
>
export interface IRegExpDto {
387
>
pattern: string;
388
>
flags?: string;
389
>
}
390
>
export interface IIndentationRuleDto {
391
>
decreaseIndentPattern: IRegExpDto;
392
>
increaseIndentPattern: IRegExpDto;
393
>
indentNextLinePattern?: IRegExpDto;
394
>
unIndentedLinePattern?: IRegExpDto;
395
>
}
396
>
export interface IOnEnterRuleDto {
397
>
beforeText: IRegExpDto;
398
>
afterText?: IRegExpDto;
399
>
previousLineText?: IRegExpDto;
400
>
action: EnterAction;
401
>
}
402
>
export interface ILanguageConfigurationDto {
403
>
comments?: CommentRule;
404
>
brackets?: CharacterPair[];
405
>
wordPattern?: IRegExpDto;
406
>
indentationRules?: IIndentationRuleDto;
407
>
onEnterRules?: IOnEnterRuleDto[];
408
>
__electricCharacterSupport?: {
409
>
brackets?: any;
410
>
docComment?: {
411
>
scope: string;
412
>
open: string;
413
>
lineStart: string;
414
>
close?: string;
415
>
};
416
>
};
417
>
__characterPairSupport?: {
418
>
autoClosingPairs: {
419
>
open: string;
420
>
close: string;
421
>
notIn?: string[];
422
>
}[];
423
>
};
424
>
autoClosingPairs?: {
425
>
open: string;
426
>
close: string;
427
>
notIn?: string[];
428
>
}[];
429
>
}
430
>
431
>
export type GlobPattern = string | IRelativePattern;
432
>
433
>
export interface IRelativePatternDto extends IRelativePattern {
434
>
baseUri: UriComponents;
435
>
}
436
>
437
>
export interface IDocumentFilterDto {
438
>
$serialized: true;
439
>
language?: string;
440
>
scheme?: string;
441
>
pattern?: string | IRelativePattern;
442
>
exclusive?: boolean;
443
>
notebookType?: string;
444
>
isBuiltin?: boolean;
445
>
}
446
>
447
>
export type ITabSelectorDto = { uri: IDocumentFilterDto[] } | { viewType: string };
448
>
449
>
export interface IShareableItemDto {
450
>
resourceUri: UriComponents;
451
>
selection?: IRange;
452
>
}
453
>
454
>
export interface IDocumentContextItemDto {
455
>
readonly uri: UriComponents;
456
>
readonly version: number;
457
>
readonly ranges: IRange[];
458
>
}
459
>
460
>
export interface IConversationItemDto {
461
>
readonly type: 'request' | 'response';
462
>
readonly message: string;
463
>
readonly references?: IDocumentContextItemDto[];
464
>
}
465
>
466
>
export interface IMappedEditsContextDto {
467
>
documents: IDocumentContextItemDto[][];
468
>
conversation?: IConversationItemDto[];
469
>
}
470
>
471
>
export interface ICodeBlockDto {
472
>
code: string;
473
>
resource: UriComponents;
474
>
}
475
>
476
>
export interface IMappedEditsRequestDto {
477
>
readonly codeBlocks: ICodeBlockDto[];
478
>
readonly conversation?: IConversationItemDto[];
479
>
}
480
>
481
>
export interface IMappedEditsResultDto {
482
>
readonly errorMessage?: string;
483
>
}
484
>
485
>
export interface ISignatureHelpProviderMetadataDto {
486
>
readonly triggerCharacters: readonly string[];
487
>
readonly retriggerCharacters: readonly string[];
488
>
}
489
>
490
>
export interface IdentifiableInlineCompletions extends languages.InlineCompletions<IdentifiableInlineCompletion> {
491
>
pid: number;
492
>
languageId: string;
493
>
}
494
>
495
>
export interface IdentifiableInlineCompletion extends languages.InlineCompletion {
496
>
pid: number;
497
>
idx: number;
498
>
suggestionId: EditSuggestionId | undefined;
499
>
}
500
>
501
>
export interface IInlineCompletionModelDto {
502
>
readonly id: string;
503
>
readonly name: string;
504
>
}
505
>
506
>
export interface IInlineCompletionModelInfoDto {
507
>
readonly models: IInlineCompletionModelDto[];
508
>
readonly currentModelId: string;
509
>
}
510
>
511
>
export interface IInlineCompletionProviderOptionValueDto {
512
>
readonly id: string;
513
>
readonly label: string;
514
>
}
515
>
516
>
export interface IInlineCompletionProviderOptionDto {
517
>
readonly id: string;
518
>
readonly label: string;
519
>
readonly values: readonly IInlineCompletionProviderOptionValueDto[];
520
>
readonly currentValueId: string;
521
>
}
522
>
523
>
export interface IInlineCompletionChangeHintDto {
524
>
readonly data?: unknown;
525
>
}
526
>
527
>
export interface MainThreadLanguageFeaturesShape extends IDisposable {
528
>
$unregister(handle: number): void;
529
>
$registerDocumentSymbolProvider(handle: number, selector: IDocumentFilterDto[], label: string): void;
530
>
$registerCodeLensSupport(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void;
531
>
$emitCodeLensEvent(eventHandle: number, event?: any): void;
532
>
$registerDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void;
533
>
$registerDeclarationSupport(handle: number, selector: IDocumentFilterDto[]): void;
534
>
$registerImplementationSupport(handle: number, selector: IDocumentFilterDto[]): void;
535
>
$registerTypeDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void;
536
>
$registerHoverProvider(handle: number, selector: IDocumentFilterDto[]): void;
537
>
$registerEvaluatableExpressionProvider(handle: number, selector: IDocumentFilterDto[]): void;
538
>
$registerInlineValuesProvider(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void;
539
>
$emitInlineValuesEvent(eventHandle: number, event?: any): void;
540
>
$registerDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void;
541
>
$registerMultiDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void;
542
>
$registerLinkedEditingRangeProvider(handle: number, selector: IDocumentFilterDto[]): void;
543
>
$registerReferenceSupport(handle: number, selector: IDocumentFilterDto[]): void;
544
>
$registerCodeActionSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto, displayName: string, extensionID: string, supportsResolve: boolean): void;
545
>
$registerPasteEditProvider(handle: number, selector: IDocumentFilterDto[], metadata: IPasteEditProviderMetadataDto): void;
546
>
$registerDocumentFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void;
547
>
$registerRangeFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string, supportRanges: boolean): void;
548
>
$registerOnTypeFormattingSupport(handle: number, selector: IDocumentFilterDto[], autoFormatTriggerCharacters: string[], extensionId: ExtensionIdentifier): void;
549
>
$registerNavigateTypeSupport(handle: number, supportsResolve: boolean): void;
550
>
$registerRenameSupport(handle: number, selector: IDocumentFilterDto[], supportsResolveInitialValues: boolean): void;
551
>
$registerNewSymbolNamesProvider(handle: number, selector: IDocumentFilterDto[]): void;
552
>
$registerDocumentSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: languages.SemanticTokensLegend, eventHandle: number | undefined): void;
553
>
$emitDocumentSemanticTokensEvent(eventHandle: number): void;
554
>
$registerDocumentRangeSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: languages.SemanticTokensLegend, eventHandle: number | undefined): void;
555
>
$emitDocumentRangeSemanticTokensEvent(eventHandle: number): void;
556
>
$registerCompletionsProvider(handle: number, selector: IDocumentFilterDto[], triggerCharacters: string[], supportsResolveDetails: boolean, extensionId: ExtensionIdentifier): void;
557
>
$registerInlineCompletionsSupport(
558
>
handle: number,
559
>
selector: IDocumentFilterDto[],
560
>
supportsHandleEvents: boolean,
561
>
extensionId: string,
562
>
extensionVersion: string,
563
>
groupId: string | undefined,
564
>
yieldsToExtensionIds: string[],
565
>
displayName: string | undefined,
566
>
debounceDelayMs: number | undefined,
567
>
excludesExtensionIds: string[],
568
>
supportsSetModelId: boolean,
569
>
supportsOnDidChange: boolean,
570
>
initialModelInfo: IInlineCompletionModelInfoDto | undefined,
571
>
supportsOnDidChangeModelInfo: boolean,
572
>
supportsSetProviderOption: boolean,
573
>
initialProviderOptions: readonly IInlineCompletionProviderOptionDto[] | undefined,
574
>
supportsOnDidChangeProviderOptions: boolean,
575
>
): void;
576
>
$emitInlineCompletionsChange(handle: number, changeHint: IInlineCompletionChangeHintDto | undefined): void;
577
>
$emitInlineCompletionModelInfoChange(handle: number, data: IInlineCompletionModelInfoDto | undefined): void;
578
>
$emitInlineCompletionProviderOptionsChange(handle: number, data: readonly IInlineCompletionProviderOptionDto[] | undefined): void;
579
>
$registerSignatureHelpProvider(handle: number, selector: IDocumentFilterDto[], metadata: ISignatureHelpProviderMetadataDto): void;
580
>
$registerInlayHintsProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean, eventHandle: number | undefined, displayName: string | undefined): void;
581
>
$emitInlayHintsEvent(eventHandle: number): void;
582
>
$registerDocumentLinkProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean): void;
583
>
$registerDocumentColorProvider(handle: number, selector: IDocumentFilterDto[]): void;
584
>
$registerFoldingRangeProvider(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, eventHandle: number | undefined): void;
585
>
$emitFoldingRangeEvent(eventHandle: number, event?: any): void;
586
>
$registerSelectionRangeProvider(handle: number, selector: IDocumentFilterDto[]): void;
587
>
$registerCallHierarchyProvider(handle: number, selector: IDocumentFilterDto[]): void;
588
>
$registerTypeHierarchyProvider(handle: number, selector: IDocumentFilterDto[]): void;
589
>
$registerDocumentOnDropEditProvider(handle: number, selector: IDocumentFilterDto[], metadata?: IDocumentDropEditProviderMetadata): void;
590
>
$resolvePasteFileData(handle: number, requestId: number, dataId: string): Promise<VSBuffer>;
591
>
$resolveDocumentOnDropFileData(handle: number, requestId: number, dataId: string): Promise<VSBuffer>;
592
>
$setLanguageConfiguration(handle: number, languageId: string, configuration: ILanguageConfigurationDto): void;
593
>
}
594
>
595
>
export interface MainThreadLanguagesShape extends IDisposable {
596
>
$changeLanguage(resource: UriComponents, languageId: string): Promise<void>;
597
>
$tokensAtPosition(resource: UriComponents, position: IPosition): Promise<undefined | { type: StandardTokenType; range: IRange }>;
598
>
$computeFullSyntaxHighlighting(source: string, languageId: string): Promise<ISyntaxHighlightingResultDto>;
599
>
$setLanguageStatus(handle: number, status: ILanguageStatus): void;
600
>
$removeLanguageStatus(handle: number): void;
601
>
}
602
>
603
>
export interface ISyntaxHighlightingTokenDto {
604
>
readonly length: number;
605
>
readonly foreground: number;
606
>
readonly fontStyle: number;
607
>
}
608
>
609
>
export interface ISyntaxHighlightingResultDto {
610
>
readonly tokens: ISyntaxHighlightingTokenDto[];
611
>
readonly colorMap: string[];
612
>
}
613
>
614
>
export interface MainThreadMessageOptions {
615
>
source?: { identifier: ExtensionIdentifier; label: string };
616
>
modal?: boolean;
617
>
detail?: string;
618
>
useCustom?: boolean;
619
>
}
620
>
621
>
export interface MainThreadMessageServiceShape extends IDisposable {
622
>
$showMessage(severity: Severity, message: string, options: MainThreadMessageOptions, commands: { title: string; isCloseAffordance: boolean; handle: number }[]): Promise<number | undefined>;
623
>
}
624
>
625
>
export interface MainThreadOutputServiceShape extends IDisposable {
626
>
$register(label: string, file: UriComponents, languageId: string | undefined, extensionId: string): Promise<string>;
627
>
$update(channelId: string, mode: OutputChannelUpdateMode, till?: number): Promise<void>;
628
>
$reveal(channelId: string, preserveFocus: boolean): Promise<void>;
629
>
$close(channelId: string): Promise<void>;
630
>
$dispose(channelId: string): Promise<void>;
631
>
}
632
>
633
>
export interface MainThreadProgressShape extends IDisposable {
634
>
635
>
$startProgress(handle: number, options: IProgressOptions, extensionId?: string): Promise<void>;
636
>
$progressReport(handle: number, message: IProgressStep): void;
637
>
$progressEnd(handle: number): void;
638
>
}
639
>
640
>
/**
641
>
* A terminal that is created on the extension host side is temporarily assigned
642
>
* a UUID by the extension host that created it. Once the renderer side has assigned
643
>
* a real numeric id, the numeric id will be used.
644
>
*
645
>
* All other terminals (that are not created on the extension host side) always
646
>
* use the numeric id.
647
>
*/
648
>
export type ExtHostTerminalIdentifier = number | string;
649
>
650
>
export interface TerminalLaunchConfig {
651
>
name?: string;
652
>
shellPath?: string;
653
>
shellArgs?: string[] | string;
654
>
cwd?: string | UriComponents;
655
>
env?: ITerminalEnvironment;
656
>
icon?: URI | { light: URI; dark: URI } | ThemeIcon;
657
>
color?: string;
658
>
initialText?: string;
659
>
waitOnExit?: boolean;
660
>
strictEnv?: boolean;
661
>
hideFromUser?: boolean;
662
>
isExtensionCustomPtyTerminal?: boolean;
663
>
forceShellIntegration?: boolean;
664
>
isFeatureTerminal?: boolean;
665
>
isExtensionOwnedTerminal?: boolean;
666
>
useShellEnvironment?: boolean;
667
>
location?: TerminalLocation | { viewColumn: number; preserveFocus?: boolean } | { parentTerminal: ExtHostTerminalIdentifier } | { splitActiveTerminal: boolean };
668
>
isTransient?: boolean;
669
>
shellIntegrationNonce?: string;
670
>
titleTemplate?: string;
671
>
}
672
>
673
>
674
>
export interface MainThreadTerminalServiceShape extends IDisposable {
675
>
$createTerminal(extHostTerminalId: string, config: TerminalLaunchConfig): Promise<void>;
676
>
$dispose(id: ExtHostTerminalIdentifier): void;
677
>
$hide(id: ExtHostTerminalIdentifier): void;
678
>
$sendText(id: ExtHostTerminalIdentifier, text: string, shouldExecute: boolean): void;
679
>
$show(id: ExtHostTerminalIdentifier, preserveFocus: boolean): void;
680
>
$registerProcessSupport(isSupported: boolean): void;
681
>
$registerProfileProvider(id: string, extensionIdentifier: string): void;
682
>
$unregisterProfileProvider(id: string): void;
683
>
$registerCompletionProvider(id: string, extensionIdentifier: string, ...triggerCharacters: string[]): void;
684
>
$unregisterCompletionProvider(id: string): void;
685
>
$registerQuickFixProvider(id: string, extensionIdentifier: string): void;
686
>
$unregisterQuickFixProvider(id: string): void;
687
>
$setEnvironmentVariableCollection(extensionIdentifier: string, persistent: boolean, collection: ISerializableEnvironmentVariableCollection | undefined, descriptionMap: ISerializableEnvironmentDescriptionMap): void;
688
>
689
>
// Optional event toggles
690
>
$startSendingDataEvents(): void;
691
>
$stopSendingDataEvents(): void;
692
>
$startSendingCommandEvents(): void;
693
>
$stopSendingCommandEvents(): void;
694
>
$startLinkProvider(): void;
695
>
$stopLinkProvider(): void;
696
>
697
>
// Process
698
>
$sendProcessData(terminalId: number, data: string): void;
699
>
$sendProcessReady(terminalId: number, pid: number, cwd: string, windowsPty: IProcessReadyWindowsPty | undefined): void;
700
>
$sendProcessProperty(terminalId: number, property: IProcessProperty<any>): void;
701
>
$sendProcessExit(terminalId: number, exitCode: number | undefined): void;
702
>
}
703
>
704
>
export interface MainThreadTerminalShellIntegrationShape extends IDisposable {
705
>
$executeCommand(terminalId: number, commandLine: string): void;
706
>
}
707
>
708
>
export type TransferQuickPickItemOrSeparator = TransferQuickPickItem | quickInput.IQuickPickSeparator;
709
>
export interface TransferQuickPickItem {
710
>
handle: number;
711
>
712
>
// shared properties from IQuickPickItem
713
>
type?: 'item';
714
>
label: string;
715
>
iconPathDto?: IconPathDto;
716
>
description?: string;
717
>
detail?: string;
718
>
picked?: boolean;
719
>
alwaysShow?: boolean;
720
>
buttons?: TransferQuickInputButton[];
721
>
resourceUri?: UriComponents;
722
>
723
>
// TODO: These properties are not used for transfer (iconPathDto is used instead) but they cannot be removed
724
>
// because this type is used as IQuickPickItem on the main thread. Ideally IQuickPickItem should also use IconPath.
725
>
iconPath?: { light?: URI; dark: URI };
726
>
iconClass?: string;
727
>
}
728
>
729
>
export interface TransferQuickInputButton extends quickInput.IQuickInputButton {
730
>
handle: number;
731
>
iconPathDto: IconPathDto;
732
>
toggle?: { checked: boolean };
733
>
734
>
// TODO: These properties are not used for transfer (iconPathDto is used instead) but they cannot be removed
735
>
// because this type is used as IQuickInputButton on the main thread. Ideally IQuickInputButton should also use IconPath.
736
>
iconPath?: { light?: URI; dark: URI };
737
>
iconClass?: string;
738
>
}
739
>
740
>
export type TransferQuickInput = TransferQuickPick | TransferInputBox;
741
>
742
>
export interface BaseTransferQuickInput {
743
>
744
>
[key: string]: any;
745
>
746
>
id: number;
747
>
748
>
title?: string;
749
>
750
>
type?: 'quickPick' | 'inputBox';
751
>
752
>
enabled?: boolean;
753
>
754
>
busy?: boolean;
755
>
756
>
visible?: boolean;
757
>
}
758
>
759
>
export interface TransferQuickPick extends BaseTransferQuickInput {
760
>
761
>
type?: 'quickPick';
762
>
763
>
value?: string;
764
>
765
>
placeholder?: string;
766
>
767
>
prompt?: string;
768
>
769
>
buttons?: TransferQuickInputButton[];
770
>
771
>
items?: TransferQuickPickItemOrSeparator[];
772
>
773
>
activeItems?: number[];
774
>
775
>
selectedItems?: number[];
776
>
777
>
canSelectMany?: boolean;
778
>
779
>
ignoreFocusOut?: boolean;
780
>
781
>
matchOnDescription?: boolean;
782
>
783
>
matchOnDetail?: boolean;
784
>
785
>
sortByLabel?: boolean;
786
>
}
787
>
788
>
export interface TransferInputBox extends BaseTransferQuickInput {
789
>
790
>
type?: 'inputBox';
791
>
792
>
value?: string;
793
>
794
>
valueSelection?: Readonly<[number, number]>;
795
>
796
>
placeholder?: string;
797
>
798
>
password?: boolean;
799
>
800
>
buttons?: TransferQuickInputButton[];
801
>
802
>
prompt?: string;
803
>
804
>
validationMessage?: string;
805
>
}
806
>
807
>
export interface IInputBoxOptions {
808
>
title?: string;
809
>
value?: string;
810
>
valueSelection?: Readonly<[number, number]>;
811
>
prompt?: string;
812
>
placeHolder?: string;
813
>
password?: boolean;
814
>
ignoreFocusOut?: boolean;
815
>
}
816
>
817
>
export interface MainThreadQuickOpenShape extends IDisposable {
818
>
$show(instance: number, options: quickInput.IPickOptions<TransferQuickPickItem>, token: CancellationToken): Promise<number | number[] | undefined>;
819
>
$setItems(instance: number, items: TransferQuickPickItemOrSeparator[]): Promise<void>;
820
>
$setError(instance: number, error: Error): Promise<void>;
821
>
$input(options: IInputBoxOptions | undefined, validateInput: boolean, token: CancellationToken): Promise<string | undefined>;
822
>
$createOrUpdate(params: TransferQuickInput): Promise<void>;
823
>
$dispose(id: number): Promise<void>;
824
>
}
825
>
826
>
export interface MainThreadStatusBarShape extends IDisposable {
827
>
$setEntry(id: string, statusId: string, extensionId: string | undefined, statusName: string, text: string, tooltip: IMarkdownString | string | undefined, hasTooltipProvider: boolean, command: ICommandDto | undefined, color: string | ThemeColor | undefined, backgroundColor: string | ThemeColor | undefined, alignLeft: boolean, priority: number | undefined, accessibilityInformation: IAccessibilityInformation | undefined): void;
828
>
$disposeEntry(id: string): void;
829
>
}
830
>
831
>
export type StatusBarItemDto = {
832
>
entryId: string;
833
>
alignLeft: boolean;
834
>
priority?: number;
835
>
name: string;
836
>
text: string;
837
>
tooltip?: string;
838
>
command?: string;
839
>
accessibilityInformation?: IAccessibilityInformation;
840
>
};
841
>
842
>
export interface ExtHostStatusBarShape {
843
>
$acceptStaticEntries(added?: StatusBarItemDto[]): void;
844
>
$provideTooltip(entryId: string, cancellation: CancellationToken): Promise<string | IMarkdownString | undefined>;
845
>
}
846
>
847
>
export interface MainThreadStorageShape extends IDisposable {
848
>
$initializeExtensionStorage(shared: boolean, extensionId: string): Promise<string | undefined>;
849
>
$setValue(shared: boolean, extensionId: string, value: object): Promise<void>;
850
>
$registerExtensionStorageKeysToSync(extension: IExtensionIdWithVersion, keys: string[]): void;
851
>
}
852
>
853
>
export interface MainThreadTelemetryShape extends IDisposable {
854
>
$publicLog(eventName: string, data?: any): void;
855
>
$publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
856
>
}
857
>
858
>
export interface MainThreadEditorInsetsShape extends IDisposable {
859
>
$createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: IWebviewContentOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void>;
860
>
$disposeEditorInset(handle: number): void;
861
>
862
>
$setHtml(handle: number, value: string): void;
863
>
$setOptions(handle: number, options: IWebviewContentOptions): void;
864
>
$postMessage(handle: number, value: any): Promise<boolean>;
865
>
}
866
>
867
>
export interface ExtHostEditorInsetsShape {
868
>
$onDidDispose(handle: number): void;
869
>
$onDidReceiveMessage(handle: number, message: any): void;
870
>
}
871
>
872
>
//#region --- tabs model
873
>
874
>
export const enum TabInputKind {
875
>
UnknownInput,
876
>
TextInput,
877
>
TextDiffInput,
878
>
TextMergeInput,
879
>
NotebookInput,
880
>
NotebookDiffInput,
881
>
CustomEditorInput,
882
>
WebviewEditorInput,
883
>
TerminalEditorInput,
884
>
InteractiveEditorInput,
885
>
ChatEditorInput,
886
>
MultiDiffEditorInput
887
>
}
888
>
889
>
export const enum TabModelOperationKind {
890
>
TAB_OPEN,
891
>
TAB_CLOSE,
892
>
TAB_UPDATE,
893
>
TAB_MOVE
894
>
}
895
>
896
>
export interface UnknownInputDto {
897
>
kind: TabInputKind.UnknownInput;
898
>
}
899
>
900
>
export interface TextInputDto {
901
>
kind: TabInputKind.TextInput;
902
>
uri: UriComponents;
903
>
}
904
>
905
>
export interface TextDiffInputDto {
906
>
kind: TabInputKind.TextDiffInput;
907
>
original: UriComponents;
908
>
modified: UriComponents;
909
>
}
910
>
911
>
export interface TextMergeInputDto {
912
>
kind: TabInputKind.TextMergeInput;
913
>
base: UriComponents;
914
>
input1: UriComponents;
915
>
input2: UriComponents;
916
>
result: UriComponents;
917
>
}
918
>
919
>
export interface NotebookInputDto {
920
>
kind: TabInputKind.NotebookInput;
921
>
notebookType: string;
922
>
uri: UriComponents;
923
>
}
924
>
925
>
export interface NotebookDiffInputDto {
926
>
kind: TabInputKind.NotebookDiffInput;
927
>
notebookType: string;
928
>
original: UriComponents;
929
>
modified: UriComponents;
930
>
}
931
>
932
>
export interface CustomInputDto {
933
>
kind: TabInputKind.CustomEditorInput;
934
>
viewType: string;
935
>
uri: UriComponents;
936
>
}
937
>
938
>
export interface WebviewInputDto {
939
>
kind: TabInputKind.WebviewEditorInput;
940
>
viewType: string;
941
>
}
942
>
943
>
export interface InteractiveEditorInputDto {
944
>
kind: TabInputKind.InteractiveEditorInput;
945
>
uri: UriComponents;
946
>
inputBoxUri: UriComponents;
947
>
}
948
>
949
>
export interface ChatEditorInputDto {
950
>
kind: TabInputKind.ChatEditorInput;
951
>
}
952
>
953
>
export interface MultiDiffEditorInputDto {
954
>
kind: TabInputKind.MultiDiffEditorInput;
955
>
diffEditors: TextDiffInputDto[];
956
>
}
957
>
958
>
export interface TabInputDto {
959
>
kind: TabInputKind.TerminalEditorInput;
960
>
}
961
>
962
>
export type AnyInputDto = UnknownInputDto | TextInputDto | TextDiffInputDto | MultiDiffEditorInputDto | TextMergeInputDto | NotebookInputDto | NotebookDiffInputDto | CustomInputDto | WebviewInputDto | InteractiveEditorInputDto | ChatEditorInputDto | TabInputDto;
963
>
964
>
export interface MainThreadEditorTabsShape extends IDisposable {
965
>
// manage tabs: move, close, rearrange etc
966
>
$moveTab(tabId: string, index: number, viewColumn: EditorGroupColumn, preserveFocus?: boolean): void;
967
>
$closeTab(tabIds: string[], preserveFocus?: boolean): Promise<boolean>;
968
>
$closeGroup(groupIds: number[], preservceFocus?: boolean): Promise<boolean>;
969
>
}
970
>
971
>
export interface IEditorTabGroupDto {
972
>
isActive: boolean;
973
>
viewColumn: EditorGroupColumn;
974
>
// Decided not to go with simple index here due to opening and closing causing index shifts
975
>
// This allows us to patch the model without having to do full rebuilds
976
>
tabs: IEditorTabDto[];
977
>
groupId: number;
978
>
}
979
>
980
>
export interface TabOperation {
981
>
readonly kind: TabModelOperationKind.TAB_OPEN | TabModelOperationKind.TAB_CLOSE | TabModelOperationKind.TAB_UPDATE | TabModelOperationKind.TAB_MOVE;
982
>
// TODO @lramos15 Possibly get rid of index for tab update, it's only needed for open and close
983
>
readonly index: number;
984
>
readonly tabDto: IEditorTabDto;
985
>
readonly groupId: number;
986
>
readonly oldIndex?: number;
987
>
}
988
>
989
>
export interface IEditorTabDto {
990
>
id: string;
991
>
label: string;
992
>
input: AnyInputDto;
993
>
editorId?: string;
994
>
isActive: boolean;
995
>
isPinned: boolean;
996
>
isPreview: boolean;
997
>
isDirty: boolean;
998
>
}
999
>
1000
>
export interface IExtHostEditorTabsShape {
1001
>
// Accepts a whole new model
1002
>
$acceptEditorTabModel(tabGroups: IEditorTabGroupDto[]): void;
1003
>
// Only when group property changes (not the tabs inside)
1004
>
$acceptTabGroupUpdate(groupDto: IEditorTabGroupDto): void;
1005
>
// When a tab is added, removed, or updated
1006
>
$acceptTabOperation(operation: TabOperation): void;
1007
>
}
1008
>
1009
>
//#endregion
1010
>
1011
>
export type WebviewHandle = string;
1012
>
1013
>
export interface WebviewPanelShowOptions {
1014
>
readonly viewColumn?: EditorGroupColumn;
1015
>
readonly preserveFocus?: boolean;
1016
>
}
1017
>
1018
>
export interface WebviewExtensionDescription {
1019
>
readonly id: ExtensionIdentifier;
1020
>
readonly location: UriComponents;
1021
>
}
1022
>
1023
>
export enum WebviewEditorCapabilities {
1024
>
Editable,
1025
>
SupportsHotExit,
1026
>
}
1027
>
1028
>
export interface IWebviewPortMapping {
1029
>
readonly webviewPort: number;
1030
>
readonly extensionHostPort: number;
1031
>
}
1032
>
1033
>
export interface IWebviewContentOptions {
1034
>
readonly enableScripts?: boolean;
1035
>
readonly enableForms?: boolean;
1036
>
readonly enableCommandUris?: boolean | readonly string[];
1037
>
readonly localResourceRoots?: readonly UriComponents[];
1038
>
readonly portMapping?: readonly IWebviewPortMapping[];
1039
>
}
1040
>
1041
>
export interface IWebviewPanelOptions {
1042
>
readonly enableFindWidget?: boolean;
1043
>
readonly retainContextWhenHidden?: boolean;
1044
>
}
1045
>
1046
>
export interface CustomEditorProviderCapabilities {
1047
>
readonly supportsMove?: boolean;
1048
>
readonly supportsInlineDiff?: boolean;
1049
>
readonly supportsSideBySideDiff?: boolean;
1050
>
}
1051
>
1052
>
export interface CustomEditorDiffInitData {
1053
>
readonly title: string;
1054
>
readonly contentOptions: IWebviewContentOptions;
1055
>
readonly options: IWebviewPanelOptions;
1056
>
readonly active: boolean;
1057
>
}
1058
>
1059
>
export interface CustomEditorSideBySideDiffWebviewHandles {
1060
>
readonly original: WebviewHandle;
1061
>
readonly modified: WebviewHandle;
1062
>
}
1063
>
1064
>
export interface CustomEditorSideBySideDiffInitData {
1065
>
readonly original: CustomEditorDiffInitData;
1066
>
readonly modified: CustomEditorDiffInitData;
1067
>
}
1068
>
1069
>
export const enum WebviewMessageArrayBufferViewType {
1070
>
Int8Array = 1,
1071
>
Uint8Array = 2,
1072
>
Uint8ClampedArray = 3,
1073
>
Int16Array = 4,
1074
>
Uint16Array = 5,
1075
>
Int32Array = 6,
1076
>
Uint32Array = 7,
1077
>
Float32Array = 8,
1078
>
Float64Array = 9,
1079
>
BigInt64Array = 10,
1080
>
BigUint64Array = 11,
1081
>
}
1082
>
1083
>
export interface WebviewMessageArrayBufferReference {
1084
>
readonly $$vscode_array_buffer_reference$$: true;
1085
>
1086
>
readonly index: number;
1087
>
1088
>
/**
1089
>
* Tracks if the reference is to a view instead of directly to an ArrayBuffer.
1090
>
*/
1091
>
readonly view?: {
1092
>
readonly type: WebviewMessageArrayBufferViewType;
1093
>
readonly byteLength: number;
1094
>
readonly byteOffset: number;
1095
>
};
1096
>
}
1097
>
1098
>
export interface MainThreadWebviewsShape extends IDisposable {
1099
>
$setHtml(handle: WebviewHandle, value: string): void;
1100
>
$setOptions(handle: WebviewHandle, options: IWebviewContentOptions): void;
1101
>
$postMessage(handle: WebviewHandle, value: string, ...buffers: VSBuffer[]): Promise<boolean>;
1102
>
}
1103
>
1104
>
export type IWebviewIconPath = ThemeIcon | {
1105
>
readonly light: UriComponents;
1106
>
readonly dark: UriComponents;
1107
>
};
1108
>
1109
>
export interface IWebviewInitData {
1110
>
readonly title: string;
1111
>
readonly webviewOptions: IWebviewContentOptions;
1112
>
readonly panelOptions: IWebviewPanelOptions;
1113
>
readonly serializeBuffersForPostMessage: boolean;
1114
>
}
1115
>
1116
>
export interface MainThreadWebviewPanelsShape extends IDisposable {
1117
>
$createWebviewPanel(
1118
>
extension: WebviewExtensionDescription,
1119
>
handle: WebviewHandle,
1120
>
viewType: string,
1121
>
initData: IWebviewInitData,
1122
>
showOptions: WebviewPanelShowOptions,
1123
>
): void;
1124
>
$disposeWebview(handle: WebviewHandle): void;
1125
>
$reveal(handle: WebviewHandle, showOptions: WebviewPanelShowOptions): void;
1126
>
$setTitle(handle: WebviewHandle, value: string): void;
1127
>
$setIconPath(handle: WebviewHandle, value: IWebviewIconPath | undefined): void;
1128
>
1129
>
$registerSerializer(viewType: string, options: { serializeBuffersForPostMessage: boolean }): void;
1130
>
$unregisterSerializer(viewType: string): void;
1131
>
}
1132
>
1133
>
export interface MainThreadCustomEditorsShape extends IDisposable {
1134
>
$registerTextEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: IWebviewPanelOptions, capabilities: CustomEditorProviderCapabilities, serializeBuffersForPostMessage: boolean): void;
1135
>
$registerCustomEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: IWebviewPanelOptions, capabilities: CustomEditorProviderCapabilities, supportsMultipleEditorsPerDocument: boolean, serializeBuffersForPostMessage: boolean): void;
1136
>
$unregisterEditorProvider(viewType: string): void;
1137
>
1138
>
$onDidEdit(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void;
1139
>
$onContentChange(resource: UriComponents, viewType: string): void;
1140
>
}
1141
>
1142
>
export interface MainThreadWebviewViewsShape extends IDisposable {
1143
>
$registerWebviewViewProvider(extension: WebviewExtensionDescription, viewType: string, options: { retainContextWhenHidden?: boolean; serializeBuffersForPostMessage: boolean }): void;
1144
>
$unregisterWebviewViewProvider(viewType: string): void;
1145
>
1146
>
$setWebviewViewTitle(handle: WebviewHandle, value: string | undefined): void;
1147
>
$setWebviewViewDescription(handle: WebviewHandle, value: string | undefined): void;
1148
>
$setWebviewViewBadge(handle: WebviewHandle, badge: IViewBadge | undefined): void;
1149
>
1150
>
$show(handle: WebviewHandle, preserveFocus: boolean): void;
1151
>
}
1152
>
1153
>
export interface WebviewPanelViewStateData {
1154
>
[handle: string]: {
1155
>
readonly active: boolean;
1156
>
readonly visible: boolean;
1157
>
readonly position: EditorGroupColumn;
1158
>
};
1159
>
}
1160
>
1161
>
export interface ExtHostWebviewsShape {
1162
>
$onMessage(handle: WebviewHandle, jsonSerializedMessage: string, buffers: SerializableObjectWithBuffers<VSBuffer[]>): void;
1163
>
$onMissingCsp(handle: WebviewHandle, extensionId: string): void;
1164
>
}
1165
>
1166
>
export interface ExtHostWebviewPanelsShape {
1167
>
$onDidChangeWebviewPanelViewStates(newState: WebviewPanelViewStateData): void;
1168
>
$onDidDisposeWebviewPanel(handle: WebviewHandle): Promise<void>;
1169
>
$deserializeWebviewPanel(
1170
>
newWebviewHandle: WebviewHandle,
1171
>
viewType: string,
1172
>
initData: {
1173
>
title: string;
1174
>
state: any;
1175
>
webviewOptions: IWebviewContentOptions;
1176
>
panelOptions: IWebviewPanelOptions;
1177
>
active: boolean;
1178
>
},
1179
>
position: EditorGroupColumn,
1180
>
): Promise<void>;
1181
>
}
1182
>
1183
>
export interface ExtHostCustomEditorsShape {
1184
>
$resolveCustomEditor(
1185
>
resource: UriComponents,
1186
>
newWebviewHandle: WebviewHandle,
1187
>
viewType: string,
1188
>
initData: {
1189
>
title: string;
1190
>
contentOptions: IWebviewContentOptions;
1191
>
options: IWebviewPanelOptions;
1192
>
active: boolean;
1193
>
},
1194
>
position: EditorGroupColumn,
1195
>
cancellation: CancellationToken
1196
>
): Promise<void>;
1197
>
$resolveCustomEditorInlineDiff(
1198
>
originalResource: UriComponents,
1199
>
modifiedResource: UriComponents,
1200
>
newWebviewHandle: WebviewHandle,
1201
>
viewType: string,
1202
>
initData: CustomEditorDiffInitData,
1203
>
position: EditorGroupColumn,
1204
>
cancellation: CancellationToken
1205
>
): Promise<void>;
1206
>
$resolveCustomEditorSideBySideDiff(
1207
>
originalResource: UriComponents,
1208
>
modifiedResource: UriComponents,
1209
>
webviewHandles: CustomEditorSideBySideDiffWebviewHandles,
1210
>
viewType: string,
1211
>
initData: CustomEditorSideBySideDiffInitData,
1212
>
position: EditorGroupColumn,
1213
>
cancellation: CancellationToken
1214
>
): Promise<void>;
1215
>
$createCustomDocument(resource: UriComponents, viewType: string, backupId: string | undefined, untitledDocumentData: VSBuffer | undefined, cancellation: CancellationToken): Promise<{ editable: boolean }>;
1216
>
$disposeCustomDocument(resource: UriComponents, viewType: string): Promise<void>;
1217
>
1218
>
$undo(resource: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void>;
1219
>
$redo(resource: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void>;
1220
>
$revert(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void>;
1221
>
$disposeEdits(resourceComponents: UriComponents, viewType: string, editIds: number[]): void;
1222
>
1223
>
$onSave(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void>;
1224
>
$onSaveAs(resource: UriComponents, viewType: string, targetResource: UriComponents, cancellation: CancellationToken): Promise<void>;
1225
>
1226
>
$backup(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<string>;
1227
>
1228
>
$onMoveCustomEditor(handle: WebviewHandle, newResource: UriComponents, viewType: string): Promise<void>;
1229
>
}
1230
>
1231
>
export interface ExtHostWebviewViewsShape {
1232
>
$resolveWebviewView(webviewHandle: WebviewHandle, viewType: string, title: string | undefined, state: any, cancellation: CancellationToken): Promise<void>;
1233
>
1234
>
$onDidChangeWebviewViewVisibility(webviewHandle: WebviewHandle, visible: boolean): void;
1235
>
1236
>
$disposeWebviewView(webviewHandle: WebviewHandle): void;
1237
>
}
1238
>
1239
>
export interface MainThreadManagedSocketsShape extends IDisposable {
1240
>
$registerSocketFactory(socketFactoryId: number): Promise<void>;
1241
>
$unregisterSocketFactory(socketFactoryId: number): Promise<void>;
1242
>
$onDidManagedSocketHaveData(socketId: number, data: VSBuffer): void;
1243
>
$onDidManagedSocketClose(socketId: number, error: string | undefined): void;
1244
>
$onDidManagedSocketEnd(socketId: number): void;
1245
>
}
1246
>
1247
>
export interface ExtHostManagedSocketsShape {
1248
>
$openRemoteSocket(socketFactoryId: number): Promise<number>;
1249
>
$remoteSocketWrite(socketId: number, buffer: VSBuffer): void;
1250
>
$remoteSocketEnd(socketId: number): void;
1251
>
$remoteSocketDrain(socketId: number): Promise<void>;
1252
>
}
1253
>
1254
>
export interface MainThreadBrowserTunnelProxyShape extends IDisposable {
1255
>
$updateProxyInfo(info: ITunnelProxyInfo | undefined): void;
1256
>
}
1257
>
1258
>
export interface ExtHostBrowserTunnelProxyShape {
1259
>
$setEnabled(enabled: boolean): void;
1260
>
}
1261
>
1262
>
export enum CellOutputKind {
1263
>
Text = 1,
1264
>
Error = 2,
1265
>
Rich = 3
1266
>
}
1267
>
1268
>
export enum NotebookEditorRevealType {
1269
>
Default = 0,
1270
>
InCenter = 1,
1271
>
InCenterIfOutsideViewport = 2,
1272
>
AtTop = 3
1273
>
}
1274
>
1275
>
export interface INotebookDocumentShowOptions {
1276
>
position?: EditorGroupColumn;
1277
>
preserveFocus?: boolean;
1278
>
pinned?: boolean;
1279
>
selections?: ICellRange[];
1280
>
label?: string;
1281
>
}
1282
>
1283
>
export type INotebookCellStatusBarEntryDto = Dto<notebookCommon.INotebookCellStatusBarItem>;
1284
>
1285
>
export interface INotebookCellStatusBarListDto {
1286
>
items: INotebookCellStatusBarEntryDto[];
1287
>
cacheId: number;
1288
>
}
1289
>
1290
>
export interface MainThreadNotebookShape extends IDisposable {
1291
>
$registerNotebookSerializer(handle: number, extension: notebookCommon.NotebookExtensionDescription, viewType: string, options: notebookCommon.TransientOptions, registration: notebookCommon.INotebookContributionData | undefined): void;
1292
>
$unregisterNotebookSerializer(handle: number): void;
1293
>
1294
>
$registerNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined, viewType: string): Promise<void>;
1295
>
$unregisterNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined): Promise<void>;
1296
>
$emitCellStatusBarEvent(eventHandle: number): void;
1297
>
}
1298
>
1299
>
export interface MainThreadNotebookEditorsShape extends IDisposable {
1300
>
$tryShowNotebookDocument(uriComponents: UriComponents, viewType: string, options: INotebookDocumentShowOptions): Promise<string>;
1301
>
$tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType): Promise<void>;
1302
>
$trySetSelections(id: string, range: ICellRange[]): void;
1303
>
}
1304
>
1305
>
export interface MainThreadNotebookDocumentsShape extends IDisposable {
1306
>
$tryCreateNotebook(options: { viewType: string; content?: NotebookDataDto }): Promise<UriComponents>;
1307
>
$tryOpenNotebook(uriComponents: UriComponents): Promise<UriComponents>;
1308
>
$trySaveNotebook(uri: UriComponents): Promise<boolean>;
1309
>
}
1310
>
1311
>
export interface INotebookKernelDto2 {
1312
>
id: string;
1313
>
notebookType: string;
1314
>
extensionId: ExtensionIdentifier;
1315
>
extensionLocation: UriComponents;
1316
>
label: string;
1317
>
detail?: string;
1318
>
description?: string;
1319
>
supportedLanguages?: string[];
1320
>
supportsInterrupt?: boolean;
1321
>
supportsExecutionOrder?: boolean;
1322
>
preloads?: { uri: UriComponents; provides: readonly string[] }[];
1323
>
hasVariableProvider?: boolean;
1324
>
}
1325
>
1326
>
export interface INotebookProxyKernelDto {
1327
>
id: string;
1328
>
notebookType: string;
1329
>
extensionId: ExtensionIdentifier;
1330
>
extensionLocation: UriComponents;
1331
>
label: string;
1332
>
detail?: string;
1333
>
description?: string;
1334
>
kind?: string;
1335
>
}
1336
>
1337
>
export interface ICellExecuteOutputEditDto {
1338
>
editType: CellExecutionUpdateType.Output;
1339
>
cellHandle: number;
1340
>
append?: boolean;
1341
>
outputs: NotebookOutputDto[];
1342
>
}
1343
>
1344
>
export interface ICellExecuteOutputItemEditDto {
1345
>
editType: CellExecutionUpdateType.OutputItems;
1346
>
append?: boolean;
1347
>
outputId: string;
1348
>
items: NotebookOutputItemDto[];
1349
>
}
1350
>
1351
>
export interface ICellExecutionStateUpdateDto extends ICellExecutionStateUpdate {
1352
>
}
1353
>
1354
>
export interface ICellExecutionCompleteDto extends ICellExecutionComplete {
1355
>
}
1356
>
1357
>
export type ICellExecuteUpdateDto = ICellExecuteOutputEditDto | ICellExecuteOutputItemEditDto | ICellExecutionStateUpdateDto;
1358
>
1359
>
export interface VariablesResult {
1360
>
id: number;
1361
>
name: string;
1362
>
value: string;
1363
>
type?: string;
1364
>
language?: string;
1365
>
expression?: string;
1366
>
hasNamedChildren: boolean;
1367
>
indexedChildrenCount: number;
1368
>
extensionId: string;
1369
>
}
1370
>
1371
>
export interface MainThreadNotebookKernelsShape extends IDisposable {
1372
>
$postMessage(handle: number, editorId: string | undefined, message: any): Promise<boolean>;
1373
>
$addKernel(handle: number, data: INotebookKernelDto2): Promise<void>;
1374
>
$updateKernel(handle: number, data: Partial<INotebookKernelDto2>): void;
1375
>
$removeKernel(handle: number): void;
1376
>
$updateNotebookPriority(handle: number, uri: UriComponents, value: number | undefined): void;
1377
>
1378
>
$createExecution(handle: number, controllerId: string, uri: UriComponents, cellHandle: number): void;
1379
>
$updateExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecuteUpdateDto[]>): void;
1380
>
$completeExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecutionCompleteDto>): void;
1381
>
1382
>
$createNotebookExecution(handle: number, controllerId: string, uri: UriComponents): void;
1383
>
$beginNotebookExecution(handle: number,): void;
1384
>
$completeNotebookExecution(handle: number): void;
1385
>
1386
>
$addKernelDetectionTask(handle: number, notebookType: string): Promise<void>;
1387
>
$removeKernelDetectionTask(handle: number): void;
1388
>
1389
>
$addKernelSourceActionProvider(handle: number, eventHandle: number, notebookType: string): Promise<void>;
1390
>
$removeKernelSourceActionProvider(handle: number, eventHandle: number): void;
1391
>
$emitNotebookKernelSourceActionsChangeEvent(eventHandle: number): void;
1392
>
$receiveVariable(requestId: string, variable: VariablesResult): void;
1393
>
$variablesUpdated(notebookUri: UriComponents): void;
1394
>
}
1395
>
1396
>
export interface MainThreadNotebookRenderersShape extends IDisposable {
1397
>
$postMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean>;
1398
>
}
1399
>
1400
>
export interface MainThreadInteractiveShape extends IDisposable {
1401
>
}
1402
>
1403
>
export interface MainThreadSpeechShape extends IDisposable {
1404
>
$registerProvider(handle: number, identifier: string, metadata: ISpeechProviderMetadata): void;
1405
>
$unregisterProvider(handle: number): void;
1406
>
1407
>
$emitSpeechToTextEvent(session: number, event: ISpeechToTextEvent): void;
1408
>
$emitTextToSpeechEvent(session: number, event: ITextToSpeechEvent): void;
1409
>
$emitKeywordRecognitionEvent(session: number, event: IKeywordRecognitionEvent): void;
1410
>
}
1411
>
1412
>
export interface ExtHostSpeechShape {
1413
>
$createSpeechToTextSession(handle: number, session: number, language?: string): Promise<void>;
1414
>
$cancelSpeechToTextSession(session: number): Promise<void>;
1415
>
1416
>
$createTextToSpeechSession(handle: number, session: number, language?: string): Promise<void>;
1417
>
$synthesizeSpeech(session: number, text: string): Promise<void>;
1418
>
$cancelTextToSpeechSession(session: number): Promise<void>;
1419
>
1420
>
$createKeywordRecognitionSession(handle: number, session: number): Promise<void>;
1421
>
$cancelKeywordRecognitionSession(session: number): Promise<void>;
1422
>
}
1423
>
1424
>
export interface BrowserTabDto {
1425
>
id: string;
1426
>
url: string;
1427
>
title: string;
1428
>
favicon: string | undefined;
1429
>
}
1430
>
1431
>
export interface MainThreadBrowsersShape extends IDisposable {
1432
>
$openBrowserTab(url: string, viewColumn?: EditorGroupColumn, options?: IEditorOptions): Promise<BrowserTabDto>;
1433
>
$closeBrowserTab(browserId: string): Promise<void>;
1434
>
$startCDPSession(sessionId: string, browserId: string): Promise<void>;
1435
>
$closeCDPSession(sessionId: string): Promise<void>;
1436
>
$sendCDPMessage(sessionId: string, message: CDPRequest): Promise<void>;
1437
>
}
1438
>
1439
>
export interface ExtHostBrowsersShape {
1440
>
$onDidOpenBrowserTab(browser: BrowserTabDto): void;
1441
>
$onDidCloseBrowserTab(browserId: string): void;
1442
>
$onDidChangeActiveBrowserTab(browserId: string | undefined): void;
1443
>
$onDidChangeBrowserTabState(browser: BrowserTabDto): void;
1444
>
$onCDPSessionMessage(sessionId: string, message: CDPResponse | CDPEvent): void;
1445
>
$onCDPSessionClosed(sessionId: string): void;
1446
>
}
1447
>
1448
>
export interface MainThreadLanguageModelsShape extends IDisposable {
1449
>
$registerLanguageModelProvider(vendor: string): void;
1450
>
$onLMProviderChange(vendor: string): void;
1451
>
$unregisterProvider(vendor: string): void;
1452
>
$tryStartChatRequest(extension: ExtensionIdentifier, modelIdentifier: string, requestId: number, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: {}, token: CancellationToken): Promise<void>;
1453
>
$reportResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
1454
>
$reportResponseDone(requestId: number, error: SerializedError | undefined): Promise<void>;
1455
>
$selectChatModels(selector: ILanguageModelChatSelector): Promise<string[]>;
1456
>
$countTokens(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
1457
>
$cancelLanguageModelChatRequest(requestId: number): void;
1458
>
$fileIsIgnored(uri: UriComponents, token: CancellationToken): Promise<boolean>;
1459
>
$registerFileIgnoreProvider(handle: number): void;
1460
>
$unregisterFileIgnoreProvider(handle: number): void;
1461
>
}
1462
>
1463
>
export interface ExtHostLanguageModelsShape {
1464
>
$provideLanguageModelChatInfo(vendor: string, options: ILanguageModelChatInfoOptions, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
1465
>
$updateModelAccesslist(data: { from: ExtensionIdentifier; to: ExtensionIdentifier; enabled: boolean }[]): void;
1466
>
$onChatModelsChange(): void;
1467
>
$startChatRequest(modelId: string, requestId: number, from: ExtensionIdentifier | undefined, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: ILanguageModelChatRequestOptions, token: CancellationToken): Promise<void>;
1468
>
$acceptResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
1469
>
$acceptResponseDone(requestId: number, error: SerializedError | undefined): Promise<void>;
1470
>
$cancelLanguageModelChatRequest(requestId: number): void;
1471
>
$provideTokenLength(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
1472
>
$isFileIgnored(handle: number, uri: UriComponents, token: CancellationToken): Promise<boolean>;
1473
>
}
1474
>
1475
>
export type IChatContextItemDto = Dto<IChatContextItem>;
1476
>
1477
>
export interface ExtHostChatContextShape {
1478
>
$provideWorkspaceChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
1479
>
$provideExplicitChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
1480
>
$resolveExplicitChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
1481
>
$provideResourceChatContext(handle: number, options: { resource: UriComponents; withValue: boolean; viewType?: string }, token: CancellationToken): Promise<IChatContextItem | undefined>;
1482
>
$resolveResourceChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
1483
>
$executeChatContextItemCommand(itemHandle: number): Promise<void>;
1484
>
}
1485
>
1486
>
export interface MainThreadChatContextShape extends IDisposable {
1487
>
$registerChatWorkspaceContextProvider(handle: number, id: string): void;
1488
>
$registerChatExplicitContextProvider(handle: number, id: string): void;
1489
>
$registerChatResourceContextProvider(handle: number, id: string, selector: ITabSelectorDto): void;
1490
>
$unregisterChatContextProvider(handle: number): void;
1491
>
$updateWorkspaceContextItems(handle: number, items: IChatContextItemDto[]): void;
1492
>
$executeChatContextItemCommand(itemHandle: number): Promise<void>;
1493
>
}
1494
>
1495
>
export interface IChatDebugEventCommonDto {
1496
>
readonly id?: string;
1497
>
readonly sessionResource?: UriComponents;
1498
>
readonly created: number;
1499
>
readonly parentEventId?: string;
1500
>
}
1501
>
1502
>
export interface IChatDebugToolCallEventDto extends IChatDebugEventCommonDto {
1503
>
readonly kind: 'toolCall';
1504
>
readonly toolName: string;
1505
>
readonly toolCallId?: string;
1506
>
readonly input?: string;
1507
>
readonly output?: string;
1508
>
readonly result?: 'success' | 'error';
1509
>
readonly durationInMillis?: number;
1510
>
}
1511
>
1512
>
export interface IChatDebugModelTurnEventDto extends IChatDebugEventCommonDto {
1513
>
readonly kind: 'modelTurn';
1514
>
readonly model?: string;
1515
>
readonly requestName?: string;
1516
>
readonly inputTokens?: number;
1517
>
readonly outputTokens?: number;
1518
>
readonly cachedTokens?: number;
1519
>
readonly totalTokens?: number;
1520
>
readonly copilotUsageNanoAiu?: number;
1521
>
readonly durationInMillis?: number;
1522
>
}
1523
>
1524
>
export interface IChatDebugGenericEventDto extends IChatDebugEventCommonDto {
1525
>
readonly kind: 'generic';
1526
>
readonly name: string;
1527
>
readonly details?: string;
1528
>
readonly level: number;
1529
>
readonly category?: string;
1530
>
}
1531
>
1532
>
export interface IChatDebugSubagentInvocationEventDto extends IChatDebugEventCommonDto {
1533
>
readonly kind: 'subagentInvocation';
1534
>
readonly agentName: string;
1535
>
readonly description?: string;
1536
>
readonly status?: 'running' | 'completed' | 'failed';
1537
>
readonly durationInMillis?: number;
1538
>
readonly toolCallCount?: number;
1539
>
readonly modelTurnCount?: number;
1540
>
}
1541
>
1542
>
export interface IChatDebugMessageSectionDto {
1543
>
readonly name: string;
1544
>
readonly content: string;
1545
>
}
1546
>
1547
>
export interface IChatDebugUserMessageEventDto extends IChatDebugEventCommonDto {
1548
>
readonly kind: 'userMessage';
1549
>
readonly message: string;
1550
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1551
>
}
1552
>
1553
>
export interface IChatDebugAgentResponseEventDto extends IChatDebugEventCommonDto {
1554
>
readonly kind: 'agentResponse';
1555
>
readonly message: string;
1556
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1557
>
}
1558
>
1559
>
export type IChatDebugEventDto = IChatDebugToolCallEventDto | IChatDebugModelTurnEventDto | IChatDebugGenericEventDto | IChatDebugSubagentInvocationEventDto | IChatDebugUserMessageEventDto | IChatDebugAgentResponseEventDto;
1560
>
1561
>
export interface IChatDebugEventTextContentDto {
1562
>
readonly kind: 'text';
1563
>
readonly value: string;
1564
>
}
1565
>
1566
>
export interface IChatDebugEventMessageContentDto {
1567
>
readonly kind: 'message';
1568
>
readonly type: 'user' | 'agent';
1569
>
readonly message: string;
1570
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1571
>
}
1572
>
1573
>
export interface IChatDebugEventToolCallContentDto {
1574
>
readonly kind: 'toolCall';
1575
>
readonly toolName: string;
1576
>
readonly result?: 'success' | 'error';
1577
>
readonly durationInMillis?: number;
1578
>
readonly input?: string;
1579
>
readonly output?: string;
1580
>
}
1581
>
1582
>
export interface IChatDebugEventModelTurnContentDto {
1583
>
readonly kind: 'modelTurn';
1584
>
readonly requestName: string;
1585
>
readonly model?: string;
1586
>
readonly status?: string;
1587
>
readonly durationInMillis?: number;
1588
>
readonly timeToFirstTokenInMillis?: number;
1589
>
readonly requestId?: string;
1590
>
readonly maxInputTokens?: number;
1591
>
readonly maxOutputTokens?: number;
1592
>
readonly inputTokens?: number;
1593
>
readonly outputTokens?: number;
1594
>
readonly cachedTokens?: number;
1595
>
readonly totalTokens?: number;
1596
>
readonly requestOptions?: string;
1597
>
readonly errorMessage?: string;
1598
>
readonly sections?: readonly IChatDebugMessageSectionDto[];
1599
>
}
1600
>
1601
>
export interface IChatDebugEventHookContentDto {
1602
>
readonly kind: 'hook';
1603
>
readonly hookType: string;
1604
>
readonly command?: string;
1605
>
readonly result?: 'success' | 'error' | 'nonBlockingError';
1606
>
readonly durationInMillis?: number;
1607
>
readonly input?: string;
1608
>
readonly output?: string;
1609
>
readonly exitCode?: number;
1610
>
readonly errorMessage?: string;
1611
>
}
1612
>
1613
>
export type IChatDebugResolvedEventContentDto = IChatDebugEventTextContentDto | IChatDebugEventMessageContentDto | IChatDebugEventToolCallContentDto | IChatDebugEventModelTurnContentDto | IChatDebugEventHookContentDto;
1614
>
1615
>
export interface ExtHostChatDebugShape {
1616
>
$provideChatDebugLog(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatDebugEventDto[] | undefined>;
1617
>
$resolveChatDebugLogEvent(handle: number, eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContentDto | undefined>;
1618
>
$exportChatDebugLog(handle: number, sessionResource: UriComponents, coreEvents: IChatDebugEventDto[], sessionTitle: string | undefined, token: CancellationToken): Promise<VSBuffer | undefined>;
1619
>
$importChatDebugLog(handle: number, data: VSBuffer, token: CancellationToken): Promise<{ uri: UriComponents; sessionTitle?: string } | undefined>;
1620
>
$getAvailableDebugSessionResources(handle: number, token: CancellationToken): Promise<{ uri: UriComponents; title?: string }[]>;
1621
>
$onCoreDebugEvent(event: IChatDebugEventDto): void;
1622
>
}
1623
>
1624
>
export interface MainThreadChatDebugShape extends IDisposable {
1625
>
$registerChatDebugLogProvider(handle: number): void;
1626
>
$unregisterChatDebugLogProvider(handle: number): void;
1627
>
$acceptChatDebugEvent(handle: number, event: IChatDebugEventDto): void;
1628
>
$subscribeToCoreDebugEvents(): void;
1629
>
$unsubscribeFromCoreDebugEvents(): void;
1630
>
}
1631
>
1632
>
export interface MainThreadEmbeddingsShape extends IDisposable {
1633
>
$registerEmbeddingProvider(handle: number, identifier: string): void;
1634
>
$unregisterEmbeddingProvider(handle: number): void;
1635
>
$computeEmbeddings(embeddingsModel: string, input: string[], token: CancellationToken): Promise<({ values: number[] }[])>;
1636
>
}
1637
>
1638
>
export interface ExtHostEmbeddingsShape {
1639
>
$provideEmbeddings(handle: number, input: string[], token: CancellationToken): Promise<{ values: number[] }[]>;
1640
>
$acceptEmbeddingModels(models: string[]): void;
1641
>
}
1642
>
1643
>
export interface IExtensionChatAgentMetadata extends Dto<IChatAgentMetadata> {
1644
>
hasFollowups?: boolean;
1645
>
}
1646
>
1647
>
export interface IDynamicChatAgentProps {
1648
>
name: string;
1649
>
publisherName: string;
1650
>
description?: string;
1651
>
fullName?: string;
1652
>
}
1653
>
1654
>
export interface IChatAgentProgressShape {
1655
>
$handleProgressChunk(requestId: string, chunks: (IChatProgressDto | [IChatProgressDto, number])[]): Promise<void>;
1656
>
$handleAnchorResolve(requestId: string, handle: string, anchor: Dto<IChatContentInlineReference>): void;
1657
>
}
1658
>
1659
>
export interface MainThreadChatAgentsShape2 extends IChatAgentProgressShape, IDisposable {
1660
>
$registerAgent(handle: number, extension: ExtensionIdentifier, id: string, metadata: IExtensionChatAgentMetadata, dynamicProps: IDynamicChatAgentProps | undefined): void;
1661
>
$registerChatParticipantDetectionProvider(handle: number): void;
1662
>
$unregisterChatParticipantDetectionProvider(handle: number): void;
1663
>
$registerPromptFileProvider(handle: number, type: string, extension: ExtensionIdentifier): void;
1664
>
$unregisterPromptFileProvider(handle: number): void;
1665
>
$onDidChangePromptFiles(handle: number): void;
1666
>
$registerChatSessionCustomizationProvider(handle: number, chatSessionType: string, metadata: IChatSessionCustomizationProviderMetadataDto, extension: ExtensionIdentifier): void;
1667
>
$unregisterChatSessionCustomizationProvider(handle: number): void;
1668
>
$onDidChangeCustomizations(handle: number): void;
1669
>
$registerAgentCompletionsProvider(handle: number, id: string, triggerCharacters: string[]): void;
1670
>
$unregisterAgentCompletionsProvider(handle: number, id: string): void;
1671
>
$updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): void;
1672
>
$unregisterAgent(handle: number): void;
1673
>
1674
>
$transferActiveChatSession(toWorkspace: UriComponents): Promise<void>;
1675
>
$provideCustomAgents(token: CancellationToken): Promise<ICustomAgentDto[]>;
1676
>
$provideInstructions(token: CancellationToken): Promise<IInstructionDto[]>;
1677
>
$provideSkills(token: CancellationToken): Promise<ISkillDto[]>;
1678
>
$provideSlashCommands(token: CancellationToken): Promise<ISlashCommandDto[]>;
1679
>
$provideHooks(token: CancellationToken): Promise<IHookDto[]>;
1680
>
$providePlugins(token: CancellationToken): Promise<IPluginDto[]>;
1681
>
}
1682
>
1683
>
export interface ICodeMapperTextEdit {
1684
>
uri: URI;
1685
>
edits: languages.TextEdit[];
1686
>
}
1687
>
1688
>
export interface ICodeMapperNotebookEditDto {
1689
>
uri: URI;
1690
>
edits: ICellEditOperationDto[];
1691
>
}
1692
>
1693
>
export type ICodeMapperProgressDto = Dto<ICodeMapperTextEdit> | Dto<ICodeMapperNotebookEditDto>;
1694
>
1695
>
export interface MainThreadCodeMapperShape extends IDisposable {
1696
>
$registerCodeMapperProvider(handle: number, displayName: string): void;
1697
>
$unregisterCodeMapperProvider(handle: number): void;
1698
>
$handleProgress(requestId: string, data: ICodeMapperProgressDto): Promise<void>;
1699
>
}
1700
>
1701
>
export interface IChatAgentCompletionItem {
1702
>
id: string;
1703
>
fullName?: string;
1704
>
icon?: string;
1705
>
insertText?: string;
1706
>
label: string | languages.CompletionItemLabel;
1707
>
value: IChatRequestVariableValueDto;
1708
>
detail?: string;
1709
>
documentation?: string | IMarkdownString;
1710
>
command?: ICommandDto;
1711
>
}
1712
>
1713
>
export type IChatContentProgressDto =
1714
>
| Dto<Exclude<IChatProgressHistoryResponseContent, IChatTask | IChatMultiDiffData>>
1715
>
| IChatMultiDiffDataSerialized
1716
>
| IChatTaskDto;
1717
>
1718
>
export type IChatAgentHistoryEntryDto = {
1719
>
request: IChatAgentRequest;
1720
>
response: ReadonlyArray<IChatContentProgressDto>;
1721
>
result: IChatAgentResult;
1722
>
};
1723
>
1724
>
export interface IChatSessionContextDto {
1725
>
readonly chatSessionResource: UriComponents;
1726
>
readonly isUntitled: boolean;
1727
>
readonly initialSessionOptions?: ReadonlyArray<{ optionId: string; value: string }>;
1728
>
}
1729
>
1730
>
export interface IChatAgentInvokeResult extends IChatAgentResult {
1731
>
/** Error callstack for telemetry only. Stripped at the RPC boundary — never persisted or sent to the model. */
1732
>
errorCallstack?: string;
1733
>
/** Error name (e.g. 'ChatQuotaExceeded', 'TypeError') for telemetry only. */
1734
>
errorName?: string;
1735
>
}
1736
>
1737
>
export interface ExtHostChatAgentsShape2 {
1738
>
$invokeAgent(handle: number, request: Dto<IChatAgentRequest>, context: { history: IChatAgentHistoryEntryDto[]; chatSessionContext?: IChatSessionContextDto }, token: CancellationToken): Promise<IChatAgentInvokeResult | undefined>;
1739
>
$provideFollowups(request: Dto<IChatAgentRequest>, handle: number, result: IChatAgentResult, context: { history: IChatAgentHistoryEntryDto[] }, token: CancellationToken): Promise<IChatFollowup[]>;
1740
>
$acceptFeedback(handle: number, result: IChatAgentResult, voteAction: IChatVoteAction): void;
1741
>
$handleQuestionCarouselAnswer(requestId: string, resolveId: string, answers: Record<string, unknown> | undefined): void;
1742
>
$acceptAction(handle: number, result: IChatAgentResult, action: IChatUserActionEvent): void;
1743
>
$invokeCompletionProvider(handle: number, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
1744
>
$provideChatTitle(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
1745
>
$provideChatSummary(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
1746
>
$releaseSession(sessionResource: UriComponents): void;
1747
>
$detectChatParticipant(handle: number, request: Dto<IChatAgentRequest>, context: { history: IChatAgentHistoryEntryDto[] }, options: { participants: IChatParticipantMetadata[]; location: ChatAgentLocation }, token: CancellationToken): Promise<IChatParticipantDetectionResult | null | undefined>;
1748
>
$providePromptFiles(handle: number, type: PromptsType, context: IPromptFileContext, token: CancellationToken): Promise<Dto<IPromptFileResource>[] | undefined>;
1749
>
$provideChatSessionCustomizations(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatSessionCustomizationItemDto[] | undefined>;
1750
>
$provideSourceFolders(handle: number, sessionResource: UriComponents, type: string, token: CancellationToken): Promise<IChatSessionCustomizationSourceFolderDto[] | undefined>;
1751
>
$setRequestTools(requestId: string, tools: UserSelectedTools): void;
1752
>
$setYieldRequested(requestId: string, value: boolean): void;
1753
>
$acceptActiveChatSession(sessionResource: UriComponents | undefined): void;
1754
>
$onDidChangeCustomAgents(): void;
1755
>
$onDidChangeInstructions(): void;
1756
>
$onDidChangeSkills(): void;
1757
>
$onDidChangeSlashCommands(): void;
1758
>
$onDidChangeHooks(): void;
1759
>
$onDidChangePlugins(): void;
1760
>
}
1761
>
1762
>
export type IChatResourceSourceDto = 'local' | 'user' | 'extension' | 'plugin' | 'builtin';
1763
>
1764
>
export interface IChatResourceDto {
1765
>
readonly uri: UriComponents;
1766
>
readonly name: string;
1767
>
readonly description?: string;
1768
>
readonly source: IChatResourceSourceDto;
1769
>
readonly extensionId?: string;
1770
>
readonly pluginUri?: UriComponents;
1771
>
readonly sessionTypes?: readonly string[];
1772
>
}
1773
>
1774
>
export interface ICustomAgentDto extends IChatResourceDto {
1775
>
readonly argumentHint?: string;
1776
>
readonly tools?: readonly string[];
1777
>
readonly model?: readonly string[];
1778
>
readonly userInvocable: boolean;
1779
>
readonly disableModelInvocation: boolean;
1780
>
readonly enabled: boolean;
1781
>
}
1782
>
1783
>
export interface IInstructionDto extends IChatResourceDto {
1784
>
readonly pattern?: string;
1785
>
}
1786
>
1787
>
export interface ISkillDto extends IChatResourceDto {
1788
>
readonly userInvocable: boolean;
1789
>
readonly disableModelInvocation: boolean;
1790
>
}
1791
>
1792
>
export interface ISlashCommandDto extends IChatResourceDto {
1793
>
readonly argumentHint?: string;
1794
>
readonly userInvocable: boolean;
1795
>
}
1796
>
1797
>
export interface IHookDto {
1798
>
readonly uri: UriComponents;
1799
>
readonly sessionTypes?: readonly string[];
1800
>
readonly source: IChatResourceSourceDto;
1801
>
readonly extensionId?: string;
1802
>
readonly pluginUri?: UriComponents;
1803
>
}
1804
>
1805
>
export interface IPluginDto {
1806
>
readonly uri: UriComponents;
1807
>
}
1808
>
1809
>
export interface IChatSessionCustomizationProviderMetadataDto {
1810
>
readonly label: string;
1811
>
readonly iconId?: string;
1812
>
readonly supportedTypes?: readonly string[];
1813
>
}
1814
>
1815
>
export interface IChatSessionCustomizationItemDto {
1816
>
readonly uri: UriComponents;
1817
>
readonly type: string;
1818
>
readonly name: string;
1819
>
readonly source: IChatResourceSourceDto;
1820
>
readonly description?: string;
1821
>
readonly groupKey?: string;
1822
>
readonly badge?: string;
1823
>
readonly extensionId?: string;
1824
>
readonly pluginUri?: UriComponents;
1825
>
readonly pluginLabel?: string;
1826
>
readonly badgeTooltip?: string;
1827
>
readonly userInvocable?: boolean;
1828
>
}
1829
>
1830
>
export interface IChatSessionCustomizationSourceFolderDto {
1831
>
readonly uri: UriComponents;
1832
>
readonly label: string;
1833
>
readonly source: IChatResourceSourceDto;
1834
>
}
1835
>
export interface IChatParticipantMetadata {
1836
>
participant: string;
1837
>
command?: string;
1838
>
disambiguation: { category: string; description: string; examples: string[] }[];
1839
>
}
1840
>
1841
>
export interface IChatParticipantDetectionResult {
1842
>
participant: string;
1843
>
command?: string;
1844
>
}
1845
>
1846
>
export interface IToolDataDto {
1847
>
id: string;
1848
>
toolReferenceName?: string;
1849
>
legacyToolReferenceFullNames?: readonly string[];
1850
>
fullReferenceName: string | undefined;
1851
>
tags?: readonly string[];
1852
>
displayName: string;
1853
>
userDescription?: string;
1854
>
modelDescription: string;
1855
>
source: Dto<ToolDataSource>;
1856
>
inputSchema?: IJSONSchema;
1857
>
}
1858
>
1859
>
export interface ILanguageModelChatSelectorDto {
1860
>
vendor?: string;
1861
>
family?: string;
1862
>
version?: string;
1863
>
id?: string;
1864
>
}
1865
>
1866
>
export interface IToolDefinitionDto extends IToolDataDto {
1867
>
icon?: IconPathDto;
1868
>
models?: ILanguageModelChatSelectorDto[];
1869
>
toolSet?: string;
1870
>
}
1871
>
1872
>
export interface MainThreadLanguageModelToolsShape extends IDisposable {
1873
>
$getTools(): Promise<Dto<IToolDataDto>[]>;
1874
>
$acceptToolProgress(callId: string, progress: IToolProgressStep): void;
1875
>
$invokeTool(dto: Dto<IToolInvocation>, token?: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
1876
>
$countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;
1877
>
$registerTool(id: string, hasHandleToolStream: boolean): void;
1878
>
$registerToolWithDefinition(extensionId: ExtensionIdentifier, definition: IToolDefinitionDto, hasHandleToolStream: boolean): void;
1879
>
$unregisterTool(name: string): void;
1880
>
}
1881
>
1882
>
export type IChatRequestVariableValueDto = Dto<IChatRequestVariableValue>;
1883
>
1884
>
export interface ExtHostLanguageModelToolsShape {
1885
>
$onDidChangeTools(tools: IToolDataDto[]): void;
1886
>
$invokeTool(dto: Dto<IToolInvocation>, token: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
1887
>
$countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;
1888
>
1889
>
$handleToolStream(toolId: string, context: IToolInvocationStreamContext, token: CancellationToken): Promise<IStreamedToolInvocation | undefined>;
1890
>
$prepareToolInvocation(toolId: string, context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
1891
>
}
1892
>
1893
>
export interface MainThreadUrlsShape extends IDisposable {
1894
>
$registerUriHandler(handle: number, extensionId: ExtensionIdentifier, extensionDisplayName: string): Promise<void>;
1895
>
$unregisterUriHandler(handle: number): Promise<void>;
1896
>
$createAppUri(uri: UriComponents): Promise<UriComponents>;
1897
>
}
1898
>
1899
>
export interface IChatResponseProgressFileTreeData {
1900
>
label: string;
1901
>
uri: URI;
1902
>
children?: IChatResponseProgressFileTreeData[];
1903
>
}
1904
>
1905
>
export type IDocumentContextDto = {
1906
>
uri: UriComponents;
1907
>
version: number;
1908
>
ranges: IRange[];
1909
>
};
1910
>
1911
>
export type IChatProgressDto =
1912
>
| Dto<Exclude<IChatProgress, IChatTask | IChatNotebookEdit>>
1913
>
| IChatTaskDto
1914
>
| IChatNotebookEditDto
1915
>
| IChatExternalEditsDto
1916
>
| IChatResponseClearToPreviousToolInvocationDto
1917
>
| IChatBeginToolInvocationDto
1918
>
| IChatUpdateToolInvocationDto
1919
>
| IChatUsageDto;
1920
>
1921
>
export interface ExtHostUrlsShape {
1922
>
$handleExternalUri(handle: number, uri: UriComponents): Promise<void>;
1923
>
}
1924
>
1925
>
export interface MainThreadUriOpenersShape extends IDisposable {
1926
>
$registerUriOpener(id: string, schemes: readonly string[], extensionId: ExtensionIdentifier, label: string): Promise<void>;
1927
>
$unregisterUriOpener(id: string): Promise<void>;
1928
>
}
1929
>
1930
>
export interface ExtHostUriOpenersShape {
1931
>
$canOpenUri(id: string, uri: UriComponents, token: CancellationToken): Promise<languages.ExternalUriOpenerPriority>;
1932
>
$openUri(id: string, context: { resolvedUri: UriComponents; sourceUri: UriComponents }, token: CancellationToken): Promise<void>;
1933
>
}
1934
>
1935
>
export interface MainThreadChatOutputRendererShape extends IDisposable {
1936
>
$registerChatOutputRenderer(viewType: string, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): void;
1937
>
$unregisterChatOutputRenderer(viewType: string): void;
1938
>
}
1939
>
1940
>
export interface IChatOutputRenderContextDto {
1941
>
readonly codeBlockContext?: {
1942
>
readonly languageIdentifier: string;
1943
>
};
1944
>
}
1945
>
1946
>
export interface ExtHostChatOutputRendererShape {
1947
>
$renderChatOutput(viewType: string, mime: string, valueData: VSBuffer, webviewHandle: string, context: IChatOutputRenderContextDto, token: CancellationToken): Promise<void>;
1948
>
}
1949
>
1950
>
export interface MainThreadProfileContentHandlersShape {
1951
>
$registerProfileContentHandler(id: string, name: string, description: string | undefined, extensionId: string): Promise<void>;
1952
>
$unregisterProfileContentHandler(id: string): Promise<void>;
1953
>
}
1954
>
1955
>
export interface ExtHostProfileContentHandlersShape {
1956
>
$saveProfile(id: string, name: string, content: string, token: CancellationToken): Promise<UriDto<ISaveProfileResult> | null>;
1957
>
$readProfile(id: string, idOrUri: string | UriComponents, token: CancellationToken): Promise<string | null>;
1958
>
}
1959
>
1960
>
export interface ITextSearchComplete {
1961
>
limitHit?: boolean;
1962
>
message?: TextSearchCompleteMessage | TextSearchCompleteMessage[];
1963
>
}
1964
>
1965
>
export interface ResourceTrustRequestOptionsDto {
1966
>
readonly uri: UriComponents;
1967
>
readonly message?: string;
1968
>
}
1969
>
1970
>
export interface MainThreadWorkspaceShape extends IDisposable {
1971
>
$startFileSearch(includeFolder: UriComponents | null, options: IFileQueryBuilderOptions, token: CancellationToken): Promise<UriComponents[] | null>;
1972
>
$startTextSearch(query: search.IPatternInfo, folder: UriComponents | null, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<ITextSearchComplete | null>;
1973
>
$checkExists(folders: readonly UriComponents[], includes: string[], token: CancellationToken): Promise<boolean>;
1974
>
$save(uri: UriComponents, options: { saveAs: boolean }): Promise<UriComponents | undefined>;
1975
>
$saveAll(includeUntitled?: boolean): Promise<boolean>;
1976
>
$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, workspaceFoldersToAdd: { uri: UriComponents; name?: string }[]): Promise<void>;
1977
>
$resolveProxy(url: string): Promise<string | undefined>;
1978
>
$lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;
1979
>
$lookupKerberosAuthorization(url: string): Promise<string | undefined>;
1980
>
$loadCertificates(): Promise<string[]>;
1981
>
$requestResourceTrust(options: ResourceTrustRequestOptionsDto): Promise<boolean | undefined>;
1982
>
$requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
1983
>
$isResourceTrusted(resource: UriComponents): Promise<boolean>;
1984
>
$registerEditSessionIdentityProvider(handle: number, scheme: string): void;
1985
>
$unregisterEditSessionIdentityProvider(handle: number): void;
1986
>
$registerCanonicalUriProvider(handle: number, scheme: string): void;
1987
>
$unregisterCanonicalUriProvider(handle: number): void;
1988
>
$resolveDecoding(resource: UriComponents | undefined, options?: { encoding?: string }): Promise<{ preferredEncoding: string; guessEncoding: boolean; candidateGuessEncodings: string[] }>;
1989
>
$validateDetectedEncoding(resource: UriComponents | undefined, detectedEncoding: string, options?: { encoding?: string }): Promise<string>;
1990
>
$resolveEncoding(resource: UriComponents | undefined, options?: { encoding?: string }): Promise<{ encoding: string; addBOM: boolean }>;
1991
>
}
1992
>
1993
>
export interface IFileChangeDto {
1994
>
resource: UriComponents;
1995
>
type: files.FileChangeType;
1996
>
}
1997
>
1998
>
export interface MainThreadFileSystemShape extends IDisposable {
1999
>
$registerFileSystemProvider(handle: number, scheme: string, capabilities: files.FileSystemProviderCapabilities, readonlyMessage?: IMarkdownString): Promise<void>;
2000
>
$unregisterProvider(handle: number): void;
2001
>
$onFileSystemChange(handle: number, resource: IFileChangeDto[]): void;
2002
>
2003
>
$stat(resource: UriComponents): Promise<files.IStat>;
2004
>
$readdir(resource: UriComponents): Promise<[string, files.FileType][]>;
2005
>
$readFile(resource: UriComponents): Promise<VSBuffer>;
2006
>
$writeFile(resource: UriComponents, content: VSBuffer): Promise<void>;
2007
>
$rename(resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2008
>
$copy(resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2009
>
$mkdir(resource: UriComponents): Promise<void>;
2010
>
$delete(resource: UriComponents, opts: files.IFileDeleteOptions): Promise<void>;
2011
>
2012
>
$ensureActivation(scheme: string): Promise<void>;
2013
>
}
2014
>
2015
>
export interface MainThreadFileSystemEventServiceShape extends IDisposable {
2016
>
$watch(extensionId: string, session: number, resource: UriComponents, opts: files.IWatchOptions, correlate: boolean): void;
2017
>
$unwatch(session: number): void;
2018
>
}
2019
>
2020
>
export interface MainThreadLabelServiceShape extends IDisposable {
2021
>
$registerResourceLabelFormatter(handle: number, formatter: ResourceLabelFormatter): void;
2022
>
$unregisterResourceLabelFormatter(handle: number): void;
2023
>
}
2024
>
2025
>
export interface MainThreadSearchShape extends IDisposable {
2026
>
$registerFileSearchProvider(handle: number, scheme: string): void;
2027
>
$registerAITextSearchProvider(handle: number, scheme: string): void;
2028
>
$registerTextSearchProvider(handle: number, scheme: string): void;
2029
>
$unregisterProvider(handle: number): void;
2030
>
$handleFileMatch(handle: number, session: number, data: UriComponents[]): void;
2031
>
$handleTextMatch(handle: number, session: number, data: search.IRawFileMatch2[]): void;
2032
>
$handleKeywordResult(handle: number, session: number, data: AISearchKeyword): void;
2033
>
$handleTelemetry(eventName: string, data: any): void;
2034
>
}
2035
>
2036
>
export interface MainThreadShareShape extends IDisposable {
2037
>
$registerShareProvider(handle: number, selector: IDocumentFilterDto[], id: string, label: string, priority: number): void;
2038
>
$unregisterShareProvider(handle: number): void;
2039
>
}
2040
>
2041
>
export interface MainThreadTaskShape extends IDisposable {
2042
>
$createTaskId(task: tasks.ITaskDTO): Promise<string>;
2043
>
$registerTaskProvider(handle: number, type: string): Promise<void>;
2044
>
$unregisterTaskProvider(handle: number): Promise<void>;
2045
>
$fetchTasks(filter?: tasks.ITaskFilterDTO): Promise<tasks.ITaskDTO[]>;
2046
>
$getTaskExecution(value: tasks.ITaskHandleDTO | tasks.ITaskDTO): Promise<tasks.ITaskExecutionDTO>;
2047
>
$executeTask(task: tasks.ITaskHandleDTO | tasks.ITaskDTO): Promise<tasks.ITaskExecutionDTO>;
2048
>
$terminateTask(id: string): Promise<void>;
2049
>
$registerTaskSystem(scheme: string, info: tasks.ITaskSystemInfoDTO): void;
2050
>
$customExecutionComplete(id: string, result?: number): Promise<void>;
2051
>
$registerSupportedExecutions(custom?: boolean, shell?: boolean, process?: boolean): Promise<void>;
2052
>
}
2053
>
2054
>
export interface MainThreadExtensionServiceShape extends IDisposable {
2055
>
$getExtension(extensionId: string): Promise<Dto<IExtensionDescription> | undefined>;
2056
>
$activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
2057
>
$onWillActivateExtension(extensionId: ExtensionIdentifier): Promise<void>;
2058
>
$onDidActivateExtension(extensionId: ExtensionIdentifier, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationReason: ExtensionActivationReason): void;
2059
>
$onExtensionActivationError(extensionId: ExtensionIdentifier, error: SerializedError, missingExtensionDependency: MissingExtensionDependency | null): Promise<void>;
2060
>
$onExtensionRuntimeError(extensionId: ExtensionIdentifier, error: SerializedError): void;
2061
>
$setPerformanceMarks(marks: performance.PerformanceMark[]): Promise<void>;
2062
>
$asBrowserUri(uri: UriComponents): Promise<UriComponents>;
2063
>
}
2064
>
2065
>
export interface SCMProviderFeatures {
2066
>
hasArtifactProvider?: boolean;
2067
>
hasHistoryProvider?: boolean;
2068
>
hasQuickDiffProvider?: boolean;
2069
>
quickDiffLabel?: string;
2070
>
hasSecondaryQuickDiffProvider?: boolean;
2071
>
secondaryQuickDiffLabel?: string;
2072
>
count?: number;
2073
>
commitTemplate?: string;
2074
>
acceptInputCommand?: languages.Command;
2075
>
actionButton?: SCMActionButtonDto | null;
2076
>
statusBarCommands?: ICommandDto[];
2077
>
contextValue?: string;
2078
>
}
2079
>
2080
>
export interface SCMActionButtonDto {
2081
>
command: ICommandDto & { shortTitle?: string };
2082
>
secondaryCommands?: ICommandDto[][];
2083
>
enabled: boolean;
2084
>
}
2085
>
2086
>
export interface SCMGroupFeatures {
2087
>
hideWhenEmpty?: boolean;
2088
>
contextValue?: string;
2089
>
}
2090
>
2091
>
export type SCMRawResource = [
2092
>
number /*handle*/,
2093
>
UriComponents /*resourceUri*/,
2094
>
[UriComponents | ThemeIcon | undefined, UriComponents | ThemeIcon | undefined] /*icons: light, dark*/,
2095
>
string /*tooltip*/,
2096
>
boolean /*strike through*/,
2097
>
boolean /*faded*/,
2098
>
string /*context value*/,
2099
>
ICommandDto | undefined /*command*/,
2100
>
UriComponents | undefined /* multiFileDiffEditorOriginalUri */,
2101
>
UriComponents | undefined /* multiFileDiffEditorModifiedUri */,
2102
>
];
2103
>
2104
>
export type SCMRawResourceSplice = [
2105
>
number /* start */,
2106
>
number /* delete count */,
2107
>
SCMRawResource[]
2108
>
];
2109
>
2110
>
export type SCMRawResourceSplices = [
2111
>
number, /*handle*/
2112
>
SCMRawResourceSplice[]
2113
>
];
2114
>
2115
>
export interface SCMHistoryItemRefDto {
2116
>
readonly id: string;
2117
>
readonly name: string;
2118
>
readonly revision?: string;
2119
>
readonly category?: string;
2120
>
readonly description?: string;
2121
>
readonly icon?: IconPathDto;
2122
>
}
2123
>
2124
>
export interface SCMHistoryItemRefsChangeEventDto {
2125
>
readonly added: readonly SCMHistoryItemRefDto[];
2126
>
readonly modified: readonly SCMHistoryItemRefDto[];
2127
>
readonly removed: readonly SCMHistoryItemRefDto[];
2128
>
readonly silent: boolean;
2129
>
}
2130
>
2131
>
export interface SCMHistoryItemDto {
2132
>
readonly id: string;
2133
>
readonly parentIds: string[];
2134
>
readonly subject: string;
2135
>
readonly message: string;
2136
>
readonly displayId?: string;
2137
>
readonly author?: string;
2138
>
readonly authorIcon?: IconPathDto;
2139
>
readonly authorEmail?: string;
2140
>
readonly timestamp?: number;
2141
>
readonly statistics?: {
2142
>
readonly files: number;
2143
>
readonly insertions: number;
2144
>
readonly deletions: number;
2145
>
};
2146
>
readonly references?: SCMHistoryItemRefDto[];
2147
>
readonly tooltip?: IMarkdownString | Array<IMarkdownString> | undefined;
2148
>
}
2149
>
2150
>
export interface SCMHistoryItemChangeDto {
2151
>
readonly uri: UriComponents;
2152
>
readonly originalUri: UriComponents | undefined;
2153
>
readonly modifiedUri: UriComponents | undefined;
2154
>
}
2155
>
2156
>
export interface SCMArtifactGroupDto {
2157
>
readonly id: string;
2158
>
readonly name: string;
2159
>
readonly icon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
2160
>
readonly supportsFolders?: boolean;
2161
>
}
2162
>
2163
>
export interface SCMArtifactDto {
2164
>
readonly id: string;
2165
>
readonly name: string;
2166
>
readonly description?: string;
2167
>
readonly icon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
2168
>
readonly timestamp?: number;
2169
>
readonly command?: ICommandDto;
2170
>
}
2171
>
2172
>
export interface MainThreadSCMShape extends IDisposable {
2173
>
$registerSourceControl(handle: number, parentHandle: number | undefined, id: string, label: string, rootUri: UriComponents | undefined, iconPath: IconPathDto | undefined, isHidden: boolean | undefined, inputBoxDocumentUri: UriComponents): Promise<void>;
2174
>
$updateSourceControl(handle: number, features: SCMProviderFeatures): Promise<void>;
2175
>
$unregisterSourceControl(handle: number): Promise<void>;
2176
>
2177
>
$registerGroups(sourceControlHandle: number, groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures, /* multiDiffEditorEnableViewChanges */ boolean][], splices: SCMRawResourceSplices[]): Promise<void>;
2178
>
$updateGroup(sourceControlHandle: number, handle: number, features: SCMGroupFeatures): Promise<void>;
2179
>
$updateGroupLabel(sourceControlHandle: number, handle: number, label: string): Promise<void>;
2180
>
$unregisterGroup(sourceControlHandle: number, handle: number): Promise<void>;
2181
>
2182
>
$spliceResourceStates(sourceControlHandle: number, splices: SCMRawResourceSplices[]): Promise<void>;
2183
>
2184
>
$setInputBoxValue(sourceControlHandle: number, value: string): Promise<void>;
2185
>
$setInputBoxPlaceholder(sourceControlHandle: number, placeholder: string): Promise<void>;
2186
>
$setInputBoxEnablement(sourceControlHandle: number, enabled: boolean): Promise<void>;
2187
>
$setInputBoxVisibility(sourceControlHandle: number, visible: boolean): Promise<void>;
2188
>
$showValidationMessage(sourceControlHandle: number, message: string | IMarkdownString, type: InputValidationType): Promise<void>;
2189
>
$setValidationProviderIsEnabled(sourceControlHandle: number, enabled: boolean): Promise<void>;
2190
>
2191
>
$onDidChangeHistoryProviderCurrentHistoryItemRefs(sourceControlHandle: number, historyItemRef?: SCMHistoryItemRefDto, historyItemRemoteRef?: SCMHistoryItemRefDto, historyItemBaseRef?: SCMHistoryItemRefDto): Promise<void>;
2192
>
$onDidChangeHistoryProviderHistoryItemRefs(sourceControlHandle: number, historyItemRefs: SCMHistoryItemRefsChangeEventDto): Promise<void>;
2193
>
2194
>
$onDidChangeArtifacts(sourceControlHandle: number, groups: string[]): Promise<void>;
2195
>
}
2196
>
2197
>
export interface MainThreadQuickDiffShape extends IDisposable {
2198
>
$registerQuickDiffProvider(handle: number, selector: IDocumentFilterDto[], id: string, label: string, rootUri: UriComponents | undefined): Promise<void>;
2199
>
$unregisterQuickDiffProvider(handle: number): Promise<void>;
2200
>
$createSourceControlDiffInformation(handle: number, uri: UriComponents): Promise<void>;
2201
>
$disposeSourceControlDiffInformation(handle: number): Promise<void>;
2202
>
}
2203
>
2204
>
export interface IAgentEditorCommentDto {
2205
>
id: string;
2206
>
range: IRange;
2207
>
body: string;
2208
>
author?: string;
2209
>
}
2210
>
2211
>
export interface MainThreadAgentEditorCommentsShape extends IDisposable {
2212
>
$createAgentEditorComments(handle: number, uri: UriComponents): Promise<void>;
2213
>
$addComment(handle: number, range: IRange, body: string): Promise<void>;
2214
>
$deleteComment(handle: number, id: string): Promise<void>;
2215
>
$disposeAgentEditorComments(handle: number): Promise<void>;
2216
>
}
2217
>
2218
>
export interface ExtHostAgentEditorCommentsShape {
2219
>
$acceptAgentEditorComments(handle: number, comments: IAgentEditorCommentDto[], acceptsComments: boolean): void;
2220
>
}
2221
>
2222
>
export interface IDocumentDiffLineChangeDto {
2223
>
originalRange: IRange;
2224
>
modifiedRange: IRange;
2225
>
innerChanges: { originalRange: IRange; modifiedRange: IRange }[] | undefined;
2226
>
}
2227
>
2228
>
export interface IDocumentDiffMoveDto {
2229
>
originalRange: IRange;
2230
>
modifiedRange: IRange;
2231
>
changes: IDocumentDiffLineChangeDto[];
2232
>
}
2233
>
2234
>
export interface IDocumentDiffResultDto {
2235
>
identical: boolean;
2236
>
quitEarly: boolean;
2237
>
changes: IDocumentDiffLineChangeDto[];
2238
>
moves: IDocumentDiffMoveDto[];
2239
>
}
2240
>
2241
>
export interface MainThreadDocumentDiffShape extends IDisposable {
2242
>
$computeDocumentDiff(originalUri: UriComponents, modifiedUri: UriComponents, ignoreTrimWhitespace: boolean, maxComputationTimeMs: number, computeMoves: boolean): Promise<IDocumentDiffResultDto | null>;
2243
>
}
2244
>
2245
>
export type DebugSessionUUID = string;
2246
>
2247
>
export interface IDebugConfiguration {
2248
>
type: string;
2249
>
name: string;
2250
>
request: string;
2251
>
[key: string]: any;
2252
>
}
2253
>
2254
>
export interface IStartDebuggingOptions {
2255
>
parentSessionID?: DebugSessionUUID;
2256
>
lifecycleManagedByParent?: boolean;
2257
>
repl?: IDebugSessionReplMode;
2258
>
noDebug?: boolean;
2259
>
compact?: boolean;
2260
>
suppressDebugToolbar?: boolean;
2261
>
suppressDebugStatusbar?: boolean;
2262
>
suppressDebugView?: boolean;
2263
>
suppressSaveBeforeStart?: boolean;
2264
>
testRun?: IDebugTestRunReference;
2265
>
}
2266
>
2267
>
export interface MainThreadDebugServiceShape extends IDisposable {
2268
>
$registerDebugTypes(debugTypes: string[]): void;
2269
>
$sessionCached(sessionID: string): void;
2270
>
$acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): void;
2271
>
$acceptDAError(handle: number, name: string, message: string, stack: string | undefined): void;
2272
>
$acceptDAExit(handle: number, code: number | undefined, signal: string | undefined): void;
2273
>
$registerDebugConfigurationProvider(type: string, triggerKind: DebugConfigurationProviderTriggerKind, hasProvideMethod: boolean, hasResolveMethod: boolean, hasResolve2Method: boolean, handle: number): Promise<void>;
2274
>
$registerDebugAdapterDescriptorFactory(type: string, handle: number): Promise<void>;
2275
>
$unregisterDebugConfigurationProvider(handle: number): void;
2276
>
$unregisterDebugAdapterDescriptorFactory(handle: number): void;
2277
>
$startDebugging(folder: UriComponents | undefined, nameOrConfig: string | IDebugConfiguration, options: IStartDebuggingOptions): Promise<boolean>;
2278
>
$stopDebugging(sessionId: DebugSessionUUID | undefined): Promise<void>;
2279
>
$setDebugSessionName(id: DebugSessionUUID, name: string): void;
2280
>
$customDebugAdapterRequest(id: DebugSessionUUID, command: string, args: any): Promise<any>;
2281
>
$getDebugProtocolBreakpoint(id: DebugSessionUUID, breakpoinId: string): Promise<DebugProtocol.Breakpoint | undefined>;
2282
>
$appendDebugConsole(value: string): void;
2283
>
$registerBreakpoints(breakpoints: Array<ISourceMultiBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>): Promise<void>;
2284
>
$unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[], dataBreakpointIds: string[]): Promise<void>;
2285
>
$registerDebugVisualizer(extensionId: string, id: string): void;
2286
>
$unregisterDebugVisualizer(extensionId: string, id: string): void;
2287
>
$registerDebugVisualizerTree(treeId: string, canEdit: boolean): void;
2288
>
$unregisterDebugVisualizerTree(treeId: string): void;
2289
>
}
2290
>
2291
>
export interface IOpenUriOptions {
2292
>
readonly allowTunneling?: boolean;
2293
>
readonly allowContributedOpeners?: boolean | string;
2294
>
}
2295
>
2296
>
export interface MainThreadWindowShape extends IDisposable {
2297
>
$getInitialState(): Promise<{ isFocused: boolean; isActive: boolean }>;
2298
>
$openUri(uri: UriComponents, uriString: string | undefined, options: IOpenUriOptions): Promise<boolean>;
2299
>
$asExternalUri(uri: UriComponents, options: IOpenUriOptions): Promise<UriComponents>;
2300
>
}
2301
>
2302
>
export enum CandidatePortSource {
2303
>
None = 0,
2304
>
Process = 1,
2305
>
Output = 2,
2306
>
Hybrid = 3
2307
>
}
2308
>
2309
>
export interface PortAttributesSelector {
2310
>
portRange?: [number, number] | number;
2311
>
commandPattern?: RegExp;
2312
>
}
2313
>
2314
>
export interface MainThreadTunnelServiceShape extends IDisposable {
2315
>
$openTunnel(tunnelOptions: TunnelOptions, source: string | undefined): Promise<TunnelDto | undefined>;
2316
>
$closeTunnel(remote: { host: string; port: number }): Promise<void>;
2317
>
$getTunnels(): Promise<TunnelDescription[]>;
2318
>
$setTunnelProvider(features: TunnelProviderFeatures | undefined, enablePortsView: boolean): Promise<void>;
2319
>
$hasTunnelProvider(): Promise<boolean>;
2320
>
$setRemoteTunnelService(processId: number): Promise<void>;
2321
>
$setCandidateFilter(): Promise<void>;
2322
>
$onFoundNewCandidates(candidates: CandidatePort[]): Promise<void>;
2323
>
$setCandidatePortSource(source: CandidatePortSource): Promise<void>;
2324
>
$registerPortsAttributesProvider(selector: PortAttributesSelector, providerHandle: number): Promise<void>;
2325
>
$unregisterPortsAttributesProvider(providerHandle: number): Promise<void>;
2326
>
}
2327
>
2328
>
export interface MainThreadTimelineShape extends IDisposable {
2329
>
$registerTimelineProvider(provider: TimelineProviderDescriptor): void;
2330
>
$unregisterTimelineProvider(source: string): void;
2331
>
$emitTimelineChangeEvent(e: TimelineChangeEvent | undefined): void;
2332
>
}
2333
>
2334
>
export interface HoverWithId extends languages.Hover {
2335
>
/**
2336
>
* Id of the hover
2337
>
*/
2338
>
id: number;
2339
>
}
2340
>
2341
>
// -- extension host
2342
>
2343
>
export interface ICommandMetadataDto {
2344
>
/**
2345
>
* NOTE: Please use an ILocalizedString. string is in the type for backcompat for now.
2346
>
* A short summary of what the command does. This will be used in:
2347
>
* - API commands
2348
>
* - when showing keybindings that have no other UX
2349
>
* - when searching for commands in the Command Palette
2350
>
*/
2351
>
readonly description: ILocalizedString | string;
2352
>
readonly args?: ReadonlyArray<{
2353
>
readonly name: string;
2354
>
readonly isOptional?: boolean;
2355
>
readonly description?: string;
2356
>
}>;
2357
>
readonly returns?: string;
2358
>
}
2359
>
2360
>
export interface ICodeMapperRequestDto extends Dto<ICodeMapperRequest> {
2361
>
requestId: string;
2362
>
}
2363
>
2364
>
export interface ExtHostCodeMapperShape {
2365
>
$mapCode(handle: number, request: ICodeMapperRequestDto, token: CancellationToken): Promise<ICodeMapperResult | null | undefined>;
2366
>
}
2367
>
2368
>
export interface ExtHostCommandsShape {
2369
>
$executeContributedCommand(id: string, ...args: unknown[]): Promise<unknown>;
2370
>
$getContributedCommandMetadata(): Promise<{ [id: string]: string | ICommandMetadataDto }>;
2371
>
}
2372
>
2373
>
export interface ExtHostConfigurationShape {
2374
>
$initializeConfiguration(data: IConfigurationInitData): void;
2375
>
$acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
2376
>
}
2377
>
2378
>
export interface ExtHostDiagnosticsShape {
2379
>
$acceptMarkersChange(data: [UriComponents, IMarkerData[]][]): void;
2380
>
}
2381
>
2382
>
export interface ExtHostDocumentContentProvidersShape {
2383
>
$provideTextDocumentContent(handle: number, uri: UriComponents): Promise<string | null | undefined>;
2384
>
}
2385
>
2386
>
export interface IModelAddedData {
2387
>
uri: UriComponents;
2388
>
versionId: number;
2389
>
lines: string[];
2390
>
EOL: string;
2391
>
languageId: string;
2392
>
isDirty: boolean;
2393
>
encoding: string;
2394
>
}
2395
>
export interface ExtHostDocumentsShape {
2396
>
$acceptModelLanguageChanged(strURL: UriComponents, newLanguageId: string): void;
2397
>
$acceptModelSaved(strURL: UriComponents): void;
2398
>
$acceptDirtyStateChanged(strURL: UriComponents, isDirty: boolean): void;
2399
>
$acceptEncodingChanged(strURL: UriComponents, encoding: string): void;
2400
>
$acceptModelChanged(strURL: UriComponents, e: ISerializedModelContentChangedEvent, isDirty: boolean): void;
2401
>
}
2402
>
2403
>
export interface ExtHostDocumentSaveParticipantShape {
2404
>
$participateInSave(resource: UriComponents, reason: SaveReason): Promise<boolean[]>;
2405
>
}
2406
>
2407
>
export interface ITextEditorAddData {
2408
>
id: string;
2409
>
documentUri: UriComponents;
2410
>
options: IResolvedTextEditorConfiguration;
2411
>
selections: ISelection[];
2412
>
visibleRanges: IRange[];
2413
>
editorPosition: EditorGroupColumn | undefined;
2414
>
}
2415
>
export interface ITextEditorPositionData {
2416
>
[id: string]: EditorGroupColumn;
2417
>
}
2418
>
2419
>
export type ITextEditorChange = [
2420
>
originalStartLineNumber: number,
2421
>
originalEndLineNumberExclusive: number,
2422
>
modifiedStartLineNumber: number,
2423
>
modifiedEndLineNumberExclusive: number
2424
>
];
2425
>
2426
>
export interface ITextEditorDiffInformation {
2427
>
readonly documentVersion: number;
2428
>
readonly original: UriComponents | undefined;
2429
>
readonly modified: UriComponents;
2430
>
readonly changes: readonly ITextEditorChange[];
2431
>
}
2432
>
2433
>
export interface IEditorPropertiesChangeData {
2434
>
options: IResolvedTextEditorConfiguration | null;
2435
>
selections: ISelectionChangeEvent | null;
2436
>
visibleRanges: IRange[] | null;
2437
>
}
2438
>
export interface ISelectionChangeEvent {
2439
>
selections: Selection[];
2440
>
source?: string;
2441
>
}
2442
>
2443
>
export interface ExtHostEditorsShape {
2444
>
$acceptEditorPropertiesChanged(id: string, props: IEditorPropertiesChangeData): void;
2445
>
$acceptEditorPositionData(data: ITextEditorPositionData): void;
2446
>
$acceptEditorDiffInformation(id: string, diffInformation: ITextEditorDiffInformation[] | undefined): void;
2447
>
}
2448
>
2449
>
export interface IDocumentsAndEditorsDelta {
2450
>
removedDocuments?: UriComponents[];
2451
>
addedDocuments?: IModelAddedData[];
2452
>
removedEditors?: string[];
2453
>
addedEditors?: ITextEditorAddData[];
2454
>
newActiveEditor?: string | null;
2455
>
}
2456
>
2457
>
export interface ExtHostDocumentsAndEditorsShape {
2458
>
$acceptDocumentsAndEditorsDelta(delta: IDocumentsAndEditorsDelta): void;
2459
>
}
2460
>
2461
>
export interface IDataTransferFileDTO {
2462
>
readonly id: string;
2463
>
readonly name: string;
2464
>
readonly uri?: UriComponents;
2465
>
}
2466
>
2467
>
export interface DataTransferItemDTO {
2468
>
id: string;
2469
>
readonly asString: string;
2470
>
readonly fileData: IDataTransferFileDTO | undefined;
2471
>
readonly uriListData?: ReadonlyArray<string | UriComponents>;
2472
>
}
2473
>
2474
>
export interface DataTransferDTO {
2475
>
items: Array<readonly [/* type */string, DataTransferItemDTO]>;
2476
>
}
2477
>
2478
>
export interface CheckboxUpdate {
2479
>
treeItemHandle: string;
2480
>
newState: boolean;
2481
>
}
2482
>
2483
>
export interface ExtHostTreeViewsShape {
2484
>
/**
2485
>
* To reduce what is sent on the wire:
2486
>
* w
2487
>
* x
2488
>
* y
2489
>
* z
2490
>
*
2491
>
* for [x,y] returns
2492
>
* [[1,z]], where the inner array is [original index, ...children]
2493
>
*/
2494
>
$getChildren(treeViewId: string, treeItemHandles?: string[]): Promise<(readonly (number | ITreeItem)[])[] | undefined>;
2495
>
$handleDrop(destinationViewId: string, requestId: number, treeDataTransfer: DataTransferDTO, targetHandle: string | undefined, token: CancellationToken, operationUuid?: string, sourceViewId?: string, sourceTreeItemHandles?: string[]): Promise<void>;
2496
>
$handleDrag(sourceViewId: string, sourceTreeItemHandles: string[], operationUuid: string, token: CancellationToken): Promise<DataTransferDTO | undefined>;
2497
>
$setExpanded(treeViewId: string, treeItemHandle: string, expanded: boolean): void;
2498
>
$setSelectionAndFocus(treeViewId: string, selectionHandles: string[], focusHandle: string): void;
2499
>
$setVisible(treeViewId: string, visible: boolean): void;
2500
>
$changeCheckboxState(treeViewId: string, checkboxUpdates: CheckboxUpdate[]): void;
2501
>
$hasResolve(treeViewId: string): Promise<boolean>;
2502
>
$resolve(treeViewId: string, treeItemHandle: string, token: CancellationToken): Promise<ITreeItem | undefined>;
2503
>
}
2504
>
2505
>
export interface ExtHostWorkspaceShape {
2506
>
$initializeWorkspace(workspace: IWorkspaceData | null, trusted: boolean): void;
2507
>
$acceptWorkspaceData(workspace: IWorkspaceData | null): void;
2508
>
$handleTextSearchResult(result: search.IRawFileMatch2, requestId: number): void;
2509
>
$onDidGrantWorkspaceTrust(): void;
2510
>
$onDidChangeWorkspaceTrustedFolders(): void;
2511
>
$getEditSessionIdentifier(folder: UriComponents, token: CancellationToken): Promise<string | undefined>;
2512
>
$provideEditSessionIdentityMatch(folder: UriComponents, identity1: string, identity2: string, token: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
2513
>
$onWillCreateEditSessionIdentity(folder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
2514
>
$provideCanonicalUri(uri: UriComponents, targetScheme: string, token: CancellationToken): Promise<UriComponents | undefined>;
2515
>
}
2516
>
2517
>
export interface ExtHostFileSystemInfoShape {
2518
>
$acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
2519
>
}
2520
>
2521
>
export interface ExtHostFileSystemShape {
2522
>
$stat(handle: number, resource: UriComponents): Promise<files.IStat>;
2523
>
$readdir(handle: number, resource: UriComponents): Promise<[string, files.FileType][]>;
2524
>
$readFile(handle: number, resource: UriComponents): Promise<VSBuffer>;
2525
>
$writeFile(handle: number, resource: UriComponents, content: VSBuffer, opts: files.IFileWriteOptions): Promise<void>;
2526
>
$rename(handle: number, resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2527
>
$copy(handle: number, resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2528
>
$mkdir(handle: number, resource: UriComponents): Promise<void>;
2529
>
$delete(handle: number, resource: UriComponents, opts: files.IFileDeleteOptions): Promise<void>;
2530
>
$watch(handle: number, session: number, resource: UriComponents, opts: files.IWatchOptions): void;
2531
>
$unwatch(handle: number, session: number): void;
2532
>
$open(handle: number, resource: UriComponents, opts: files.IFileOpenOptions): Promise<number>;
2533
>
$close(handle: number, fd: number): Promise<void>;
2534
>
$read(handle: number, fd: number, pos: number, length: number): Promise<VSBuffer>;
2535
>
$write(handle: number, fd: number, pos: number, data: VSBuffer): Promise<number>;
2536
>
}
2537
>
2538
>
export interface ExtHostLabelServiceShape {
2539
>
$registerResourceLabelFormatter(formatter: ResourceLabelFormatter): IDisposable;
2540
>
}
2541
>
2542
>
export interface ExtHostAuthenticationShape {
2543
>
$getSessions(id: string, scopes: string[] | undefined, options: IAuthenticationGetSessionsOptions): Promise<ReadonlyArray<AuthenticationSession>>;
2544
>
$createSession(id: string, scopes: string[], options: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
2545
>
$getSessionsFromChallenges(id: string, constraint: IAuthenticationConstraint, options: IAuthenticationGetSessionsOptions): Promise<ReadonlyArray<AuthenticationSession>>;
2546
>
$createSessionFromChallenges(id: string, constraint: IAuthenticationConstraint, options: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
2547
>
$removeSession(id: string, sessionId: string): Promise<void>;
2548
>
$onDidChangeAuthenticationSessions(id: string, label: string, extensionIdFilter?: string[]): Promise<void>;
2549
>
$onDidUnregisterAuthenticationProvider(id: string): Promise<void>;
2550
>
$registerDynamicAuthProvider(authorizationServer: UriComponents, serverMetadata: IAuthorizationServerMetadata, resource?: IAuthorizationProtectedResourceMetadata, clientId?: string, clientSecret?: string, initialTokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<string>;
2551
>
$registerXaaAuthProvider(issuer: UriComponents, serverMetadata: IAuthorizationServerMetadata, clientId?: string, clientSecret?: string, initialTokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<string>;
2552
>
$onDidChangeDynamicAuthProviderTokens(authProviderId: string, clientId: string, tokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<void>;
2553
>
}
2554
>
2555
>
export interface ExtHostAiRelatedInformationShape {
2556
>
$provideAiRelatedInformation(handle: number, query: string, token: CancellationToken): Promise<RelatedInformationResult[]>;
2557
>
}
2558
>
2559
>
export interface MainThreadAiRelatedInformationShape {
2560
>
$getAiRelatedInformation(query: string, types: RelatedInformationType[]): Promise<RelatedInformationResult[]>;
2561
>
$registerAiRelatedInformationProvider(handle: number, type: RelatedInformationType): void;
2562
>
$unregisterAiRelatedInformationProvider(handle: number): void;
2563
>
}
2564
>
2565
>
export interface ExtHostAiSettingsSearchShape {
2566
>
$startSearch(handle: number, query: string, option: AiSettingsSearchProviderOptions, token: CancellationToken): Promise<void>;
2567
>
}
2568
>
2569
>
export interface MainThreadAiSettingsSearchShape {
2570
>
$registerAiSettingsSearchProvider(handle: number): void;
2571
>
$unregisterAiSettingsSearchProvider(handle: number): void;
2572
>
$handleSearchResult(handle: number, result: AiSettingsSearchResult): void;
2573
>
}
2574
>
2575
>
export interface ExtHostAiEmbeddingVectorShape {
2576
>
$provideAiEmbeddingVector(handle: number, strings: string[], token: CancellationToken): Promise<number[][]>;
2577
>
}
2578
>
2579
>
export interface MainThreadAiEmbeddingVectorShape {
2580
>
$registerAiEmbeddingVectorProvider(model: string, handle: number): void;
2581
>
$unregisterAiEmbeddingVectorProvider(handle: number): void;
2582
>
}
2583
>
2584
>
export interface ExtHostSecretStateShape {
2585
>
$onDidChangePassword(e: { extensionId: string; key: string }): Promise<void>;
2586
>
}
2587
>
2588
>
export interface ExtHostSearchShape {
2589
>
$enableExtensionHostSearch(): void;
2590
>
$getAIName(handle: number): Promise<string | undefined>;
2591
>
$provideFileSearchResults(handle: number, session: number, query: search.IRawQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2592
>
$provideAITextSearchResults(handle: number, session: number, query: search.IRawAITextQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2593
>
$provideTextSearchResults(handle: number, session: number, query: search.IRawTextQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2594
>
$clearCache(cacheKey: string): Promise<void>;
2595
>
}
2596
>
2597
>
export interface ExtHostExtensionServiceShape {
2598
>
$resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
2599
>
/**
2600
>
* Returns `null` if no resolver for `remoteAuthority` is found.
2601
>
*/
2602
>
$getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
2603
>
$startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
2604
>
$extensionTestsExecute(): Promise<number>;
2605
>
$activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
2606
>
$activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
2607
>
$setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void>;
2608
>
$updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
2609
>
2610
>
$deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
2611
>
2612
>
$test_latency(n: number): Promise<number>;
2613
>
$test_up(b: VSBuffer): Promise<number>;
2614
>
$test_down(size: number): Promise<VSBuffer>;
2615
>
}
2616
>
2617
>
export interface FileSystemEvents {
2618
>
session?: number;
2619
>
created: UriComponents[];
2620
>
changed: UriComponents[];
2621
>
deleted: UriComponents[];
2622
>
}
2623
>
2624
>
export interface SourceTargetPair {
2625
>
source?: UriComponents;
2626
>
target: UriComponents;
2627
>
}
2628
>
2629
>
export interface IWillRunFileOperationParticipation {
2630
>
edit: IWorkspaceEditDto;
2631
>
extensionNames: string[];
2632
>
}
2633
>
2634
>
export interface ExtHostFileSystemEventServiceShape {
2635
>
$onFileEvent(events: FileSystemEvents): void;
2636
>
$onWillRunFileOperation(operation: files.FileOperation, files: readonly SourceTargetPair[], timeout: number, token: CancellationToken): Promise<IWillRunFileOperationParticipation | undefined>;
2637
>
$onDidRunFileOperation(operation: files.FileOperation, files: readonly SourceTargetPair[]): void;
2638
>
}
2639
>
2640
>
export interface ExtHostLanguagesShape {
2641
>
$acceptLanguageIds(ids: string[]): void;
2642
>
$acceptSyntaxHighlightingThemeChanged(): void;
2643
>
}
2644
>
2645
>
export interface ExtHostHeapServiceShape {
2646
>
$onGarbageCollection(ids: number[]): void;
2647
>
}
2648
>
export interface IRawColorInfo {
2649
>
color: [number, number, number, number];
2650
>
range: IRange;
2651
>
}
2652
>
2653
>
export class IdObject {
2654
>
_id?: number;
2655
>
private static _n = 0;
2656
>
static mixin<T extends object>(object: T): T & IdObject {
2657
// eslint-disable-next-line local/code-no-any-casts
2658
(<any>object)._id = IdObject._n++;