@mcp-b/extension-tools 0.2.2 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/index.d.ts +2434 -2310
  2. package/dist/index.d.ts.map +1 -0
  3. package/dist/index.js +24 -6
  4. package/dist/index.js.map +1 -1
  5. package/package.json +7 -6
package/dist/index.d.ts CHANGED
@@ -1,1624 +1,1697 @@
1
- import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
2
- import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
3
- import { z } from 'zod';
1
+ import { z } from "zod";
2
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
3
+ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
4
4
 
5
+ //#region src/BaseApiTools.d.ts
5
6
  interface ApiAvailability {
6
- available: boolean;
7
- message: string;
8
- details?: string;
9
- }
10
- declare abstract class BaseApiTools {
11
- protected server: McpServer;
12
- protected options: any;
13
- protected abstract apiName: string;
14
- constructor(server: McpServer, options?: any);
15
- abstract checkAvailability(): ApiAvailability;
16
- abstract registerTools(): void;
17
- protected shouldRegisterTool(toolName: string): boolean;
18
- protected formatError(error: unknown): CallToolResult;
19
- protected formatSuccess(message: string, data?: any): CallToolResult;
20
- protected formatJson(data: any): CallToolResult;
21
- register(): void;
22
- }
23
-
7
+ available: boolean;
8
+ message: string;
9
+ details?: string;
10
+ }
11
+ declare abstract class BaseApiTools<TOptions = Record<string, unknown>> {
12
+ protected server: McpServer;
13
+ protected options: TOptions;
14
+ protected abstract apiName: string;
15
+ constructor(server: McpServer, options?: TOptions);
16
+ abstract checkAvailability(): ApiAvailability;
17
+ abstract registerTools(): void;
18
+ protected shouldRegisterTool(toolName: string): boolean;
19
+ protected formatError(error: unknown): CallToolResult;
20
+ protected formatSuccess(message: string, data?: unknown): CallToolResult;
21
+ protected formatJson(data: unknown): CallToolResult;
22
+ register(): void;
23
+ }
24
+ //#endregion
25
+ //#region src/chrome-apis/AlarmsApiTools.d.ts
24
26
  interface AlarmsApiToolsOptions {
25
- createAlarm?: boolean;
26
- getAlarm?: boolean;
27
- getAllAlarms?: boolean;
28
- clearAlarm?: boolean;
29
- clearAllAlarms?: boolean;
30
- }
31
- declare class AlarmsApiTools extends BaseApiTools {
32
- protected apiName: string;
33
- constructor(server: McpServer, options?: AlarmsApiToolsOptions);
34
- checkAvailability(): ApiAvailability;
35
- registerTools(): void;
36
- private registerCreateAlarm;
37
- private registerGetAlarm;
38
- private registerGetAllAlarms;
39
- private registerClearAlarm;
40
- private registerClearAllAlarms;
41
- }
42
-
27
+ createAlarm?: boolean;
28
+ getAlarm?: boolean;
29
+ getAllAlarms?: boolean;
30
+ clearAlarm?: boolean;
31
+ clearAllAlarms?: boolean;
32
+ }
33
+ declare class AlarmsApiTools extends BaseApiTools<AlarmsApiToolsOptions> {
34
+ protected apiName: string;
35
+ constructor(server: McpServer, options?: AlarmsApiToolsOptions);
36
+ checkAvailability(): ApiAvailability;
37
+ registerTools(): void;
38
+ private registerCreateAlarm;
39
+ private registerGetAlarm;
40
+ private registerGetAllAlarms;
41
+ private registerClearAlarm;
42
+ private registerClearAllAlarms;
43
+ }
44
+ //#endregion
45
+ //#region src/chrome-apis/AudioApiTools.d.ts
43
46
  interface AudioApiToolsOptions {
44
- getDevices?: boolean;
45
- getMute?: boolean;
46
- setActiveDevices?: boolean;
47
- setMute?: boolean;
48
- setProperties?: boolean;
49
- }
50
- declare class AudioApiTools extends BaseApiTools {
51
- protected apiName: string;
52
- constructor(server: McpServer, options?: AudioApiToolsOptions);
53
- checkAvailability(): ApiAvailability;
54
- registerTools(): void;
55
- private registerGetDevices;
56
- private registerGetMute;
57
- private registerSetActiveDevices;
58
- private registerSetMute;
59
- private registerSetProperties;
60
- }
61
-
47
+ getDevices?: boolean;
48
+ getMute?: boolean;
49
+ setActiveDevices?: boolean;
50
+ setMute?: boolean;
51
+ setProperties?: boolean;
52
+ }
53
+ declare class AudioApiTools extends BaseApiTools<AudioApiToolsOptions> {
54
+ protected apiName: string;
55
+ constructor(server: McpServer, options?: AudioApiToolsOptions);
56
+ checkAvailability(): ApiAvailability;
57
+ registerTools(): void;
58
+ private registerGetDevices;
59
+ private registerGetMute;
60
+ private registerSetActiveDevices;
61
+ private registerSetMute;
62
+ private registerSetProperties;
63
+ }
64
+ //#endregion
65
+ //#region src/chrome-apis/BookmarksApiTools.d.ts
62
66
  interface BookmarksApiToolsOptions {
63
- create?: boolean;
64
- get?: boolean;
65
- getChildren?: boolean;
66
- getRecent?: boolean;
67
- getSubTree?: boolean;
68
- getTree?: boolean;
69
- move?: boolean;
70
- remove?: boolean;
71
- removeTree?: boolean;
72
- search?: boolean;
73
- update?: boolean;
67
+ create?: boolean;
68
+ get?: boolean;
69
+ getChildren?: boolean;
70
+ getRecent?: boolean;
71
+ getSubTree?: boolean;
72
+ getTree?: boolean;
73
+ move?: boolean;
74
+ remove?: boolean;
75
+ removeTree?: boolean;
76
+ search?: boolean;
77
+ update?: boolean;
74
78
  }
75
79
  declare const BOOKMARK_ACTIONS: readonly ["create", "get", "getChildren", "getRecent", "getSubTree", "getTree", "move", "remove", "removeTree", "search", "update"];
76
- declare class BookmarksApiTools extends BaseApiTools {
77
- protected apiName: string;
78
- constructor(server: McpServer, options?: BookmarksApiToolsOptions);
79
- checkAvailability(): ApiAvailability;
80
- registerTools(): void;
81
- private createSchema;
82
- private getSchema;
83
- private getChildrenSchema;
84
- private getRecentSchema;
85
- private getSubTreeSchema;
86
- private moveSchema;
87
- private removeSchema;
88
- private removeTreeSchema;
89
- private searchSchema;
90
- private updateSchema;
91
- private handleCreate;
92
- private handleGet;
93
- private handleGetChildren;
94
- private handleGetRecent;
95
- private handleGetSubTree;
96
- private handleGetTree;
97
- private handleMove;
98
- private handleRemove;
99
- private handleRemoveTree;
100
- private handleSearch;
101
- private handleUpdate;
102
- private isActionEnabled;
103
- }
104
-
80
+ declare class BookmarksApiTools extends BaseApiTools<BookmarksApiToolsOptions> {
81
+ protected apiName: string;
82
+ constructor(server: McpServer, options?: BookmarksApiToolsOptions);
83
+ checkAvailability(): ApiAvailability;
84
+ registerTools(): void;
85
+ private createSchema;
86
+ private getSchema;
87
+ private getChildrenSchema;
88
+ private getRecentSchema;
89
+ private getSubTreeSchema;
90
+ private moveSchema;
91
+ private removeSchema;
92
+ private removeTreeSchema;
93
+ private searchSchema;
94
+ private updateSchema;
95
+ private handleCreate;
96
+ private handleGet;
97
+ private handleGetChildren;
98
+ private handleGetRecent;
99
+ private handleGetSubTree;
100
+ private handleGetTree;
101
+ private handleMove;
102
+ private handleRemove;
103
+ private handleRemoveTree;
104
+ private handleSearch;
105
+ private handleUpdate;
106
+ private isActionEnabled;
107
+ }
108
+ //#endregion
109
+ //#region src/chrome-apis/BrowsingDataApiTools.d.ts
105
110
  interface BrowsingDataApiToolsOptions {
106
- remove?: boolean;
107
- removeAppcache?: boolean;
108
- removeCache?: boolean;
109
- removeCacheStorage?: boolean;
110
- removeCookies?: boolean;
111
- removeDownloads?: boolean;
112
- removeFileSystems?: boolean;
113
- removeFormData?: boolean;
114
- removeHistory?: boolean;
115
- removeIndexedDB?: boolean;
116
- removeLocalStorage?: boolean;
117
- removePasswords?: boolean;
118
- removeServiceWorkers?: boolean;
119
- removeWebSQL?: boolean;
120
- settings?: boolean;
121
- }
122
- declare class BrowsingDataApiTools extends BaseApiTools {
123
- protected apiName: string;
124
- constructor(server: McpServer, options?: BrowsingDataApiToolsOptions);
125
- checkAvailability(): ApiAvailability;
126
- registerTools(): void;
127
- private registerRemove;
128
- private registerRemoveAppcache;
129
- private registerRemoveCache;
130
- private registerRemoveCacheStorage;
131
- private registerRemoveCookies;
132
- private registerRemoveDownloads;
133
- private registerRemoveFileSystems;
134
- private registerRemoveFormData;
135
- private registerRemoveHistory;
136
- private registerRemoveIndexedDB;
137
- private registerRemoveLocalStorage;
138
- private registerRemovePasswords;
139
- private registerRemoveServiceWorkers;
140
- private registerRemoveWebSQL;
141
- private registerSettings;
142
- }
143
-
111
+ remove?: boolean;
112
+ removeAppcache?: boolean;
113
+ removeCache?: boolean;
114
+ removeCacheStorage?: boolean;
115
+ removeCookies?: boolean;
116
+ removeDownloads?: boolean;
117
+ removeFileSystems?: boolean;
118
+ removeFormData?: boolean;
119
+ removeHistory?: boolean;
120
+ removeIndexedDB?: boolean;
121
+ removeLocalStorage?: boolean;
122
+ removePasswords?: boolean;
123
+ removeServiceWorkers?: boolean;
124
+ removeWebSQL?: boolean;
125
+ settings?: boolean;
126
+ }
127
+ declare class BrowsingDataApiTools extends BaseApiTools<BrowsingDataApiToolsOptions> {
128
+ protected apiName: string;
129
+ constructor(server: McpServer, options?: BrowsingDataApiToolsOptions);
130
+ checkAvailability(): ApiAvailability;
131
+ registerTools(): void;
132
+ private registerRemove;
133
+ private registerRemoveAppcache;
134
+ private registerRemoveCache;
135
+ private registerRemoveCacheStorage;
136
+ private registerRemoveCookies;
137
+ private registerRemoveDownloads;
138
+ private registerRemoveFileSystems;
139
+ private registerRemoveFormData;
140
+ private registerRemoveHistory;
141
+ private registerRemoveIndexedDB;
142
+ private registerRemoveLocalStorage;
143
+ private registerRemovePasswords;
144
+ private registerRemoveServiceWorkers;
145
+ private registerRemoveWebSQL;
146
+ private registerSettings;
147
+ }
148
+ //#endregion
149
+ //#region src/chrome-apis/CertificateProviderApiTools.d.ts
144
150
  interface CertificateProviderApiToolsOptions {
145
- setCertificates?: boolean;
146
- reportSignature?: boolean;
147
- requestPin?: boolean;
148
- stopPinRequest?: boolean;
149
- onCertificatesUpdateRequested?: boolean;
150
- onSignatureRequested?: boolean;
151
- }
152
- declare class CertificateProviderApiTools extends BaseApiTools {
153
- protected apiName: string;
154
- constructor(server: McpServer, options?: CertificateProviderApiToolsOptions);
155
- checkAvailability(): ApiAvailability;
156
- registerTools(): void;
157
- private registerSetCertificates;
158
- private registerReportSignature;
159
- private registerRequestPin;
160
- private registerStopPinRequest;
161
- private registerOnCertificatesUpdateRequested;
162
- private registerOnSignatureRequested;
163
- private handleCertificatesUpdateRequested;
164
- private handleSignatureRequested;
165
- }
166
-
151
+ setCertificates?: boolean;
152
+ reportSignature?: boolean;
153
+ requestPin?: boolean;
154
+ stopPinRequest?: boolean;
155
+ onCertificatesUpdateRequested?: boolean;
156
+ onSignatureRequested?: boolean;
157
+ }
158
+ declare class CertificateProviderApiTools extends BaseApiTools<CertificateProviderApiToolsOptions> {
159
+ protected apiName: string;
160
+ constructor(server: McpServer, options?: CertificateProviderApiToolsOptions);
161
+ checkAvailability(): ApiAvailability;
162
+ registerTools(): void;
163
+ private registerSetCertificates;
164
+ private registerReportSignature;
165
+ private registerRequestPin;
166
+ private registerStopPinRequest;
167
+ private registerOnCertificatesUpdateRequested;
168
+ private registerOnSignatureRequested;
169
+ private handleCertificatesUpdateRequested;
170
+ private handleSignatureRequested;
171
+ }
172
+ //#endregion
173
+ //#region src/chrome-apis/CommandsApiTools.d.ts
167
174
  interface CommandsApiToolsOptions {
168
- getAll?: boolean;
175
+ getAll?: boolean;
169
176
  }
170
- declare class CommandsApiTools extends BaseApiTools {
171
- protected apiName: string;
172
- constructor(server: McpServer, options?: CommandsApiToolsOptions);
173
- checkAvailability(): ApiAvailability;
174
- registerTools(): void;
175
- private registerGetAll;
177
+ declare class CommandsApiTools extends BaseApiTools<CommandsApiToolsOptions> {
178
+ protected apiName: string;
179
+ constructor(server: McpServer, options?: CommandsApiToolsOptions);
180
+ checkAvailability(): ApiAvailability;
181
+ registerTools(): void;
182
+ private registerGetAll;
176
183
  }
177
-
184
+ //#endregion
185
+ //#region src/chrome-apis/ContentSettingsApiTools.d.ts
178
186
  interface ContentSettingsApiToolsOptions {
179
- getCookiesSetting?: boolean;
180
- setCookiesSetting?: boolean;
181
- clearCookiesSetting?: boolean;
182
- getJavascriptSetting?: boolean;
183
- setJavascriptSetting?: boolean;
184
- clearJavascriptSetting?: boolean;
185
- getImagesSetting?: boolean;
186
- setImagesSetting?: boolean;
187
- clearImagesSetting?: boolean;
188
- getLocationSetting?: boolean;
189
- setLocationSetting?: boolean;
190
- clearLocationSetting?: boolean;
191
- getNotificationsSetting?: boolean;
192
- setNotificationsSetting?: boolean;
193
- clearNotificationsSetting?: boolean;
194
- getPopupsSetting?: boolean;
195
- setPopupsSetting?: boolean;
196
- clearPopupsSetting?: boolean;
197
- getCameraSetting?: boolean;
198
- setCameraSetting?: boolean;
199
- clearCameraSetting?: boolean;
200
- getMicrophoneSetting?: boolean;
201
- setMicrophoneSetting?: boolean;
202
- clearMicrophoneSetting?: boolean;
203
- getAutomaticDownloadsSetting?: boolean;
204
- setAutomaticDownloadsSetting?: boolean;
205
- clearAutomaticDownloadsSetting?: boolean;
206
- getClipboardSetting?: boolean;
207
- setClipboardSetting?: boolean;
208
- clearClipboardSetting?: boolean;
209
- getAutoVerifySetting?: boolean;
210
- setAutoVerifySetting?: boolean;
211
- clearAutoVerifySetting?: boolean;
212
- getPluginsResourceIdentifiers?: boolean;
213
- }
214
- declare class ContentSettingsApiTools extends BaseApiTools {
215
- protected apiName: string;
216
- constructor(server: McpServer, options?: ContentSettingsApiToolsOptions);
217
- checkAvailability(): ApiAvailability;
218
- registerTools(): void;
219
- private registerGetCookiesSetting;
220
- private registerSetCookiesSetting;
221
- private registerClearCookiesSetting;
222
- private registerGetJavascriptSetting;
223
- private registerSetJavascriptSetting;
224
- private registerClearJavascriptSetting;
225
- private registerGetImagesSetting;
226
- private registerSetImagesSetting;
227
- private registerClearImagesSetting;
228
- private registerGetLocationSetting;
229
- private registerSetLocationSetting;
230
- private registerClearLocationSetting;
231
- private registerGetNotificationsSetting;
232
- private registerSetNotificationsSetting;
233
- private registerClearNotificationsSetting;
234
- private registerGetPopupsSetting;
235
- private registerSetPopupsSetting;
236
- private registerClearPopupsSetting;
237
- private registerGetCameraSetting;
238
- private registerSetCameraSetting;
239
- private registerClearCameraSetting;
240
- private registerGetMicrophoneSetting;
241
- private registerSetMicrophoneSetting;
242
- private registerClearMicrophoneSetting;
243
- private registerGetAutomaticDownloadsSetting;
244
- private registerSetAutomaticDownloadsSetting;
245
- private registerClearAutomaticDownloadsSetting;
246
- private registerGetClipboardSetting;
247
- private registerSetClipboardSetting;
248
- private registerClearClipboardSetting;
249
- private registerGetAutoVerifySetting;
250
- private registerSetAutoVerifySetting;
251
- private registerClearAutoVerifySetting;
252
- private registerGetPluginsResourceIdentifiers;
253
- }
254
-
187
+ getCookiesSetting?: boolean;
188
+ setCookiesSetting?: boolean;
189
+ clearCookiesSetting?: boolean;
190
+ getJavascriptSetting?: boolean;
191
+ setJavascriptSetting?: boolean;
192
+ clearJavascriptSetting?: boolean;
193
+ getImagesSetting?: boolean;
194
+ setImagesSetting?: boolean;
195
+ clearImagesSetting?: boolean;
196
+ getLocationSetting?: boolean;
197
+ setLocationSetting?: boolean;
198
+ clearLocationSetting?: boolean;
199
+ getNotificationsSetting?: boolean;
200
+ setNotificationsSetting?: boolean;
201
+ clearNotificationsSetting?: boolean;
202
+ getPopupsSetting?: boolean;
203
+ setPopupsSetting?: boolean;
204
+ clearPopupsSetting?: boolean;
205
+ getCameraSetting?: boolean;
206
+ setCameraSetting?: boolean;
207
+ clearCameraSetting?: boolean;
208
+ getMicrophoneSetting?: boolean;
209
+ setMicrophoneSetting?: boolean;
210
+ clearMicrophoneSetting?: boolean;
211
+ getAutomaticDownloadsSetting?: boolean;
212
+ setAutomaticDownloadsSetting?: boolean;
213
+ clearAutomaticDownloadsSetting?: boolean;
214
+ getClipboardSetting?: boolean;
215
+ setClipboardSetting?: boolean;
216
+ clearClipboardSetting?: boolean;
217
+ getAutoVerifySetting?: boolean;
218
+ setAutoVerifySetting?: boolean;
219
+ clearAutoVerifySetting?: boolean;
220
+ getPluginsResourceIdentifiers?: boolean;
221
+ }
222
+ declare class ContentSettingsApiTools extends BaseApiTools<ContentSettingsApiToolsOptions> {
223
+ protected apiName: string;
224
+ constructor(server: McpServer, options?: ContentSettingsApiToolsOptions);
225
+ checkAvailability(): ApiAvailability;
226
+ registerTools(): void;
227
+ private registerGetCookiesSetting;
228
+ private registerSetCookiesSetting;
229
+ private registerClearCookiesSetting;
230
+ private registerGetJavascriptSetting;
231
+ private registerSetJavascriptSetting;
232
+ private registerClearJavascriptSetting;
233
+ private registerGetImagesSetting;
234
+ private registerSetImagesSetting;
235
+ private registerClearImagesSetting;
236
+ private registerGetLocationSetting;
237
+ private registerSetLocationSetting;
238
+ private registerClearLocationSetting;
239
+ private registerGetNotificationsSetting;
240
+ private registerSetNotificationsSetting;
241
+ private registerClearNotificationsSetting;
242
+ private registerGetPopupsSetting;
243
+ private registerSetPopupsSetting;
244
+ private registerClearPopupsSetting;
245
+ private registerGetCameraSetting;
246
+ private registerSetCameraSetting;
247
+ private registerClearCameraSetting;
248
+ private registerGetMicrophoneSetting;
249
+ private registerSetMicrophoneSetting;
250
+ private registerClearMicrophoneSetting;
251
+ private registerGetAutomaticDownloadsSetting;
252
+ private registerSetAutomaticDownloadsSetting;
253
+ private registerClearAutomaticDownloadsSetting;
254
+ private registerGetClipboardSetting;
255
+ private registerSetClipboardSetting;
256
+ private registerClearClipboardSetting;
257
+ private registerGetAutoVerifySetting;
258
+ private registerSetAutoVerifySetting;
259
+ private registerClearAutoVerifySetting;
260
+ private registerGetPluginsResourceIdentifiers;
261
+ }
262
+ //#endregion
263
+ //#region src/chrome-apis/ContextMenusApiTools.d.ts
255
264
  interface ContextMenusApiToolsOptions {
256
- createContextMenu?: boolean;
257
- updateContextMenu?: boolean;
258
- removeContextMenu?: boolean;
259
- removeAllContextMenus?: boolean;
260
- }
261
- declare class ContextMenusApiTools extends BaseApiTools {
262
- protected apiName: string;
263
- constructor(server: McpServer, options?: ContextMenusApiToolsOptions);
264
- checkAvailability(): ApiAvailability;
265
- registerTools(): void;
266
- private registerCreateContextMenu;
267
- private registerUpdateContextMenu;
268
- private registerRemoveContextMenu;
269
- private registerRemoveAllContextMenus;
270
- }
271
-
265
+ createContextMenu?: boolean;
266
+ updateContextMenu?: boolean;
267
+ removeContextMenu?: boolean;
268
+ removeAllContextMenus?: boolean;
269
+ }
270
+ declare class ContextMenusApiTools extends BaseApiTools<ContextMenusApiToolsOptions> {
271
+ protected apiName: string;
272
+ constructor(server: McpServer, options?: ContextMenusApiToolsOptions);
273
+ checkAvailability(): ApiAvailability;
274
+ registerTools(): void;
275
+ private registerCreateContextMenu;
276
+ private registerUpdateContextMenu;
277
+ private registerRemoveContextMenu;
278
+ private registerRemoveAllContextMenus;
279
+ }
280
+ //#endregion
281
+ //#region src/chrome-apis/CookiesApiTools.d.ts
272
282
  interface CookiesApiToolsOptions {
273
- getCookie?: boolean;
274
- getAllCookies?: boolean;
275
- getAllCookieStores?: boolean;
276
- getPartitionKey?: boolean;
277
- setCookie?: boolean;
278
- removeCookie?: boolean;
279
- }
280
- declare class CookiesApiTools extends BaseApiTools {
281
- protected apiName: string;
282
- constructor(server: McpServer, options?: CookiesApiToolsOptions);
283
- checkAvailability(): ApiAvailability;
284
- registerTools(): void;
285
- private registerGetCookie;
286
- private registerGetAllCookies;
287
- private registerGetAllCookieStores;
288
- private registerGetPartitionKey;
289
- private registerSetCookie;
290
- private registerRemoveCookie;
291
- }
292
-
283
+ getCookie?: boolean;
284
+ getAllCookies?: boolean;
285
+ getAllCookieStores?: boolean;
286
+ getPartitionKey?: boolean;
287
+ setCookie?: boolean;
288
+ removeCookie?: boolean;
289
+ }
290
+ declare class CookiesApiTools extends BaseApiTools<CookiesApiToolsOptions> {
291
+ protected apiName: string;
292
+ constructor(server: McpServer, options?: CookiesApiToolsOptions);
293
+ checkAvailability(): ApiAvailability;
294
+ registerTools(): void;
295
+ private registerGetCookie;
296
+ private registerGetAllCookies;
297
+ private registerGetAllCookieStores;
298
+ private registerGetPartitionKey;
299
+ private registerSetCookie;
300
+ private registerRemoveCookie;
301
+ }
302
+ //#endregion
303
+ //#region src/chrome-apis/DebuggerApiTools.d.ts
293
304
  interface DebuggerApiToolsOptions {
294
- attach?: boolean;
295
- detach?: boolean;
296
- sendCommand?: boolean;
297
- getTargets?: boolean;
298
- }
299
- declare class DebuggerApiTools extends BaseApiTools {
300
- protected apiName: string;
301
- constructor(server: McpServer, options?: DebuggerApiToolsOptions);
302
- checkAvailability(): ApiAvailability;
303
- registerTools(): void;
304
- private registerAttach;
305
- private registerDetach;
306
- private registerSendCommand;
307
- private registerGetTargets;
308
- }
309
-
305
+ attach?: boolean;
306
+ detach?: boolean;
307
+ sendCommand?: boolean;
308
+ getTargets?: boolean;
309
+ }
310
+ declare class DebuggerApiTools extends BaseApiTools<DebuggerApiToolsOptions> {
311
+ protected apiName: string;
312
+ constructor(server: McpServer, options?: DebuggerApiToolsOptions);
313
+ checkAvailability(): ApiAvailability;
314
+ registerTools(): void;
315
+ private registerAttach;
316
+ private registerDetach;
317
+ private registerSendCommand;
318
+ private registerGetTargets;
319
+ }
320
+ //#endregion
321
+ //#region src/chrome-apis/DeclarativeContentApiTools.d.ts
310
322
  interface DeclarativeContentApiToolsOptions {
311
- addRules?: boolean;
312
- removeRules?: boolean;
313
- getRules?: boolean;
314
- }
315
- declare class DeclarativeContentApiTools extends BaseApiTools {
316
- protected apiName: string;
317
- constructor(server: McpServer, options?: DeclarativeContentApiToolsOptions);
318
- checkAvailability(): ApiAvailability;
319
- registerTools(): void;
320
- private registerAddRules;
321
- private registerRemoveRules;
322
- private registerGetRules;
323
- }
324
-
323
+ addRules?: boolean;
324
+ removeRules?: boolean;
325
+ getRules?: boolean;
326
+ }
327
+ declare class DeclarativeContentApiTools extends BaseApiTools<DeclarativeContentApiToolsOptions> {
328
+ protected apiName: string;
329
+ constructor(server: McpServer, options?: DeclarativeContentApiToolsOptions);
330
+ checkAvailability(): ApiAvailability;
331
+ registerTools(): void;
332
+ private registerAddRules;
333
+ private registerRemoveRules;
334
+ private registerGetRules;
335
+ }
336
+ //#endregion
337
+ //#region src/chrome-apis/DeclarativeNetRequestApiTools.d.ts
325
338
  interface DeclarativeNetRequestApiToolsOptions {
326
- getDynamicRules?: boolean;
327
- updateDynamicRules?: boolean;
328
- getSessionRules?: boolean;
329
- updateSessionRules?: boolean;
330
- getEnabledRulesets?: boolean;
331
- updateEnabledRulesets?: boolean;
332
- updateStaticRules?: boolean;
333
- getAvailableStaticRuleCount?: boolean;
334
- getMatchedRules?: boolean;
335
- isRegexSupported?: boolean;
336
- testMatchOutcome?: boolean;
337
- setExtensionActionOptions?: boolean;
338
- }
339
- declare class DeclarativeNetRequestApiTools extends BaseApiTools {
340
- protected apiName: string;
341
- constructor(server: McpServer, options?: DeclarativeNetRequestApiToolsOptions);
342
- checkAvailability(): ApiAvailability;
343
- registerTools(): void;
344
- private registerGetDynamicRules;
345
- private registerUpdateDynamicRules;
346
- private registerGetSessionRules;
347
- private registerUpdateSessionRules;
348
- private registerGetEnabledRulesets;
349
- private registerUpdateEnabledRulesets;
350
- private registerUpdateStaticRules;
351
- private registerGetAvailableStaticRuleCount;
352
- private registerGetMatchedRules;
353
- private registerIsRegexSupported;
354
- private registerTestMatchOutcome;
355
- private registerSetExtensionActionOptions;
356
- }
357
-
339
+ getDynamicRules?: boolean;
340
+ updateDynamicRules?: boolean;
341
+ getSessionRules?: boolean;
342
+ updateSessionRules?: boolean;
343
+ getEnabledRulesets?: boolean;
344
+ updateEnabledRulesets?: boolean;
345
+ updateStaticRules?: boolean;
346
+ getAvailableStaticRuleCount?: boolean;
347
+ getMatchedRules?: boolean;
348
+ isRegexSupported?: boolean;
349
+ testMatchOutcome?: boolean;
350
+ setExtensionActionOptions?: boolean;
351
+ }
352
+ declare class DeclarativeNetRequestApiTools extends BaseApiTools<DeclarativeNetRequestApiToolsOptions> {
353
+ protected apiName: string;
354
+ constructor(server: McpServer, options?: DeclarativeNetRequestApiToolsOptions);
355
+ checkAvailability(): ApiAvailability;
356
+ registerTools(): void;
357
+ private registerGetDynamicRules;
358
+ private registerUpdateDynamicRules;
359
+ private registerGetSessionRules;
360
+ private registerUpdateSessionRules;
361
+ private registerGetEnabledRulesets;
362
+ private registerUpdateEnabledRulesets;
363
+ private registerUpdateStaticRules;
364
+ private registerGetAvailableStaticRuleCount;
365
+ private registerGetMatchedRules;
366
+ private registerIsRegexSupported;
367
+ private registerTestMatchOutcome;
368
+ private registerSetExtensionActionOptions;
369
+ }
370
+ //#endregion
371
+ //#region src/chrome-apis/DesktopCaptureApiTools.d.ts
358
372
  interface DesktopCaptureApiToolsOptions {
359
- chooseDesktopMedia?: boolean;
360
- cancelChooseDesktopMedia?: boolean;
361
- }
362
- declare class DesktopCaptureApiTools extends BaseApiTools {
363
- protected apiName: string;
364
- constructor(server: McpServer, options?: DesktopCaptureApiToolsOptions);
365
- checkAvailability(): ApiAvailability;
366
- registerTools(): void;
367
- private registerChooseDesktopMedia;
368
- private registerCancelChooseDesktopMedia;
369
- }
370
-
373
+ chooseDesktopMedia?: boolean;
374
+ cancelChooseDesktopMedia?: boolean;
375
+ }
376
+ declare class DesktopCaptureApiTools extends BaseApiTools<DesktopCaptureApiToolsOptions> {
377
+ protected apiName: string;
378
+ constructor(server: McpServer, options?: DesktopCaptureApiToolsOptions);
379
+ checkAvailability(): ApiAvailability;
380
+ registerTools(): void;
381
+ private registerChooseDesktopMedia;
382
+ private registerCancelChooseDesktopMedia;
383
+ }
384
+ //#endregion
385
+ //#region src/chrome-apis/DevtoolsInspectedWindowApiTools.d.ts
371
386
  interface DevtoolsInspectedWindowApiToolsOptions {
372
- eval?: boolean;
373
- reload?: boolean;
374
- getResources?: boolean;
375
- }
376
- declare class DevtoolsInspectedWindowApiTools extends BaseApiTools {
377
- protected apiName: string;
378
- constructor(server: McpServer, options?: DevtoolsInspectedWindowApiToolsOptions);
379
- checkAvailability(): ApiAvailability;
380
- registerTools(): void;
381
- private registerEval;
382
- private registerReload;
383
- private registerGetResources;
384
- }
385
-
387
+ eval?: boolean;
388
+ reload?: boolean;
389
+ getResources?: boolean;
390
+ }
391
+ declare class DevtoolsInspectedWindowApiTools extends BaseApiTools<DevtoolsInspectedWindowApiToolsOptions> {
392
+ protected apiName: string;
393
+ constructor(server: McpServer, options?: DevtoolsInspectedWindowApiToolsOptions);
394
+ checkAvailability(): ApiAvailability;
395
+ registerTools(): void;
396
+ private registerEval;
397
+ private registerReload;
398
+ private registerGetResources;
399
+ }
400
+ //#endregion
401
+ //#region src/chrome-apis/DevtoolsNetworkApiTools.d.ts
386
402
  interface DevtoolsNetworkApiToolsOptions {
387
- getHAR?: boolean;
388
- onNavigated?: boolean;
389
- onRequestFinished?: boolean;
390
- }
391
- declare class DevtoolsNetworkApiTools extends BaseApiTools {
392
- protected apiName: string;
393
- constructor(server: McpServer, options?: DevtoolsNetworkApiToolsOptions);
394
- checkAvailability(): ApiAvailability;
395
- registerTools(): void;
396
- private registerGetHAR;
397
- private registerOnNavigated;
398
- private registerOnRequestFinished;
399
- }
400
-
403
+ getHAR?: boolean;
404
+ onNavigated?: boolean;
405
+ onRequestFinished?: boolean;
406
+ }
407
+ declare class DevtoolsNetworkApiTools extends BaseApiTools<DevtoolsNetworkApiToolsOptions> {
408
+ protected apiName: string;
409
+ constructor(server: McpServer, options?: DevtoolsNetworkApiToolsOptions);
410
+ checkAvailability(): ApiAvailability;
411
+ registerTools(): void;
412
+ private registerGetHAR;
413
+ private registerOnNavigated;
414
+ private registerOnRequestFinished;
415
+ }
416
+ //#endregion
417
+ //#region src/chrome-apis/DevtoolsPanelsApiTools.d.ts
401
418
  interface DevtoolsPanelsApiToolsOptions {
402
- createPanel?: boolean;
403
- createSidebarPane?: boolean;
404
- getThemeColor?: boolean;
405
- openResource?: boolean;
406
- setOpenResourceHandler?: boolean;
407
- }
408
- declare class DevtoolsPanelsApiTools extends BaseApiTools {
409
- protected apiName: string;
410
- constructor(server: McpServer, options?: DevtoolsPanelsApiToolsOptions);
411
- checkAvailability(): ApiAvailability;
412
- registerTools(): void;
413
- private registerCreatePanel;
414
- private registerCreateSidebarPane;
415
- private registerGetThemeColor;
416
- private registerOpenResource;
417
- private registerSetOpenResourceHandler;
418
- }
419
-
419
+ createPanel?: boolean;
420
+ createSidebarPane?: boolean;
421
+ getThemeColor?: boolean;
422
+ openResource?: boolean;
423
+ setOpenResourceHandler?: boolean;
424
+ }
425
+ declare class DevtoolsPanelsApiTools extends BaseApiTools<DevtoolsPanelsApiToolsOptions> {
426
+ protected apiName: string;
427
+ constructor(server: McpServer, options?: DevtoolsPanelsApiToolsOptions);
428
+ checkAvailability(): ApiAvailability;
429
+ registerTools(): void;
430
+ private registerCreatePanel;
431
+ private registerCreateSidebarPane;
432
+ private registerGetThemeColor;
433
+ private registerOpenResource;
434
+ private registerSetOpenResourceHandler;
435
+ }
436
+ //#endregion
437
+ //#region src/chrome-apis/DocumentScanApiTools.d.ts
420
438
  interface DocumentScanApiToolsOptions {
421
- scan?: boolean;
422
- getScannerList?: boolean;
423
- openScanner?: boolean;
424
- closeScanner?: boolean;
425
- getOptionGroups?: boolean;
426
- setOptions?: boolean;
427
- startScan?: boolean;
428
- readScanData?: boolean;
429
- cancelScan?: boolean;
430
- }
431
- declare class DocumentScanApiTools extends BaseApiTools {
432
- protected apiName: string;
433
- constructor(server: McpServer, options?: DocumentScanApiToolsOptions);
434
- checkAvailability(): ApiAvailability;
435
- registerTools(): void;
436
- private registerScan;
437
- private registerGetScannerList;
438
- private registerOpenScanner;
439
- private registerCloseScanner;
440
- private registerGetOptionGroups;
441
- private registerSetOptions;
442
- private registerStartScan;
443
- private registerReadScanData;
444
- private registerCancelScan;
445
- }
446
-
439
+ scan?: boolean;
440
+ getScannerList?: boolean;
441
+ openScanner?: boolean;
442
+ closeScanner?: boolean;
443
+ getOptionGroups?: boolean;
444
+ setOptions?: boolean;
445
+ startScan?: boolean;
446
+ readScanData?: boolean;
447
+ cancelScan?: boolean;
448
+ }
449
+ declare class DocumentScanApiTools extends BaseApiTools<DocumentScanApiToolsOptions> {
450
+ protected apiName: string;
451
+ constructor(server: McpServer, options?: DocumentScanApiToolsOptions);
452
+ checkAvailability(): ApiAvailability;
453
+ registerTools(): void;
454
+ private registerScan;
455
+ private registerGetScannerList;
456
+ private registerOpenScanner;
457
+ private registerCloseScanner;
458
+ private registerGetOptionGroups;
459
+ private registerSetOptions;
460
+ private registerStartScan;
461
+ private registerReadScanData;
462
+ private registerCancelScan;
463
+ }
464
+ //#endregion
465
+ //#region src/chrome-apis/DomApiTools.d.ts
447
466
  interface DomApiToolsOptions {
448
- openOrClosedShadowRoot?: boolean;
467
+ openOrClosedShadowRoot?: boolean;
449
468
  }
450
- declare class DomApiTools extends BaseApiTools {
451
- protected apiName: string;
452
- constructor(server: McpServer, options?: DomApiToolsOptions);
453
- checkAvailability(): ApiAvailability;
454
- registerTools(): void;
455
- private registerOpenOrClosedShadowRoot;
469
+ declare class DomApiTools extends BaseApiTools<DomApiToolsOptions> {
470
+ protected apiName: string;
471
+ constructor(server: McpServer, options?: DomApiToolsOptions);
472
+ checkAvailability(): ApiAvailability;
473
+ registerTools(): void;
474
+ private registerOpenOrClosedShadowRoot;
456
475
  }
457
-
476
+ //#endregion
477
+ //#region src/chrome-apis/DownloadsApiTools.d.ts
458
478
  interface DownloadsApiToolsOptions {
459
- download?: boolean;
460
- search?: boolean;
461
- pause?: boolean;
462
- resume?: boolean;
463
- cancel?: boolean;
464
- getFileIcon?: boolean;
465
- open?: boolean;
466
- show?: boolean;
467
- showDefaultFolder?: boolean;
468
- erase?: boolean;
469
- removeFile?: boolean;
470
- acceptDanger?: boolean;
471
- setUiOptions?: boolean;
472
- }
473
- declare class DownloadsApiTools extends BaseApiTools {
474
- protected apiName: string;
475
- constructor(server: McpServer, options?: DownloadsApiToolsOptions);
476
- checkAvailability(): ApiAvailability;
477
- registerTools(): void;
478
- private registerDownload;
479
- private registerSearch;
480
- private registerPause;
481
- private registerResume;
482
- private registerCancel;
483
- private registerGetFileIcon;
484
- private registerOpen;
485
- private registerShow;
486
- private registerShowDefaultFolder;
487
- private registerErase;
488
- private registerRemoveFile;
489
- private registerAcceptDanger;
490
- private registerSetUiOptions;
491
- }
492
-
479
+ download?: boolean;
480
+ search?: boolean;
481
+ pause?: boolean;
482
+ resume?: boolean;
483
+ cancel?: boolean;
484
+ getFileIcon?: boolean;
485
+ open?: boolean;
486
+ show?: boolean;
487
+ showDefaultFolder?: boolean;
488
+ erase?: boolean;
489
+ removeFile?: boolean;
490
+ acceptDanger?: boolean;
491
+ setUiOptions?: boolean;
492
+ }
493
+ declare class DownloadsApiTools extends BaseApiTools<DownloadsApiToolsOptions> {
494
+ protected apiName: string;
495
+ constructor(server: McpServer, options?: DownloadsApiToolsOptions);
496
+ checkAvailability(): ApiAvailability;
497
+ registerTools(): void;
498
+ private registerDownload;
499
+ private registerSearch;
500
+ private registerPause;
501
+ private registerResume;
502
+ private registerCancel;
503
+ private registerGetFileIcon;
504
+ private registerOpen;
505
+ private registerShow;
506
+ private registerShowDefaultFolder;
507
+ private registerErase;
508
+ private registerRemoveFile;
509
+ private registerAcceptDanger;
510
+ private registerSetUiOptions;
511
+ }
512
+ //#endregion
513
+ //#region src/chrome-apis/EnterpriseDeviceAttributesApiTools.d.ts
493
514
  interface EnterpriseDeviceAttributesApiToolsOptions {
494
- getDirectoryDeviceId?: boolean;
495
- getDeviceSerialNumber?: boolean;
496
- getDeviceAssetId?: boolean;
497
- getDeviceAnnotatedLocation?: boolean;
498
- getDeviceHostname?: boolean;
499
- }
500
- declare class EnterpriseDeviceAttributesApiTools extends BaseApiTools {
501
- protected apiName: string;
502
- constructor(server: McpServer, options?: EnterpriseDeviceAttributesApiToolsOptions);
503
- checkAvailability(): ApiAvailability;
504
- registerTools(): void;
505
- private registerGetDirectoryDeviceId;
506
- private registerGetDeviceSerialNumber;
507
- private registerGetDeviceAssetId;
508
- private registerGetDeviceAnnotatedLocation;
509
- private registerGetDeviceHostname;
510
- }
511
-
515
+ getDirectoryDeviceId?: boolean;
516
+ getDeviceSerialNumber?: boolean;
517
+ getDeviceAssetId?: boolean;
518
+ getDeviceAnnotatedLocation?: boolean;
519
+ getDeviceHostname?: boolean;
520
+ }
521
+ declare class EnterpriseDeviceAttributesApiTools extends BaseApiTools<EnterpriseDeviceAttributesApiToolsOptions> {
522
+ protected apiName: string;
523
+ constructor(server: McpServer, options?: EnterpriseDeviceAttributesApiToolsOptions);
524
+ checkAvailability(): ApiAvailability;
525
+ registerTools(): void;
526
+ private registerGetDirectoryDeviceId;
527
+ private registerGetDeviceSerialNumber;
528
+ private registerGetDeviceAssetId;
529
+ private registerGetDeviceAnnotatedLocation;
530
+ private registerGetDeviceHostname;
531
+ }
532
+ //#endregion
533
+ //#region src/chrome-apis/EnterpriseHardwarePlatformApiTools.d.ts
512
534
  interface EnterpriseHardwarePlatformApiToolsOptions {
513
- getHardwarePlatformInfo?: boolean;
535
+ getHardwarePlatformInfo?: boolean;
514
536
  }
515
- declare class EnterpriseHardwarePlatformApiTools extends BaseApiTools {
516
- protected apiName: string;
517
- constructor(server: McpServer, options?: EnterpriseHardwarePlatformApiToolsOptions);
518
- checkAvailability(): ApiAvailability;
519
- registerTools(): void;
520
- private registerGetHardwarePlatformInfo;
537
+ declare class EnterpriseHardwarePlatformApiTools extends BaseApiTools<EnterpriseHardwarePlatformApiToolsOptions> {
538
+ protected apiName: string;
539
+ constructor(server: McpServer, options?: EnterpriseHardwarePlatformApiToolsOptions);
540
+ checkAvailability(): ApiAvailability;
541
+ registerTools(): void;
542
+ private registerGetHardwarePlatformInfo;
521
543
  }
522
-
544
+ //#endregion
545
+ //#region src/chrome-apis/EnterpriseNetworkingAttributesApiTools.d.ts
523
546
  interface EnterpriseNetworkingAttributesApiToolsOptions {
524
- getNetworkDetails?: boolean;
547
+ getNetworkDetails?: boolean;
525
548
  }
526
- declare class EnterpriseNetworkingAttributesApiTools extends BaseApiTools {
527
- protected apiName: string;
528
- constructor(server: McpServer, options?: EnterpriseNetworkingAttributesApiToolsOptions);
529
- checkAvailability(): ApiAvailability;
530
- registerTools(): void;
531
- private registerGetNetworkDetails;
549
+ declare class EnterpriseNetworkingAttributesApiTools extends BaseApiTools<EnterpriseNetworkingAttributesApiToolsOptions> {
550
+ protected apiName: string;
551
+ constructor(server: McpServer, options?: EnterpriseNetworkingAttributesApiToolsOptions);
552
+ checkAvailability(): ApiAvailability;
553
+ registerTools(): void;
554
+ private registerGetNetworkDetails;
532
555
  }
533
-
556
+ //#endregion
557
+ //#region src/chrome-apis/EnterprisePlatformKeysApiTools.d.ts
534
558
  interface EnterprisePlatformKeysApiToolsOptions {
535
- getTokens?: boolean;
536
- getCertificates?: boolean;
537
- importCertificate?: boolean;
538
- removeCertificate?: boolean;
539
- challengeMachineKey?: boolean;
540
- challengeUserKey?: boolean;
541
- }
542
- declare class EnterprisePlatformKeysApiTools extends BaseApiTools {
543
- protected apiName: string;
544
- constructor(server: McpServer, options?: EnterprisePlatformKeysApiToolsOptions);
545
- checkAvailability(): ApiAvailability;
546
- registerTools(): void;
547
- private registerGetTokens;
548
- private registerGetCertificates;
549
- private registerImportCertificate;
550
- private registerRemoveCertificate;
551
- private registerChallengeMachineKey;
552
- private registerChallengeUserKey;
553
- }
554
-
559
+ getTokens?: boolean;
560
+ getCertificates?: boolean;
561
+ importCertificate?: boolean;
562
+ removeCertificate?: boolean;
563
+ challengeMachineKey?: boolean;
564
+ challengeUserKey?: boolean;
565
+ }
566
+ declare class EnterprisePlatformKeysApiTools extends BaseApiTools<EnterprisePlatformKeysApiToolsOptions> {
567
+ protected apiName: string;
568
+ constructor(server: McpServer, options?: EnterprisePlatformKeysApiToolsOptions);
569
+ checkAvailability(): ApiAvailability;
570
+ registerTools(): void;
571
+ private registerGetTokens;
572
+ private registerGetCertificates;
573
+ private registerImportCertificate;
574
+ private registerRemoveCertificate;
575
+ private registerChallengeMachineKey;
576
+ private registerChallengeUserKey;
577
+ }
578
+ //#endregion
579
+ //#region src/chrome-apis/ExtensionApiTools.d.ts
555
580
  interface ExtensionApiToolsOptions {
556
- getBackgroundPage?: boolean;
557
- getViews?: boolean;
558
- isAllowedFileSchemeAccess?: boolean;
559
- isAllowedIncognitoAccess?: boolean;
560
- setUpdateUrlData?: boolean;
561
- }
562
- declare class ExtensionApiTools extends BaseApiTools {
563
- protected apiName: string;
564
- constructor(server: McpServer, options?: ExtensionApiToolsOptions);
565
- checkAvailability(): ApiAvailability;
566
- registerTools(): void;
567
- private registerGetBackgroundPage;
568
- private registerGetViews;
569
- private registerIsAllowedFileSchemeAccess;
570
- private registerIsAllowedIncognitoAccess;
571
- private registerSetUpdateUrlData;
572
- }
573
-
581
+ getBackgroundPage?: boolean;
582
+ getViews?: boolean;
583
+ isAllowedFileSchemeAccess?: boolean;
584
+ isAllowedIncognitoAccess?: boolean;
585
+ setUpdateUrlData?: boolean;
586
+ }
587
+ declare class ExtensionApiTools extends BaseApiTools<ExtensionApiToolsOptions> {
588
+ protected apiName: string;
589
+ constructor(server: McpServer, options?: ExtensionApiToolsOptions);
590
+ checkAvailability(): ApiAvailability;
591
+ registerTools(): void;
592
+ private registerGetBackgroundPage;
593
+ private registerGetViews;
594
+ private registerIsAllowedFileSchemeAccess;
595
+ private registerIsAllowedIncognitoAccess;
596
+ private registerSetUpdateUrlData;
597
+ }
598
+ //#endregion
599
+ //#region src/chrome-apis/FileBrowserHandlerApiTools.d.ts
574
600
  interface FileBrowserHandlerApiToolsOptions {
575
- getExecuteEventDetails?: boolean;
576
- addExecuteListener?: boolean;
577
- removeExecuteListener?: boolean;
578
- }
579
- declare class FileBrowserHandlerApiTools extends BaseApiTools {
580
- protected apiName: string;
581
- constructor(server: McpServer, options?: FileBrowserHandlerApiToolsOptions);
582
- checkAvailability(): ApiAvailability;
583
- registerTools(): void;
584
- private registerGetExecuteEventDetails;
585
- private registerAddExecuteListener;
586
- private registerRemoveExecuteListener;
587
- }
588
-
601
+ getExecuteEventDetails?: boolean;
602
+ addExecuteListener?: boolean;
603
+ removeExecuteListener?: boolean;
604
+ }
605
+ declare class FileBrowserHandlerApiTools extends BaseApiTools<FileBrowserHandlerApiToolsOptions> {
606
+ protected apiName: string;
607
+ constructor(server: McpServer, options?: FileBrowserHandlerApiToolsOptions);
608
+ checkAvailability(): ApiAvailability;
609
+ registerTools(): void;
610
+ private registerGetExecuteEventDetails;
611
+ private registerAddExecuteListener;
612
+ private registerRemoveExecuteListener;
613
+ }
614
+ //#endregion
615
+ //#region src/chrome-apis/FileSystemProviderApiTools.d.ts
589
616
  interface FileSystemProviderApiToolsOptions {
590
- mount?: boolean;
591
- unmount?: boolean;
592
- get?: boolean;
593
- getAll?: boolean;
594
- notify?: boolean;
595
- }
596
- declare class FileSystemProviderApiTools extends BaseApiTools {
597
- protected apiName: string;
598
- constructor(server: McpServer, options?: FileSystemProviderApiToolsOptions);
599
- checkAvailability(): ApiAvailability;
600
- registerTools(): void;
601
- private registerMount;
602
- private registerUnmount;
603
- private registerGet;
604
- private registerGetAll;
605
- private registerNotify;
606
- }
607
-
617
+ mount?: boolean;
618
+ unmount?: boolean;
619
+ get?: boolean;
620
+ getAll?: boolean;
621
+ notify?: boolean;
622
+ }
623
+ declare class FileSystemProviderApiTools extends BaseApiTools<FileSystemProviderApiToolsOptions> {
624
+ protected apiName: string;
625
+ constructor(server: McpServer, options?: FileSystemProviderApiToolsOptions);
626
+ checkAvailability(): ApiAvailability;
627
+ registerTools(): void;
628
+ private registerMount;
629
+ private registerUnmount;
630
+ private registerGet;
631
+ private registerGetAll;
632
+ private registerNotify;
633
+ }
634
+ //#endregion
635
+ //#region src/chrome-apis/FontSettingsApiTools.d.ts
608
636
  interface FontSettingsApiToolsOptions {
609
- getFont?: boolean;
610
- setFont?: boolean;
611
- clearFont?: boolean;
612
- getFontList?: boolean;
613
- getDefaultFontSize?: boolean;
614
- setDefaultFontSize?: boolean;
615
- clearDefaultFontSize?: boolean;
616
- getDefaultFixedFontSize?: boolean;
617
- setDefaultFixedFontSize?: boolean;
618
- clearDefaultFixedFontSize?: boolean;
619
- getMinimumFontSize?: boolean;
620
- setMinimumFontSize?: boolean;
621
- clearMinimumFontSize?: boolean;
622
- }
623
- declare class FontSettingsApiTools extends BaseApiTools {
624
- protected apiName: string;
625
- constructor(server: McpServer, options?: FontSettingsApiToolsOptions);
626
- checkAvailability(): ApiAvailability;
627
- registerTools(): void;
628
- private registerGetFont;
629
- private registerSetFont;
630
- private registerClearFont;
631
- private registerGetFontList;
632
- private registerGetDefaultFontSize;
633
- private registerSetDefaultFontSize;
634
- private registerClearDefaultFontSize;
635
- private registerGetDefaultFixedFontSize;
636
- private registerSetDefaultFixedFontSize;
637
- private registerClearDefaultFixedFontSize;
638
- private registerGetMinimumFontSize;
639
- private registerSetMinimumFontSize;
640
- private registerClearMinimumFontSize;
641
- }
642
-
637
+ getFont?: boolean;
638
+ setFont?: boolean;
639
+ clearFont?: boolean;
640
+ getFontList?: boolean;
641
+ getDefaultFontSize?: boolean;
642
+ setDefaultFontSize?: boolean;
643
+ clearDefaultFontSize?: boolean;
644
+ getDefaultFixedFontSize?: boolean;
645
+ setDefaultFixedFontSize?: boolean;
646
+ clearDefaultFixedFontSize?: boolean;
647
+ getMinimumFontSize?: boolean;
648
+ setMinimumFontSize?: boolean;
649
+ clearMinimumFontSize?: boolean;
650
+ }
651
+ declare class FontSettingsApiTools extends BaseApiTools<FontSettingsApiToolsOptions> {
652
+ protected apiName: string;
653
+ constructor(server: McpServer, options?: FontSettingsApiToolsOptions);
654
+ checkAvailability(): ApiAvailability;
655
+ registerTools(): void;
656
+ private registerGetFont;
657
+ private registerSetFont;
658
+ private registerClearFont;
659
+ private registerGetFontList;
660
+ private registerGetDefaultFontSize;
661
+ private registerSetDefaultFontSize;
662
+ private registerClearDefaultFontSize;
663
+ private registerGetDefaultFixedFontSize;
664
+ private registerSetDefaultFixedFontSize;
665
+ private registerClearDefaultFixedFontSize;
666
+ private registerGetMinimumFontSize;
667
+ private registerSetMinimumFontSize;
668
+ private registerClearMinimumFontSize;
669
+ }
670
+ //#endregion
671
+ //#region src/chrome-apis/GcmApiTools.d.ts
643
672
  interface GcmApiToolsOptions {
644
- register?: boolean;
645
- send?: boolean;
646
- unregister?: boolean;
647
- }
648
- declare class GcmApiTools extends BaseApiTools {
649
- protected apiName: string;
650
- constructor(server: McpServer, options?: GcmApiToolsOptions);
651
- checkAvailability(): ApiAvailability;
652
- registerTools(): void;
653
- private registerRegister;
654
- private registerSend;
655
- private registerUnregister;
656
- }
657
-
673
+ register?: boolean;
674
+ send?: boolean;
675
+ unregister?: boolean;
676
+ }
677
+ declare class GcmApiTools extends BaseApiTools<GcmApiToolsOptions> {
678
+ protected apiName: string;
679
+ constructor(server: McpServer, options?: GcmApiToolsOptions);
680
+ checkAvailability(): ApiAvailability;
681
+ registerTools(): void;
682
+ private registerRegister;
683
+ private registerSend;
684
+ private registerUnregister;
685
+ }
686
+ //#endregion
687
+ //#region src/chrome-apis/HistoryApiTools.d.ts
658
688
  interface HistoryApiToolsOptions {
659
- addUrl?: boolean;
660
- deleteAll?: boolean;
661
- deleteRange?: boolean;
662
- deleteUrl?: boolean;
663
- getVisits?: boolean;
664
- search?: boolean;
689
+ addUrl?: boolean;
690
+ deleteAll?: boolean;
691
+ deleteRange?: boolean;
692
+ deleteUrl?: boolean;
693
+ getVisits?: boolean;
694
+ search?: boolean;
665
695
  }
666
696
  declare const HISTORY_ACTIONS: readonly ["addUrl", "deleteAll", "deleteRange", "deleteUrl", "getVisits", "search"];
667
- declare class HistoryApiTools extends BaseApiTools {
668
- protected apiName: string;
669
- constructor(server: McpServer, options?: HistoryApiToolsOptions);
670
- checkAvailability(): ApiAvailability;
671
- registerTools(): void;
672
- private handleAddUrl;
673
- private handleDeleteAll;
674
- private handleDeleteRange;
675
- private handleDeleteUrl;
676
- private handleGetVisits;
677
- private handleSearch;
678
- private addUrlSchema;
679
- private deleteAllSchema;
680
- private deleteRangeSchema;
681
- private deleteUrlSchema;
682
- private getVisitsSchema;
683
- private searchSchema;
684
- }
685
-
697
+ declare class HistoryApiTools extends BaseApiTools<HistoryApiToolsOptions> {
698
+ protected apiName: string;
699
+ constructor(server: McpServer, options?: HistoryApiToolsOptions);
700
+ checkAvailability(): ApiAvailability;
701
+ registerTools(): void;
702
+ private handleAddUrl;
703
+ private handleDeleteAll;
704
+ private handleDeleteRange;
705
+ private handleDeleteUrl;
706
+ private handleGetVisits;
707
+ private handleSearch;
708
+ private addUrlSchema;
709
+ private deleteAllSchema;
710
+ private deleteRangeSchema;
711
+ private deleteUrlSchema;
712
+ private getVisitsSchema;
713
+ private searchSchema;
714
+ }
715
+ //#endregion
716
+ //#region src/chrome-apis/I18nApiTools.d.ts
686
717
  interface I18nApiToolsOptions {
687
- getMessage?: boolean;
688
- getUILanguage?: boolean;
689
- getAcceptLanguages?: boolean;
690
- detectLanguage?: boolean;
691
- }
692
- declare class I18nApiTools extends BaseApiTools {
693
- protected apiName: string;
694
- constructor(server: McpServer, options?: I18nApiToolsOptions);
695
- checkAvailability(): ApiAvailability;
696
- registerTools(): void;
697
- private registerGetMessage;
698
- private registerGetUILanguage;
699
- private registerGetAcceptLanguages;
700
- private registerDetectLanguage;
701
- }
702
-
718
+ getMessage?: boolean;
719
+ getUILanguage?: boolean;
720
+ getAcceptLanguages?: boolean;
721
+ detectLanguage?: boolean;
722
+ }
723
+ declare class I18nApiTools extends BaseApiTools<I18nApiToolsOptions> {
724
+ protected apiName: string;
725
+ constructor(server: McpServer, options?: I18nApiToolsOptions);
726
+ checkAvailability(): ApiAvailability;
727
+ registerTools(): void;
728
+ private registerGetMessage;
729
+ private registerGetUILanguage;
730
+ private registerGetAcceptLanguages;
731
+ private registerDetectLanguage;
732
+ }
733
+ //#endregion
734
+ //#region src/chrome-apis/IdentityApiTools.d.ts
703
735
  interface IdentityApiToolsOptions {
704
- getAuthToken?: boolean;
705
- getProfileUserInfo?: boolean;
706
- getAccounts?: boolean;
707
- getRedirectURL?: boolean;
708
- launchWebAuthFlow?: boolean;
709
- removeCachedAuthToken?: boolean;
710
- clearAllCachedAuthTokens?: boolean;
711
- }
712
- declare class IdentityApiTools extends BaseApiTools {
713
- protected apiName: string;
714
- constructor(server: McpServer, options?: IdentityApiToolsOptions);
715
- checkAvailability(): ApiAvailability;
716
- registerTools(): void;
717
- private registerGetAuthToken;
718
- private registerGetProfileUserInfo;
719
- private registerGetAccounts;
720
- private registerGetRedirectURL;
721
- private registerLaunchWebAuthFlow;
722
- private registerRemoveCachedAuthToken;
723
- private registerClearAllCachedAuthTokens;
724
- }
725
-
736
+ getAuthToken?: boolean;
737
+ getProfileUserInfo?: boolean;
738
+ getAccounts?: boolean;
739
+ getRedirectURL?: boolean;
740
+ launchWebAuthFlow?: boolean;
741
+ removeCachedAuthToken?: boolean;
742
+ clearAllCachedAuthTokens?: boolean;
743
+ }
744
+ declare class IdentityApiTools extends BaseApiTools<IdentityApiToolsOptions> {
745
+ protected apiName: string;
746
+ constructor(server: McpServer, options?: IdentityApiToolsOptions);
747
+ checkAvailability(): ApiAvailability;
748
+ registerTools(): void;
749
+ private registerGetAuthToken;
750
+ private registerGetProfileUserInfo;
751
+ private registerGetAccounts;
752
+ private registerGetRedirectURL;
753
+ private registerLaunchWebAuthFlow;
754
+ private registerRemoveCachedAuthToken;
755
+ private registerClearAllCachedAuthTokens;
756
+ }
757
+ //#endregion
758
+ //#region src/chrome-apis/IdleApiTools.d.ts
726
759
  interface IdleApiToolsOptions {
727
- queryState?: boolean;
728
- setDetectionInterval?: boolean;
729
- getAutoLockDelay?: boolean;
730
- }
731
- declare class IdleApiTools extends BaseApiTools {
732
- protected apiName: string;
733
- constructor(server: McpServer, options?: IdleApiToolsOptions);
734
- checkAvailability(): ApiAvailability;
735
- registerTools(): void;
736
- private registerQueryState;
737
- private registerSetDetectionInterval;
738
- private registerGetAutoLockDelay;
739
- }
740
-
760
+ queryState?: boolean;
761
+ setDetectionInterval?: boolean;
762
+ getAutoLockDelay?: boolean;
763
+ }
764
+ declare class IdleApiTools extends BaseApiTools<IdleApiToolsOptions> {
765
+ protected apiName: string;
766
+ constructor(server: McpServer, options?: IdleApiToolsOptions);
767
+ checkAvailability(): ApiAvailability;
768
+ registerTools(): void;
769
+ private registerQueryState;
770
+ private registerSetDetectionInterval;
771
+ private registerGetAutoLockDelay;
772
+ }
773
+ //#endregion
774
+ //#region src/chrome-apis/InputImeApiTools.d.ts
741
775
  interface InputImeApiToolsOptions {
742
- setComposition?: boolean;
743
- clearComposition?: boolean;
744
- commitText?: boolean;
745
- sendKeyEvents?: boolean;
746
- hideInputView?: boolean;
747
- setCandidateWindowProperties?: boolean;
748
- setCandidates?: boolean;
749
- setCursorPosition?: boolean;
750
- setMenuItems?: boolean;
751
- updateMenuItems?: boolean;
752
- deleteSurroundingText?: boolean;
753
- }
754
- declare class InputImeApiTools extends BaseApiTools {
755
- protected apiName: string;
756
- constructor(server: McpServer, options?: InputImeApiToolsOptions);
757
- checkAvailability(): ApiAvailability;
758
- registerTools(): void;
759
- private registerSetComposition;
760
- private registerClearComposition;
761
- private registerCommitText;
762
- private registerSendKeyEvents;
763
- private registerHideInputView;
764
- private registerSetCandidateWindowProperties;
765
- private registerSetCandidates;
766
- private registerSetCursorPosition;
767
- private registerSetMenuItems;
768
- private registerUpdateMenuItems;
769
- private registerDeleteSurroundingText;
770
- }
771
-
776
+ setComposition?: boolean;
777
+ clearComposition?: boolean;
778
+ commitText?: boolean;
779
+ sendKeyEvents?: boolean;
780
+ hideInputView?: boolean;
781
+ setCandidateWindowProperties?: boolean;
782
+ setCandidates?: boolean;
783
+ setCursorPosition?: boolean;
784
+ setMenuItems?: boolean;
785
+ updateMenuItems?: boolean;
786
+ deleteSurroundingText?: boolean;
787
+ }
788
+ declare class InputImeApiTools extends BaseApiTools<InputImeApiToolsOptions> {
789
+ protected apiName: string;
790
+ constructor(server: McpServer, options?: InputImeApiToolsOptions);
791
+ checkAvailability(): ApiAvailability;
792
+ registerTools(): void;
793
+ private registerSetComposition;
794
+ private registerClearComposition;
795
+ private registerCommitText;
796
+ private registerSendKeyEvents;
797
+ private registerHideInputView;
798
+ private registerSetCandidateWindowProperties;
799
+ private registerSetCandidates;
800
+ private registerSetCursorPosition;
801
+ private registerSetMenuItems;
802
+ private registerUpdateMenuItems;
803
+ private registerDeleteSurroundingText;
804
+ }
805
+ //#endregion
806
+ //#region src/chrome-apis/InstanceIDApiTools.d.ts
772
807
  interface InstanceIDApiToolsOptions {
773
- getID?: boolean;
774
- getCreationTime?: boolean;
775
- getToken?: boolean;
776
- deleteToken?: boolean;
777
- deleteID?: boolean;
778
- }
779
- declare class InstanceIDApiTools extends BaseApiTools {
780
- protected apiName: string;
781
- constructor(server: McpServer, options?: InstanceIDApiToolsOptions);
782
- checkAvailability(): ApiAvailability;
783
- registerTools(): void;
784
- private registerGetID;
785
- private registerGetCreationTime;
786
- private registerGetToken;
787
- private registerDeleteToken;
788
- private registerDeleteID;
789
- }
790
-
808
+ getID?: boolean;
809
+ getCreationTime?: boolean;
810
+ getToken?: boolean;
811
+ deleteToken?: boolean;
812
+ deleteID?: boolean;
813
+ }
814
+ declare class InstanceIDApiTools extends BaseApiTools<InstanceIDApiToolsOptions> {
815
+ protected apiName: string;
816
+ constructor(server: McpServer, options?: InstanceIDApiToolsOptions);
817
+ checkAvailability(): ApiAvailability;
818
+ registerTools(): void;
819
+ private registerGetID;
820
+ private registerGetCreationTime;
821
+ private registerGetToken;
822
+ private registerDeleteToken;
823
+ private registerDeleteID;
824
+ }
825
+ //#endregion
826
+ //#region src/chrome-apis/LoginStateApiTools.d.ts
791
827
  interface LoginStateApiToolsOptions {
792
- getProfileType?: boolean;
793
- getSessionState?: boolean;
794
- }
795
- declare class LoginStateApiTools extends BaseApiTools {
796
- protected apiName: string;
797
- constructor(server: McpServer, options?: LoginStateApiToolsOptions);
798
- checkAvailability(): ApiAvailability;
799
- registerTools(): void;
800
- private registerGetProfileType;
801
- private registerGetSessionState;
802
- }
803
-
828
+ getProfileType?: boolean;
829
+ getSessionState?: boolean;
830
+ }
831
+ declare class LoginStateApiTools extends BaseApiTools<LoginStateApiToolsOptions> {
832
+ protected apiName: string;
833
+ constructor(server: McpServer, options?: LoginStateApiToolsOptions);
834
+ checkAvailability(): ApiAvailability;
835
+ registerTools(): void;
836
+ private registerGetProfileType;
837
+ private registerGetSessionState;
838
+ }
839
+ //#endregion
840
+ //#region src/chrome-apis/ManagementApiTools.d.ts
804
841
  interface ManagementApiToolsOptions {
805
- get?: boolean;
806
- getAll?: boolean;
807
- getSelf?: boolean;
808
- setEnabled?: boolean;
809
- uninstall?: boolean;
810
- uninstallSelf?: boolean;
811
- launchApp?: boolean;
812
- createAppShortcut?: boolean;
813
- generateAppForLink?: boolean;
814
- setLaunchType?: boolean;
815
- getPermissionWarningsById?: boolean;
816
- getPermissionWarningsByManifest?: boolean;
817
- }
818
- declare class ManagementApiTools extends BaseApiTools {
819
- protected apiName: string;
820
- constructor(server: McpServer, options?: ManagementApiToolsOptions);
821
- checkAvailability(): ApiAvailability;
822
- registerTools(): void;
823
- private registerGet;
824
- private registerGetAll;
825
- private registerGetSelf;
826
- private registerSetEnabled;
827
- private registerUninstall;
828
- private registerUninstallSelf;
829
- private registerLaunchApp;
830
- private registerCreateAppShortcut;
831
- private registerGenerateAppForLink;
832
- private registerSetLaunchType;
833
- private registerGetPermissionWarningsById;
834
- private registerGetPermissionWarningsByManifest;
835
- }
836
-
842
+ get?: boolean;
843
+ getAll?: boolean;
844
+ getSelf?: boolean;
845
+ setEnabled?: boolean;
846
+ uninstall?: boolean;
847
+ uninstallSelf?: boolean;
848
+ launchApp?: boolean;
849
+ createAppShortcut?: boolean;
850
+ generateAppForLink?: boolean;
851
+ setLaunchType?: boolean;
852
+ getPermissionWarningsById?: boolean;
853
+ getPermissionWarningsByManifest?: boolean;
854
+ }
855
+ declare class ManagementApiTools extends BaseApiTools<ManagementApiToolsOptions> {
856
+ protected apiName: string;
857
+ constructor(server: McpServer, options?: ManagementApiToolsOptions);
858
+ checkAvailability(): ApiAvailability;
859
+ registerTools(): void;
860
+ private registerGet;
861
+ private registerGetAll;
862
+ private registerGetSelf;
863
+ private registerSetEnabled;
864
+ private registerUninstall;
865
+ private registerUninstallSelf;
866
+ private registerLaunchApp;
867
+ private registerCreateAppShortcut;
868
+ private registerGenerateAppForLink;
869
+ private registerSetLaunchType;
870
+ private registerGetPermissionWarningsById;
871
+ private registerGetPermissionWarningsByManifest;
872
+ }
873
+ //#endregion
874
+ //#region src/chrome-apis/NotificationsApiTools.d.ts
837
875
  interface NotificationsApiToolsOptions {
838
- createNotification?: boolean;
839
- updateNotification?: boolean;
840
- clearNotification?: boolean;
841
- getAllNotifications?: boolean;
842
- getPermissionLevel?: boolean;
843
- }
844
- declare class NotificationsApiTools extends BaseApiTools {
845
- protected apiName: string;
846
- constructor(server: McpServer, options?: NotificationsApiToolsOptions);
847
- checkAvailability(): ApiAvailability;
848
- registerTools(): void;
849
- private registerCreateNotification;
850
- private registerUpdateNotification;
851
- private registerClearNotification;
852
- private registerGetAllNotifications;
853
- private registerGetPermissionLevel;
854
- }
855
-
876
+ createNotification?: boolean;
877
+ updateNotification?: boolean;
878
+ clearNotification?: boolean;
879
+ getAllNotifications?: boolean;
880
+ getPermissionLevel?: boolean;
881
+ }
882
+ declare class NotificationsApiTools extends BaseApiTools<NotificationsApiToolsOptions> {
883
+ protected apiName: string;
884
+ constructor(server: McpServer, options?: NotificationsApiToolsOptions);
885
+ checkAvailability(): ApiAvailability;
886
+ registerTools(): void;
887
+ private registerCreateNotification;
888
+ private registerUpdateNotification;
889
+ private registerClearNotification;
890
+ private registerGetAllNotifications;
891
+ private registerGetPermissionLevel;
892
+ }
893
+ //#endregion
894
+ //#region src/chrome-apis/OffscreenApiTools.d.ts
856
895
  interface OffscreenApiToolsOptions {
857
- createDocument?: boolean;
858
- closeDocument?: boolean;
859
- hasOffscreenDocument?: boolean;
860
- }
861
- declare class OffscreenApiTools extends BaseApiTools {
862
- protected apiName: string;
863
- constructor(server: McpServer, options?: OffscreenApiToolsOptions);
864
- checkAvailability(): ApiAvailability;
865
- registerTools(): void;
866
- private registerCreateDocument;
867
- private registerCloseDocument;
868
- private registerHasOffscreenDocument;
869
- }
870
-
896
+ createDocument?: boolean;
897
+ closeDocument?: boolean;
898
+ hasOffscreenDocument?: boolean;
899
+ }
900
+ declare class OffscreenApiTools extends BaseApiTools<OffscreenApiToolsOptions> {
901
+ protected apiName: string;
902
+ constructor(server: McpServer, options?: OffscreenApiToolsOptions);
903
+ checkAvailability(): ApiAvailability;
904
+ registerTools(): void;
905
+ private registerCreateDocument;
906
+ private registerCloseDocument;
907
+ private registerHasOffscreenDocument;
908
+ }
909
+ //#endregion
910
+ //#region src/chrome-apis/OmniboxApiTools.d.ts
871
911
  interface OmniboxApiToolsOptions {
872
- setDefaultSuggestion?: boolean;
873
- onInputStarted?: boolean;
874
- onInputChanged?: boolean;
875
- onInputEntered?: boolean;
876
- onInputCancelled?: boolean;
877
- onDeleteSuggestion?: boolean;
878
- }
879
- declare class OmniboxApiTools extends BaseApiTools {
880
- protected apiName: string;
881
- constructor(server: McpServer, options?: OmniboxApiToolsOptions);
882
- checkAvailability(): ApiAvailability;
883
- registerTools(): void;
884
- private registerSetDefaultSuggestion;
885
- private registerOnInputStarted;
886
- private registerOnInputChanged;
887
- private registerOnInputEntered;
888
- private registerOnInputCancelled;
889
- private registerOnDeleteSuggestion;
890
- }
891
-
912
+ setDefaultSuggestion?: boolean;
913
+ onInputStarted?: boolean;
914
+ onInputChanged?: boolean;
915
+ onInputEntered?: boolean;
916
+ onInputCancelled?: boolean;
917
+ onDeleteSuggestion?: boolean;
918
+ }
919
+ declare class OmniboxApiTools extends BaseApiTools<OmniboxApiToolsOptions> {
920
+ protected apiName: string;
921
+ constructor(server: McpServer, options?: OmniboxApiToolsOptions);
922
+ checkAvailability(): ApiAvailability;
923
+ registerTools(): void;
924
+ private registerSetDefaultSuggestion;
925
+ private registerOnInputStarted;
926
+ private registerOnInputChanged;
927
+ private registerOnInputEntered;
928
+ private registerOnInputCancelled;
929
+ private registerOnDeleteSuggestion;
930
+ }
931
+ //#endregion
932
+ //#region src/chrome-apis/PageCaptureApiTools.d.ts
892
933
  interface PageCaptureApiToolsOptions {
893
- saveAsMHTML?: boolean;
934
+ saveAsMHTML?: boolean;
894
935
  }
895
- declare class PageCaptureApiTools extends BaseApiTools {
896
- protected apiName: string;
897
- constructor(server: McpServer, options?: PageCaptureApiToolsOptions);
898
- checkAvailability(): ApiAvailability;
899
- registerTools(): void;
900
- private registerSaveAsMHTML;
936
+ declare class PageCaptureApiTools extends BaseApiTools<PageCaptureApiToolsOptions> {
937
+ protected apiName: string;
938
+ constructor(server: McpServer, options?: PageCaptureApiToolsOptions);
939
+ checkAvailability(): ApiAvailability;
940
+ registerTools(): void;
941
+ private registerSaveAsMHTML;
901
942
  }
902
-
943
+ //#endregion
944
+ //#region src/chrome-apis/PermissionsApiTools.d.ts
903
945
  interface PermissionsApiToolsOptions {
904
- request?: boolean;
905
- contains?: boolean;
906
- getAll?: boolean;
907
- remove?: boolean;
908
- addHostAccessRequest?: boolean;
909
- removeHostAccessRequest?: boolean;
910
- }
911
- declare class PermissionsApiTools extends BaseApiTools {
912
- protected apiName: string;
913
- constructor(server: McpServer, options?: PermissionsApiToolsOptions);
914
- checkAvailability(): ApiAvailability;
915
- registerTools(): void;
916
- private registerRequest;
917
- private registerContains;
918
- private registerGetAll;
919
- private registerRemove;
920
- private registerAddHostAccessRequest;
921
- private registerRemoveHostAccessRequest;
922
- }
923
-
946
+ request?: boolean;
947
+ contains?: boolean;
948
+ getAll?: boolean;
949
+ remove?: boolean;
950
+ addHostAccessRequest?: boolean;
951
+ removeHostAccessRequest?: boolean;
952
+ }
953
+ declare class PermissionsApiTools extends BaseApiTools<PermissionsApiToolsOptions> {
954
+ protected apiName: string;
955
+ constructor(server: McpServer, options?: PermissionsApiToolsOptions);
956
+ checkAvailability(): ApiAvailability;
957
+ registerTools(): void;
958
+ private registerRequest;
959
+ private registerContains;
960
+ private registerGetAll;
961
+ private registerRemove;
962
+ private registerAddHostAccessRequest;
963
+ private registerRemoveHostAccessRequest;
964
+ }
965
+ //#endregion
966
+ //#region src/chrome-apis/PlatformKeysApiTools.d.ts
924
967
  interface PlatformKeysApiToolsOptions {
925
- selectClientCertificates?: boolean;
926
- getKeyPair?: boolean;
927
- getKeyPairBySpki?: boolean;
928
- verifyTLSServerCertificate?: boolean;
929
- getSubtleCrypto?: boolean;
930
- }
931
- declare class PlatformKeysApiTools extends BaseApiTools {
932
- protected apiName: string;
933
- constructor(server: McpServer, options?: PlatformKeysApiToolsOptions);
934
- checkAvailability(): ApiAvailability;
935
- registerTools(): void;
936
- private registerSelectClientCertificates;
937
- private registerGetKeyPair;
938
- private registerGetKeyPairBySpki;
939
- private registerVerifyTLSServerCertificate;
940
- private registerGetSubtleCrypto;
941
- }
942
-
968
+ selectClientCertificates?: boolean;
969
+ getKeyPair?: boolean;
970
+ getKeyPairBySpki?: boolean;
971
+ verifyTLSServerCertificate?: boolean;
972
+ getSubtleCrypto?: boolean;
973
+ }
974
+ declare class PlatformKeysApiTools extends BaseApiTools<PlatformKeysApiToolsOptions> {
975
+ protected apiName: string;
976
+ constructor(server: McpServer, options?: PlatformKeysApiToolsOptions);
977
+ checkAvailability(): ApiAvailability;
978
+ registerTools(): void;
979
+ private registerSelectClientCertificates;
980
+ private registerGetKeyPair;
981
+ private registerGetKeyPairBySpki;
982
+ private registerVerifyTLSServerCertificate;
983
+ private registerGetSubtleCrypto;
984
+ }
985
+ //#endregion
986
+ //#region src/chrome-apis/PowerApiTools.d.ts
943
987
  interface PowerApiToolsOptions {
944
- requestKeepAwake?: boolean;
945
- releaseKeepAwake?: boolean;
946
- reportActivity?: boolean;
947
- }
948
- declare class PowerApiTools extends BaseApiTools {
949
- protected apiName: string;
950
- constructor(server: McpServer, options?: PowerApiToolsOptions);
951
- checkAvailability(): ApiAvailability;
952
- registerTools(): void;
953
- private registerRequestKeepAwake;
954
- private registerReleaseKeepAwake;
955
- private registerReportActivity;
956
- }
957
-
988
+ requestKeepAwake?: boolean;
989
+ releaseKeepAwake?: boolean;
990
+ reportActivity?: boolean;
991
+ }
992
+ declare class PowerApiTools extends BaseApiTools<PowerApiToolsOptions> {
993
+ protected apiName: string;
994
+ constructor(server: McpServer, options?: PowerApiToolsOptions);
995
+ checkAvailability(): ApiAvailability;
996
+ registerTools(): void;
997
+ private registerRequestKeepAwake;
998
+ private registerReleaseKeepAwake;
999
+ private registerReportActivity;
1000
+ }
1001
+ //#endregion
1002
+ //#region src/chrome-apis/PrintingApiTools.d.ts
958
1003
  interface PrintingApiToolsOptions {
959
- getPrinters?: boolean;
960
- getPrinterInfo?: boolean;
961
- submitJob?: boolean;
962
- cancelJob?: boolean;
963
- getJobStatus?: boolean;
964
- }
965
- declare class PrintingApiTools extends BaseApiTools {
966
- protected apiName: string;
967
- constructor(server: McpServer, options?: PrintingApiToolsOptions);
968
- checkAvailability(): ApiAvailability;
969
- registerTools(): void;
970
- private registerGetPrinters;
971
- private registerGetPrinterInfo;
972
- private registerSubmitJob;
973
- private registerCancelJob;
974
- private registerGetJobStatus;
975
- private getJobStatusDescription;
976
- }
977
-
1004
+ getPrinters?: boolean;
1005
+ getPrinterInfo?: boolean;
1006
+ submitJob?: boolean;
1007
+ cancelJob?: boolean;
1008
+ getJobStatus?: boolean;
1009
+ }
1010
+ declare class PrintingApiTools extends BaseApiTools<PrintingApiToolsOptions> {
1011
+ protected apiName: string;
1012
+ constructor(server: McpServer, options?: PrintingApiToolsOptions);
1013
+ checkAvailability(): ApiAvailability;
1014
+ registerTools(): void;
1015
+ private registerGetPrinters;
1016
+ private registerGetPrinterInfo;
1017
+ private registerSubmitJob;
1018
+ private registerCancelJob;
1019
+ private registerGetJobStatus;
1020
+ private getJobStatusDescription;
1021
+ }
1022
+ //#endregion
1023
+ //#region src/chrome-apis/PrintingMetricsApiTools.d.ts
978
1024
  interface PrintingMetricsApiToolsOptions {
979
- getPrintJobs?: boolean;
1025
+ getPrintJobs?: boolean;
980
1026
  }
981
- declare class PrintingMetricsApiTools extends BaseApiTools {
982
- protected apiName: string;
983
- constructor(server: McpServer, options?: PrintingMetricsApiToolsOptions);
984
- checkAvailability(): ApiAvailability;
985
- registerTools(): void;
986
- private registerGetPrintJobs;
1027
+ declare class PrintingMetricsApiTools extends BaseApiTools<PrintingMetricsApiToolsOptions> {
1028
+ protected apiName: string;
1029
+ constructor(server: McpServer, options?: PrintingMetricsApiToolsOptions);
1030
+ checkAvailability(): ApiAvailability;
1031
+ registerTools(): void;
1032
+ private registerGetPrintJobs;
987
1033
  }
988
-
1034
+ //#endregion
1035
+ //#region src/chrome-apis/ProxyApiTools.d.ts
989
1036
  interface ProxyApiToolsOptions {
990
- getProxySettings?: boolean;
991
- setProxySettings?: boolean;
992
- clearProxySettings?: boolean;
993
- }
994
- declare class ProxyApiTools extends BaseApiTools {
995
- protected apiName: string;
996
- constructor(server: McpServer, options?: ProxyApiToolsOptions);
997
- checkAvailability(): ApiAvailability;
998
- registerTools(): void;
999
- private registerGetProxySettings;
1000
- private registerSetProxySettings;
1001
- private registerClearProxySettings;
1002
- }
1003
-
1037
+ getProxySettings?: boolean;
1038
+ setProxySettings?: boolean;
1039
+ clearProxySettings?: boolean;
1040
+ }
1041
+ declare class ProxyApiTools extends BaseApiTools<ProxyApiToolsOptions> {
1042
+ protected apiName: string;
1043
+ constructor(server: McpServer, options?: ProxyApiToolsOptions);
1044
+ checkAvailability(): ApiAvailability;
1045
+ registerTools(): void;
1046
+ private registerGetProxySettings;
1047
+ private registerSetProxySettings;
1048
+ private registerClearProxySettings;
1049
+ }
1050
+ //#endregion
1051
+ //#region src/chrome-apis/ReadingListApiTools.d.ts
1004
1052
  interface ReadingListApiToolsOptions {
1005
- addEntry?: boolean;
1006
- query?: boolean;
1007
- removeEntry?: boolean;
1008
- updateEntry?: boolean;
1009
- }
1010
- declare class ReadingListApiTools extends BaseApiTools {
1011
- protected apiName: string;
1012
- constructor(server: McpServer, options?: ReadingListApiToolsOptions);
1013
- checkAvailability(): ApiAvailability;
1014
- registerTools(): void;
1015
- private registerAddEntry;
1016
- private registerQuery;
1017
- private registerRemoveEntry;
1018
- private registerUpdateEntry;
1019
- }
1020
-
1053
+ addEntry?: boolean;
1054
+ query?: boolean;
1055
+ removeEntry?: boolean;
1056
+ updateEntry?: boolean;
1057
+ }
1058
+ declare class ReadingListApiTools extends BaseApiTools<ReadingListApiToolsOptions> {
1059
+ protected apiName: string;
1060
+ constructor(server: McpServer, options?: ReadingListApiToolsOptions);
1061
+ checkAvailability(): ApiAvailability;
1062
+ registerTools(): void;
1063
+ private registerAddEntry;
1064
+ private registerQuery;
1065
+ private registerRemoveEntry;
1066
+ private registerUpdateEntry;
1067
+ }
1068
+ //#endregion
1069
+ //#region src/chrome-apis/RuntimeApiTools.d.ts
1021
1070
  interface RuntimeApiToolsOptions {
1022
- connect?: boolean;
1023
- connectNative?: boolean;
1024
- getContexts?: boolean;
1025
- getManifest?: boolean;
1026
- getPackageDirectoryEntry?: boolean;
1027
- getPlatformInfo?: boolean;
1028
- getURL?: boolean;
1029
- openOptionsPage?: boolean;
1030
- reload?: boolean;
1031
- requestUpdateCheck?: boolean;
1032
- restart?: boolean;
1033
- restartAfterDelay?: boolean;
1034
- sendMessage?: boolean;
1035
- sendNativeMessage?: boolean;
1036
- setUninstallURL?: boolean;
1037
- }
1038
- declare class RuntimeApiTools extends BaseApiTools {
1039
- protected apiName: string;
1040
- constructor(server: McpServer, options?: RuntimeApiToolsOptions);
1041
- checkAvailability(): ApiAvailability;
1042
- registerTools(): void;
1043
- private registerConnect;
1044
- private registerConnectNative;
1045
- private registerGetContexts;
1046
- private registerGetManifest;
1047
- private registerGetPackageDirectoryEntry;
1048
- private registerGetPlatformInfo;
1049
- private registerGetURL;
1050
- private registerOpenOptionsPage;
1051
- private registerReload;
1052
- private registerRequestUpdateCheck;
1053
- private registerRestart;
1054
- private registerRestartAfterDelay;
1055
- private registerSendMessage;
1056
- private registerSendNativeMessage;
1057
- private registerSetUninstallURL;
1058
- }
1059
-
1071
+ connect?: boolean;
1072
+ connectNative?: boolean;
1073
+ getContexts?: boolean;
1074
+ getManifest?: boolean;
1075
+ getPackageDirectoryEntry?: boolean;
1076
+ getPlatformInfo?: boolean;
1077
+ getURL?: boolean;
1078
+ openOptionsPage?: boolean;
1079
+ reload?: boolean;
1080
+ requestUpdateCheck?: boolean;
1081
+ restart?: boolean;
1082
+ restartAfterDelay?: boolean;
1083
+ sendMessage?: boolean;
1084
+ sendNativeMessage?: boolean;
1085
+ setUninstallURL?: boolean;
1086
+ }
1087
+ declare class RuntimeApiTools extends BaseApiTools<RuntimeApiToolsOptions> {
1088
+ protected apiName: string;
1089
+ constructor(server: McpServer, options?: RuntimeApiToolsOptions);
1090
+ checkAvailability(): ApiAvailability;
1091
+ registerTools(): void;
1092
+ private registerConnect;
1093
+ private registerConnectNative;
1094
+ private registerGetContexts;
1095
+ private registerGetManifest;
1096
+ private registerGetPackageDirectoryEntry;
1097
+ private registerGetPlatformInfo;
1098
+ private registerGetURL;
1099
+ private registerOpenOptionsPage;
1100
+ private registerReload;
1101
+ private registerRequestUpdateCheck;
1102
+ private registerRestart;
1103
+ private registerRestartAfterDelay;
1104
+ private registerSendMessage;
1105
+ private registerSendNativeMessage;
1106
+ private registerSetUninstallURL;
1107
+ }
1108
+ //#endregion
1109
+ //#region src/chrome-apis/ScriptingApiTools.d.ts
1060
1110
  interface ScriptingApiToolsOptions {
1061
- executeScript?: boolean;
1062
- executeUserScript?: boolean;
1063
- insertCSS?: boolean;
1064
- removeCSS?: boolean;
1065
- }
1066
- declare class ScriptingApiTools extends BaseApiTools {
1067
- protected apiName: string;
1068
- constructor(server: McpServer, options?: ScriptingApiToolsOptions);
1069
- checkAvailability(): ApiAvailability;
1070
- registerTools(): void;
1071
- private checkAndRegisterUserScripts;
1072
- private getChromeVersion;
1073
- private registerExecuteScript;
1074
- private registerUserScriptExecute;
1075
- private registerUserScriptLegacy;
1076
- private registerInsertCSS;
1077
- private registerRemoveCSS;
1078
- }
1079
-
1111
+ executeScript?: boolean;
1112
+ executeUserScript?: boolean;
1113
+ insertCSS?: boolean;
1114
+ removeCSS?: boolean;
1115
+ }
1116
+ declare class ScriptingApiTools extends BaseApiTools<ScriptingApiToolsOptions> {
1117
+ protected apiName: string;
1118
+ constructor(server: McpServer, options?: ScriptingApiToolsOptions);
1119
+ checkAvailability(): ApiAvailability;
1120
+ registerTools(): void;
1121
+ private checkAndRegisterUserScripts;
1122
+ private getChromeVersion;
1123
+ private registerExecuteScript;
1124
+ private registerUserScriptExecute;
1125
+ private registerUserScriptLegacy;
1126
+ private registerInsertCSS;
1127
+ private registerRemoveCSS;
1128
+ }
1129
+ //#endregion
1130
+ //#region src/chrome-apis/SearchApiTools.d.ts
1080
1131
  interface SearchApiToolsOptions {
1081
- query?: boolean;
1132
+ query?: boolean;
1082
1133
  }
1083
- declare class SearchApiTools extends BaseApiTools {
1084
- protected apiName: string;
1085
- constructor(server: McpServer, options?: SearchApiToolsOptions);
1086
- checkAvailability(): ApiAvailability;
1087
- registerTools(): void;
1088
- private registerQuery;
1134
+ declare class SearchApiTools extends BaseApiTools<SearchApiToolsOptions> {
1135
+ protected apiName: string;
1136
+ constructor(server: McpServer, options?: SearchApiToolsOptions);
1137
+ checkAvailability(): ApiAvailability;
1138
+ registerTools(): void;
1139
+ private registerQuery;
1089
1140
  }
1090
-
1141
+ //#endregion
1142
+ //#region src/chrome-apis/SessionsApiTools.d.ts
1091
1143
  interface SessionsApiToolsOptions {
1092
- getDevices?: boolean;
1093
- getRecentlyClosed?: boolean;
1094
- restore?: boolean;
1095
- }
1096
- declare class SessionsApiTools extends BaseApiTools {
1097
- protected apiName: string;
1098
- constructor(server: McpServer, options?: SessionsApiToolsOptions);
1099
- checkAvailability(): ApiAvailability;
1100
- registerTools(): void;
1101
- private registerGetDevices;
1102
- private registerGetRecentlyClosed;
1103
- private registerRestore;
1104
- }
1105
-
1144
+ getDevices?: boolean;
1145
+ getRecentlyClosed?: boolean;
1146
+ restore?: boolean;
1147
+ }
1148
+ declare class SessionsApiTools extends BaseApiTools<SessionsApiToolsOptions> {
1149
+ protected apiName: string;
1150
+ constructor(server: McpServer, options?: SessionsApiToolsOptions);
1151
+ checkAvailability(): ApiAvailability;
1152
+ registerTools(): void;
1153
+ private registerGetDevices;
1154
+ private registerGetRecentlyClosed;
1155
+ private registerRestore;
1156
+ }
1157
+ //#endregion
1158
+ //#region src/chrome-apis/SidePanelApiTools.d.ts
1106
1159
  interface SidePanelApiToolsOptions {
1107
- getOptions?: boolean;
1108
- setOptions?: boolean;
1109
- getPanelBehavior?: boolean;
1110
- setPanelBehavior?: boolean;
1111
- open?: boolean;
1112
- }
1113
- declare class SidePanelApiTools extends BaseApiTools {
1114
- protected apiName: string;
1115
- constructor(server: McpServer, options?: SidePanelApiToolsOptions);
1116
- checkAvailability(): ApiAvailability;
1117
- registerTools(): void;
1118
- private registerGetOptions;
1119
- private registerSetOptions;
1120
- private registerGetPanelBehavior;
1121
- private registerSetPanelBehavior;
1122
- private registerOpen;
1123
- }
1124
-
1160
+ getOptions?: boolean;
1161
+ setOptions?: boolean;
1162
+ getPanelBehavior?: boolean;
1163
+ setPanelBehavior?: boolean;
1164
+ open?: boolean;
1165
+ }
1166
+ declare class SidePanelApiTools extends BaseApiTools<SidePanelApiToolsOptions> {
1167
+ protected apiName: string;
1168
+ constructor(server: McpServer, options?: SidePanelApiToolsOptions);
1169
+ checkAvailability(): ApiAvailability;
1170
+ registerTools(): void;
1171
+ private registerGetOptions;
1172
+ private registerSetOptions;
1173
+ private registerGetPanelBehavior;
1174
+ private registerSetPanelBehavior;
1175
+ private registerOpen;
1176
+ }
1177
+ //#endregion
1178
+ //#region src/chrome-apis/StorageApiTools.d.ts
1125
1179
  interface StorageApiToolsOptions {
1126
- getStorage?: boolean;
1127
- setStorage?: boolean;
1128
- removeStorage?: boolean;
1129
- clearStorage?: boolean;
1130
- getBytesInUse?: boolean;
1180
+ getStorage?: boolean;
1181
+ setStorage?: boolean;
1182
+ removeStorage?: boolean;
1183
+ clearStorage?: boolean;
1184
+ getBytesInUse?: boolean;
1131
1185
  }
1132
1186
  declare const STORAGE_ACTIONS: readonly ["getStorage", "setStorage", "removeStorage", "clearStorage", "getBytesInUse"];
1133
- declare class StorageApiTools extends BaseApiTools {
1134
- protected apiName: string;
1135
- constructor(server: McpServer, options?: StorageApiToolsOptions);
1136
- checkAvailability(): ApiAvailability;
1137
- registerTools(): void;
1138
- private getAvailableAreas;
1139
- private handleGetStorage;
1140
- private handleSetStorage;
1141
- private handleRemoveStorage;
1142
- private handleClearStorage;
1143
- private handleGetBytesInUse;
1144
- private getStorageSchema;
1145
- private setStorageSchema;
1146
- private removeStorageSchema;
1147
- private clearStorageSchema;
1148
- private getBytesInUseSchema;
1149
- private formatBytes;
1150
- }
1151
-
1187
+ declare class StorageApiTools extends BaseApiTools<StorageApiToolsOptions> {
1188
+ protected apiName: string;
1189
+ constructor(server: McpServer, options?: StorageApiToolsOptions);
1190
+ checkAvailability(): ApiAvailability;
1191
+ registerTools(): void;
1192
+ private getAvailableAreas;
1193
+ private handleGetStorage;
1194
+ private handleSetStorage;
1195
+ private handleRemoveStorage;
1196
+ private handleClearStorage;
1197
+ private handleGetBytesInUse;
1198
+ private getStorageSchema;
1199
+ private setStorageSchema;
1200
+ private removeStorageSchema;
1201
+ private clearStorageSchema;
1202
+ private getBytesInUseSchema;
1203
+ private formatBytes;
1204
+ }
1205
+ //#endregion
1206
+ //#region src/chrome-apis/SystemCpuApiTools.d.ts
1152
1207
  interface SystemCpuApiToolsOptions {
1153
- getInfo?: boolean;
1208
+ getInfo?: boolean;
1154
1209
  }
1155
- declare class SystemCpuApiTools extends BaseApiTools {
1156
- protected apiName: string;
1157
- constructor(server: McpServer, options?: SystemCpuApiToolsOptions);
1158
- checkAvailability(): ApiAvailability;
1159
- registerTools(): void;
1160
- private registerGetInfo;
1210
+ declare class SystemCpuApiTools extends BaseApiTools<SystemCpuApiToolsOptions> {
1211
+ protected apiName: string;
1212
+ constructor(server: McpServer, options?: SystemCpuApiToolsOptions);
1213
+ checkAvailability(): ApiAvailability;
1214
+ registerTools(): void;
1215
+ private registerGetInfo;
1161
1216
  }
1162
-
1217
+ //#endregion
1218
+ //#region src/chrome-apis/SystemLogApiTools.d.ts
1163
1219
  interface SystemLogApiToolsOptions {
1164
- addLog?: boolean;
1220
+ addLog?: boolean;
1165
1221
  }
1166
- declare class SystemLogApiTools extends BaseApiTools {
1167
- protected apiName: string;
1168
- constructor(server: McpServer, options?: SystemLogApiToolsOptions);
1169
- checkAvailability(): ApiAvailability;
1170
- registerTools(): void;
1171
- private registerAddLog;
1222
+ declare class SystemLogApiTools extends BaseApiTools<SystemLogApiToolsOptions> {
1223
+ protected apiName: string;
1224
+ constructor(server: McpServer, options?: SystemLogApiToolsOptions);
1225
+ checkAvailability(): ApiAvailability;
1226
+ registerTools(): void;
1227
+ private registerAddLog;
1172
1228
  }
1173
-
1229
+ //#endregion
1230
+ //#region src/chrome-apis/SystemMemoryApiTools.d.ts
1174
1231
  interface SystemMemoryApiToolsOptions {
1175
- getInfo?: boolean;
1232
+ getInfo?: boolean;
1176
1233
  }
1177
- declare class SystemMemoryApiTools extends BaseApiTools {
1178
- protected apiName: string;
1179
- constructor(server: McpServer, options?: SystemMemoryApiToolsOptions);
1180
- checkAvailability(): ApiAvailability;
1181
- registerTools(): void;
1182
- private registerGetInfo;
1234
+ declare class SystemMemoryApiTools extends BaseApiTools<SystemMemoryApiToolsOptions> {
1235
+ protected apiName: string;
1236
+ constructor(server: McpServer, options?: SystemMemoryApiToolsOptions);
1237
+ checkAvailability(): ApiAvailability;
1238
+ registerTools(): void;
1239
+ private registerGetInfo;
1183
1240
  }
1184
-
1241
+ //#endregion
1242
+ //#region src/chrome-apis/SystemStorageApiTools.d.ts
1185
1243
  interface SystemStorageApiToolsOptions {
1186
- getInfo?: boolean;
1187
- ejectDevice?: boolean;
1188
- getAvailableCapacity?: boolean;
1189
- }
1190
- declare class SystemStorageApiTools extends BaseApiTools {
1191
- protected apiName: string;
1192
- constructor(server: McpServer, options?: SystemStorageApiToolsOptions);
1193
- checkAvailability(): ApiAvailability;
1194
- registerTools(): void;
1195
- private registerGetInfo;
1196
- private registerEjectDevice;
1197
- private registerGetAvailableCapacity;
1198
- private getEjectResultMessage;
1199
- private formatBytes;
1200
- }
1201
-
1244
+ getInfo?: boolean;
1245
+ ejectDevice?: boolean;
1246
+ getAvailableCapacity?: boolean;
1247
+ }
1248
+ declare class SystemStorageApiTools extends BaseApiTools<SystemStorageApiToolsOptions> {
1249
+ protected apiName: string;
1250
+ constructor(server: McpServer, options?: SystemStorageApiToolsOptions);
1251
+ checkAvailability(): ApiAvailability;
1252
+ registerTools(): void;
1253
+ private registerGetInfo;
1254
+ private registerEjectDevice;
1255
+ private registerGetAvailableCapacity;
1256
+ private getEjectResultMessage;
1257
+ private formatBytes;
1258
+ }
1259
+ //#endregion
1260
+ //#region src/chrome-apis/TabCaptureApiTools.d.ts
1202
1261
  interface TabCaptureApiToolsOptions {
1203
- capture?: boolean;
1204
- getCapturedTabs?: boolean;
1205
- getMediaStreamId?: boolean;
1206
- }
1207
- declare class TabCaptureApiTools extends BaseApiTools {
1208
- protected apiName: string;
1209
- constructor(server: McpServer, options?: TabCaptureApiToolsOptions);
1210
- checkAvailability(): ApiAvailability;
1211
- registerTools(): void;
1212
- private registerCapture;
1213
- private registerGetCapturedTabs;
1214
- private registerGetMediaStreamId;
1215
- }
1216
-
1262
+ capture?: boolean;
1263
+ getCapturedTabs?: boolean;
1264
+ getMediaStreamId?: boolean;
1265
+ }
1266
+ declare class TabCaptureApiTools extends BaseApiTools<TabCaptureApiToolsOptions> {
1267
+ protected apiName: string;
1268
+ constructor(server: McpServer, options?: TabCaptureApiToolsOptions);
1269
+ checkAvailability(): ApiAvailability;
1270
+ registerTools(): void;
1271
+ private registerCapture;
1272
+ private registerGetCapturedTabs;
1273
+ private registerGetMediaStreamId;
1274
+ }
1275
+ //#endregion
1276
+ //#region src/chrome-apis/TabGroupsApiTools.d.ts
1217
1277
  interface TabGroupsApiToolsOptions {
1218
- get?: boolean;
1219
- query?: boolean;
1220
- update?: boolean;
1221
- move?: boolean;
1278
+ get?: boolean;
1279
+ query?: boolean;
1280
+ update?: boolean;
1281
+ move?: boolean;
1222
1282
  }
1223
1283
  declare const TAB_GROUP_ACTIONS: readonly ["get", "query", "update", "move"];
1224
- declare class TabGroupsApiTools extends BaseApiTools {
1225
- protected apiName: string;
1226
- constructor(server: McpServer, options?: TabGroupsApiToolsOptions);
1227
- checkAvailability(): ApiAvailability;
1228
- registerTools(): void;
1229
- private handleGetTabGroup;
1230
- private handleQueryTabGroups;
1231
- private handleUpdateTabGroup;
1232
- private handleMoveTabGroup;
1233
- private getSchema;
1234
- private querySchema;
1235
- private updateSchema;
1236
- private moveSchema;
1237
- }
1238
-
1284
+ declare class TabGroupsApiTools extends BaseApiTools<TabGroupsApiToolsOptions> {
1285
+ protected apiName: string;
1286
+ constructor(server: McpServer, options?: TabGroupsApiToolsOptions);
1287
+ checkAvailability(): ApiAvailability;
1288
+ registerTools(): void;
1289
+ private handleGetTabGroup;
1290
+ private handleQueryTabGroups;
1291
+ private handleUpdateTabGroup;
1292
+ private handleMoveTabGroup;
1293
+ private getSchema;
1294
+ private querySchema;
1295
+ private updateSchema;
1296
+ private moveSchema;
1297
+ }
1298
+ //#endregion
1299
+ //#region src/chrome-apis/TabsApiTools.d.ts
1239
1300
  interface TabsApiToolsOptions {
1240
- listActiveTabs?: boolean;
1241
- createTab?: boolean;
1242
- updateTab?: boolean;
1243
- closeTabs?: boolean;
1244
- getAllTabs?: boolean;
1245
- navigateHistory?: boolean;
1246
- reloadTab?: boolean;
1247
- captureVisibleTab?: boolean;
1248
- detectLanguage?: boolean;
1249
- discardTab?: boolean;
1250
- duplicateTab?: boolean;
1251
- getTab?: boolean;
1252
- getZoom?: boolean;
1253
- setZoom?: boolean;
1254
- groupTabs?: boolean;
1255
- ungroupTabs?: boolean;
1256
- highlightTabs?: boolean;
1257
- moveTabs?: boolean;
1258
- sendMessage?: boolean;
1301
+ listActiveTabs?: boolean;
1302
+ createTab?: boolean;
1303
+ updateTab?: boolean;
1304
+ closeTabs?: boolean;
1305
+ getAllTabs?: boolean;
1306
+ navigateHistory?: boolean;
1307
+ reloadTab?: boolean;
1308
+ captureVisibleTab?: boolean;
1309
+ detectLanguage?: boolean;
1310
+ discardTab?: boolean;
1311
+ duplicateTab?: boolean;
1312
+ getTab?: boolean;
1313
+ getZoom?: boolean;
1314
+ setZoom?: boolean;
1315
+ groupTabs?: boolean;
1316
+ ungroupTabs?: boolean;
1317
+ highlightTabs?: boolean;
1318
+ moveTabs?: boolean;
1319
+ sendMessage?: boolean;
1259
1320
  }
1260
1321
  declare const TAB_ACTIONS: readonly ["listActiveTabs", "createTab", "updateTab", "closeTabs", "getAllTabs", "navigateHistory", "reloadTab", "captureVisibleTab", "detectLanguage", "discardTab", "duplicateTab", "getTab", "getZoom", "getZoomSettings", "setZoom", "setZoomSettings", "groupTabs", "ungroupTabs", "highlightTabs", "moveTabs", "sendMessage"];
1261
- declare class TabsApiTools extends BaseApiTools {
1262
- protected apiName: string;
1263
- constructor(server: McpServer, options?: TabsApiToolsOptions);
1264
- checkAvailability(): ApiAvailability;
1265
- registerTools(): void;
1266
- private handleListActiveTabs;
1267
- private handleCreateTab;
1268
- private handleUpdateTab;
1269
- private handleCloseTabs;
1270
- private handleGetAllTabs;
1271
- private handleNavigateHistory;
1272
- private handleReloadTab;
1273
- private handleCaptureVisibleTab;
1274
- private handleDetectLanguage;
1275
- private handleDiscardTab;
1276
- private handleDuplicateTab;
1277
- private handleGetTab;
1278
- private handleGetZoom;
1279
- private handleGetZoomSettings;
1280
- private handleSetZoom;
1281
- private handleSetZoomSettings;
1282
- private handleGroupTabs;
1283
- private handleUngroupTabs;
1284
- private handleHighlightTabs;
1285
- private handleMoveTabs;
1286
- private handleSendMessage;
1287
- private listActiveTabsSchema;
1288
- private createTabSchema;
1289
- private updateTabSchema;
1290
- private closeTabsSchema;
1291
- private getAllTabsSchema;
1292
- private navigateHistorySchema;
1293
- private reloadTabSchema;
1294
- private captureVisibleTabSchema;
1295
- private detectLanguageSchema;
1296
- private discardTabSchema;
1297
- private duplicateTabSchema;
1298
- private getTabSchema;
1299
- private getZoomSchema;
1300
- private getZoomSettingsSchema;
1301
- private setZoomSchema;
1302
- private setZoomSettingsSchema;
1303
- private groupTabsSchema;
1304
- private ungroupTabsSchema;
1305
- private highlightTabsSchema;
1306
- private moveTabsSchema;
1307
- private sendMessageSchema;
1308
- }
1309
-
1322
+ declare class TabsApiTools extends BaseApiTools<TabsApiToolsOptions> {
1323
+ protected apiName: string;
1324
+ constructor(server: McpServer, options?: TabsApiToolsOptions);
1325
+ checkAvailability(): ApiAvailability;
1326
+ registerTools(): void;
1327
+ private handleListActiveTabs;
1328
+ private handleCreateTab;
1329
+ private handleUpdateTab;
1330
+ private handleCloseTabs;
1331
+ private handleGetAllTabs;
1332
+ private handleNavigateHistory;
1333
+ private handleReloadTab;
1334
+ private handleCaptureVisibleTab;
1335
+ private handleDetectLanguage;
1336
+ private handleDiscardTab;
1337
+ private handleDuplicateTab;
1338
+ private handleGetTab;
1339
+ private handleGetZoom;
1340
+ private handleGetZoomSettings;
1341
+ private handleSetZoom;
1342
+ private handleSetZoomSettings;
1343
+ private handleGroupTabs;
1344
+ private handleUngroupTabs;
1345
+ private handleHighlightTabs;
1346
+ private handleMoveTabs;
1347
+ private handleSendMessage;
1348
+ private listActiveTabsSchema;
1349
+ private createTabSchema;
1350
+ private updateTabSchema;
1351
+ private closeTabsSchema;
1352
+ private getAllTabsSchema;
1353
+ private navigateHistorySchema;
1354
+ private reloadTabSchema;
1355
+ private captureVisibleTabSchema;
1356
+ private detectLanguageSchema;
1357
+ private discardTabSchema;
1358
+ private duplicateTabSchema;
1359
+ private getTabSchema;
1360
+ private getZoomSchema;
1361
+ private getZoomSettingsSchema;
1362
+ private setZoomSchema;
1363
+ private setZoomSettingsSchema;
1364
+ private groupTabsSchema;
1365
+ private ungroupTabsSchema;
1366
+ private highlightTabsSchema;
1367
+ private moveTabsSchema;
1368
+ private sendMessageSchema;
1369
+ }
1370
+ //#endregion
1371
+ //#region src/chrome-apis/TopSitesApiTools.d.ts
1310
1372
  interface TopSitesApiToolsOptions {
1311
- getTopSites?: boolean;
1373
+ getTopSites?: boolean;
1312
1374
  }
1313
- declare class TopSitesApiTools extends BaseApiTools {
1314
- protected apiName: string;
1315
- constructor(server: McpServer, options?: TopSitesApiToolsOptions);
1316
- checkAvailability(): ApiAvailability;
1317
- registerTools(): void;
1318
- private registerGetTopSites;
1375
+ declare class TopSitesApiTools extends BaseApiTools<TopSitesApiToolsOptions> {
1376
+ protected apiName: string;
1377
+ constructor(server: McpServer, options?: TopSitesApiToolsOptions);
1378
+ checkAvailability(): ApiAvailability;
1379
+ registerTools(): void;
1380
+ private registerGetTopSites;
1319
1381
  }
1320
-
1382
+ //#endregion
1383
+ //#region src/chrome-apis/TtsApiTools.d.ts
1321
1384
  interface TtsApiToolsOptions {
1322
- speak?: boolean;
1323
- stop?: boolean;
1324
- pause?: boolean;
1325
- resume?: boolean;
1326
- isSpeaking?: boolean;
1327
- getVoices?: boolean;
1328
- }
1329
- declare class TtsApiTools extends BaseApiTools {
1330
- protected apiName: string;
1331
- constructor(server: McpServer, options?: TtsApiToolsOptions);
1332
- checkAvailability(): ApiAvailability;
1333
- registerTools(): void;
1334
- private registerSpeak;
1335
- private registerStop;
1336
- private registerPause;
1337
- private registerResume;
1338
- private registerIsSpeaking;
1339
- private registerGetVoices;
1340
- }
1341
-
1385
+ speak?: boolean;
1386
+ stop?: boolean;
1387
+ pause?: boolean;
1388
+ resume?: boolean;
1389
+ isSpeaking?: boolean;
1390
+ getVoices?: boolean;
1391
+ }
1392
+ declare class TtsApiTools extends BaseApiTools<TtsApiToolsOptions> {
1393
+ protected apiName: string;
1394
+ constructor(server: McpServer, options?: TtsApiToolsOptions);
1395
+ checkAvailability(): ApiAvailability;
1396
+ registerTools(): void;
1397
+ private registerSpeak;
1398
+ private registerStop;
1399
+ private registerPause;
1400
+ private registerResume;
1401
+ private registerIsSpeaking;
1402
+ private registerGetVoices;
1403
+ }
1404
+ //#endregion
1405
+ //#region src/chrome-apis/TtsEngineApiTools.d.ts
1342
1406
  interface TtsEngineApiToolsOptions {
1343
- updateVoices?: boolean;
1344
- updateLanguage?: boolean;
1345
- onSpeak?: boolean;
1346
- onStop?: boolean;
1347
- onPause?: boolean;
1348
- onResume?: boolean;
1349
- onSpeakWithAudioStream?: boolean;
1350
- onInstallLanguageRequest?: boolean;
1351
- onLanguageStatusRequest?: boolean;
1352
- onUninstallLanguageRequest?: boolean;
1353
- }
1354
- declare class TtsEngineApiTools extends BaseApiTools {
1355
- protected apiName: string;
1356
- constructor(server: McpServer, options?: TtsEngineApiToolsOptions);
1357
- checkAvailability(): ApiAvailability;
1358
- registerTools(): void;
1359
- private registerUpdateVoices;
1360
- private registerUpdateLanguage;
1361
- private registerOnSpeak;
1362
- private registerOnStop;
1363
- private registerOnPause;
1364
- private registerOnResume;
1365
- private registerOnSpeakWithAudioStream;
1366
- private registerOnInstallLanguageRequest;
1367
- private registerOnLanguageStatusRequest;
1368
- private registerOnUninstallLanguageRequest;
1369
- }
1370
-
1407
+ updateVoices?: boolean;
1408
+ updateLanguage?: boolean;
1409
+ onSpeak?: boolean;
1410
+ onStop?: boolean;
1411
+ onPause?: boolean;
1412
+ onResume?: boolean;
1413
+ onSpeakWithAudioStream?: boolean;
1414
+ onInstallLanguageRequest?: boolean;
1415
+ onLanguageStatusRequest?: boolean;
1416
+ onUninstallLanguageRequest?: boolean;
1417
+ }
1418
+ declare class TtsEngineApiTools extends BaseApiTools<TtsEngineApiToolsOptions> {
1419
+ protected apiName: string;
1420
+ constructor(server: McpServer, options?: TtsEngineApiToolsOptions);
1421
+ checkAvailability(): ApiAvailability;
1422
+ registerTools(): void;
1423
+ private registerUpdateVoices;
1424
+ private registerUpdateLanguage;
1425
+ private registerOnSpeak;
1426
+ private registerOnStop;
1427
+ private registerOnPause;
1428
+ private registerOnResume;
1429
+ private registerOnSpeakWithAudioStream;
1430
+ private registerOnInstallLanguageRequest;
1431
+ private registerOnLanguageStatusRequest;
1432
+ private registerOnUninstallLanguageRequest;
1433
+ }
1434
+ //#endregion
1435
+ //#region src/chrome-apis/UserScriptsApiTools.d.ts
1371
1436
  interface UserScriptsApiToolsOptions {
1372
- register?: boolean;
1373
- getScripts?: boolean;
1374
- update?: boolean;
1375
- unregister?: boolean;
1376
- configureWorld?: boolean;
1377
- getWorldConfigurations?: boolean;
1378
- resetWorldConfiguration?: boolean;
1379
- execute?: boolean;
1380
- }
1381
- declare class UserScriptsApiTools extends BaseApiTools {
1382
- protected apiName: string;
1383
- constructor(server: McpServer, options?: UserScriptsApiToolsOptions);
1384
- checkAvailability(): ApiAvailability;
1385
- registerTools(): void;
1386
- private registerRegister;
1387
- private registerGetScripts;
1388
- private registerUpdate;
1389
- private registerUnregister;
1390
- private registerConfigureWorld;
1391
- private registerGetWorldConfigurations;
1392
- private registerResetWorldConfiguration;
1393
- private registerExecute;
1394
- }
1395
-
1437
+ register?: boolean;
1438
+ getScripts?: boolean;
1439
+ update?: boolean;
1440
+ unregister?: boolean;
1441
+ configureWorld?: boolean;
1442
+ getWorldConfigurations?: boolean;
1443
+ resetWorldConfiguration?: boolean;
1444
+ execute?: boolean;
1445
+ }
1446
+ declare class UserScriptsApiTools extends BaseApiTools<UserScriptsApiToolsOptions> {
1447
+ protected apiName: string;
1448
+ constructor(server: McpServer, options?: UserScriptsApiToolsOptions);
1449
+ checkAvailability(): ApiAvailability;
1450
+ registerTools(): void;
1451
+ private registerRegister;
1452
+ private registerGetScripts;
1453
+ private registerUpdate;
1454
+ private registerUnregister;
1455
+ private registerConfigureWorld;
1456
+ private registerGetWorldConfigurations;
1457
+ private registerResetWorldConfiguration;
1458
+ private registerExecute;
1459
+ }
1460
+ //#endregion
1461
+ //#region src/chrome-apis/VpnProviderApiTools.d.ts
1396
1462
  interface VpnProviderApiToolsOptions {
1397
- createConfig?: boolean;
1398
- destroyConfig?: boolean;
1399
- setParameters?: boolean;
1400
- notifyConnectionStateChanged?: boolean;
1401
- sendPacket?: boolean;
1402
- }
1403
- declare class VpnProviderApiTools extends BaseApiTools {
1404
- protected apiName: string;
1405
- constructor(server: McpServer, options?: VpnProviderApiToolsOptions);
1406
- checkAvailability(): ApiAvailability;
1407
- registerTools(): void;
1408
- private registerCreateConfig;
1409
- private registerDestroyConfig;
1410
- private registerSetParameters;
1411
- private registerNotifyConnectionStateChanged;
1412
- private registerSendPacket;
1413
- }
1414
-
1463
+ createConfig?: boolean;
1464
+ destroyConfig?: boolean;
1465
+ setParameters?: boolean;
1466
+ notifyConnectionStateChanged?: boolean;
1467
+ sendPacket?: boolean;
1468
+ }
1469
+ declare class VpnProviderApiTools extends BaseApiTools<VpnProviderApiToolsOptions> {
1470
+ protected apiName: string;
1471
+ constructor(server: McpServer, options?: VpnProviderApiToolsOptions);
1472
+ checkAvailability(): ApiAvailability;
1473
+ registerTools(): void;
1474
+ private registerCreateConfig;
1475
+ private registerDestroyConfig;
1476
+ private registerSetParameters;
1477
+ private registerNotifyConnectionStateChanged;
1478
+ private registerSendPacket;
1479
+ }
1480
+ //#endregion
1481
+ //#region src/chrome-apis/WallpaperApiTools.d.ts
1415
1482
  interface WallpaperApiToolsOptions {
1416
- setWallpaper?: boolean;
1483
+ setWallpaper?: boolean;
1417
1484
  }
1418
- declare class WallpaperApiTools extends BaseApiTools {
1419
- protected apiName: string;
1420
- constructor(server: McpServer, options?: WallpaperApiToolsOptions);
1421
- checkAvailability(): ApiAvailability;
1422
- registerTools(): void;
1423
- private registerSetWallpaper;
1485
+ declare class WallpaperApiTools extends BaseApiTools<WallpaperApiToolsOptions> {
1486
+ protected apiName: string;
1487
+ constructor(server: McpServer, options?: WallpaperApiToolsOptions);
1488
+ checkAvailability(): ApiAvailability;
1489
+ registerTools(): void;
1490
+ private registerSetWallpaper;
1424
1491
  }
1425
-
1492
+ //#endregion
1493
+ //#region src/chrome-apis/WebAuthenticationProxyApiTools.d.ts
1426
1494
  interface WebAuthenticationProxyApiToolsOptions {
1427
- attach?: boolean;
1428
- detach?: boolean;
1429
- completeCreateRequest?: boolean;
1430
- completeGetRequest?: boolean;
1431
- completeIsUvpaaRequest?: boolean;
1432
- onCreateRequest?: boolean;
1433
- onGetRequest?: boolean;
1434
- onIsUvpaaRequest?: boolean;
1435
- onRemoteSessionStateChange?: boolean;
1436
- onRequestCanceled?: boolean;
1437
- }
1438
- declare class WebAuthenticationProxyApiTools extends BaseApiTools {
1439
- protected apiName: string;
1440
- constructor(server: McpServer, options?: WebAuthenticationProxyApiToolsOptions);
1441
- checkAvailability(): ApiAvailability;
1442
- registerTools(): void;
1443
- private registerAttach;
1444
- private registerDetach;
1445
- private registerCompleteCreateRequest;
1446
- private registerCompleteGetRequest;
1447
- private registerCompleteIsUvpaaRequest;
1448
- private registerOnCreateRequest;
1449
- private registerOnGetRequest;
1450
- private registerOnIsUvpaaRequest;
1451
- private registerOnRemoteSessionStateChange;
1452
- private registerOnRequestCanceled;
1453
- }
1454
-
1495
+ attach?: boolean;
1496
+ detach?: boolean;
1497
+ completeCreateRequest?: boolean;
1498
+ completeGetRequest?: boolean;
1499
+ completeIsUvpaaRequest?: boolean;
1500
+ onCreateRequest?: boolean;
1501
+ onGetRequest?: boolean;
1502
+ onIsUvpaaRequest?: boolean;
1503
+ onRemoteSessionStateChange?: boolean;
1504
+ onRequestCanceled?: boolean;
1505
+ }
1506
+ declare class WebAuthenticationProxyApiTools extends BaseApiTools<WebAuthenticationProxyApiToolsOptions> {
1507
+ protected apiName: string;
1508
+ constructor(server: McpServer, options?: WebAuthenticationProxyApiToolsOptions);
1509
+ checkAvailability(): ApiAvailability;
1510
+ registerTools(): void;
1511
+ private registerAttach;
1512
+ private registerDetach;
1513
+ private registerCompleteCreateRequest;
1514
+ private registerCompleteGetRequest;
1515
+ private registerCompleteIsUvpaaRequest;
1516
+ private registerOnCreateRequest;
1517
+ private registerOnGetRequest;
1518
+ private registerOnIsUvpaaRequest;
1519
+ private registerOnRemoteSessionStateChange;
1520
+ private registerOnRequestCanceled;
1521
+ }
1522
+ //#endregion
1523
+ //#region src/chrome-apis/WebNavigationApiTools.d.ts
1455
1524
  interface WebNavigationApiToolsOptions {
1456
- getAllFrames?: boolean;
1457
- getFrame?: boolean;
1458
- onBeforeNavigate?: boolean;
1459
- onCommitted?: boolean;
1460
- onCompleted?: boolean;
1461
- onCreatedNavigationTarget?: boolean;
1462
- onDOMContentLoaded?: boolean;
1463
- onErrorOccurred?: boolean;
1464
- onHistoryStateUpdated?: boolean;
1465
- onReferenceFragmentUpdated?: boolean;
1466
- onTabReplaced?: boolean;
1467
- }
1468
- declare class WebNavigationApiTools extends BaseApiTools {
1469
- protected apiName: string;
1470
- constructor(server: McpServer, options?: WebNavigationApiToolsOptions);
1471
- checkAvailability(): ApiAvailability;
1472
- registerTools(): void;
1473
- private registerGetAllFrames;
1474
- private registerGetFrame;
1475
- private registerOnBeforeNavigate;
1476
- private registerOnCommitted;
1477
- private registerOnCompleted;
1478
- private registerOnCreatedNavigationTarget;
1479
- private registerOnDOMContentLoaded;
1480
- private registerOnErrorOccurred;
1481
- private registerOnHistoryStateUpdated;
1482
- private registerOnReferenceFragmentUpdated;
1483
- private registerOnTabReplaced;
1484
- }
1485
-
1525
+ getAllFrames?: boolean;
1526
+ getFrame?: boolean;
1527
+ onBeforeNavigate?: boolean;
1528
+ onCommitted?: boolean;
1529
+ onCompleted?: boolean;
1530
+ onCreatedNavigationTarget?: boolean;
1531
+ onDOMContentLoaded?: boolean;
1532
+ onErrorOccurred?: boolean;
1533
+ onHistoryStateUpdated?: boolean;
1534
+ onReferenceFragmentUpdated?: boolean;
1535
+ onTabReplaced?: boolean;
1536
+ }
1537
+ declare class WebNavigationApiTools extends BaseApiTools<WebNavigationApiToolsOptions> {
1538
+ protected apiName: string;
1539
+ constructor(server: McpServer, options?: WebNavigationApiToolsOptions);
1540
+ checkAvailability(): ApiAvailability;
1541
+ registerTools(): void;
1542
+ private registerGetAllFrames;
1543
+ private registerGetFrame;
1544
+ private registerOnBeforeNavigate;
1545
+ private registerOnCommitted;
1546
+ private registerOnCompleted;
1547
+ private registerOnCreatedNavigationTarget;
1548
+ private registerOnDOMContentLoaded;
1549
+ private registerOnErrorOccurred;
1550
+ private registerOnHistoryStateUpdated;
1551
+ private registerOnReferenceFragmentUpdated;
1552
+ private registerOnTabReplaced;
1553
+ }
1554
+ //#endregion
1555
+ //#region src/chrome-apis/WebRequestApiTools.d.ts
1486
1556
  interface WebRequestApiToolsOptions {
1487
- addListener?: boolean;
1488
- removeListener?: boolean;
1489
- hasListener?: boolean;
1490
- handlerBehaviorChanged?: boolean;
1491
- getActiveListeners?: boolean;
1492
- }
1493
- declare class WebRequestApiTools extends BaseApiTools {
1494
- protected apiName: string;
1495
- constructor(server: McpServer, options?: WebRequestApiToolsOptions);
1496
- checkAvailability(): ApiAvailability;
1497
- registerTools(): void;
1498
- private registerAddListener;
1499
- private registerRemoveListener;
1500
- private registerHasListener;
1501
- private registerHandlerBehaviorChanged;
1502
- private registerGetActiveListeners;
1503
- }
1504
-
1557
+ addListener?: boolean;
1558
+ removeListener?: boolean;
1559
+ hasListener?: boolean;
1560
+ handlerBehaviorChanged?: boolean;
1561
+ getActiveListeners?: boolean;
1562
+ }
1563
+ declare class WebRequestApiTools extends BaseApiTools<WebRequestApiToolsOptions> {
1564
+ protected apiName: string;
1565
+ constructor(server: McpServer, options?: WebRequestApiToolsOptions);
1566
+ checkAvailability(): ApiAvailability;
1567
+ registerTools(): void;
1568
+ private registerAddListener;
1569
+ private registerRemoveListener;
1570
+ private registerHasListener;
1571
+ private registerHandlerBehaviorChanged;
1572
+ private registerGetActiveListeners;
1573
+ }
1574
+ //#endregion
1575
+ //#region src/chrome-apis/WindowsApiTools.d.ts
1505
1576
  interface WindowsApiToolsOptions {
1506
- create?: boolean;
1507
- get?: boolean;
1508
- getAll?: boolean;
1509
- getCurrent?: boolean;
1510
- getLastFocused?: boolean;
1511
- remove?: boolean;
1512
- update?: boolean;
1577
+ create?: boolean;
1578
+ get?: boolean;
1579
+ getAll?: boolean;
1580
+ getCurrent?: boolean;
1581
+ getLastFocused?: boolean;
1582
+ remove?: boolean;
1583
+ update?: boolean;
1513
1584
  }
1514
1585
  declare const WINDOW_ACTIONS: readonly ["create", "get", "getAll", "getCurrent", "getLastFocused", "remove", "update"];
1515
- declare class WindowsApiTools extends BaseApiTools {
1516
- protected apiName: string;
1517
- constructor(server: McpServer, options?: WindowsApiToolsOptions);
1518
- checkAvailability(): ApiAvailability;
1519
- registerTools(): void;
1520
- private createSchema;
1521
- private getSchema;
1522
- private getAllSchema;
1523
- private getCurrentSchema;
1524
- private getLastFocusedSchema;
1525
- private removeSchema;
1526
- private updateSchema;
1527
- private handleCreate;
1528
- private handleGet;
1529
- private handleGetAll;
1530
- private handleGetCurrent;
1531
- private handleGetLastFocused;
1532
- private handleRemove;
1533
- private handleUpdate;
1534
- }
1535
-
1586
+ declare class WindowsApiTools extends BaseApiTools<WindowsApiToolsOptions> {
1587
+ protected apiName: string;
1588
+ constructor(server: McpServer, options?: WindowsApiToolsOptions);
1589
+ checkAvailability(): ApiAvailability;
1590
+ registerTools(): void;
1591
+ private createSchema;
1592
+ private getSchema;
1593
+ private getAllSchema;
1594
+ private getCurrentSchema;
1595
+ private getLastFocusedSchema;
1596
+ private removeSchema;
1597
+ private updateSchema;
1598
+ private handleCreate;
1599
+ private handleGet;
1600
+ private handleGetAll;
1601
+ private handleGetCurrent;
1602
+ private handleGetLastFocused;
1603
+ private handleRemove;
1604
+ private handleUpdate;
1605
+ }
1606
+ //#endregion
1607
+ //#region src/chromeApiRegistry.d.ts
1536
1608
  /**
1537
1609
  * Enum of all Chrome Extension APIs
1538
1610
  */
1539
1611
  declare enum ChromeApi {
1540
- ACCESSIBILITY_FEATURES = "accessibilityFeatures",
1541
- ACTION = "action",
1542
- ALARMS = "alarms",
1543
- AUDIO = "audio",
1544
- BOOKMARKS = "bookmarks",
1545
- BROWSING_DATA = "browsingData",
1546
- CERTIFICATE_PROVIDER = "certificateProvider",
1547
- COMMANDS = "commands",
1548
- CONTENT_SETTINGS = "contentSettings",
1549
- CONTEXT_MENUS = "contextMenus",
1550
- COOKIES = "cookies",
1551
- DEBUGGER = "debugger",
1552
- DECLARATIVE_CONTENT = "declarativeContent",
1553
- DECLARATIVE_NET_REQUEST = "declarativeNetRequest",
1554
- DESKTOP_CAPTURE = "desktopCapture",
1555
- DEVTOOLS_INSPECTED_WINDOW = "devtools.inspectedWindow",
1556
- DEVTOOLS_NETWORK = "devtools.network",
1557
- DEVTOOLS_PANELS = "devtools.panels",
1558
- DEVTOOLS_PERFORMANCE = "devtools.performance",
1559
- DEVTOOLS_RECORDER = "devtools.recorder",
1560
- DNS = "dns",
1561
- DOCUMENT_SCAN = "documentScan",
1562
- DOM = "dom",
1563
- DOWNLOADS = "downloads",
1564
- ENTERPRISE_DEVICE_ATTRIBUTES = "enterprise.deviceAttributes",
1565
- ENTERPRISE_HARDWARE_PLATFORM = "enterprise.hardwarePlatform",
1566
- ENTERPRISE_NETWORKING_ATTRIBUTES = "enterprise.networkingAttributes",
1567
- ENTERPRISE_PLATFORM_KEYS = "enterprise.platformKeys",
1568
- EVENTS = "events",
1569
- EXTENSION = "extension",
1570
- EXTENSION_TYPES = "extensionTypes",
1571
- FILE_BROWSER_HANDLER = "fileBrowserHandler",
1572
- FILE_SYSTEM_PROVIDER = "fileSystemProvider",
1573
- FONT_SETTINGS = "fontSettings",
1574
- GCM = "gcm",
1575
- HISTORY = "history",
1576
- I18N = "i18n",
1577
- IDENTITY = "identity",
1578
- IDLE = "idle",
1579
- INPUT_IME = "input.ime",
1580
- INSTANCE_ID = "instanceID",
1581
- LOGIN_STATE = "loginState",
1582
- MANAGEMENT = "management",
1583
- NOTIFICATIONS = "notifications",
1584
- OFFSCREEN = "offscreen",
1585
- OMNIBOX = "omnibox",
1586
- PAGE_CAPTURE = "pageCapture",
1587
- PERMISSIONS = "permissions",
1588
- PLATFORM_KEYS = "platformKeys",
1589
- POWER = "power",
1590
- PRINTER_PROVIDER = "printerProvider",
1591
- PRINTING = "printing",
1592
- PRINTING_METRICS = "printingMetrics",
1593
- PRIVACY = "privacy",
1594
- PROCESSES = "processes",
1595
- PROXY = "proxy",
1596
- READING_LIST = "readingList",
1597
- RUNTIME = "runtime",
1598
- SCRIPTING = "scripting",
1599
- SEARCH = "search",
1600
- SESSIONS = "sessions",
1601
- SIDE_PANEL = "sidePanel",
1602
- STORAGE = "storage",
1603
- SYSTEM_CPU = "system.cpu",
1604
- SYSTEM_DISPLAY = "system.display",
1605
- SYSTEM_MEMORY = "system.memory",
1606
- SYSTEM_STORAGE = "system.storage",
1607
- SYSTEM_LOG = "systemLog",
1608
- TAB_CAPTURE = "tabCapture",
1609
- TAB_GROUPS = "tabGroups",
1610
- TABS = "tabs",
1611
- TOP_SITES = "topSites",
1612
- TTS = "tts",
1613
- TTS_ENGINE = "ttsEngine",
1614
- TYPES = "types",
1615
- USER_SCRIPTS = "userScripts",
1616
- VPN_PROVIDER = "vpnProvider",
1617
- WALLPAPER = "wallpaper",
1618
- WEB_AUTHENTICATION_PROXY = "webAuthenticationProxy",
1619
- WEB_NAVIGATION = "webNavigation",
1620
- WEB_REQUEST = "webRequest",
1621
- WINDOWS = "windows"
1612
+ ACCESSIBILITY_FEATURES = "accessibilityFeatures",
1613
+ ACTION = "action",
1614
+ ALARMS = "alarms",
1615
+ AUDIO = "audio",
1616
+ BOOKMARKS = "bookmarks",
1617
+ BROWSING_DATA = "browsingData",
1618
+ CERTIFICATE_PROVIDER = "certificateProvider",
1619
+ COMMANDS = "commands",
1620
+ CONTENT_SETTINGS = "contentSettings",
1621
+ CONTEXT_MENUS = "contextMenus",
1622
+ COOKIES = "cookies",
1623
+ DEBUGGER = "debugger",
1624
+ DECLARATIVE_CONTENT = "declarativeContent",
1625
+ DECLARATIVE_NET_REQUEST = "declarativeNetRequest",
1626
+ DESKTOP_CAPTURE = "desktopCapture",
1627
+ DEVTOOLS_INSPECTED_WINDOW = "devtools.inspectedWindow",
1628
+ DEVTOOLS_NETWORK = "devtools.network",
1629
+ DEVTOOLS_PANELS = "devtools.panels",
1630
+ DEVTOOLS_PERFORMANCE = "devtools.performance",
1631
+ DEVTOOLS_RECORDER = "devtools.recorder",
1632
+ DNS = "dns",
1633
+ DOCUMENT_SCAN = "documentScan",
1634
+ DOM = "dom",
1635
+ DOWNLOADS = "downloads",
1636
+ ENTERPRISE_DEVICE_ATTRIBUTES = "enterprise.deviceAttributes",
1637
+ ENTERPRISE_HARDWARE_PLATFORM = "enterprise.hardwarePlatform",
1638
+ ENTERPRISE_NETWORKING_ATTRIBUTES = "enterprise.networkingAttributes",
1639
+ ENTERPRISE_PLATFORM_KEYS = "enterprise.platformKeys",
1640
+ EVENTS = "events",
1641
+ EXTENSION = "extension",
1642
+ EXTENSION_TYPES = "extensionTypes",
1643
+ FILE_BROWSER_HANDLER = "fileBrowserHandler",
1644
+ FILE_SYSTEM_PROVIDER = "fileSystemProvider",
1645
+ FONT_SETTINGS = "fontSettings",
1646
+ GCM = "gcm",
1647
+ HISTORY = "history",
1648
+ I18N = "i18n",
1649
+ IDENTITY = "identity",
1650
+ IDLE = "idle",
1651
+ INPUT_IME = "input.ime",
1652
+ INSTANCE_ID = "instanceID",
1653
+ LOGIN_STATE = "loginState",
1654
+ MANAGEMENT = "management",
1655
+ NOTIFICATIONS = "notifications",
1656
+ OFFSCREEN = "offscreen",
1657
+ OMNIBOX = "omnibox",
1658
+ PAGE_CAPTURE = "pageCapture",
1659
+ PERMISSIONS = "permissions",
1660
+ PLATFORM_KEYS = "platformKeys",
1661
+ POWER = "power",
1662
+ PRINTER_PROVIDER = "printerProvider",
1663
+ PRINTING = "printing",
1664
+ PRINTING_METRICS = "printingMetrics",
1665
+ PRIVACY = "privacy",
1666
+ PROCESSES = "processes",
1667
+ PROXY = "proxy",
1668
+ READING_LIST = "readingList",
1669
+ RUNTIME = "runtime",
1670
+ SCRIPTING = "scripting",
1671
+ SEARCH = "search",
1672
+ SMART_DOM_READER = "smartDomReader",
1673
+ SESSIONS = "sessions",
1674
+ SIDE_PANEL = "sidePanel",
1675
+ STORAGE = "storage",
1676
+ SYSTEM_CPU = "system.cpu",
1677
+ SYSTEM_DISPLAY = "system.display",
1678
+ SYSTEM_MEMORY = "system.memory",
1679
+ SYSTEM_STORAGE = "system.storage",
1680
+ SYSTEM_LOG = "systemLog",
1681
+ TAB_CAPTURE = "tabCapture",
1682
+ TAB_GROUPS = "tabGroups",
1683
+ TABS = "tabs",
1684
+ TOP_SITES = "topSites",
1685
+ TTS = "tts",
1686
+ TTS_ENGINE = "ttsEngine",
1687
+ TYPES = "types",
1688
+ USER_SCRIPTS = "userScripts",
1689
+ VPN_PROVIDER = "vpnProvider",
1690
+ WALLPAPER = "wallpaper",
1691
+ WEB_AUTHENTICATION_PROXY = "webAuthenticationProxy",
1692
+ WEB_NAVIGATION = "webNavigation",
1693
+ WEB_REQUEST = "webRequest",
1694
+ WINDOWS = "windows",
1622
1695
  }
1623
1696
  /**
1624
1697
  * Supported platforms for Chrome APIs
@@ -1639,812 +1712,822 @@ type ChromeContext = z.infer<typeof ChromeContextSchema>;
1639
1712
  * Metadata for each Chrome API
1640
1713
  */
1641
1714
  declare const ChromeApiMetadataSchema: z.ZodObject<{
1642
- /** Minimum Chrome version required */
1643
- minChromeVersion: z.ZodOptional<z.ZodNumber>;
1644
- /** Platform restrictions */
1645
- platform: z.ZodEnum<["all", "chromeos"]>;
1646
- /** Channel requirement */
1647
- channel: z.ZodEnum<["stable", "dev"]>;
1648
- /** Manifest version requirement (2, 3, or both) */
1649
- manifestVersions: z.ZodArray<z.ZodUnion<[z.ZodLiteral<2>, z.ZodLiteral<3>]>, "many">;
1650
- /** Whether this API requires enterprise policy */
1651
- requiresPolicy: z.ZodBoolean;
1652
- /** Whether this API is foreground only */
1653
- foregroundOnly: z.ZodBoolean;
1654
- /** Contexts where this API can run */
1655
- contexts: z.ZodArray<z.ZodEnum<["background", "content", "devtools", "all"]>, "many">;
1656
- /** API namespace in chrome object */
1657
- namespace: z.ZodString;
1715
+ /** Minimum Chrome version required */
1716
+ minChromeVersion: z.ZodOptional<z.ZodNumber>;
1717
+ /** Platform restrictions */
1718
+ platform: z.ZodEnum<["all", "chromeos"]>;
1719
+ /** Channel requirement */
1720
+ channel: z.ZodEnum<["stable", "dev"]>;
1721
+ /** Manifest version requirement (2, 3, or both) */
1722
+ manifestVersions: z.ZodArray<z.ZodUnion<[z.ZodLiteral<2>, z.ZodLiteral<3>]>, "many">;
1723
+ /** Whether this API requires enterprise policy */
1724
+ requiresPolicy: z.ZodBoolean;
1725
+ /** Whether this API is foreground only */
1726
+ foregroundOnly: z.ZodBoolean;
1727
+ /** Contexts where this API can run */
1728
+ contexts: z.ZodArray<z.ZodEnum<["background", "content", "devtools", "all"]>, "many">;
1729
+ /** API namespace in chrome object */
1730
+ namespace: z.ZodString;
1658
1731
  }, "strip", z.ZodTypeAny, {
1659
- contexts: ("content" | "all" | "background" | "devtools")[];
1660
- platform: "all" | "chromeos";
1661
- channel: "stable" | "dev";
1662
- manifestVersions: (2 | 3)[];
1663
- requiresPolicy: boolean;
1664
- foregroundOnly: boolean;
1665
- namespace: string;
1666
- minChromeVersion?: number | undefined;
1732
+ platform: "all" | "chromeos";
1733
+ channel: "stable" | "dev";
1734
+ manifestVersions: (2 | 3)[];
1735
+ requiresPolicy: boolean;
1736
+ foregroundOnly: boolean;
1737
+ contexts: ("all" | "background" | "content" | "devtools")[];
1738
+ namespace: string;
1739
+ minChromeVersion?: number | undefined;
1667
1740
  }, {
1668
- contexts: ("content" | "all" | "background" | "devtools")[];
1669
- platform: "all" | "chromeos";
1670
- channel: "stable" | "dev";
1671
- manifestVersions: (2 | 3)[];
1672
- requiresPolicy: boolean;
1673
- foregroundOnly: boolean;
1674
- namespace: string;
1675
- minChromeVersion?: number | undefined;
1741
+ platform: "all" | "chromeos";
1742
+ channel: "stable" | "dev";
1743
+ manifestVersions: (2 | 3)[];
1744
+ requiresPolicy: boolean;
1745
+ foregroundOnly: boolean;
1746
+ contexts: ("all" | "background" | "content" | "devtools")[];
1747
+ namespace: string;
1748
+ minChromeVersion?: number | undefined;
1676
1749
  }>;
1677
1750
  type ChromeApiMetadata = z.infer<typeof ChromeApiMetadataSchema>;
1678
1751
  /**
1679
1752
  * Registry of all Chrome APIs with their metadata
1680
1753
  */
1681
1754
  declare const CHROME_API_REGISTRY: {
1682
- readonly accessibilityFeatures: {
1683
- readonly platform: "all";
1684
- readonly channel: "stable";
1685
- readonly manifestVersions: [2, 3];
1686
- readonly requiresPolicy: false;
1687
- readonly foregroundOnly: false;
1688
- readonly contexts: ["background"];
1689
- readonly namespace: "accessibilityFeatures";
1690
- };
1691
- readonly action: {
1692
- readonly minChromeVersion: 88;
1693
- readonly platform: "all";
1694
- readonly channel: "stable";
1695
- readonly manifestVersions: [3];
1696
- readonly requiresPolicy: false;
1697
- readonly foregroundOnly: false;
1698
- readonly contexts: ["background"];
1699
- readonly namespace: "action";
1700
- };
1701
- readonly alarms: {
1702
- readonly platform: "all";
1703
- readonly channel: "stable";
1704
- readonly manifestVersions: [2, 3];
1705
- readonly requiresPolicy: false;
1706
- readonly foregroundOnly: false;
1707
- readonly contexts: ["background"];
1708
- readonly namespace: "alarms";
1709
- };
1710
- readonly audio: {
1711
- readonly minChromeVersion: 59;
1712
- readonly platform: "chromeos";
1713
- readonly channel: "stable";
1714
- readonly manifestVersions: [2, 3];
1715
- readonly requiresPolicy: false;
1716
- readonly foregroundOnly: false;
1717
- readonly contexts: ["background"];
1718
- readonly namespace: "audio";
1719
- };
1720
- readonly bookmarks: {
1721
- readonly platform: "all";
1722
- readonly channel: "stable";
1723
- readonly manifestVersions: [2, 3];
1724
- readonly requiresPolicy: false;
1725
- readonly foregroundOnly: false;
1726
- readonly contexts: ["background", "content"];
1727
- readonly namespace: "bookmarks";
1728
- };
1729
- readonly browsingData: {
1730
- readonly platform: "all";
1731
- readonly channel: "stable";
1732
- readonly manifestVersions: [2, 3];
1733
- readonly requiresPolicy: false;
1734
- readonly foregroundOnly: false;
1735
- readonly contexts: ["background"];
1736
- readonly namespace: "browsingData";
1737
- };
1738
- readonly certificateProvider: {
1739
- readonly minChromeVersion: 46;
1740
- readonly platform: "chromeos";
1741
- readonly channel: "stable";
1742
- readonly manifestVersions: [2, 3];
1743
- readonly requiresPolicy: false;
1744
- readonly foregroundOnly: false;
1745
- readonly contexts: ["background"];
1746
- readonly namespace: "certificateProvider";
1747
- };
1748
- readonly commands: {
1749
- readonly platform: "all";
1750
- readonly channel: "stable";
1751
- readonly manifestVersions: [2, 3];
1752
- readonly requiresPolicy: false;
1753
- readonly foregroundOnly: false;
1754
- readonly contexts: ["background"];
1755
- readonly namespace: "commands";
1756
- };
1757
- readonly contentSettings: {
1758
- readonly platform: "all";
1759
- readonly channel: "stable";
1760
- readonly manifestVersions: [2, 3];
1761
- readonly requiresPolicy: false;
1762
- readonly foregroundOnly: false;
1763
- readonly contexts: ["background"];
1764
- readonly namespace: "contentSettings";
1765
- };
1766
- readonly contextMenus: {
1767
- readonly platform: "all";
1768
- readonly channel: "stable";
1769
- readonly manifestVersions: [2, 3];
1770
- readonly requiresPolicy: false;
1771
- readonly foregroundOnly: false;
1772
- readonly contexts: ["background"];
1773
- readonly namespace: "contextMenus";
1774
- };
1775
- readonly cookies: {
1776
- readonly platform: "all";
1777
- readonly channel: "stable";
1778
- readonly manifestVersions: [2, 3];
1779
- readonly requiresPolicy: false;
1780
- readonly foregroundOnly: false;
1781
- readonly contexts: ["background", "content"];
1782
- readonly namespace: "cookies";
1783
- };
1784
- readonly debugger: {
1785
- readonly platform: "all";
1786
- readonly channel: "stable";
1787
- readonly manifestVersions: [2, 3];
1788
- readonly requiresPolicy: false;
1789
- readonly foregroundOnly: false;
1790
- readonly contexts: ["background"];
1791
- readonly namespace: "debugger";
1792
- };
1793
- readonly declarativeContent: {
1794
- readonly platform: "all";
1795
- readonly channel: "stable";
1796
- readonly manifestVersions: [2, 3];
1797
- readonly requiresPolicy: false;
1798
- readonly foregroundOnly: false;
1799
- readonly contexts: ["background"];
1800
- readonly namespace: "declarativeContent";
1801
- };
1802
- readonly declarativeNetRequest: {
1803
- readonly minChromeVersion: 84;
1804
- readonly platform: "all";
1805
- readonly channel: "stable";
1806
- readonly manifestVersions: [2, 3];
1807
- readonly requiresPolicy: false;
1808
- readonly foregroundOnly: false;
1809
- readonly contexts: ["background"];
1810
- readonly namespace: "declarativeNetRequest";
1811
- };
1812
- readonly desktopCapture: {
1813
- readonly platform: "all";
1814
- readonly channel: "stable";
1815
- readonly manifestVersions: [2, 3];
1816
- readonly requiresPolicy: false;
1817
- readonly foregroundOnly: false;
1818
- readonly contexts: ["background"];
1819
- readonly namespace: "desktopCapture";
1820
- };
1821
- readonly "devtools.inspectedWindow": {
1822
- readonly platform: "all";
1823
- readonly channel: "stable";
1824
- readonly manifestVersions: [2, 3];
1825
- readonly requiresPolicy: false;
1826
- readonly foregroundOnly: false;
1827
- readonly contexts: ["devtools"];
1828
- readonly namespace: "devtools.inspectedWindow";
1829
- };
1830
- readonly "devtools.network": {
1831
- readonly platform: "all";
1832
- readonly channel: "stable";
1833
- readonly manifestVersions: [2, 3];
1834
- readonly requiresPolicy: false;
1835
- readonly foregroundOnly: false;
1836
- readonly contexts: ["devtools"];
1837
- readonly namespace: "devtools.network";
1838
- };
1839
- readonly "devtools.panels": {
1840
- readonly platform: "all";
1841
- readonly channel: "stable";
1842
- readonly manifestVersions: [2, 3];
1843
- readonly requiresPolicy: false;
1844
- readonly foregroundOnly: false;
1845
- readonly contexts: ["devtools"];
1846
- readonly namespace: "devtools.panels";
1847
- };
1848
- readonly "devtools.performance": {
1849
- readonly minChromeVersion: 129;
1850
- readonly platform: "all";
1851
- readonly channel: "stable";
1852
- readonly manifestVersions: [2, 3];
1853
- readonly requiresPolicy: false;
1854
- readonly foregroundOnly: false;
1855
- readonly contexts: ["devtools"];
1856
- readonly namespace: "devtools.performance";
1857
- };
1858
- readonly "devtools.recorder": {
1859
- readonly minChromeVersion: 105;
1860
- readonly platform: "all";
1861
- readonly channel: "stable";
1862
- readonly manifestVersions: [2, 3];
1863
- readonly requiresPolicy: false;
1864
- readonly foregroundOnly: false;
1865
- readonly contexts: ["devtools"];
1866
- readonly namespace: "devtools.recorder";
1867
- };
1868
- readonly dns: {
1869
- readonly platform: "all";
1870
- readonly channel: "dev";
1871
- readonly manifestVersions: [2, 3];
1872
- readonly requiresPolicy: false;
1873
- readonly foregroundOnly: false;
1874
- readonly contexts: ["background"];
1875
- readonly namespace: "dns";
1876
- };
1877
- readonly documentScan: {
1878
- readonly minChromeVersion: 44;
1879
- readonly platform: "chromeos";
1880
- readonly channel: "stable";
1881
- readonly manifestVersions: [2, 3];
1882
- readonly requiresPolicy: false;
1883
- readonly foregroundOnly: false;
1884
- readonly contexts: ["background"];
1885
- readonly namespace: "documentScan";
1886
- };
1887
- readonly dom: {
1888
- readonly minChromeVersion: 88;
1889
- readonly platform: "all";
1890
- readonly channel: "stable";
1891
- readonly manifestVersions: [2, 3];
1892
- readonly requiresPolicy: false;
1893
- readonly foregroundOnly: false;
1894
- readonly contexts: ["content"];
1895
- readonly namespace: "dom";
1896
- };
1897
- readonly downloads: {
1898
- readonly platform: "all";
1899
- readonly channel: "stable";
1900
- readonly manifestVersions: [2, 3];
1901
- readonly requiresPolicy: false;
1902
- readonly foregroundOnly: false;
1903
- readonly contexts: ["background"];
1904
- readonly namespace: "downloads";
1905
- };
1906
- readonly "enterprise.deviceAttributes": {
1907
- readonly minChromeVersion: 46;
1908
- readonly platform: "chromeos";
1909
- readonly channel: "stable";
1910
- readonly manifestVersions: [2, 3];
1911
- readonly requiresPolicy: true;
1912
- readonly foregroundOnly: false;
1913
- readonly contexts: ["background"];
1914
- readonly namespace: "enterprise.deviceAttributes";
1915
- };
1916
- readonly "enterprise.hardwarePlatform": {
1917
- readonly minChromeVersion: 71;
1918
- readonly platform: "all";
1919
- readonly channel: "stable";
1920
- readonly manifestVersions: [2, 3];
1921
- readonly requiresPolicy: true;
1922
- readonly foregroundOnly: false;
1923
- readonly contexts: ["background"];
1924
- readonly namespace: "enterprise.hardwarePlatform";
1925
- };
1926
- readonly "enterprise.networkingAttributes": {
1927
- readonly minChromeVersion: 85;
1928
- readonly platform: "chromeos";
1929
- readonly channel: "stable";
1930
- readonly manifestVersions: [2, 3];
1931
- readonly requiresPolicy: true;
1932
- readonly foregroundOnly: false;
1933
- readonly contexts: ["background"];
1934
- readonly namespace: "enterprise.networkingAttributes";
1935
- };
1936
- readonly "enterprise.platformKeys": {
1937
- readonly platform: "chromeos";
1938
- readonly channel: "stable";
1939
- readonly manifestVersions: [2, 3];
1940
- readonly requiresPolicy: true;
1941
- readonly foregroundOnly: false;
1942
- readonly contexts: ["background"];
1943
- readonly namespace: "enterprise.platformKeys";
1944
- };
1945
- readonly events: {
1946
- readonly platform: "all";
1947
- readonly channel: "stable";
1948
- readonly manifestVersions: [2, 3];
1949
- readonly requiresPolicy: false;
1950
- readonly foregroundOnly: false;
1951
- readonly contexts: ["all"];
1952
- readonly namespace: "events";
1953
- };
1954
- readonly extension: {
1955
- readonly platform: "all";
1956
- readonly channel: "stable";
1957
- readonly manifestVersions: [2, 3];
1958
- readonly requiresPolicy: false;
1959
- readonly foregroundOnly: false;
1960
- readonly contexts: ["all"];
1961
- readonly namespace: "extension";
1962
- };
1963
- readonly extensionTypes: {
1964
- readonly platform: "all";
1965
- readonly channel: "stable";
1966
- readonly manifestVersions: [2, 3];
1967
- readonly requiresPolicy: false;
1968
- readonly foregroundOnly: false;
1969
- readonly contexts: ["all"];
1970
- readonly namespace: "extensionTypes";
1971
- };
1972
- readonly fileBrowserHandler: {
1973
- readonly platform: "chromeos";
1974
- readonly channel: "stable";
1975
- readonly manifestVersions: [2, 3];
1976
- readonly requiresPolicy: false;
1977
- readonly foregroundOnly: true;
1978
- readonly contexts: ["background"];
1979
- readonly namespace: "fileBrowserHandler";
1980
- };
1981
- readonly fileSystemProvider: {
1982
- readonly platform: "chromeos";
1983
- readonly channel: "stable";
1984
- readonly manifestVersions: [2, 3];
1985
- readonly requiresPolicy: false;
1986
- readonly foregroundOnly: false;
1987
- readonly contexts: ["background"];
1988
- readonly namespace: "fileSystemProvider";
1989
- };
1990
- readonly fontSettings: {
1991
- readonly platform: "all";
1992
- readonly channel: "stable";
1993
- readonly manifestVersions: [2, 3];
1994
- readonly requiresPolicy: false;
1995
- readonly foregroundOnly: false;
1996
- readonly contexts: ["background"];
1997
- readonly namespace: "fontSettings";
1998
- };
1999
- readonly gcm: {
2000
- readonly platform: "all";
2001
- readonly channel: "stable";
2002
- readonly manifestVersions: [2, 3];
2003
- readonly requiresPolicy: false;
2004
- readonly foregroundOnly: false;
2005
- readonly contexts: ["background"];
2006
- readonly namespace: "gcm";
2007
- };
2008
- readonly history: {
2009
- readonly platform: "all";
2010
- readonly channel: "stable";
2011
- readonly manifestVersions: [2, 3];
2012
- readonly requiresPolicy: false;
2013
- readonly foregroundOnly: false;
2014
- readonly contexts: ["background", "content"];
2015
- readonly namespace: "history";
2016
- };
2017
- readonly i18n: {
2018
- readonly platform: "all";
2019
- readonly channel: "stable";
2020
- readonly manifestVersions: [2, 3];
2021
- readonly requiresPolicy: false;
2022
- readonly foregroundOnly: false;
2023
- readonly contexts: ["all"];
2024
- readonly namespace: "i18n";
2025
- };
2026
- readonly identity: {
2027
- readonly platform: "all";
2028
- readonly channel: "stable";
2029
- readonly manifestVersions: [2, 3];
2030
- readonly requiresPolicy: false;
2031
- readonly foregroundOnly: false;
2032
- readonly contexts: ["background"];
2033
- readonly namespace: "identity";
2034
- };
2035
- readonly idle: {
2036
- readonly platform: "all";
2037
- readonly channel: "stable";
2038
- readonly manifestVersions: [2, 3];
2039
- readonly requiresPolicy: false;
2040
- readonly foregroundOnly: false;
2041
- readonly contexts: ["background"];
2042
- readonly namespace: "idle";
2043
- };
2044
- readonly "input.ime": {
2045
- readonly platform: "chromeos";
2046
- readonly channel: "stable";
2047
- readonly manifestVersions: [2, 3];
2048
- readonly requiresPolicy: false;
2049
- readonly foregroundOnly: false;
2050
- readonly contexts: ["background"];
2051
- readonly namespace: "input.ime";
2052
- };
2053
- readonly instanceID: {
2054
- readonly minChromeVersion: 44;
2055
- readonly platform: "all";
2056
- readonly channel: "stable";
2057
- readonly manifestVersions: [2, 3];
2058
- readonly requiresPolicy: false;
2059
- readonly foregroundOnly: false;
2060
- readonly contexts: ["background"];
2061
- readonly namespace: "instanceID";
2062
- };
2063
- readonly loginState: {
2064
- readonly minChromeVersion: 78;
2065
- readonly platform: "chromeos";
2066
- readonly channel: "stable";
2067
- readonly manifestVersions: [2, 3];
2068
- readonly requiresPolicy: false;
2069
- readonly foregroundOnly: false;
2070
- readonly contexts: ["background"];
2071
- readonly namespace: "loginState";
2072
- };
2073
- readonly management: {
2074
- readonly platform: "all";
2075
- readonly channel: "stable";
2076
- readonly manifestVersions: [2, 3];
2077
- readonly requiresPolicy: false;
2078
- readonly foregroundOnly: false;
2079
- readonly contexts: ["background"];
2080
- readonly namespace: "management";
2081
- };
2082
- readonly notifications: {
2083
- readonly platform: "all";
2084
- readonly channel: "stable";
2085
- readonly manifestVersions: [2, 3];
2086
- readonly requiresPolicy: false;
2087
- readonly foregroundOnly: false;
2088
- readonly contexts: ["background"];
2089
- readonly namespace: "notifications";
2090
- };
2091
- readonly offscreen: {
2092
- readonly minChromeVersion: 109;
2093
- readonly platform: "all";
2094
- readonly channel: "stable";
2095
- readonly manifestVersions: [3];
2096
- readonly requiresPolicy: false;
2097
- readonly foregroundOnly: false;
2098
- readonly contexts: ["background"];
2099
- readonly namespace: "offscreen";
2100
- };
2101
- readonly omnibox: {
2102
- readonly platform: "all";
2103
- readonly channel: "stable";
2104
- readonly manifestVersions: [2, 3];
2105
- readonly requiresPolicy: false;
2106
- readonly foregroundOnly: false;
2107
- readonly contexts: ["background"];
2108
- readonly namespace: "omnibox";
2109
- };
2110
- readonly pageCapture: {
2111
- readonly platform: "all";
2112
- readonly channel: "stable";
2113
- readonly manifestVersions: [2, 3];
2114
- readonly requiresPolicy: false;
2115
- readonly foregroundOnly: false;
2116
- readonly contexts: ["background"];
2117
- readonly namespace: "pageCapture";
2118
- };
2119
- readonly permissions: {
2120
- readonly platform: "all";
2121
- readonly channel: "stable";
2122
- readonly manifestVersions: [2, 3];
2123
- readonly requiresPolicy: false;
2124
- readonly foregroundOnly: false;
2125
- readonly contexts: ["background", "content"];
2126
- readonly namespace: "permissions";
2127
- };
2128
- readonly platformKeys: {
2129
- readonly minChromeVersion: 45;
2130
- readonly platform: "chromeos";
2131
- readonly channel: "stable";
2132
- readonly manifestVersions: [2, 3];
2133
- readonly requiresPolicy: false;
2134
- readonly foregroundOnly: false;
2135
- readonly contexts: ["background"];
2136
- readonly namespace: "platformKeys";
2137
- };
2138
- readonly power: {
2139
- readonly platform: "all";
2140
- readonly channel: "stable";
2141
- readonly manifestVersions: [2, 3];
2142
- readonly requiresPolicy: false;
2143
- readonly foregroundOnly: false;
2144
- readonly contexts: ["background"];
2145
- readonly namespace: "power";
2146
- };
2147
- readonly printerProvider: {
2148
- readonly minChromeVersion: 44;
2149
- readonly platform: "all";
2150
- readonly channel: "stable";
2151
- readonly manifestVersions: [2, 3];
2152
- readonly requiresPolicy: false;
2153
- readonly foregroundOnly: false;
2154
- readonly contexts: ["background"];
2155
- readonly namespace: "printerProvider";
2156
- };
2157
- readonly printing: {
2158
- readonly minChromeVersion: 81;
2159
- readonly platform: "chromeos";
2160
- readonly channel: "stable";
2161
- readonly manifestVersions: [2, 3];
2162
- readonly requiresPolicy: false;
2163
- readonly foregroundOnly: false;
2164
- readonly contexts: ["background"];
2165
- readonly namespace: "printing";
2166
- };
2167
- readonly printingMetrics: {
2168
- readonly minChromeVersion: 79;
2169
- readonly platform: "chromeos";
2170
- readonly channel: "stable";
2171
- readonly manifestVersions: [2, 3];
2172
- readonly requiresPolicy: true;
2173
- readonly foregroundOnly: false;
2174
- readonly contexts: ["background"];
2175
- readonly namespace: "printingMetrics";
2176
- };
2177
- readonly privacy: {
2178
- readonly platform: "all";
2179
- readonly channel: "stable";
2180
- readonly manifestVersions: [2, 3];
2181
- readonly requiresPolicy: false;
2182
- readonly foregroundOnly: false;
2183
- readonly contexts: ["background"];
2184
- readonly namespace: "privacy";
2185
- };
2186
- readonly processes: {
2187
- readonly platform: "all";
2188
- readonly channel: "dev";
2189
- readonly manifestVersions: [2, 3];
2190
- readonly requiresPolicy: false;
2191
- readonly foregroundOnly: false;
2192
- readonly contexts: ["background"];
2193
- readonly namespace: "processes";
2194
- };
2195
- readonly proxy: {
2196
- readonly platform: "all";
2197
- readonly channel: "stable";
2198
- readonly manifestVersions: [2, 3];
2199
- readonly requiresPolicy: false;
2200
- readonly foregroundOnly: false;
2201
- readonly contexts: ["background"];
2202
- readonly namespace: "proxy";
2203
- };
2204
- readonly readingList: {
2205
- readonly minChromeVersion: 120;
2206
- readonly platform: "all";
2207
- readonly channel: "stable";
2208
- readonly manifestVersions: [3];
2209
- readonly requiresPolicy: false;
2210
- readonly foregroundOnly: false;
2211
- readonly contexts: ["background"];
2212
- readonly namespace: "readingList";
2213
- };
2214
- readonly runtime: {
2215
- readonly platform: "all";
2216
- readonly channel: "stable";
2217
- readonly manifestVersions: [2, 3];
2218
- readonly requiresPolicy: false;
2219
- readonly foregroundOnly: false;
2220
- readonly contexts: ["all"];
2221
- readonly namespace: "runtime";
2222
- };
2223
- readonly scripting: {
2224
- readonly minChromeVersion: 88;
2225
- readonly platform: "all";
2226
- readonly channel: "stable";
2227
- readonly manifestVersions: [3];
2228
- readonly requiresPolicy: false;
2229
- readonly foregroundOnly: false;
2230
- readonly contexts: ["background"];
2231
- readonly namespace: "scripting";
2232
- };
2233
- readonly search: {
2234
- readonly minChromeVersion: 87;
2235
- readonly platform: "all";
2236
- readonly channel: "stable";
2237
- readonly manifestVersions: [2, 3];
2238
- readonly requiresPolicy: false;
2239
- readonly foregroundOnly: false;
2240
- readonly contexts: ["background"];
2241
- readonly namespace: "search";
2242
- };
2243
- readonly sessions: {
2244
- readonly platform: "all";
2245
- readonly channel: "stable";
2246
- readonly manifestVersions: [2, 3];
2247
- readonly requiresPolicy: false;
2248
- readonly foregroundOnly: false;
2249
- readonly contexts: ["background"];
2250
- readonly namespace: "sessions";
2251
- };
2252
- readonly sidePanel: {
2253
- readonly minChromeVersion: 114;
2254
- readonly platform: "all";
2255
- readonly channel: "stable";
2256
- readonly manifestVersions: [3];
2257
- readonly requiresPolicy: false;
2258
- readonly foregroundOnly: false;
2259
- readonly contexts: ["background"];
2260
- readonly namespace: "sidePanel";
2261
- };
2262
- readonly storage: {
2263
- readonly platform: "all";
2264
- readonly channel: "stable";
2265
- readonly manifestVersions: [2, 3];
2266
- readonly requiresPolicy: false;
2267
- readonly foregroundOnly: false;
2268
- readonly contexts: ["all"];
2269
- readonly namespace: "storage";
2270
- };
2271
- readonly "system.cpu": {
2272
- readonly platform: "all";
2273
- readonly channel: "stable";
2274
- readonly manifestVersions: [2, 3];
2275
- readonly requiresPolicy: false;
2276
- readonly foregroundOnly: false;
2277
- readonly contexts: ["background"];
2278
- readonly namespace: "system.cpu";
2279
- };
2280
- readonly "system.display": {
2281
- readonly platform: "all";
2282
- readonly channel: "stable";
2283
- readonly manifestVersions: [2, 3];
2284
- readonly requiresPolicy: false;
2285
- readonly foregroundOnly: false;
2286
- readonly contexts: ["background"];
2287
- readonly namespace: "system.display";
2288
- };
2289
- readonly "system.memory": {
2290
- readonly platform: "all";
2291
- readonly channel: "stable";
2292
- readonly manifestVersions: [2, 3];
2293
- readonly requiresPolicy: false;
2294
- readonly foregroundOnly: false;
2295
- readonly contexts: ["background"];
2296
- readonly namespace: "system.memory";
2297
- };
2298
- readonly "system.storage": {
2299
- readonly platform: "all";
2300
- readonly channel: "stable";
2301
- readonly manifestVersions: [2, 3];
2302
- readonly requiresPolicy: false;
2303
- readonly foregroundOnly: false;
2304
- readonly contexts: ["background"];
2305
- readonly namespace: "system.storage";
2306
- };
2307
- readonly systemLog: {
2308
- readonly minChromeVersion: 125;
2309
- readonly platform: "chromeos";
2310
- readonly channel: "stable";
2311
- readonly manifestVersions: [2, 3];
2312
- readonly requiresPolicy: true;
2313
- readonly foregroundOnly: false;
2314
- readonly contexts: ["background"];
2315
- readonly namespace: "systemLog";
2316
- };
2317
- readonly tabCapture: {
2318
- readonly platform: "all";
2319
- readonly channel: "stable";
2320
- readonly manifestVersions: [2, 3];
2321
- readonly requiresPolicy: false;
2322
- readonly foregroundOnly: false;
2323
- readonly contexts: ["background"];
2324
- readonly namespace: "tabCapture";
2325
- };
2326
- readonly tabGroups: {
2327
- readonly minChromeVersion: 89;
2328
- readonly platform: "all";
2329
- readonly channel: "stable";
2330
- readonly manifestVersions: [3];
2331
- readonly requiresPolicy: false;
2332
- readonly foregroundOnly: false;
2333
- readonly contexts: ["background"];
2334
- readonly namespace: "tabGroups";
2335
- };
2336
- readonly tabs: {
2337
- readonly platform: "all";
2338
- readonly channel: "stable";
2339
- readonly manifestVersions: [2, 3];
2340
- readonly requiresPolicy: false;
2341
- readonly foregroundOnly: false;
2342
- readonly contexts: ["background", "content"];
2343
- readonly namespace: "tabs";
2344
- };
2345
- readonly topSites: {
2346
- readonly platform: "all";
2347
- readonly channel: "stable";
2348
- readonly manifestVersions: [2, 3];
2349
- readonly requiresPolicy: false;
2350
- readonly foregroundOnly: false;
2351
- readonly contexts: ["background"];
2352
- readonly namespace: "topSites";
2353
- };
2354
- readonly tts: {
2355
- readonly platform: "all";
2356
- readonly channel: "stable";
2357
- readonly manifestVersions: [2, 3];
2358
- readonly requiresPolicy: false;
2359
- readonly foregroundOnly: false;
2360
- readonly contexts: ["background"];
2361
- readonly namespace: "tts";
2362
- };
2363
- readonly ttsEngine: {
2364
- readonly platform: "all";
2365
- readonly channel: "stable";
2366
- readonly manifestVersions: [2, 3];
2367
- readonly requiresPolicy: false;
2368
- readonly foregroundOnly: false;
2369
- readonly contexts: ["background"];
2370
- readonly namespace: "ttsEngine";
2371
- };
2372
- readonly types: {
2373
- readonly platform: "all";
2374
- readonly channel: "stable";
2375
- readonly manifestVersions: [2, 3];
2376
- readonly requiresPolicy: false;
2377
- readonly foregroundOnly: false;
2378
- readonly contexts: ["all"];
2379
- readonly namespace: "types";
2380
- };
2381
- readonly userScripts: {
2382
- readonly minChromeVersion: 120;
2383
- readonly platform: "all";
2384
- readonly channel: "stable";
2385
- readonly manifestVersions: [3];
2386
- readonly requiresPolicy: false;
2387
- readonly foregroundOnly: false;
2388
- readonly contexts: ["background"];
2389
- readonly namespace: "userScripts";
2390
- };
2391
- readonly vpnProvider: {
2392
- readonly minChromeVersion: 43;
2393
- readonly platform: "chromeos";
2394
- readonly channel: "stable";
2395
- readonly manifestVersions: [2, 3];
2396
- readonly requiresPolicy: false;
2397
- readonly foregroundOnly: false;
2398
- readonly contexts: ["background"];
2399
- readonly namespace: "vpnProvider";
2400
- };
2401
- readonly wallpaper: {
2402
- readonly minChromeVersion: 43;
2403
- readonly platform: "chromeos";
2404
- readonly channel: "stable";
2405
- readonly manifestVersions: [2, 3];
2406
- readonly requiresPolicy: false;
2407
- readonly foregroundOnly: false;
2408
- readonly contexts: ["background"];
2409
- readonly namespace: "wallpaper";
2410
- };
2411
- readonly webAuthenticationProxy: {
2412
- readonly minChromeVersion: 115;
2413
- readonly platform: "all";
2414
- readonly channel: "stable";
2415
- readonly manifestVersions: [3];
2416
- readonly requiresPolicy: false;
2417
- readonly foregroundOnly: false;
2418
- readonly contexts: ["background"];
2419
- readonly namespace: "webAuthenticationProxy";
2420
- };
2421
- readonly webNavigation: {
2422
- readonly platform: "all";
2423
- readonly channel: "stable";
2424
- readonly manifestVersions: [2, 3];
2425
- readonly requiresPolicy: false;
2426
- readonly foregroundOnly: false;
2427
- readonly contexts: ["background"];
2428
- readonly namespace: "webNavigation";
2429
- };
2430
- readonly webRequest: {
2431
- readonly platform: "all";
2432
- readonly channel: "stable";
2433
- readonly manifestVersions: [2, 3];
2434
- readonly requiresPolicy: false;
2435
- readonly foregroundOnly: false;
2436
- readonly contexts: ["background"];
2437
- readonly namespace: "webRequest";
2438
- };
2439
- readonly windows: {
2440
- readonly platform: "all";
2441
- readonly channel: "stable";
2442
- readonly manifestVersions: [2, 3];
2443
- readonly requiresPolicy: false;
2444
- readonly foregroundOnly: false;
2445
- readonly contexts: ["background"];
2446
- readonly namespace: "windows";
2447
- };
1755
+ readonly accessibilityFeatures: {
1756
+ readonly platform: "all";
1757
+ readonly channel: "stable";
1758
+ readonly manifestVersions: [2, 3];
1759
+ readonly requiresPolicy: false;
1760
+ readonly foregroundOnly: false;
1761
+ readonly contexts: ["background"];
1762
+ readonly namespace: "accessibilityFeatures";
1763
+ };
1764
+ readonly action: {
1765
+ readonly minChromeVersion: 88;
1766
+ readonly platform: "all";
1767
+ readonly channel: "stable";
1768
+ readonly manifestVersions: [3];
1769
+ readonly requiresPolicy: false;
1770
+ readonly foregroundOnly: false;
1771
+ readonly contexts: ["background"];
1772
+ readonly namespace: "action";
1773
+ };
1774
+ readonly alarms: {
1775
+ readonly platform: "all";
1776
+ readonly channel: "stable";
1777
+ readonly manifestVersions: [2, 3];
1778
+ readonly requiresPolicy: false;
1779
+ readonly foregroundOnly: false;
1780
+ readonly contexts: ["background"];
1781
+ readonly namespace: "alarms";
1782
+ };
1783
+ readonly audio: {
1784
+ readonly minChromeVersion: 59;
1785
+ readonly platform: "chromeos";
1786
+ readonly channel: "stable";
1787
+ readonly manifestVersions: [2, 3];
1788
+ readonly requiresPolicy: false;
1789
+ readonly foregroundOnly: false;
1790
+ readonly contexts: ["background"];
1791
+ readonly namespace: "audio";
1792
+ };
1793
+ readonly bookmarks: {
1794
+ readonly platform: "all";
1795
+ readonly channel: "stable";
1796
+ readonly manifestVersions: [2, 3];
1797
+ readonly requiresPolicy: false;
1798
+ readonly foregroundOnly: false;
1799
+ readonly contexts: ["background", "content"];
1800
+ readonly namespace: "bookmarks";
1801
+ };
1802
+ readonly browsingData: {
1803
+ readonly platform: "all";
1804
+ readonly channel: "stable";
1805
+ readonly manifestVersions: [2, 3];
1806
+ readonly requiresPolicy: false;
1807
+ readonly foregroundOnly: false;
1808
+ readonly contexts: ["background"];
1809
+ readonly namespace: "browsingData";
1810
+ };
1811
+ readonly certificateProvider: {
1812
+ readonly minChromeVersion: 46;
1813
+ readonly platform: "chromeos";
1814
+ readonly channel: "stable";
1815
+ readonly manifestVersions: [2, 3];
1816
+ readonly requiresPolicy: false;
1817
+ readonly foregroundOnly: false;
1818
+ readonly contexts: ["background"];
1819
+ readonly namespace: "certificateProvider";
1820
+ };
1821
+ readonly commands: {
1822
+ readonly platform: "all";
1823
+ readonly channel: "stable";
1824
+ readonly manifestVersions: [2, 3];
1825
+ readonly requiresPolicy: false;
1826
+ readonly foregroundOnly: false;
1827
+ readonly contexts: ["background"];
1828
+ readonly namespace: "commands";
1829
+ };
1830
+ readonly contentSettings: {
1831
+ readonly platform: "all";
1832
+ readonly channel: "stable";
1833
+ readonly manifestVersions: [2, 3];
1834
+ readonly requiresPolicy: false;
1835
+ readonly foregroundOnly: false;
1836
+ readonly contexts: ["background"];
1837
+ readonly namespace: "contentSettings";
1838
+ };
1839
+ readonly contextMenus: {
1840
+ readonly platform: "all";
1841
+ readonly channel: "stable";
1842
+ readonly manifestVersions: [2, 3];
1843
+ readonly requiresPolicy: false;
1844
+ readonly foregroundOnly: false;
1845
+ readonly contexts: ["background"];
1846
+ readonly namespace: "contextMenus";
1847
+ };
1848
+ readonly cookies: {
1849
+ readonly platform: "all";
1850
+ readonly channel: "stable";
1851
+ readonly manifestVersions: [2, 3];
1852
+ readonly requiresPolicy: false;
1853
+ readonly foregroundOnly: false;
1854
+ readonly contexts: ["background", "content"];
1855
+ readonly namespace: "cookies";
1856
+ };
1857
+ readonly debugger: {
1858
+ readonly platform: "all";
1859
+ readonly channel: "stable";
1860
+ readonly manifestVersions: [2, 3];
1861
+ readonly requiresPolicy: false;
1862
+ readonly foregroundOnly: false;
1863
+ readonly contexts: ["background"];
1864
+ readonly namespace: "debugger";
1865
+ };
1866
+ readonly declarativeContent: {
1867
+ readonly platform: "all";
1868
+ readonly channel: "stable";
1869
+ readonly manifestVersions: [2, 3];
1870
+ readonly requiresPolicy: false;
1871
+ readonly foregroundOnly: false;
1872
+ readonly contexts: ["background"];
1873
+ readonly namespace: "declarativeContent";
1874
+ };
1875
+ readonly declarativeNetRequest: {
1876
+ readonly minChromeVersion: 84;
1877
+ readonly platform: "all";
1878
+ readonly channel: "stable";
1879
+ readonly manifestVersions: [2, 3];
1880
+ readonly requiresPolicy: false;
1881
+ readonly foregroundOnly: false;
1882
+ readonly contexts: ["background"];
1883
+ readonly namespace: "declarativeNetRequest";
1884
+ };
1885
+ readonly desktopCapture: {
1886
+ readonly platform: "all";
1887
+ readonly channel: "stable";
1888
+ readonly manifestVersions: [2, 3];
1889
+ readonly requiresPolicy: false;
1890
+ readonly foregroundOnly: false;
1891
+ readonly contexts: ["background"];
1892
+ readonly namespace: "desktopCapture";
1893
+ };
1894
+ readonly "devtools.inspectedWindow": {
1895
+ readonly platform: "all";
1896
+ readonly channel: "stable";
1897
+ readonly manifestVersions: [2, 3];
1898
+ readonly requiresPolicy: false;
1899
+ readonly foregroundOnly: false;
1900
+ readonly contexts: ["devtools"];
1901
+ readonly namespace: "devtools.inspectedWindow";
1902
+ };
1903
+ readonly "devtools.network": {
1904
+ readonly platform: "all";
1905
+ readonly channel: "stable";
1906
+ readonly manifestVersions: [2, 3];
1907
+ readonly requiresPolicy: false;
1908
+ readonly foregroundOnly: false;
1909
+ readonly contexts: ["devtools"];
1910
+ readonly namespace: "devtools.network";
1911
+ };
1912
+ readonly "devtools.panels": {
1913
+ readonly platform: "all";
1914
+ readonly channel: "stable";
1915
+ readonly manifestVersions: [2, 3];
1916
+ readonly requiresPolicy: false;
1917
+ readonly foregroundOnly: false;
1918
+ readonly contexts: ["devtools"];
1919
+ readonly namespace: "devtools.panels";
1920
+ };
1921
+ readonly "devtools.performance": {
1922
+ readonly minChromeVersion: 129;
1923
+ readonly platform: "all";
1924
+ readonly channel: "stable";
1925
+ readonly manifestVersions: [2, 3];
1926
+ readonly requiresPolicy: false;
1927
+ readonly foregroundOnly: false;
1928
+ readonly contexts: ["devtools"];
1929
+ readonly namespace: "devtools.performance";
1930
+ };
1931
+ readonly "devtools.recorder": {
1932
+ readonly minChromeVersion: 105;
1933
+ readonly platform: "all";
1934
+ readonly channel: "stable";
1935
+ readonly manifestVersions: [2, 3];
1936
+ readonly requiresPolicy: false;
1937
+ readonly foregroundOnly: false;
1938
+ readonly contexts: ["devtools"];
1939
+ readonly namespace: "devtools.recorder";
1940
+ };
1941
+ readonly dns: {
1942
+ readonly platform: "all";
1943
+ readonly channel: "dev";
1944
+ readonly manifestVersions: [2, 3];
1945
+ readonly requiresPolicy: false;
1946
+ readonly foregroundOnly: false;
1947
+ readonly contexts: ["background"];
1948
+ readonly namespace: "dns";
1949
+ };
1950
+ readonly documentScan: {
1951
+ readonly minChromeVersion: 44;
1952
+ readonly platform: "chromeos";
1953
+ readonly channel: "stable";
1954
+ readonly manifestVersions: [2, 3];
1955
+ readonly requiresPolicy: false;
1956
+ readonly foregroundOnly: false;
1957
+ readonly contexts: ["background"];
1958
+ readonly namespace: "documentScan";
1959
+ };
1960
+ readonly dom: {
1961
+ readonly minChromeVersion: 88;
1962
+ readonly platform: "all";
1963
+ readonly channel: "stable";
1964
+ readonly manifestVersions: [2, 3];
1965
+ readonly requiresPolicy: false;
1966
+ readonly foregroundOnly: false;
1967
+ readonly contexts: ["content"];
1968
+ readonly namespace: "dom";
1969
+ };
1970
+ readonly downloads: {
1971
+ readonly platform: "all";
1972
+ readonly channel: "stable";
1973
+ readonly manifestVersions: [2, 3];
1974
+ readonly requiresPolicy: false;
1975
+ readonly foregroundOnly: false;
1976
+ readonly contexts: ["background"];
1977
+ readonly namespace: "downloads";
1978
+ };
1979
+ readonly "enterprise.deviceAttributes": {
1980
+ readonly minChromeVersion: 46;
1981
+ readonly platform: "chromeos";
1982
+ readonly channel: "stable";
1983
+ readonly manifestVersions: [2, 3];
1984
+ readonly requiresPolicy: true;
1985
+ readonly foregroundOnly: false;
1986
+ readonly contexts: ["background"];
1987
+ readonly namespace: "enterprise.deviceAttributes";
1988
+ };
1989
+ readonly "enterprise.hardwarePlatform": {
1990
+ readonly minChromeVersion: 71;
1991
+ readonly platform: "all";
1992
+ readonly channel: "stable";
1993
+ readonly manifestVersions: [2, 3];
1994
+ readonly requiresPolicy: true;
1995
+ readonly foregroundOnly: false;
1996
+ readonly contexts: ["background"];
1997
+ readonly namespace: "enterprise.hardwarePlatform";
1998
+ };
1999
+ readonly "enterprise.networkingAttributes": {
2000
+ readonly minChromeVersion: 85;
2001
+ readonly platform: "chromeos";
2002
+ readonly channel: "stable";
2003
+ readonly manifestVersions: [2, 3];
2004
+ readonly requiresPolicy: true;
2005
+ readonly foregroundOnly: false;
2006
+ readonly contexts: ["background"];
2007
+ readonly namespace: "enterprise.networkingAttributes";
2008
+ };
2009
+ readonly "enterprise.platformKeys": {
2010
+ readonly platform: "chromeos";
2011
+ readonly channel: "stable";
2012
+ readonly manifestVersions: [2, 3];
2013
+ readonly requiresPolicy: true;
2014
+ readonly foregroundOnly: false;
2015
+ readonly contexts: ["background"];
2016
+ readonly namespace: "enterprise.platformKeys";
2017
+ };
2018
+ readonly events: {
2019
+ readonly platform: "all";
2020
+ readonly channel: "stable";
2021
+ readonly manifestVersions: [2, 3];
2022
+ readonly requiresPolicy: false;
2023
+ readonly foregroundOnly: false;
2024
+ readonly contexts: ["all"];
2025
+ readonly namespace: "events";
2026
+ };
2027
+ readonly extension: {
2028
+ readonly platform: "all";
2029
+ readonly channel: "stable";
2030
+ readonly manifestVersions: [2, 3];
2031
+ readonly requiresPolicy: false;
2032
+ readonly foregroundOnly: false;
2033
+ readonly contexts: ["all"];
2034
+ readonly namespace: "extension";
2035
+ };
2036
+ readonly extensionTypes: {
2037
+ readonly platform: "all";
2038
+ readonly channel: "stable";
2039
+ readonly manifestVersions: [2, 3];
2040
+ readonly requiresPolicy: false;
2041
+ readonly foregroundOnly: false;
2042
+ readonly contexts: ["all"];
2043
+ readonly namespace: "extensionTypes";
2044
+ };
2045
+ readonly fileBrowserHandler: {
2046
+ readonly platform: "chromeos";
2047
+ readonly channel: "stable";
2048
+ readonly manifestVersions: [2, 3];
2049
+ readonly requiresPolicy: false;
2050
+ readonly foregroundOnly: true;
2051
+ readonly contexts: ["background"];
2052
+ readonly namespace: "fileBrowserHandler";
2053
+ };
2054
+ readonly fileSystemProvider: {
2055
+ readonly platform: "chromeos";
2056
+ readonly channel: "stable";
2057
+ readonly manifestVersions: [2, 3];
2058
+ readonly requiresPolicy: false;
2059
+ readonly foregroundOnly: false;
2060
+ readonly contexts: ["background"];
2061
+ readonly namespace: "fileSystemProvider";
2062
+ };
2063
+ readonly fontSettings: {
2064
+ readonly platform: "all";
2065
+ readonly channel: "stable";
2066
+ readonly manifestVersions: [2, 3];
2067
+ readonly requiresPolicy: false;
2068
+ readonly foregroundOnly: false;
2069
+ readonly contexts: ["background"];
2070
+ readonly namespace: "fontSettings";
2071
+ };
2072
+ readonly gcm: {
2073
+ readonly platform: "all";
2074
+ readonly channel: "stable";
2075
+ readonly manifestVersions: [2, 3];
2076
+ readonly requiresPolicy: false;
2077
+ readonly foregroundOnly: false;
2078
+ readonly contexts: ["background"];
2079
+ readonly namespace: "gcm";
2080
+ };
2081
+ readonly history: {
2082
+ readonly platform: "all";
2083
+ readonly channel: "stable";
2084
+ readonly manifestVersions: [2, 3];
2085
+ readonly requiresPolicy: false;
2086
+ readonly foregroundOnly: false;
2087
+ readonly contexts: ["background", "content"];
2088
+ readonly namespace: "history";
2089
+ };
2090
+ readonly i18n: {
2091
+ readonly platform: "all";
2092
+ readonly channel: "stable";
2093
+ readonly manifestVersions: [2, 3];
2094
+ readonly requiresPolicy: false;
2095
+ readonly foregroundOnly: false;
2096
+ readonly contexts: ["all"];
2097
+ readonly namespace: "i18n";
2098
+ };
2099
+ readonly identity: {
2100
+ readonly platform: "all";
2101
+ readonly channel: "stable";
2102
+ readonly manifestVersions: [2, 3];
2103
+ readonly requiresPolicy: false;
2104
+ readonly foregroundOnly: false;
2105
+ readonly contexts: ["background"];
2106
+ readonly namespace: "identity";
2107
+ };
2108
+ readonly idle: {
2109
+ readonly platform: "all";
2110
+ readonly channel: "stable";
2111
+ readonly manifestVersions: [2, 3];
2112
+ readonly requiresPolicy: false;
2113
+ readonly foregroundOnly: false;
2114
+ readonly contexts: ["background"];
2115
+ readonly namespace: "idle";
2116
+ };
2117
+ readonly "input.ime": {
2118
+ readonly platform: "chromeos";
2119
+ readonly channel: "stable";
2120
+ readonly manifestVersions: [2, 3];
2121
+ readonly requiresPolicy: false;
2122
+ readonly foregroundOnly: false;
2123
+ readonly contexts: ["background"];
2124
+ readonly namespace: "input.ime";
2125
+ };
2126
+ readonly instanceID: {
2127
+ readonly minChromeVersion: 44;
2128
+ readonly platform: "all";
2129
+ readonly channel: "stable";
2130
+ readonly manifestVersions: [2, 3];
2131
+ readonly requiresPolicy: false;
2132
+ readonly foregroundOnly: false;
2133
+ readonly contexts: ["background"];
2134
+ readonly namespace: "instanceID";
2135
+ };
2136
+ readonly loginState: {
2137
+ readonly minChromeVersion: 78;
2138
+ readonly platform: "chromeos";
2139
+ readonly channel: "stable";
2140
+ readonly manifestVersions: [2, 3];
2141
+ readonly requiresPolicy: false;
2142
+ readonly foregroundOnly: false;
2143
+ readonly contexts: ["background"];
2144
+ readonly namespace: "loginState";
2145
+ };
2146
+ readonly management: {
2147
+ readonly platform: "all";
2148
+ readonly channel: "stable";
2149
+ readonly manifestVersions: [2, 3];
2150
+ readonly requiresPolicy: false;
2151
+ readonly foregroundOnly: false;
2152
+ readonly contexts: ["background"];
2153
+ readonly namespace: "management";
2154
+ };
2155
+ readonly notifications: {
2156
+ readonly platform: "all";
2157
+ readonly channel: "stable";
2158
+ readonly manifestVersions: [2, 3];
2159
+ readonly requiresPolicy: false;
2160
+ readonly foregroundOnly: false;
2161
+ readonly contexts: ["background"];
2162
+ readonly namespace: "notifications";
2163
+ };
2164
+ readonly offscreen: {
2165
+ readonly minChromeVersion: 109;
2166
+ readonly platform: "all";
2167
+ readonly channel: "stable";
2168
+ readonly manifestVersions: [3];
2169
+ readonly requiresPolicy: false;
2170
+ readonly foregroundOnly: false;
2171
+ readonly contexts: ["background"];
2172
+ readonly namespace: "offscreen";
2173
+ };
2174
+ readonly omnibox: {
2175
+ readonly platform: "all";
2176
+ readonly channel: "stable";
2177
+ readonly manifestVersions: [2, 3];
2178
+ readonly requiresPolicy: false;
2179
+ readonly foregroundOnly: false;
2180
+ readonly contexts: ["background"];
2181
+ readonly namespace: "omnibox";
2182
+ };
2183
+ readonly pageCapture: {
2184
+ readonly platform: "all";
2185
+ readonly channel: "stable";
2186
+ readonly manifestVersions: [2, 3];
2187
+ readonly requiresPolicy: false;
2188
+ readonly foregroundOnly: false;
2189
+ readonly contexts: ["background"];
2190
+ readonly namespace: "pageCapture";
2191
+ };
2192
+ readonly permissions: {
2193
+ readonly platform: "all";
2194
+ readonly channel: "stable";
2195
+ readonly manifestVersions: [2, 3];
2196
+ readonly requiresPolicy: false;
2197
+ readonly foregroundOnly: false;
2198
+ readonly contexts: ["background", "content"];
2199
+ readonly namespace: "permissions";
2200
+ };
2201
+ readonly platformKeys: {
2202
+ readonly minChromeVersion: 45;
2203
+ readonly platform: "chromeos";
2204
+ readonly channel: "stable";
2205
+ readonly manifestVersions: [2, 3];
2206
+ readonly requiresPolicy: false;
2207
+ readonly foregroundOnly: false;
2208
+ readonly contexts: ["background"];
2209
+ readonly namespace: "platformKeys";
2210
+ };
2211
+ readonly power: {
2212
+ readonly platform: "all";
2213
+ readonly channel: "stable";
2214
+ readonly manifestVersions: [2, 3];
2215
+ readonly requiresPolicy: false;
2216
+ readonly foregroundOnly: false;
2217
+ readonly contexts: ["background"];
2218
+ readonly namespace: "power";
2219
+ };
2220
+ readonly printerProvider: {
2221
+ readonly minChromeVersion: 44;
2222
+ readonly platform: "all";
2223
+ readonly channel: "stable";
2224
+ readonly manifestVersions: [2, 3];
2225
+ readonly requiresPolicy: false;
2226
+ readonly foregroundOnly: false;
2227
+ readonly contexts: ["background"];
2228
+ readonly namespace: "printerProvider";
2229
+ };
2230
+ readonly printing: {
2231
+ readonly minChromeVersion: 81;
2232
+ readonly platform: "chromeos";
2233
+ readonly channel: "stable";
2234
+ readonly manifestVersions: [2, 3];
2235
+ readonly requiresPolicy: false;
2236
+ readonly foregroundOnly: false;
2237
+ readonly contexts: ["background"];
2238
+ readonly namespace: "printing";
2239
+ };
2240
+ readonly printingMetrics: {
2241
+ readonly minChromeVersion: 79;
2242
+ readonly platform: "chromeos";
2243
+ readonly channel: "stable";
2244
+ readonly manifestVersions: [2, 3];
2245
+ readonly requiresPolicy: true;
2246
+ readonly foregroundOnly: false;
2247
+ readonly contexts: ["background"];
2248
+ readonly namespace: "printingMetrics";
2249
+ };
2250
+ readonly privacy: {
2251
+ readonly platform: "all";
2252
+ readonly channel: "stable";
2253
+ readonly manifestVersions: [2, 3];
2254
+ readonly requiresPolicy: false;
2255
+ readonly foregroundOnly: false;
2256
+ readonly contexts: ["background"];
2257
+ readonly namespace: "privacy";
2258
+ };
2259
+ readonly processes: {
2260
+ readonly platform: "all";
2261
+ readonly channel: "dev";
2262
+ readonly manifestVersions: [2, 3];
2263
+ readonly requiresPolicy: false;
2264
+ readonly foregroundOnly: false;
2265
+ readonly contexts: ["background"];
2266
+ readonly namespace: "processes";
2267
+ };
2268
+ readonly proxy: {
2269
+ readonly platform: "all";
2270
+ readonly channel: "stable";
2271
+ readonly manifestVersions: [2, 3];
2272
+ readonly requiresPolicy: false;
2273
+ readonly foregroundOnly: false;
2274
+ readonly contexts: ["background"];
2275
+ readonly namespace: "proxy";
2276
+ };
2277
+ readonly readingList: {
2278
+ readonly minChromeVersion: 120;
2279
+ readonly platform: "all";
2280
+ readonly channel: "stable";
2281
+ readonly manifestVersions: [3];
2282
+ readonly requiresPolicy: false;
2283
+ readonly foregroundOnly: false;
2284
+ readonly contexts: ["background"];
2285
+ readonly namespace: "readingList";
2286
+ };
2287
+ readonly runtime: {
2288
+ readonly platform: "all";
2289
+ readonly channel: "stable";
2290
+ readonly manifestVersions: [2, 3];
2291
+ readonly requiresPolicy: false;
2292
+ readonly foregroundOnly: false;
2293
+ readonly contexts: ["all"];
2294
+ readonly namespace: "runtime";
2295
+ };
2296
+ readonly scripting: {
2297
+ readonly minChromeVersion: 88;
2298
+ readonly platform: "all";
2299
+ readonly channel: "stable";
2300
+ readonly manifestVersions: [3];
2301
+ readonly requiresPolicy: false;
2302
+ readonly foregroundOnly: false;
2303
+ readonly contexts: ["background"];
2304
+ readonly namespace: "scripting";
2305
+ };
2306
+ readonly search: {
2307
+ readonly minChromeVersion: 87;
2308
+ readonly platform: "all";
2309
+ readonly channel: "stable";
2310
+ readonly manifestVersions: [2, 3];
2311
+ readonly requiresPolicy: false;
2312
+ readonly foregroundOnly: false;
2313
+ readonly contexts: ["background"];
2314
+ readonly namespace: "search";
2315
+ };
2316
+ readonly smartDomReader: {
2317
+ readonly minChromeVersion: 88;
2318
+ readonly platform: "all";
2319
+ readonly channel: "stable";
2320
+ readonly manifestVersions: [3];
2321
+ readonly requiresPolicy: false;
2322
+ readonly foregroundOnly: false;
2323
+ readonly contexts: ["background"];
2324
+ readonly namespace: "smartDomReader";
2325
+ };
2326
+ readonly sessions: {
2327
+ readonly platform: "all";
2328
+ readonly channel: "stable";
2329
+ readonly manifestVersions: [2, 3];
2330
+ readonly requiresPolicy: false;
2331
+ readonly foregroundOnly: false;
2332
+ readonly contexts: ["background"];
2333
+ readonly namespace: "sessions";
2334
+ };
2335
+ readonly sidePanel: {
2336
+ readonly minChromeVersion: 114;
2337
+ readonly platform: "all";
2338
+ readonly channel: "stable";
2339
+ readonly manifestVersions: [3];
2340
+ readonly requiresPolicy: false;
2341
+ readonly foregroundOnly: false;
2342
+ readonly contexts: ["background"];
2343
+ readonly namespace: "sidePanel";
2344
+ };
2345
+ readonly storage: {
2346
+ readonly platform: "all";
2347
+ readonly channel: "stable";
2348
+ readonly manifestVersions: [2, 3];
2349
+ readonly requiresPolicy: false;
2350
+ readonly foregroundOnly: false;
2351
+ readonly contexts: ["all"];
2352
+ readonly namespace: "storage";
2353
+ };
2354
+ readonly "system.cpu": {
2355
+ readonly platform: "all";
2356
+ readonly channel: "stable";
2357
+ readonly manifestVersions: [2, 3];
2358
+ readonly requiresPolicy: false;
2359
+ readonly foregroundOnly: false;
2360
+ readonly contexts: ["background"];
2361
+ readonly namespace: "system.cpu";
2362
+ };
2363
+ readonly "system.display": {
2364
+ readonly platform: "all";
2365
+ readonly channel: "stable";
2366
+ readonly manifestVersions: [2, 3];
2367
+ readonly requiresPolicy: false;
2368
+ readonly foregroundOnly: false;
2369
+ readonly contexts: ["background"];
2370
+ readonly namespace: "system.display";
2371
+ };
2372
+ readonly "system.memory": {
2373
+ readonly platform: "all";
2374
+ readonly channel: "stable";
2375
+ readonly manifestVersions: [2, 3];
2376
+ readonly requiresPolicy: false;
2377
+ readonly foregroundOnly: false;
2378
+ readonly contexts: ["background"];
2379
+ readonly namespace: "system.memory";
2380
+ };
2381
+ readonly "system.storage": {
2382
+ readonly platform: "all";
2383
+ readonly channel: "stable";
2384
+ readonly manifestVersions: [2, 3];
2385
+ readonly requiresPolicy: false;
2386
+ readonly foregroundOnly: false;
2387
+ readonly contexts: ["background"];
2388
+ readonly namespace: "system.storage";
2389
+ };
2390
+ readonly systemLog: {
2391
+ readonly minChromeVersion: 125;
2392
+ readonly platform: "chromeos";
2393
+ readonly channel: "stable";
2394
+ readonly manifestVersions: [2, 3];
2395
+ readonly requiresPolicy: true;
2396
+ readonly foregroundOnly: false;
2397
+ readonly contexts: ["background"];
2398
+ readonly namespace: "systemLog";
2399
+ };
2400
+ readonly tabCapture: {
2401
+ readonly platform: "all";
2402
+ readonly channel: "stable";
2403
+ readonly manifestVersions: [2, 3];
2404
+ readonly requiresPolicy: false;
2405
+ readonly foregroundOnly: false;
2406
+ readonly contexts: ["background"];
2407
+ readonly namespace: "tabCapture";
2408
+ };
2409
+ readonly tabGroups: {
2410
+ readonly minChromeVersion: 89;
2411
+ readonly platform: "all";
2412
+ readonly channel: "stable";
2413
+ readonly manifestVersions: [3];
2414
+ readonly requiresPolicy: false;
2415
+ readonly foregroundOnly: false;
2416
+ readonly contexts: ["background"];
2417
+ readonly namespace: "tabGroups";
2418
+ };
2419
+ readonly tabs: {
2420
+ readonly platform: "all";
2421
+ readonly channel: "stable";
2422
+ readonly manifestVersions: [2, 3];
2423
+ readonly requiresPolicy: false;
2424
+ readonly foregroundOnly: false;
2425
+ readonly contexts: ["background", "content"];
2426
+ readonly namespace: "tabs";
2427
+ };
2428
+ readonly topSites: {
2429
+ readonly platform: "all";
2430
+ readonly channel: "stable";
2431
+ readonly manifestVersions: [2, 3];
2432
+ readonly requiresPolicy: false;
2433
+ readonly foregroundOnly: false;
2434
+ readonly contexts: ["background"];
2435
+ readonly namespace: "topSites";
2436
+ };
2437
+ readonly tts: {
2438
+ readonly platform: "all";
2439
+ readonly channel: "stable";
2440
+ readonly manifestVersions: [2, 3];
2441
+ readonly requiresPolicy: false;
2442
+ readonly foregroundOnly: false;
2443
+ readonly contexts: ["background"];
2444
+ readonly namespace: "tts";
2445
+ };
2446
+ readonly ttsEngine: {
2447
+ readonly platform: "all";
2448
+ readonly channel: "stable";
2449
+ readonly manifestVersions: [2, 3];
2450
+ readonly requiresPolicy: false;
2451
+ readonly foregroundOnly: false;
2452
+ readonly contexts: ["background"];
2453
+ readonly namespace: "ttsEngine";
2454
+ };
2455
+ readonly types: {
2456
+ readonly platform: "all";
2457
+ readonly channel: "stable";
2458
+ readonly manifestVersions: [2, 3];
2459
+ readonly requiresPolicy: false;
2460
+ readonly foregroundOnly: false;
2461
+ readonly contexts: ["all"];
2462
+ readonly namespace: "types";
2463
+ };
2464
+ readonly userScripts: {
2465
+ readonly minChromeVersion: 120;
2466
+ readonly platform: "all";
2467
+ readonly channel: "stable";
2468
+ readonly manifestVersions: [3];
2469
+ readonly requiresPolicy: false;
2470
+ readonly foregroundOnly: false;
2471
+ readonly contexts: ["background"];
2472
+ readonly namespace: "userScripts";
2473
+ };
2474
+ readonly vpnProvider: {
2475
+ readonly minChromeVersion: 43;
2476
+ readonly platform: "chromeos";
2477
+ readonly channel: "stable";
2478
+ readonly manifestVersions: [2, 3];
2479
+ readonly requiresPolicy: false;
2480
+ readonly foregroundOnly: false;
2481
+ readonly contexts: ["background"];
2482
+ readonly namespace: "vpnProvider";
2483
+ };
2484
+ readonly wallpaper: {
2485
+ readonly minChromeVersion: 43;
2486
+ readonly platform: "chromeos";
2487
+ readonly channel: "stable";
2488
+ readonly manifestVersions: [2, 3];
2489
+ readonly requiresPolicy: false;
2490
+ readonly foregroundOnly: false;
2491
+ readonly contexts: ["background"];
2492
+ readonly namespace: "wallpaper";
2493
+ };
2494
+ readonly webAuthenticationProxy: {
2495
+ readonly minChromeVersion: 115;
2496
+ readonly platform: "all";
2497
+ readonly channel: "stable";
2498
+ readonly manifestVersions: [3];
2499
+ readonly requiresPolicy: false;
2500
+ readonly foregroundOnly: false;
2501
+ readonly contexts: ["background"];
2502
+ readonly namespace: "webAuthenticationProxy";
2503
+ };
2504
+ readonly webNavigation: {
2505
+ readonly platform: "all";
2506
+ readonly channel: "stable";
2507
+ readonly manifestVersions: [2, 3];
2508
+ readonly requiresPolicy: false;
2509
+ readonly foregroundOnly: false;
2510
+ readonly contexts: ["background"];
2511
+ readonly namespace: "webNavigation";
2512
+ };
2513
+ readonly webRequest: {
2514
+ readonly platform: "all";
2515
+ readonly channel: "stable";
2516
+ readonly manifestVersions: [2, 3];
2517
+ readonly requiresPolicy: false;
2518
+ readonly foregroundOnly: false;
2519
+ readonly contexts: ["background"];
2520
+ readonly namespace: "webRequest";
2521
+ };
2522
+ readonly windows: {
2523
+ readonly platform: "all";
2524
+ readonly channel: "stable";
2525
+ readonly manifestVersions: [2, 3];
2526
+ readonly requiresPolicy: false;
2527
+ readonly foregroundOnly: false;
2528
+ readonly contexts: ["background"];
2529
+ readonly namespace: "windows";
2530
+ };
2448
2531
  };
2449
2532
  /**
2450
2533
  * Helper function to check if an API is available in the current context
@@ -2453,10 +2536,51 @@ declare function isApiAvailable(api: ChromeApi, context: ChromeContext, manifest
2453
2536
  /**
2454
2537
  * Get the Chrome API object reference by API enum
2455
2538
  */
2456
- declare function getChromeApiReference(api: ChromeApi): any;
2539
+ declare function getChromeApiReference(api: ChromeApi): unknown;
2457
2540
  /**
2458
2541
  * Get all available APIs for a given context and manifest version
2459
2542
  */
2460
2543
  declare function getAvailableApis(context: ChromeContext, manifestVersion: 2 | 3, platform?: ChromePlatform, chromeVersion?: number): ChromeApi[];
2461
-
2462
- export { AlarmsApiTools, type AlarmsApiToolsOptions, type ApiAvailability, AudioApiTools, type AudioApiToolsOptions, BOOKMARK_ACTIONS, BaseApiTools, BookmarksApiTools, type BookmarksApiToolsOptions, BrowsingDataApiTools, type BrowsingDataApiToolsOptions, CHROME_API_REGISTRY, CertificateProviderApiTools, type CertificateProviderApiToolsOptions, ChromeApi, type ChromeApiMetadata, ChromeApiMetadataSchema, type ChromeChannel, ChromeChannelSchema, type ChromeContext, ChromeContextSchema, type ChromePlatform, ChromePlatformSchema, CommandsApiTools, type CommandsApiToolsOptions, ContentSettingsApiTools, type ContentSettingsApiToolsOptions, ContextMenusApiTools, type ContextMenusApiToolsOptions, CookiesApiTools, type CookiesApiToolsOptions, DebuggerApiTools, type DebuggerApiToolsOptions, DeclarativeContentApiTools, type DeclarativeContentApiToolsOptions, DeclarativeNetRequestApiTools, type DeclarativeNetRequestApiToolsOptions, DesktopCaptureApiTools, type DesktopCaptureApiToolsOptions, DevtoolsInspectedWindowApiTools, type DevtoolsInspectedWindowApiToolsOptions, DevtoolsNetworkApiTools, type DevtoolsNetworkApiToolsOptions, DevtoolsPanelsApiTools, type DevtoolsPanelsApiToolsOptions, DocumentScanApiTools, type DocumentScanApiToolsOptions, DomApiTools, type DomApiToolsOptions, DownloadsApiTools, type DownloadsApiToolsOptions, EnterpriseDeviceAttributesApiTools, type EnterpriseDeviceAttributesApiToolsOptions, EnterpriseHardwarePlatformApiTools, type EnterpriseHardwarePlatformApiToolsOptions, EnterpriseNetworkingAttributesApiTools, type EnterpriseNetworkingAttributesApiToolsOptions, EnterprisePlatformKeysApiTools, type EnterprisePlatformKeysApiToolsOptions, ExtensionApiTools, type ExtensionApiToolsOptions, FileBrowserHandlerApiTools, type FileBrowserHandlerApiToolsOptions, FileSystemProviderApiTools, type FileSystemProviderApiToolsOptions, FontSettingsApiTools, type FontSettingsApiToolsOptions, GcmApiTools, type GcmApiToolsOptions, HISTORY_ACTIONS, HistoryApiTools, type HistoryApiToolsOptions, I18nApiTools, type I18nApiToolsOptions, IdentityApiTools, type IdentityApiToolsOptions, IdleApiTools, type IdleApiToolsOptions, InputImeApiTools, type InputImeApiToolsOptions, InstanceIDApiTools, type InstanceIDApiToolsOptions, LoginStateApiTools, type LoginStateApiToolsOptions, ManagementApiTools, type ManagementApiToolsOptions, NotificationsApiTools, type NotificationsApiToolsOptions, OffscreenApiTools, type OffscreenApiToolsOptions, OmniboxApiTools, type OmniboxApiToolsOptions, PageCaptureApiTools, type PageCaptureApiToolsOptions, PermissionsApiTools, type PermissionsApiToolsOptions, PlatformKeysApiTools, type PlatformKeysApiToolsOptions, PowerApiTools, type PowerApiToolsOptions, PrintingApiTools, type PrintingApiToolsOptions, PrintingMetricsApiTools, type PrintingMetricsApiToolsOptions, ProxyApiTools, type ProxyApiToolsOptions, ReadingListApiTools, type ReadingListApiToolsOptions, RuntimeApiTools, type RuntimeApiToolsOptions, STORAGE_ACTIONS, ScriptingApiTools, type ScriptingApiToolsOptions, SearchApiTools, type SearchApiToolsOptions, SessionsApiTools, type SessionsApiToolsOptions, SidePanelApiTools, type SidePanelApiToolsOptions, StorageApiTools, type StorageApiToolsOptions, SystemCpuApiTools, type SystemCpuApiToolsOptions, SystemLogApiTools, type SystemLogApiToolsOptions, SystemMemoryApiTools, type SystemMemoryApiToolsOptions, SystemStorageApiTools, type SystemStorageApiToolsOptions, TAB_ACTIONS, TAB_GROUP_ACTIONS, TabCaptureApiTools, type TabCaptureApiToolsOptions, TabGroupsApiTools, type TabGroupsApiToolsOptions, TabsApiTools, type TabsApiToolsOptions, TopSitesApiTools, type TopSitesApiToolsOptions, TtsApiTools, type TtsApiToolsOptions, TtsEngineApiTools, type TtsEngineApiToolsOptions, UserScriptsApiTools, type UserScriptsApiToolsOptions, VpnProviderApiTools, type VpnProviderApiToolsOptions, WINDOW_ACTIONS, WallpaperApiTools, type WallpaperApiToolsOptions, WebAuthenticationProxyApiTools, type WebAuthenticationProxyApiToolsOptions, WebNavigationApiTools, type WebNavigationApiToolsOptions, WebRequestApiTools, type WebRequestApiToolsOptions, WindowsApiTools, type WindowsApiToolsOptions, getAvailableApis, getChromeApiReference, isApiAvailable };
2544
+ //#endregion
2545
+ //#region src/DomExtractionTools.d.ts
2546
+ interface DomExtractionToolsOptions {
2547
+ extractStructure?: boolean;
2548
+ extractRegion?: boolean;
2549
+ extractContent?: boolean;
2550
+ }
2551
+ /**
2552
+ * DOM Extraction Tools for AI Browser Agents
2553
+ *
2554
+ * Provides step-by-step DOM extraction optimized for token efficiency.
2555
+ * Designed for AI agents to progressively understand and interact with web pages.
2556
+ *
2557
+ * Workflow:
2558
+ * 1. extractStructure - Get high-level page overview (minimal tokens)
2559
+ * 2. extractRegion - Extract details from specific region based on structure
2560
+ * 3. extractContent - Get readable content from a region
2561
+ *
2562
+ * Uses chrome.userScripts.execute to dynamically import the Smart DOM Reader
2563
+ * module inside the page context and immediately return structured data without
2564
+ * mutating window scope.
2565
+ */
2566
+ declare class DomExtractionTools extends BaseApiTools<DomExtractionToolsOptions> {
2567
+ protected apiName: string;
2568
+ private bundleScript;
2569
+ private userScriptsSupport;
2570
+ constructor(server: McpServer, options?: DomExtractionToolsOptions);
2571
+ private getBundleScript;
2572
+ private resolveTabId;
2573
+ private canUseUserScripts;
2574
+ private isExtractionError;
2575
+ private ensureUserScriptsEnabled;
2576
+ private serializeArgs;
2577
+ private executeExtraction;
2578
+ checkAvailability(): ApiAvailability;
2579
+ registerTools(): void;
2580
+ private registerExtractStructure;
2581
+ private registerExtractRegion;
2582
+ private registerExtractContent;
2583
+ }
2584
+ //#endregion
2585
+ export { AlarmsApiTools, AlarmsApiToolsOptions, ApiAvailability, AudioApiTools, AudioApiToolsOptions, BOOKMARK_ACTIONS, BaseApiTools, BookmarksApiTools, BookmarksApiToolsOptions, BrowsingDataApiTools, BrowsingDataApiToolsOptions, CHROME_API_REGISTRY, CertificateProviderApiTools, CertificateProviderApiToolsOptions, ChromeApi, ChromeApiMetadata, ChromeApiMetadataSchema, ChromeChannel, ChromeChannelSchema, ChromeContext, ChromeContextSchema, ChromePlatform, ChromePlatformSchema, CommandsApiTools, CommandsApiToolsOptions, ContentSettingsApiTools, ContentSettingsApiToolsOptions, ContextMenusApiTools, ContextMenusApiToolsOptions, CookiesApiTools, CookiesApiToolsOptions, DebuggerApiTools, DebuggerApiToolsOptions, DeclarativeContentApiTools, DeclarativeContentApiToolsOptions, DeclarativeNetRequestApiTools, DeclarativeNetRequestApiToolsOptions, DesktopCaptureApiTools, DesktopCaptureApiToolsOptions, DevtoolsInspectedWindowApiTools, DevtoolsInspectedWindowApiToolsOptions, DevtoolsNetworkApiTools, DevtoolsNetworkApiToolsOptions, DevtoolsPanelsApiTools, DevtoolsPanelsApiToolsOptions, DocumentScanApiTools, DocumentScanApiToolsOptions, DomApiTools, DomApiToolsOptions, DomExtractionTools, DomExtractionToolsOptions, DownloadsApiTools, DownloadsApiToolsOptions, EnterpriseDeviceAttributesApiTools, EnterpriseDeviceAttributesApiToolsOptions, EnterpriseHardwarePlatformApiTools, EnterpriseHardwarePlatformApiToolsOptions, EnterpriseNetworkingAttributesApiTools, EnterpriseNetworkingAttributesApiToolsOptions, EnterprisePlatformKeysApiTools, EnterprisePlatformKeysApiToolsOptions, ExtensionApiTools, ExtensionApiToolsOptions, FileBrowserHandlerApiTools, FileBrowserHandlerApiToolsOptions, FileSystemProviderApiTools, FileSystemProviderApiToolsOptions, FontSettingsApiTools, FontSettingsApiToolsOptions, GcmApiTools, GcmApiToolsOptions, HISTORY_ACTIONS, HistoryApiTools, HistoryApiToolsOptions, I18nApiTools, I18nApiToolsOptions, IdentityApiTools, IdentityApiToolsOptions, IdleApiTools, IdleApiToolsOptions, InputImeApiTools, InputImeApiToolsOptions, InstanceIDApiTools, InstanceIDApiToolsOptions, LoginStateApiTools, LoginStateApiToolsOptions, ManagementApiTools, ManagementApiToolsOptions, NotificationsApiTools, NotificationsApiToolsOptions, OffscreenApiTools, OffscreenApiToolsOptions, OmniboxApiTools, OmniboxApiToolsOptions, PageCaptureApiTools, PageCaptureApiToolsOptions, PermissionsApiTools, PermissionsApiToolsOptions, PlatformKeysApiTools, PlatformKeysApiToolsOptions, PowerApiTools, PowerApiToolsOptions, PrintingApiTools, PrintingApiToolsOptions, PrintingMetricsApiTools, PrintingMetricsApiToolsOptions, ProxyApiTools, ProxyApiToolsOptions, ReadingListApiTools, ReadingListApiToolsOptions, RuntimeApiTools, RuntimeApiToolsOptions, STORAGE_ACTIONS, ScriptingApiTools, ScriptingApiToolsOptions, SearchApiTools, SearchApiToolsOptions, SessionsApiTools, SessionsApiToolsOptions, SidePanelApiTools, SidePanelApiToolsOptions, StorageApiTools, StorageApiToolsOptions, SystemCpuApiTools, SystemCpuApiToolsOptions, SystemLogApiTools, SystemLogApiToolsOptions, SystemMemoryApiTools, SystemMemoryApiToolsOptions, SystemStorageApiTools, SystemStorageApiToolsOptions, TAB_ACTIONS, TAB_GROUP_ACTIONS, TabCaptureApiTools, TabCaptureApiToolsOptions, TabGroupsApiTools, TabGroupsApiToolsOptions, TabsApiTools, TabsApiToolsOptions, TopSitesApiTools, TopSitesApiToolsOptions, TtsApiTools, TtsApiToolsOptions, TtsEngineApiTools, TtsEngineApiToolsOptions, UserScriptsApiTools, UserScriptsApiToolsOptions, VpnProviderApiTools, VpnProviderApiToolsOptions, WINDOW_ACTIONS, WallpaperApiTools, WallpaperApiToolsOptions, WebAuthenticationProxyApiTools, WebAuthenticationProxyApiToolsOptions, WebNavigationApiTools, WebNavigationApiToolsOptions, WebRequestApiTools, WebRequestApiToolsOptions, WindowsApiTools, WindowsApiToolsOptions, getAvailableApis, getChromeApiReference, isApiAvailable };
2586
+ //# sourceMappingURL=index.d.ts.map