devtools-tracing 1.2.1 → 1.2.2

package/dist/lib/front_end/core/common/Object.d.ts

@@ -0,0 +1,25 @@
+import type * as Platform from '../platform/platform.js';
+import type { EventDescriptor, EventListener, EventPayloadToRestParameters, EventTarget, EventTargetEvent } from './EventTarget.js';
+export interface ListenerCallbackTuple<Events, T extends keyof Events> {
+    thisObject?: Object;
+    listener: EventListener<Events, T>;
+    disposed?: boolean;
+}
+export declare class ObjectWrapper<Events> implements EventTarget<Events> {
+    listeners?: Map<keyof Events, Set<ListenerCallbackTuple<Events, any>>>;
+    addEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object): EventDescriptor<Events, T>;
+    once<T extends keyof Events>(eventType: T): Promise<Events[T]>;
+    removeEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object): void;
+    hasEventListeners(eventType: keyof Events): boolean;
+    dispatchEventToListeners<T extends keyof Events>(eventType: Platform.TypeScriptUtilities.NoUnion<T>, ...[eventData]: EventPayloadToRestParameters<Events, T>): void;
+}
+export declare function eventMixin<Events, Base extends Platform.Constructor.Constructor<object>>(base: Base): {
+    new (...args: any[]): {
+        "__#private@#events": ObjectWrapper<Events>;
+        addEventListener<T extends keyof Events>(eventType: T, listener: (arg0: EventTargetEvent<Events[T]>) => void, thisObject?: Object): EventDescriptor<Events, T>;
+        once<T extends keyof Events>(eventType: T): Promise<Events[T]>;
+        removeEventListener<T extends keyof Events>(eventType: T, listener: (arg0: EventTargetEvent<Events[T]>) => void, thisObject?: Object): void;
+        hasEventListeners(eventType: keyof Events): boolean;
+        dispatchEventToListeners<T extends keyof Events>(eventType: Platform.TypeScriptUtilities.NoUnion<T>, ...eventData: EventPayloadToRestParameters<Events, T>): void;
+    };
+} & Base;

package/dist/lib/front_end/core/common/ParsedURL.d.ts

@@ -0,0 +1,87 @@
+import * as Platform from '../platform/platform.js';
+/**
+ * http://tools.ietf.org/html/rfc3986#section-5.2.4
+ */
+export declare function normalizePath(path: string): string;
+export declare function schemeIs(url: Platform.DevToolsPath.UrlString | URL, scheme: string): boolean;
+/**
+ * File paths in DevTools that are represented either as unencoded absolute or relative paths, or encoded paths, or URLs.
+ * @example
+ * RawPathString: “/Hello World/file.js”
+ * EncodedPathString: “/Hello%20World/file.js”
+ * UrlString: “file:///Hello%20World/file/js”
+ */
+type BrandedPathString = Platform.DevToolsPath.UrlString | Platform.DevToolsPath.RawPathString | Platform.DevToolsPath.EncodedPathString;
+export declare class ParsedURL {
+    #private;
+    isValid: boolean;
+    url: string;
+    scheme: string;
+    user: string;
+    host: string;
+    port: string;
+    path: string;
+    queryParams: string;
+    fragment: string;
+    folderPathComponents: string;
+    lastPathComponent: string;
+    readonly blobInnerScheme: string | undefined;
+    constructor(url: string);
+    static fromString(string: string): ParsedURL | null;
+    static preEncodeSpecialCharactersInPath(path: string): string;
+    static rawPathToEncodedPathString(path: Platform.DevToolsPath.RawPathString): Platform.DevToolsPath.EncodedPathString;
+    /**
+     * @param name Must not be encoded
+     */
+    static encodedFromParentPathAndName(parentPath: Platform.DevToolsPath.EncodedPathString, name: string): Platform.DevToolsPath.EncodedPathString;
+    /**
+     * @param name Must not be encoded
+     */
+    static urlFromParentUrlAndName(parentUrl: Platform.DevToolsPath.UrlString, name: string): Platform.DevToolsPath.UrlString;
+    static encodedPathToRawPathString(encPath: Platform.DevToolsPath.EncodedPathString): Platform.DevToolsPath.RawPathString;
+    static rawPathToUrlString(fileSystemPath: Platform.DevToolsPath.RawPathString): Platform.DevToolsPath.UrlString;
+    static relativePathToUrlString(relativePath: Platform.DevToolsPath.RawPathString, baseURL: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString;
+    static urlToRawPathString(fileURL: Platform.DevToolsPath.UrlString, isWindows?: boolean): Platform.DevToolsPath.RawPathString;
+    static sliceUrlToEncodedPathString(url: Platform.DevToolsPath.UrlString, start: number): Platform.DevToolsPath.EncodedPathString;
+    static substr<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType, from: number, length?: number): DevToolsPathType;
+    static substring<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType, start: number, end?: number): DevToolsPathType;
+    static prepend<DevToolsPathType extends BrandedPathString>(prefix: string, devToolsPath: DevToolsPathType): DevToolsPathType;
+    static concatenate<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType, ...appendage: string[]): DevToolsPathType;
+    static trim<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType): DevToolsPathType;
+    static slice<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType, start?: number, end?: number): DevToolsPathType;
+    static join<DevToolsPathType extends BrandedPathString>(devToolsPaths: DevToolsPathType[], separator?: string): DevToolsPathType;
+    static split<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType, separator: string | RegExp, limit?: number): DevToolsPathType[];
+    static toLowerCase<DevToolsPathType extends BrandedPathString>(devToolsPath: DevToolsPathType): DevToolsPathType;
+    static isValidUrlString(str: string): str is Platform.DevToolsPath.UrlString;
+    static urlWithoutHash(url: string): string;
+    static urlRegex(): RegExp;
+    static extractPath(url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.EncodedPathString;
+    static extractOrigin(url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString;
+    static extractExtension(url: string): string;
+    static extractName(url: string): string;
+    static completeURL(baseURL: Platform.DevToolsPath.UrlString, href: string): Platform.DevToolsPath.UrlString | null;
+    static splitLineAndColumn(string: string): {
+        url: Platform.DevToolsPath.UrlString;
+        lineNumber?: number;
+        columnNumber?: number;
+    };
+    static removeWasmFunctionInfoFromURL(url: string): Platform.DevToolsPath.UrlString;
+    private static beginsWithWindowsDriveLetter;
+    private static beginsWithScheme;
+    static isRelativeURL(url: string): boolean;
+    get displayName(): string;
+    dataURLDisplayName(): string;
+    isAboutBlank(): boolean;
+    isDataURL(): boolean;
+    extractDataUrlMimeType(): {
+        type?: string;
+        subtype?: string | undefined;
+    };
+    isBlobURL(): boolean;
+    lastPathComponentWithFragment(): string;
+    domain(): string;
+    securityOrigin(): Platform.DevToolsPath.UrlString;
+    urlWithoutScheme(): string;
+    static urlRegexInstance: RegExp | null;
+}
+export {};

package/dist/lib/front_end/core/common/Progress.d.ts

@@ -0,0 +1,47 @@
+export interface Progress {
+    totalWork: number;
+    worked: number;
+    title?: string;
+    canceled: boolean;
+    done: boolean;
+}
+export declare class Progress implements Progress {
+    totalWork: number;
+    worked: number;
+    title?: string;
+    canceled: boolean;
+    done: boolean;
+}
+export declare class CompositeProgress {
+    #private;
+    readonly parent: Progress;
+    constructor(parent: Progress);
+    childDone(): void;
+    createSubProgress(weight?: number): SubProgress;
+    update(): void;
+}
+export declare class SubProgress implements Progress {
+    #private;
+    constructor(composite: CompositeProgress, weight?: number);
+    get canceled(): boolean;
+    set title(title: string);
+    set done(done: boolean);
+    set totalWork(totalWork: number);
+    set worked(worked: number);
+    get weight(): number;
+    get worked(): number;
+    get totalWork(): number;
+}
+export declare class ProgressProxy implements Progress {
+    #private;
+    constructor(delegate?: Progress | null, doneCallback?: (() => void), updateCallback?: (() => void));
+    get canceled(): boolean;
+    set title(title: string);
+    get title(): string;
+    set done(done: boolean);
+    get done(): boolean;
+    set totalWork(totalWork: number);
+    get totalWork(): number;
+    set worked(worked: number);
+    get worked(): number;
+}

package/dist/lib/front_end/core/common/ResolverBase.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A class that facilitates resolving a id to an object of type T. If the id does not yet resolve, a promise
+ * is created that gets resolved once `onResolve` is called with the corresponding id.
+ *
+ * This class enables clients to control the duration of the wait and the lifetime of the associated
+ * promises by using the `clear` method on this class.
+ */
+export declare abstract class ResolverBase<Id, T> {
+    #private;
+    protected abstract getForId(id: Id): T | null;
+    protected abstract startListening(): void;
+    protected abstract stopListening(): void;
+    /**
+     * Returns a promise that resolves once the `id` can be resolved to an object.
+     */
+    waitFor(id: Id): Promise<T>;
+    /**
+     * Resolve the `id`. Returns the object immediately if it can be resolved,
+     * and otherwise waits for the object to appear and calls `callback` once
+     * it is resolved.
+     */
+    tryGet(id: Id, callback: (t: T) => void): T | null;
+    /**
+     * Aborts all waiting and rejects all unresolved promises.
+     */
+    clear(): void;
+    private getOrCreatePromise;
+    protected onResolve(id: Id, t: T): void;
+}

package/dist/lib/front_end/core/common/ResourceType.d.ts

@@ -0,0 +1,89 @@
+import type * as Platform from '../platform/platform.js';
+export declare class ResourceType {
+    #private;
+    constructor(name: string, title: () => Platform.UIString.LocalizedString, category: ResourceCategory, isTextType: boolean);
+    static fromMimeType(mimeType: string | null): ResourceType;
+    static fromMimeTypeOverride(mimeType: string | null): ResourceType | null;
+    static fromURL(url: string): ResourceType | null;
+    static fromName(name: string): ResourceType | null;
+    static mimeFromURL(url: Platform.DevToolsPath.UrlString): string | undefined;
+    static mimeFromExtension(ext: string): string | undefined;
+    static simplifyContentType(contentType: string): string;
+    /**
+     * Checks whether the given MIME type represents JavaScript content.
+     */
+    static isJavaScriptMimeType(mimeType: string): boolean;
+    /**
+     * Adds suffixes iff the mimeType is 'text/javascript' to denote whether the JS is minified or from
+     * a source map.
+     */
+    static mediaTypeForMetrics(mimeType: string, isFromSourceMap: boolean, isMinified: boolean, isSnippet: boolean, isDebugger: boolean): string;
+    name(): string;
+    title(): string;
+    category(): ResourceCategory;
+    isTextType(): boolean;
+    isScript(): boolean;
+    hasScripts(): boolean;
+    isStyleSheet(): boolean;
+    hasStyleSheets(): boolean;
+    isDocument(): boolean;
+    isDocumentOrScriptOrStyleSheet(): boolean;
+    isFont(): boolean;
+    isImage(): boolean;
+    isFromSourceMap(): boolean;
+    toString(): string;
+    canonicalMimeType(): string;
+}
+export declare class ResourceCategory {
+    readonly name: string;
+    title: () => Platform.UIString.LocalizedString;
+    shortTitle: () => Platform.UIString.LocalizedString;
+    constructor(name: string, title: () => Platform.UIString.LocalizedString, shortTitle: () => Platform.UIString.LocalizedString);
+}
+export declare const resourceCategories: {
+    XHR: ResourceCategory;
+    Document: ResourceCategory;
+    Stylesheet: ResourceCategory;
+    Script: ResourceCategory;
+    Font: ResourceCategory;
+    Image: ResourceCategory;
+    Media: ResourceCategory;
+    Manifest: ResourceCategory;
+    Socket: ResourceCategory;
+    Wasm: ResourceCategory;
+    Other: ResourceCategory;
+};
+/**
+ * This enum is a superset of all types defined in WebCore::InspectorPageAgent::resourceTypeJson
+ * For DevTools-only types that are based on MIME-types that are backed by other request types
+ * (for example Wasm that is based on Fetch), additional types are added here.
+ * For these types, make sure to update `fromMimeTypeOverride` to implement the custom logic.
+ */
+export declare const resourceTypes: {
+    readonly Document: ResourceType;
+    readonly Stylesheet: ResourceType;
+    readonly Image: ResourceType;
+    readonly Media: ResourceType;
+    readonly Font: ResourceType;
+    readonly Script: ResourceType;
+    readonly TextTrack: ResourceType;
+    readonly XHR: ResourceType;
+    readonly Fetch: ResourceType;
+    readonly Prefetch: ResourceType;
+    readonly EventSource: ResourceType;
+    readonly WebSocket: ResourceType;
+    readonly WebTransport: ResourceType;
+    readonly DirectSocket: ResourceType;
+    readonly Wasm: ResourceType;
+    readonly Manifest: ResourceType;
+    readonly SignedExchange: ResourceType;
+    readonly Ping: ResourceType;
+    readonly CSPViolationReport: ResourceType;
+    readonly Other: ResourceType;
+    readonly Preflight: ResourceType;
+    readonly SourceMapScript: ResourceType;
+    readonly SourceMapStyleSheet: ResourceType;
+    readonly FedCM: ResourceType;
+};
+export declare const resourceTypeByExtension: Map<string, ResourceType>;
+export declare const mimeTypeByExtension: Map<string, string>;

package/dist/lib/front_end/core/common/ReturnToPanel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Set instance of this class as flavor to mark what panel triggered the
+ * 'elements.toggle-element-search' action if it was not the elements panel.
+ * This will cause specified panel to be made visible instead of the elements
+ * panel after the inspection is done.
+ **/
+export declare class ReturnToPanelFlavor {
+    readonly viewId: string;
+    constructor(viewId: string);
+}

package/dist/lib/front_end/core/common/Revealer.d.ts

@@ -0,0 +1,79 @@
+import type * as Platform from '../platform/platform.js';
+/**
+ * Interface for global revealers, which are entities responsible for
+ * dealing with revealing certain types of objects. For example, the
+ * Sources panel will register a revealer for `UISourceCode` objects,
+ * which will ensure that its visible in an editor tab.
+ */
+export interface Revealer<T> {
+    reveal(revealable: T, omitFocus?: boolean): Promise<void>;
+}
+/**
+ * Registration for revealers, which deals with keeping a list of all possible
+ * revealers, lazily instantiating them as necessary and invoking their `reveal`
+ * methods depending on the _context types_ they were registered for.
+ *
+ * @see Revealer
+ */
+export declare class RevealerRegistry {
+    private readonly registeredRevealers;
+    /**
+     * Yields the singleton instance, creating it on-demand when necessary.
+     *
+     * @returns the singleton instance.
+     */
+    static instance(): RevealerRegistry;
+    /**
+     * Clears the singleton instance (if any).
+     */
+    static removeInstance(): void;
+    /**
+     * Register a new `Revealer` as described by the `registration`.
+     *
+     * @param registration the description.
+     */
+    register(registration: RevealerRegistration<unknown>): void;
+    /**
+     * Reveals the `revealable`.
+     *
+     * @param revealable the object to reveal.
+     * @param omitFocus whether to omit focusing on the presentation of `revealable` afterwards.
+     */
+    reveal(revealable: unknown, omitFocus: boolean): Promise<void>;
+    getApplicableRegisteredRevealers(revealable: unknown): Array<RevealerRegistration<unknown>>;
+}
+export declare function revealDestination(revealable: unknown): string | null;
+/**
+ * Register a new `Revealer` as described by the `registration` on the singleton
+ * {@link RevealerRegistry} instance.
+ *
+ * @param registration the description.
+ */
+export declare function registerRevealer<T>(registration: RevealerRegistration<T>): void;
+/**
+ * Reveals the `revealable` via the singleton {@link RevealerRegistry} instance.
+ *
+ * @param revealable the object to reveal.
+ * @param omitFocus whether to omit focusing on the presentation of `revealable` afterwards.
+ */
+export declare function reveal(revealable: unknown, omitFocus?: boolean): Promise<void>;
+export interface RevealerRegistration<T> {
+    contextTypes: () => Array<abstract new (...any: any[]) => T>;
+    loadRevealer: () => Promise<Revealer<T>>;
+    destination?: RevealerDestination;
+}
+export declare const RevealerDestination: {
+    DEVELOPER_RESOURCES_PANEL: any;
+    ELEMENTS_PANEL: any;
+    STYLES_SIDEBAR: any;
+    CHANGES_DRAWER: any;
+    ISSUES_VIEW: any;
+    NETWORK_PANEL: any;
+    REQUEST_CONDITIONS_DRAWER: any;
+    TIMELINE_PANEL: any;
+    APPLICATION_PANEL: any;
+    SOURCES_PANEL: any;
+    MEMORY_INSPECTOR_PANEL: any;
+    ANIMATIONS_PANEL: any;
+};
+export type RevealerDestination = () => Platform.UIString.LocalizedString;

package/dist/lib/front_end/core/common/Runnable.d.ts

@@ -0,0 +1,14 @@
+export interface Runnable {
+    run(): Promise<void>;
+}
+type LateInitializationLoader = () => Promise<Runnable>;
+export interface LateInitializableRunnableSetting {
+    id: string;
+    loadRunnable: LateInitializationLoader;
+}
+export declare function registerLateInitializationRunnable(setting: LateInitializableRunnableSetting): void;
+export declare function maybeRemoveLateInitializationRunnable(runnableId: string): boolean;
+export declare function lateInitializationRunnables(): LateInitializationLoader[];
+export declare function registerEarlyInitializationRunnable(runnable: () => Runnable): void;
+export declare function earlyInitializationRunnables(): Array<() => Runnable>;
+export {};

package/dist/lib/front_end/core/common/SegmentedRange.d.ts

@@ -0,0 +1,14 @@
+export declare class Segment<T> {
+    begin: number;
+    end: number;
+    data: T;
+    constructor(begin: number, end: number, data: T);
+    intersects(that: Segment<T>): boolean;
+}
+export declare class SegmentedRange<T> {
+    #private;
+    constructor(mergeCallback?: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T> | null));
+    append(newSegment: Segment<T>): void;
+    segments(): Array<Segment<T>>;
+    private tryMerge;
+}

package/dist/lib/front_end/core/common/SettingRegistration.d.ts

@@ -0,0 +1,175 @@
+import type * as Platform from '../platform/platform.js';
+import * as Root from '../root/root.js';
+import type { SettingStorageType } from './Settings.js';
+export declare function registerSettingExtension(registration: SettingRegistration): void;
+export declare function getRegisteredSettings(): SettingRegistration[];
+export declare function registerSettingsForTest(settings: SettingRegistration[], forceReset?: boolean): void;
+export declare function resetSettings(): void;
+export declare function maybeRemoveSettingExtension(settingName: string): boolean;
+export declare const enum SettingCategory {
+    NONE = "",// `NONE` must be a falsy value. Legacy code uses if-checks for the category.
+    ELEMENTS = "ELEMENTS",
+    AI = "AI",
+    APPEARANCE = "APPEARANCE",
+    SOURCES = "SOURCES",
+    NETWORK = "NETWORK",
+    PERFORMANCE = "PERFORMANCE",
+    CONSOLE = "CONSOLE",
+    PERSISTENCE = "PERSISTENCE",
+    DEBUGGER = "DEBUGGER",
+    GLOBAL = "GLOBAL",
+    RENDERING = "RENDERING",
+    GRID = "GRID",
+    MOBILE = "MOBILE",
+    EMULATION = "EMULATION",
+    MEMORY = "MEMORY",
+    EXTENSIONS = "EXTENSIONS",
+    ADORNER = "ADORNER",
+    ACCOUNT = "ACCOUNT",
+    PRIVACY = "PRIVACY"
+}
+export declare function getLocalizedSettingsCategory(category: SettingCategory): Platform.UIString.LocalizedString;
+export declare const enum SettingType {
+    ARRAY = "array",
+    REGEX = "regex",
+    ENUM = "enum",
+    BOOLEAN = "boolean"
+}
+export interface RegExpSettingItem {
+    /**
+     * A regular expression matched against URLs for ignore listing.
+     */
+    pattern: string;
+    /**
+     * If true, ignore this rule.
+     */
+    disabled?: boolean;
+    /**
+     * When a rule is disabled due to requesting through a script's context menu
+     * that it no longer be ignore listed, this field is set to the URL of that
+     * script, so that if the user requests through the same context menu to
+     * enable ignore listing, the rule can be reenabled.
+     */
+    disabledForUrl?: Platform.DevToolsPath.UrlString;
+}
+export interface SettingRegistration {
+    /**
+     * The category with which the setting is displayed in the UI.
+     */
+    category?: SettingCategory;
+    /**
+     * Used to sort on screen the settings that belong to the same category.
+     */
+    order?: number;
+    /**
+     * The title with which the setting is shown on screen.
+     */
+    title?: () => Platform.UIString.LocalizedString;
+    /**
+     * The identifier of the setting.
+     */
+    settingName: string;
+    /**
+     * Determines how the possible values of the setting are expressed.
+     *
+     * - If the setting can only be enabled and disabled use BOOLEAN
+     * - If the setting has a list of possible values use ENUM
+     * - If each setting value is a set of objects use ARRAY
+     * - If the setting value is a regular expression use REGEX
+     */
+    settingType: SettingType;
+    /**
+     * The value set by default to the setting.
+     */
+    defaultValue: unknown;
+    /**
+     * Words used to find a setting in the Command Menu.
+     */
+    tags?: Array<() => Platform.UIString.LocalizedString>;
+    /**
+     * The possible values the setting can have, each with a description composed of a title and an optional text.
+     */
+    options?: SettingExtensionOption[];
+    /**
+     * Whether DevTools must be reloaded for a change in the setting to take effect.
+     */
+    reloadRequired?: boolean;
+    /**
+     * Determines if the setting value is stored in the global, local or session storage.
+     */
+    storageType?: SettingStorageType;
+    /**
+     * A condition that, when present in the queryParamsObject of Runtime, constraints the value
+     * of the setting to be changed only if the user set it.
+     */
+    userActionCondition?: string;
+    /**
+     * The name of the experiment a setting is associated with. Enabling and disabling the declared
+     * experiment will enable and disable the setting respectively.
+     */
+    experiment?: Root.ExperimentNames.ExperimentName;
+    /**
+     * A condition is a function that will make the setting available if it
+     * returns true, and not available, otherwise. Make sure that objects you
+     * access from inside the condition function are ready at the time when the
+     * setting conditions are checked.
+     */
+    condition?: Root.Runtime.Condition;
+    /**
+     * A function that returns true if the setting should be disabled, along with
+     * the reason why.
+     */
+    disabledCondition?: (config?: Root.Runtime.HostConfig) => DisabledConditionResult;
+    /**
+     * If a setting is deprecated, define this notice to show an appropriate warning according to the `warning` property.
+     * If `disabled` is set, the setting will be disabled in the settings UI. In that case, `experiment` optionally can be
+     * set to link to an experiment (by experiment name). The information icon in the settings UI can then be clicked to
+     * jump to the experiment. If a setting is not disabled, the experiment entry will be ignored.
+     */
+    deprecationNotice?: {
+        disabled: boolean;
+        warning: () => Platform.UIString.LocalizedString;
+        experiment?: string;
+    };
+    /**
+     * See {@link LearnMore} for more info.
+     */
+    learnMore?: LearnMore;
+}
+/**
+ * Optional information to learn more about the setting.
+ *
+ * If tooltip is provided creates a (i) icon with rich tooltip with said tooltip
+ *
+ * If url is provided creates a (?) icon with a link to said url
+ *
+ * If both tooltip is provided creates a (i) icon with rich tooltip
+ * and a link inside the rich tool tip with text `Learn more`
+ */
+export interface LearnMore {
+    tooltip?: () => Platform.UIString.LocalizedString;
+    url?: Platform.DevToolsPath.UrlString;
+}
+interface LocalizedSettingExtensionOption {
+    value: boolean | string;
+    title: () => Platform.UIString.LocalizedString;
+    text?: () => Platform.UIString.LocalizedString;
+    raw?: false;
+}
+interface RawSettingExtensionOption {
+    value: boolean | string;
+    title: () => Platform.UIString.LocalizedString;
+    /**
+     * Text used to describe the option. Must be localized if 'raw' is false.
+     */
+    text?: string;
+    raw: true;
+}
+export type SettingExtensionOption = LocalizedSettingExtensionOption | RawSettingExtensionOption;
+export type DisabledConditionResult = {
+    disabled: true;
+    reasons: Platform.UIString.LocalizedString[];
+} | {
+    disabled: false;
+};
+export {};