@types/chrome 0.1.19 → 0.1.20

chrome/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for chrome (https://developer.chrome.com/
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chrome.
 
 ### Additional Details
- * Last updated: Thu, 02 Oct 2025 20:02:36 GMT
+ * Last updated: Fri, 03 Oct 2025 06:02:16 GMT
  * Dependencies: [@types/filesystem](https://npmjs.com/package/@types/filesystem), [@types/har-format](https://npmjs.com/package/@types/har-format)
 
 # Credits

chrome/index.d.ts

@@ -10720,11 +10720,8 @@ declare namespace chrome {
         export interface CaptureInfo {
             /** The id of the tab whose status changed. */
             tabId: number;
-            /**
-             * The new capture status of the tab.
-             * One of: "pending", "active", "stopped", or "error"
-             */
-            status: string;
+            /** The new capture status of the tab. */
+            status: `${TabCaptureState}`;
             /** Whether an element in the tab being captured is in fullscreen mode. */
             fullscreen: boolean;
         }
@@ -10735,46 +10732,55 @@ declare namespace chrome {
         }
 
         export interface CaptureOptions {
-            /** Optional. */
             audio?: boolean | undefined;
-            /** Optional. */
             video?: boolean | undefined;
-            /** Optional. */
             audioConstraints?: MediaStreamConstraint | undefined;
-            /** Optional. */
             videoConstraints?: MediaStreamConstraint | undefined;
         }
 
+        /** @since Chrome 71 */
         export interface GetMediaStreamOptions {
-            /** Optional tab id of the tab which will later invoke getUserMedia() to consume the stream. If not specified then the resulting stream can be used only by the calling extension. The stream can only be used by frames in the given tab whose security origin matches the consumber tab's origin. The tab's origin must be a secure origin, e.g. HTTPS. */
+            /** Optional tab id of the tab which will later invoke `getUserMedia()` to consume the stream. If not specified then the resulting stream can be used only by the calling extension. The stream can only be used by frames in the given tab whose security origin matches the consumber tab's origin. The tab's origin must be a secure origin, e.g. HTTPS. */
             consumerTabId?: number | undefined;
-            /** Optional tab id of the tab which will be captured. If not specified then the current active tab will be selected. Only tabs for which the extension has been granted the activeTab permission can be used as the target tab. */
+            /** Optional tab id of the tab which will be captured. If not specified then the current active tab will be selected. Only tabs for which the extension has been granted the `activeTab` permission can be used as the target tab. */
             targetTabId?: number | undefined;
         }
 
-        export interface CaptureStatusChangedEvent extends chrome.events.Event<(info: CaptureInfo) => void> {}
+        export enum TabCaptureState {
+            PENDING = "pending",
+            ACTIVE = "active",
+            STOPPED = "stopped",
+            ERROR = "error",
+        }
 
         /**
-         * Captures the visible area of the currently active tab. Capture can only be started on the currently active tab after the extension has been invoked. Capture is maintained across page navigations within the tab, and stops when the tab is closed, or the media stream is closed by the extension.
+         * Captures the visible area of the currently active tab. Capture can only be started on the currently active tab after the extension has been invoked, similar to the way that activeTab works. Capture is maintained across page navigations within the tab, and stops when the tab is closed, or the media stream is closed by the extension.
          * @param options Configures the returned media stream.
-         * @param callback Callback with either the tab capture stream or null.
          */
         export function capture(options: CaptureOptions, callback: (stream: MediaStream | null) => void): void;
+
         /**
          * Returns a list of tabs that have requested capture or are being captured, i.e. status != stopped and status != error. This allows extensions to inform the user that there is an existing tab capture that would prevent a new tab capture from succeeding (or to prevent redundant requests for the same tab).
-         * @param callback Callback invoked with CaptureInfo[] for captured tabs.
+         *
+         * Can return its result via Promise in Manifest V3 or later since Chrome 116.
          */
+        export function getCapturedTabs(): Promise<CaptureInfo[]>;
         export function getCapturedTabs(callback: (result: CaptureInfo[]) => void): void;
 
         /**
          * Creates a stream ID to capture the target tab. Similar to chrome.tabCapture.capture() method, but returns a media stream ID, instead of a media stream, to the consumer tab.
-         * @param options Options for the media stream id to retrieve.
-         * @param callback Callback to invoke with the result. If successful, the result is an opaque string that can be passed to the getUserMedia() API to generate a media stream that corresponds to the target tab. The created streamId can only be used once and expires after a few seconds if it is not used.
+         *
+         * Can return its result via Promise in Manifest V3 or later since Chrome 116.
          */
-        export function getMediaStreamId(options: GetMediaStreamOptions, callback: (streamId: string) => void): void;
+        export function getMediaStreamId(options?: GetMediaStreamOptions): Promise<string>;
+        export function getMediaStreamId(callback: (streamId: string) => void): void;
+        export function getMediaStreamId(
+            options: GetMediaStreamOptions | undefined,
+            callback: (streamId: string) => void,
+        ): void;
 
         /** Event fired when the capture status of a tab changes. This allows extension authors to keep track of the capture status of tabs to keep UI elements like page actions in sync. */
-        export var onStatusChanged: CaptureStatusChangedEvent;
+        export const onStatusChanged: events.Event<(info: CaptureInfo) => void>;
     }
 
     ////////////////////

chrome/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/chrome",
-    "version": "0.1.19",
+    "version": "0.1.20",
     "description": "TypeScript definitions for chrome",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chrome",
     "license": "MIT",
@@ -94,6 +94,6 @@
         "@types/har-format": "*"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "a82926d5a4b7fddf359d40643638f66c3408efcef582bb042d95e2827cc75f8a",
+    "typesPublisherContentHash": "433cd27fa4711e2223cc598ccb6f0921c2fdadb29d28cee16f78c1f291cce217",
     "typeScriptVersion": "5.2"
 }