@mcp-b/extension-tools/dist/index.d.ts

Chrome Extension API tools for Model Context Protocol (MCP) - provides MCP-compatible wrappers for browser extension APIs

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';

interface ApiAvailability {
    available: boolean;
    message: string;
    details?: string;
}
declare abstract class BaseApiTools {
    protected server: McpServer;
    protected options: any;
    protected abstract apiName: string;
    constructor(server: McpServer, options?: any);
    abstract checkAvailability(): ApiAvailability;
    abstract registerTools(): void;
    protected shouldRegisterTool(toolName: string): boolean;
    protected formatError(error: unknown): CallToolResult;
    protected formatSuccess(message: string, data?: any): CallToolResult;
    protected formatJson(data: any): CallToolResult;
    register(): void;
}

interface AlarmsApiToolsOptions {
    createAlarm?: boolean;
    getAlarm?: boolean;
    getAllAlarms?: boolean;
    clearAlarm?: boolean;
    clearAllAlarms?: boolean;
}
declare class AlarmsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: AlarmsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreateAlarm;
    private registerGetAlarm;
    private registerGetAllAlarms;
    private registerClearAlarm;
    private registerClearAllAlarms;
}

interface AudioApiToolsOptions {
    getDevices?: boolean;
    getMute?: boolean;
    setActiveDevices?: boolean;
    setMute?: boolean;
    setProperties?: boolean;
}
declare class AudioApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: AudioApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetDevices;
    private registerGetMute;
    private registerSetActiveDevices;
    private registerSetMute;
    private registerSetProperties;
}

interface BookmarksApiToolsOptions {
    create?: boolean;
    get?: boolean;
    getChildren?: boolean;
    getRecent?: boolean;
    getSubTree?: boolean;
    getTree?: boolean;
    move?: boolean;
    remove?: boolean;
    removeTree?: boolean;
    search?: boolean;
    update?: boolean;
}
declare class BookmarksApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: BookmarksApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreate;
    private registerGet;
    private registerGetChildren;
    private registerGetRecent;
    private registerGetSubTree;
    private registerGetTree;
    private registerMove;
    private registerRemove;
    private registerRemoveTree;
    private registerSearch;
    private registerUpdate;
}

interface BrowsingDataApiToolsOptions {
    remove?: boolean;
    removeAppcache?: boolean;
    removeCache?: boolean;
    removeCacheStorage?: boolean;
    removeCookies?: boolean;
    removeDownloads?: boolean;
    removeFileSystems?: boolean;
    removeFormData?: boolean;
    removeHistory?: boolean;
    removeIndexedDB?: boolean;
    removeLocalStorage?: boolean;
    removePasswords?: boolean;
    removeServiceWorkers?: boolean;
    removeWebSQL?: boolean;
    settings?: boolean;
}
declare class BrowsingDataApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: BrowsingDataApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerRemove;
    private registerRemoveAppcache;
    private registerRemoveCache;
    private registerRemoveCacheStorage;
    private registerRemoveCookies;
    private registerRemoveDownloads;
    private registerRemoveFileSystems;
    private registerRemoveFormData;
    private registerRemoveHistory;
    private registerRemoveIndexedDB;
    private registerRemoveLocalStorage;
    private registerRemovePasswords;
    private registerRemoveServiceWorkers;
    private registerRemoveWebSQL;
    private registerSettings;
}

interface CertificateProviderApiToolsOptions {
    setCertificates?: boolean;
    reportSignature?: boolean;
    requestPin?: boolean;
    stopPinRequest?: boolean;
    onCertificatesUpdateRequested?: boolean;
    onSignatureRequested?: boolean;
}
declare class CertificateProviderApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: CertificateProviderApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSetCertificates;
    private registerReportSignature;
    private registerRequestPin;
    private registerStopPinRequest;
    private registerOnCertificatesUpdateRequested;
    private registerOnSignatureRequested;
    private handleCertificatesUpdateRequested;
    private handleSignatureRequested;
}

interface CommandsApiToolsOptions {
    getAll?: boolean;
}
declare class CommandsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: CommandsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetAll;
}

interface ContentSettingsApiToolsOptions {
    getCookiesSetting?: boolean;
    setCookiesSetting?: boolean;
    clearCookiesSetting?: boolean;
    getJavascriptSetting?: boolean;
    setJavascriptSetting?: boolean;
    clearJavascriptSetting?: boolean;
    getImagesSetting?: boolean;
    setImagesSetting?: boolean;
    clearImagesSetting?: boolean;
    getLocationSetting?: boolean;
    setLocationSetting?: boolean;
    clearLocationSetting?: boolean;
    getNotificationsSetting?: boolean;
    setNotificationsSetting?: boolean;
    clearNotificationsSetting?: boolean;
    getPopupsSetting?: boolean;
    setPopupsSetting?: boolean;
    clearPopupsSetting?: boolean;
    getCameraSetting?: boolean;
    setCameraSetting?: boolean;
    clearCameraSetting?: boolean;
    getMicrophoneSetting?: boolean;
    setMicrophoneSetting?: boolean;
    clearMicrophoneSetting?: boolean;
    getAutomaticDownloadsSetting?: boolean;
    setAutomaticDownloadsSetting?: boolean;
    clearAutomaticDownloadsSetting?: boolean;
    getClipboardSetting?: boolean;
    setClipboardSetting?: boolean;
    clearClipboardSetting?: boolean;
    getAutoVerifySetting?: boolean;
    setAutoVerifySetting?: boolean;
    clearAutoVerifySetting?: boolean;
    getPluginsResourceIdentifiers?: boolean;
}
declare class ContentSettingsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ContentSettingsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetCookiesSetting;
    private registerSetCookiesSetting;
    private registerClearCookiesSetting;
    private registerGetJavascriptSetting;
    private registerSetJavascriptSetting;
    private registerClearJavascriptSetting;
    private registerGetImagesSetting;
    private registerSetImagesSetting;
    private registerClearImagesSetting;
    private registerGetLocationSetting;
    private registerSetLocationSetting;
    private registerClearLocationSetting;
    private registerGetNotificationsSetting;
    private registerSetNotificationsSetting;
    private registerClearNotificationsSetting;
    private registerGetPopupsSetting;
    private registerSetPopupsSetting;
    private registerClearPopupsSetting;
    private registerGetCameraSetting;
    private registerSetCameraSetting;
    private registerClearCameraSetting;
    private registerGetMicrophoneSetting;
    private registerSetMicrophoneSetting;
    private registerClearMicrophoneSetting;
    private registerGetAutomaticDownloadsSetting;
    private registerSetAutomaticDownloadsSetting;
    private registerClearAutomaticDownloadsSetting;
    private registerGetClipboardSetting;
    private registerSetClipboardSetting;
    private registerClearClipboardSetting;
    private registerGetAutoVerifySetting;
    private registerSetAutoVerifySetting;
    private registerClearAutoVerifySetting;
    private registerGetPluginsResourceIdentifiers;
}

interface ContextMenusApiToolsOptions {
    createContextMenu?: boolean;
    updateContextMenu?: boolean;
    removeContextMenu?: boolean;
    removeAllContextMenus?: boolean;
}
declare class ContextMenusApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ContextMenusApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreateContextMenu;
    private registerUpdateContextMenu;
    private registerRemoveContextMenu;
    private registerRemoveAllContextMenus;
}

interface CookiesApiToolsOptions {
    getCookie?: boolean;
    getAllCookies?: boolean;
    getAllCookieStores?: boolean;
    getPartitionKey?: boolean;
    setCookie?: boolean;
    removeCookie?: boolean;
}
declare class CookiesApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: CookiesApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetCookie;
    private registerGetAllCookies;
    private registerGetAllCookieStores;
    private registerGetPartitionKey;
    private registerSetCookie;
    private registerRemoveCookie;
}

interface DebuggerApiToolsOptions {
    attach?: boolean;
    detach?: boolean;
    sendCommand?: boolean;
    getTargets?: boolean;
}
declare class DebuggerApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DebuggerApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAttach;
    private registerDetach;
    private registerSendCommand;
    private registerGetTargets;
}

interface DeclarativeContentApiToolsOptions {
    addRules?: boolean;
    removeRules?: boolean;
    getRules?: boolean;
}
declare class DeclarativeContentApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DeclarativeContentApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAddRules;
    private registerRemoveRules;
    private registerGetRules;
}

interface DeclarativeNetRequestApiToolsOptions {
    getDynamicRules?: boolean;
    updateDynamicRules?: boolean;
    getSessionRules?: boolean;
    updateSessionRules?: boolean;
    getEnabledRulesets?: boolean;
    updateEnabledRulesets?: boolean;
    updateStaticRules?: boolean;
    getAvailableStaticRuleCount?: boolean;
    getMatchedRules?: boolean;
    isRegexSupported?: boolean;
    testMatchOutcome?: boolean;
    setExtensionActionOptions?: boolean;
}
declare class DeclarativeNetRequestApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DeclarativeNetRequestApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetDynamicRules;
    private registerUpdateDynamicRules;
    private registerGetSessionRules;
    private registerUpdateSessionRules;
    private registerGetEnabledRulesets;
    private registerUpdateEnabledRulesets;
    private registerUpdateStaticRules;
    private registerGetAvailableStaticRuleCount;
    private registerGetMatchedRules;
    private registerIsRegexSupported;
    private registerTestMatchOutcome;
    private registerSetExtensionActionOptions;
}

interface DesktopCaptureApiToolsOptions {
    chooseDesktopMedia?: boolean;
    cancelChooseDesktopMedia?: boolean;
}
declare class DesktopCaptureApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DesktopCaptureApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerChooseDesktopMedia;
    private registerCancelChooseDesktopMedia;
}

interface DevtoolsInspectedWindowApiToolsOptions {
    eval?: boolean;
    reload?: boolean;
    getResources?: boolean;
}
declare class DevtoolsInspectedWindowApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DevtoolsInspectedWindowApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerEval;
    private registerReload;
    private registerGetResources;
}

interface DevtoolsNetworkApiToolsOptions {
    getHAR?: boolean;
    onNavigated?: boolean;
    onRequestFinished?: boolean;
}
declare class DevtoolsNetworkApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DevtoolsNetworkApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetHAR;
    private registerOnNavigated;
    private registerOnRequestFinished;
}

interface DevtoolsPanelsApiToolsOptions {
    createPanel?: boolean;
    createSidebarPane?: boolean;
    getThemeColor?: boolean;
    openResource?: boolean;
    setOpenResourceHandler?: boolean;
}
declare class DevtoolsPanelsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DevtoolsPanelsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreatePanel;
    private registerCreateSidebarPane;
    private registerGetThemeColor;
    private registerOpenResource;
    private registerSetOpenResourceHandler;
}

interface DocumentScanApiToolsOptions {
    scan?: boolean;
    getScannerList?: boolean;
    openScanner?: boolean;
    closeScanner?: boolean;
    getOptionGroups?: boolean;
    setOptions?: boolean;
    startScan?: boolean;
    readScanData?: boolean;
    cancelScan?: boolean;
}
declare class DocumentScanApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DocumentScanApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerScan;
    private registerGetScannerList;
    private registerOpenScanner;
    private registerCloseScanner;
    private registerGetOptionGroups;
    private registerSetOptions;
    private registerStartScan;
    private registerReadScanData;
    private registerCancelScan;
}

interface DomApiToolsOptions {
    openOrClosedShadowRoot?: boolean;
}
declare class DomApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DomApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerOpenOrClosedShadowRoot;
}

interface DownloadsApiToolsOptions {
    download?: boolean;
    search?: boolean;
    pause?: boolean;
    resume?: boolean;
    cancel?: boolean;
    getFileIcon?: boolean;
    open?: boolean;
    show?: boolean;
    showDefaultFolder?: boolean;
    erase?: boolean;
    removeFile?: boolean;
    acceptDanger?: boolean;
    setUiOptions?: boolean;
}
declare class DownloadsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: DownloadsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerDownload;
    private registerSearch;
    private registerPause;
    private registerResume;
    private registerCancel;
    private registerGetFileIcon;
    private registerOpen;
    private registerShow;
    private registerShowDefaultFolder;
    private registerErase;
    private registerRemoveFile;
    private registerAcceptDanger;
    private registerSetUiOptions;
}

interface EnterpriseDeviceAttributesApiToolsOptions {
    getDirectoryDeviceId?: boolean;
    getDeviceSerialNumber?: boolean;
    getDeviceAssetId?: boolean;
    getDeviceAnnotatedLocation?: boolean;
    getDeviceHostname?: boolean;
}
declare class EnterpriseDeviceAttributesApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: EnterpriseDeviceAttributesApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetDirectoryDeviceId;
    private registerGetDeviceSerialNumber;
    private registerGetDeviceAssetId;
    private registerGetDeviceAnnotatedLocation;
    private registerGetDeviceHostname;
}

interface EnterpriseHardwarePlatformApiToolsOptions {
    getHardwarePlatformInfo?: boolean;
}
declare class EnterpriseHardwarePlatformApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: EnterpriseHardwarePlatformApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetHardwarePlatformInfo;
}

interface EnterpriseNetworkingAttributesApiToolsOptions {
    getNetworkDetails?: boolean;
}
declare class EnterpriseNetworkingAttributesApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: EnterpriseNetworkingAttributesApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetNetworkDetails;
}

interface EnterprisePlatformKeysApiToolsOptions {
    getTokens?: boolean;
    getCertificates?: boolean;
    importCertificate?: boolean;
    removeCertificate?: boolean;
    challengeMachineKey?: boolean;
    challengeUserKey?: boolean;
}
declare class EnterprisePlatformKeysApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: EnterprisePlatformKeysApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetTokens;
    private registerGetCertificates;
    private registerImportCertificate;
    private registerRemoveCertificate;
    private registerChallengeMachineKey;
    private registerChallengeUserKey;
}

interface ExtensionApiToolsOptions {
    getBackgroundPage?: boolean;
    getViews?: boolean;
    isAllowedFileSchemeAccess?: boolean;
    isAllowedIncognitoAccess?: boolean;
    setUpdateUrlData?: boolean;
}
declare class ExtensionApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ExtensionApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetBackgroundPage;
    private registerGetViews;
    private registerIsAllowedFileSchemeAccess;
    private registerIsAllowedIncognitoAccess;
    private registerSetUpdateUrlData;
}

interface FileBrowserHandlerApiToolsOptions {
    getExecuteEventDetails?: boolean;
    addExecuteListener?: boolean;
    removeExecuteListener?: boolean;
}
declare class FileBrowserHandlerApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: FileBrowserHandlerApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetExecuteEventDetails;
    private registerAddExecuteListener;
    private registerRemoveExecuteListener;
}

interface FileSystemProviderApiToolsOptions {
    mount?: boolean;
    unmount?: boolean;
    get?: boolean;
    getAll?: boolean;
    notify?: boolean;
}
declare class FileSystemProviderApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: FileSystemProviderApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerMount;
    private registerUnmount;
    private registerGet;
    private registerGetAll;
    private registerNotify;
}

interface FontSettingsApiToolsOptions {
    getFont?: boolean;
    setFont?: boolean;
    clearFont?: boolean;
    getFontList?: boolean;
    getDefaultFontSize?: boolean;
    setDefaultFontSize?: boolean;
    clearDefaultFontSize?: boolean;
    getDefaultFixedFontSize?: boolean;
    setDefaultFixedFontSize?: boolean;
    clearDefaultFixedFontSize?: boolean;
    getMinimumFontSize?: boolean;
    setMinimumFontSize?: boolean;
    clearMinimumFontSize?: boolean;
}
declare class FontSettingsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: FontSettingsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetFont;
    private registerSetFont;
    private registerClearFont;
    private registerGetFontList;
    private registerGetDefaultFontSize;
    private registerSetDefaultFontSize;
    private registerClearDefaultFontSize;
    private registerGetDefaultFixedFontSize;
    private registerSetDefaultFixedFontSize;
    private registerClearDefaultFixedFontSize;
    private registerGetMinimumFontSize;
    private registerSetMinimumFontSize;
    private registerClearMinimumFontSize;
}

interface GcmApiToolsOptions {
    register?: boolean;
    send?: boolean;
    unregister?: boolean;
}
declare class GcmApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: GcmApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerRegister;
    private registerSend;
    private registerUnregister;
}

interface HistoryApiToolsOptions {
    addUrl?: boolean;
    deleteAll?: boolean;
    deleteRange?: boolean;
    deleteUrl?: boolean;
    getVisits?: boolean;
    search?: boolean;
}
declare class HistoryApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: HistoryApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAddUrl;
    private registerDeleteAll;
    private registerDeleteRange;
    private registerDeleteUrl;
    private registerGetVisits;
    private registerSearch;
}

interface I18nApiToolsOptions {
    getMessage?: boolean;
    getUILanguage?: boolean;
    getAcceptLanguages?: boolean;
    detectLanguage?: boolean;
}
declare class I18nApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: I18nApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetMessage;
    private registerGetUILanguage;
    private registerGetAcceptLanguages;
    private registerDetectLanguage;
}

interface IdentityApiToolsOptions {
    getAuthToken?: boolean;
    getProfileUserInfo?: boolean;
    getAccounts?: boolean;
    getRedirectURL?: boolean;
    launchWebAuthFlow?: boolean;
    removeCachedAuthToken?: boolean;
    clearAllCachedAuthTokens?: boolean;
}
declare class IdentityApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: IdentityApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetAuthToken;
    private registerGetProfileUserInfo;
    private registerGetAccounts;
    private registerGetRedirectURL;
    private registerLaunchWebAuthFlow;
    private registerRemoveCachedAuthToken;
    private registerClearAllCachedAuthTokens;
}

interface IdleApiToolsOptions {
    queryState?: boolean;
    setDetectionInterval?: boolean;
    getAutoLockDelay?: boolean;
}
declare class IdleApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: IdleApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerQueryState;
    private registerSetDetectionInterval;
    private registerGetAutoLockDelay;
}

interface InputImeApiToolsOptions {
    setComposition?: boolean;
    clearComposition?: boolean;
    commitText?: boolean;
    sendKeyEvents?: boolean;
    hideInputView?: boolean;
    setCandidateWindowProperties?: boolean;
    setCandidates?: boolean;
    setCursorPosition?: boolean;
    setMenuItems?: boolean;
    updateMenuItems?: boolean;
    deleteSurroundingText?: boolean;
}
declare class InputImeApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: InputImeApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSetComposition;
    private registerClearComposition;
    private registerCommitText;
    private registerSendKeyEvents;
    private registerHideInputView;
    private registerSetCandidateWindowProperties;
    private registerSetCandidates;
    private registerSetCursorPosition;
    private registerSetMenuItems;
    private registerUpdateMenuItems;
    private registerDeleteSurroundingText;
}

interface InstanceIDApiToolsOptions {
    getID?: boolean;
    getCreationTime?: boolean;
    getToken?: boolean;
    deleteToken?: boolean;
    deleteID?: boolean;
}
declare class InstanceIDApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: InstanceIDApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetID;
    private registerGetCreationTime;
    private registerGetToken;
    private registerDeleteToken;
    private registerDeleteID;
}

interface LoginStateApiToolsOptions {
    getProfileType?: boolean;
    getSessionState?: boolean;
}
declare class LoginStateApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: LoginStateApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetProfileType;
    private registerGetSessionState;
}

interface ManagementApiToolsOptions {
    get?: boolean;
    getAll?: boolean;
    getSelf?: boolean;
    setEnabled?: boolean;
    uninstall?: boolean;
    uninstallSelf?: boolean;
    launchApp?: boolean;
    createAppShortcut?: boolean;
    generateAppForLink?: boolean;
    setLaunchType?: boolean;
    getPermissionWarningsById?: boolean;
    getPermissionWarningsByManifest?: boolean;
}
declare class ManagementApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ManagementApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGet;
    private registerGetAll;
    private registerGetSelf;
    private registerSetEnabled;
    private registerUninstall;
    private registerUninstallSelf;
    private registerLaunchApp;
    private registerCreateAppShortcut;
    private registerGenerateAppForLink;
    private registerSetLaunchType;
    private registerGetPermissionWarningsById;
    private registerGetPermissionWarningsByManifest;
}

interface NotificationsApiToolsOptions {
    createNotification?: boolean;
    updateNotification?: boolean;
    clearNotification?: boolean;
    getAllNotifications?: boolean;
    getPermissionLevel?: boolean;
}
declare class NotificationsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: NotificationsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreateNotification;
    private registerUpdateNotification;
    private registerClearNotification;
    private registerGetAllNotifications;
    private registerGetPermissionLevel;
}

interface OffscreenApiToolsOptions {
    createDocument?: boolean;
    closeDocument?: boolean;
    hasOffscreenDocument?: boolean;
}
declare class OffscreenApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: OffscreenApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreateDocument;
    private registerCloseDocument;
    private registerHasOffscreenDocument;
}

interface OmniboxApiToolsOptions {
    setDefaultSuggestion?: boolean;
    onInputStarted?: boolean;
    onInputChanged?: boolean;
    onInputEntered?: boolean;
    onInputCancelled?: boolean;
    onDeleteSuggestion?: boolean;
}
declare class OmniboxApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: OmniboxApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSetDefaultSuggestion;
    private registerOnInputStarted;
    private registerOnInputChanged;
    private registerOnInputEntered;
    private registerOnInputCancelled;
    private registerOnDeleteSuggestion;
}

interface PageCaptureApiToolsOptions {
    saveAsMHTML?: boolean;
}
declare class PageCaptureApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PageCaptureApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSaveAsMHTML;
}

interface PermissionsApiToolsOptions {
    request?: boolean;
    contains?: boolean;
    getAll?: boolean;
    remove?: boolean;
    addHostAccessRequest?: boolean;
    removeHostAccessRequest?: boolean;
}
declare class PermissionsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PermissionsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerRequest;
    private registerContains;
    private registerGetAll;
    private registerRemove;
    private registerAddHostAccessRequest;
    private registerRemoveHostAccessRequest;
}

interface PlatformKeysApiToolsOptions {
    selectClientCertificates?: boolean;
    getKeyPair?: boolean;
    getKeyPairBySpki?: boolean;
    verifyTLSServerCertificate?: boolean;
    getSubtleCrypto?: boolean;
}
declare class PlatformKeysApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PlatformKeysApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSelectClientCertificates;
    private registerGetKeyPair;
    private registerGetKeyPairBySpki;
    private registerVerifyTLSServerCertificate;
    private registerGetSubtleCrypto;
}

interface PowerApiToolsOptions {
    requestKeepAwake?: boolean;
    releaseKeepAwake?: boolean;
    reportActivity?: boolean;
}
declare class PowerApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PowerApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerRequestKeepAwake;
    private registerReleaseKeepAwake;
    private registerReportActivity;
}

interface PrintingApiToolsOptions {
    getPrinters?: boolean;
    getPrinterInfo?: boolean;
    submitJob?: boolean;
    cancelJob?: boolean;
    getJobStatus?: boolean;
}
declare class PrintingApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PrintingApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetPrinters;
    private registerGetPrinterInfo;
    private registerSubmitJob;
    private registerCancelJob;
    private registerGetJobStatus;
    private getJobStatusDescription;
}

interface PrintingMetricsApiToolsOptions {
    getPrintJobs?: boolean;
}
declare class PrintingMetricsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: PrintingMetricsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetPrintJobs;
}

interface ProxyApiToolsOptions {
    getProxySettings?: boolean;
    setProxySettings?: boolean;
    clearProxySettings?: boolean;
}
declare class ProxyApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ProxyApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetProxySettings;
    private registerSetProxySettings;
    private registerClearProxySettings;
}

interface ReadingListApiToolsOptions {
    addEntry?: boolean;
    query?: boolean;
    removeEntry?: boolean;
    updateEntry?: boolean;
}
declare class ReadingListApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ReadingListApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAddEntry;
    private registerQuery;
    private registerRemoveEntry;
    private registerUpdateEntry;
}

interface RuntimeApiToolsOptions {
    connect?: boolean;
    connectNative?: boolean;
    getContexts?: boolean;
    getManifest?: boolean;
    getPackageDirectoryEntry?: boolean;
    getPlatformInfo?: boolean;
    getURL?: boolean;
    openOptionsPage?: boolean;
    reload?: boolean;
    requestUpdateCheck?: boolean;
    restart?: boolean;
    restartAfterDelay?: boolean;
    sendMessage?: boolean;
    sendNativeMessage?: boolean;
    setUninstallURL?: boolean;
}
declare class RuntimeApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: RuntimeApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerConnect;
    private registerConnectNative;
    private registerGetContexts;
    private registerGetManifest;
    private registerGetPackageDirectoryEntry;
    private registerGetPlatformInfo;
    private registerGetURL;
    private registerOpenOptionsPage;
    private registerReload;
    private registerRequestUpdateCheck;
    private registerRestart;
    private registerRestartAfterDelay;
    private registerSendMessage;
    private registerSendNativeMessage;
    private registerSetUninstallURL;
}

interface ScriptingApiToolsOptions {
    executeScript?: boolean;
    executeUserScript?: boolean;
    insertCSS?: boolean;
    removeCSS?: boolean;
}
declare class ScriptingApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: ScriptingApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private checkAndRegisterUserScripts;
    private getChromeVersion;
    private registerExecuteScript;
    private registerUserScriptExecute;
    private registerUserScriptLegacy;
    private registerInsertCSS;
    private registerRemoveCSS;
}

interface SearchApiToolsOptions {
    query?: boolean;
}
declare class SearchApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SearchApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerQuery;
}

interface SessionsApiToolsOptions {
    getDevices?: boolean;
    getRecentlyClosed?: boolean;
    restore?: boolean;
}
declare class SessionsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SessionsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetDevices;
    private registerGetRecentlyClosed;
    private registerRestore;
}

interface SidePanelApiToolsOptions {
    getOptions?: boolean;
    setOptions?: boolean;
    getPanelBehavior?: boolean;
    setPanelBehavior?: boolean;
    open?: boolean;
}
declare class SidePanelApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SidePanelApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetOptions;
    private registerSetOptions;
    private registerGetPanelBehavior;
    private registerSetPanelBehavior;
    private registerOpen;
}

interface StorageApiToolsOptions {
    getStorage?: boolean;
    setStorage?: boolean;
    removeStorage?: boolean;
    clearStorage?: boolean;
    getBytesInUse?: boolean;
}
declare class StorageApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: StorageApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private getAvailableAreas;
    private registerGetStorage;
    private registerSetStorage;
    private registerRemoveStorage;
    private registerClearStorage;
    private registerGetBytesInUse;
    private formatBytes;
}

interface SystemCpuApiToolsOptions {
    getInfo?: boolean;
}
declare class SystemCpuApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SystemCpuApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetInfo;
}

interface SystemLogApiToolsOptions {
    addLog?: boolean;
}
declare class SystemLogApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SystemLogApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAddLog;
}

interface SystemMemoryApiToolsOptions {
    getInfo?: boolean;
}
declare class SystemMemoryApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SystemMemoryApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetInfo;
}

interface SystemStorageApiToolsOptions {
    getInfo?: boolean;
    ejectDevice?: boolean;
    getAvailableCapacity?: boolean;
}
declare class SystemStorageApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: SystemStorageApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetInfo;
    private registerEjectDevice;
    private registerGetAvailableCapacity;
    private getEjectResultMessage;
    private formatBytes;
}

interface TabCaptureApiToolsOptions {
    capture?: boolean;
    getCapturedTabs?: boolean;
    getMediaStreamId?: boolean;
}
declare class TabCaptureApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TabCaptureApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCapture;
    private registerGetCapturedTabs;
    private registerGetMediaStreamId;
}

interface TabGroupsApiToolsOptions {
    get?: boolean;
    query?: boolean;
    update?: boolean;
    move?: boolean;
}
declare class TabGroupsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TabGroupsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGet;
    private registerQuery;
    private registerUpdate;
    private registerMove;
}

interface TabsApiToolsOptions {
    listActiveTabs?: boolean;
    createTab?: boolean;
    updateTab?: boolean;
    closeTabs?: boolean;
    getAllTabs?: boolean;
    navigateHistory?: boolean;
    reloadTab?: boolean;
    captureVisibleTab?: boolean;
    detectLanguage?: boolean;
    discardTab?: boolean;
    duplicateTab?: boolean;
    getTab?: boolean;
    getZoom?: boolean;
    setZoom?: boolean;
    groupTabs?: boolean;
    ungroupTabs?: boolean;
    highlightTabs?: boolean;
    moveTabs?: boolean;
    sendMessage?: boolean;
}
declare class TabsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TabsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private checkAndRegisterNavigationTools;
    private checkAndRegisterScreenshotTool;
    private registerListActiveTabs;
    private registerCreateTab;
    private registerUpdateTab;
    private registerCloseTabs;
    private registerGetAllTabs;
    private registerNavigateHistory;
    private registerReloadTab;
    private registerCaptureVisibleTab;
    private registerDetectLanguage;
    private registerDiscardTab;
    private registerDuplicateTab;
    private registerGetTab;
    private registerGetZoom;
    private registerSetZoom;
    private registerGetZoomSettings;
    private registerSetZoomSettings;
    private registerGroupTabs;
    private registerUngroupTabs;
    private registerHighlightTabs;
    private registerMoveTabs;
    private registerSendMessage;
}

interface TopSitesApiToolsOptions {
    getTopSites?: boolean;
}
declare class TopSitesApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TopSitesApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetTopSites;
}

interface TtsApiToolsOptions {
    speak?: boolean;
    stop?: boolean;
    pause?: boolean;
    resume?: boolean;
    isSpeaking?: boolean;
    getVoices?: boolean;
}
declare class TtsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TtsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSpeak;
    private registerStop;
    private registerPause;
    private registerResume;
    private registerIsSpeaking;
    private registerGetVoices;
}

interface TtsEngineApiToolsOptions {
    updateVoices?: boolean;
    updateLanguage?: boolean;
    onSpeak?: boolean;
    onStop?: boolean;
    onPause?: boolean;
    onResume?: boolean;
    onSpeakWithAudioStream?: boolean;
    onInstallLanguageRequest?: boolean;
    onLanguageStatusRequest?: boolean;
    onUninstallLanguageRequest?: boolean;
}
declare class TtsEngineApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: TtsEngineApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerUpdateVoices;
    private registerUpdateLanguage;
    private registerOnSpeak;
    private registerOnStop;
    private registerOnPause;
    private registerOnResume;
    private registerOnSpeakWithAudioStream;
    private registerOnInstallLanguageRequest;
    private registerOnLanguageStatusRequest;
    private registerOnUninstallLanguageRequest;
}

interface UserScriptsApiToolsOptions {
    register?: boolean;
    getScripts?: boolean;
    update?: boolean;
    unregister?: boolean;
    configureWorld?: boolean;
    getWorldConfigurations?: boolean;
    resetWorldConfiguration?: boolean;
    execute?: boolean;
}
declare class UserScriptsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: UserScriptsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerRegister;
    private registerGetScripts;
    private registerUpdate;
    private registerUnregister;
    private registerConfigureWorld;
    private registerGetWorldConfigurations;
    private registerResetWorldConfiguration;
    private registerExecute;
}

interface VpnProviderApiToolsOptions {
    createConfig?: boolean;
    destroyConfig?: boolean;
    setParameters?: boolean;
    notifyConnectionStateChanged?: boolean;
    sendPacket?: boolean;
}
declare class VpnProviderApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: VpnProviderApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreateConfig;
    private registerDestroyConfig;
    private registerSetParameters;
    private registerNotifyConnectionStateChanged;
    private registerSendPacket;
}

interface WallpaperApiToolsOptions {
    setWallpaper?: boolean;
}
declare class WallpaperApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: WallpaperApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerSetWallpaper;
}

interface WebAuthenticationProxyApiToolsOptions {
    attach?: boolean;
    detach?: boolean;
    completeCreateRequest?: boolean;
    completeGetRequest?: boolean;
    completeIsUvpaaRequest?: boolean;
    onCreateRequest?: boolean;
    onGetRequest?: boolean;
    onIsUvpaaRequest?: boolean;
    onRemoteSessionStateChange?: boolean;
    onRequestCanceled?: boolean;
}
declare class WebAuthenticationProxyApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: WebAuthenticationProxyApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAttach;
    private registerDetach;
    private registerCompleteCreateRequest;
    private registerCompleteGetRequest;
    private registerCompleteIsUvpaaRequest;
    private registerOnCreateRequest;
    private registerOnGetRequest;
    private registerOnIsUvpaaRequest;
    private registerOnRemoteSessionStateChange;
    private registerOnRequestCanceled;
}

interface WebNavigationApiToolsOptions {
    getAllFrames?: boolean;
    getFrame?: boolean;
    onBeforeNavigate?: boolean;
    onCommitted?: boolean;
    onCompleted?: boolean;
    onCreatedNavigationTarget?: boolean;
    onDOMContentLoaded?: boolean;
    onErrorOccurred?: boolean;
    onHistoryStateUpdated?: boolean;
    onReferenceFragmentUpdated?: boolean;
    onTabReplaced?: boolean;
}
declare class WebNavigationApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: WebNavigationApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerGetAllFrames;
    private registerGetFrame;
    private registerOnBeforeNavigate;
    private registerOnCommitted;
    private registerOnCompleted;
    private registerOnCreatedNavigationTarget;
    private registerOnDOMContentLoaded;
    private registerOnErrorOccurred;
    private registerOnHistoryStateUpdated;
    private registerOnReferenceFragmentUpdated;
    private registerOnTabReplaced;
}

interface WebRequestApiToolsOptions {
    addListener?: boolean;
    removeListener?: boolean;
    hasListener?: boolean;
    handlerBehaviorChanged?: boolean;
    getActiveListeners?: boolean;
}
declare class WebRequestApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: WebRequestApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerAddListener;
    private registerRemoveListener;
    private registerHasListener;
    private registerHandlerBehaviorChanged;
    private registerGetActiveListeners;
}

interface WindowsApiToolsOptions {
    create?: boolean;
    get?: boolean;
    getAll?: boolean;
    getCurrent?: boolean;
    getLastFocused?: boolean;
    remove?: boolean;
    update?: boolean;
}
declare class WindowsApiTools extends BaseApiTools {
    protected apiName: string;
    constructor(server: McpServer, options?: WindowsApiToolsOptions);
    checkAvailability(): ApiAvailability;
    registerTools(): void;
    private registerCreate;
    private registerGet;
    private registerGetAll;
    private registerGetCurrent;
    private registerGetLastFocused;
    private registerRemove;
    private registerUpdate;
}

/**
 * Enum of all Chrome Extension APIs
 */
declare enum ChromeApi {
    ACCESSIBILITY_FEATURES = "accessibilityFeatures",
    ACTION = "action",
    ALARMS = "alarms",
    AUDIO = "audio",
    BOOKMARKS = "bookmarks",
    BROWSING_DATA = "browsingData",
    CERTIFICATE_PROVIDER = "certificateProvider",
    COMMANDS = "commands",
    CONTENT_SETTINGS = "contentSettings",
    CONTEXT_MENUS = "contextMenus",
    COOKIES = "cookies",
    DEBUGGER = "debugger",
    DECLARATIVE_CONTENT = "declarativeContent",
    DECLARATIVE_NET_REQUEST = "declarativeNetRequest",
    DESKTOP_CAPTURE = "desktopCapture",
    DEVTOOLS_INSPECTED_WINDOW = "devtools.inspectedWindow",
    DEVTOOLS_NETWORK = "devtools.network",
    DEVTOOLS_PANELS = "devtools.panels",
    DEVTOOLS_PERFORMANCE = "devtools.performance",
    DEVTOOLS_RECORDER = "devtools.recorder",
    DNS = "dns",
    DOCUMENT_SCAN = "documentScan",
    DOM = "dom",
    DOWNLOADS = "downloads",
    ENTERPRISE_DEVICE_ATTRIBUTES = "enterprise.deviceAttributes",
    ENTERPRISE_HARDWARE_PLATFORM = "enterprise.hardwarePlatform",
    ENTERPRISE_NETWORKING_ATTRIBUTES = "enterprise.networkingAttributes",
    ENTERPRISE_PLATFORM_KEYS = "enterprise.platformKeys",
    EVENTS = "events",
    EXTENSION = "extension",
    EXTENSION_TYPES = "extensionTypes",
    FILE_BROWSER_HANDLER = "fileBrowserHandler",
    FILE_SYSTEM_PROVIDER = "fileSystemProvider",
    FONT_SETTINGS = "fontSettings",
    GCM = "gcm",
    HISTORY = "history",
    I18N = "i18n",
    IDENTITY = "identity",
    IDLE = "idle",
    INPUT_IME = "input.ime",
    INSTANCE_ID = "instanceID",
    LOGIN_STATE = "loginState",
    MANAGEMENT = "management",
    NOTIFICATIONS = "notifications",
    OFFSCREEN = "offscreen",
    OMNIBOX = "omnibox",
    PAGE_CAPTURE = "pageCapture",
    PERMISSIONS = "permissions",
    PLATFORM_KEYS = "platformKeys",
    POWER = "power",
    PRINTER_PROVIDER = "printerProvider",
    PRINTING = "printing",
    PRINTING_METRICS = "printingMetrics",
    PRIVACY = "privacy",
    PROCESSES = "processes",
    PROXY = "proxy",
    READING_LIST = "readingList",
    RUNTIME = "runtime",
    SCRIPTING = "scripting",
    SEARCH = "search",
    SESSIONS = "sessions",
    SIDE_PANEL = "sidePanel",
    STORAGE = "storage",
    SYSTEM_CPU = "system.cpu",
    SYSTEM_DISPLAY = "system.display",
    SYSTEM_MEMORY = "system.memory",
    SYSTEM_STORAGE = "system.storage",
    SYSTEM_LOG = "systemLog",
    TAB_CAPTURE = "tabCapture",
    TAB_GROUPS = "tabGroups",
    TABS = "tabs",
    TOP_SITES = "topSites",
    TTS = "tts",
    TTS_ENGINE = "ttsEngine",
    TYPES = "types",
    USER_SCRIPTS = "userScripts",
    VPN_PROVIDER = "vpnProvider",
    WALLPAPER = "wallpaper",
    WEB_AUTHENTICATION_PROXY = "webAuthenticationProxy",
    WEB_NAVIGATION = "webNavigation",
    WEB_REQUEST = "webRequest",
    WINDOWS = "windows"
}
/**
 * Supported platforms for Chrome APIs
 */
declare const ChromePlatformSchema: z.ZodEnum<["all", "chromeos"]>;
type ChromePlatform = z.i