devtools-tracing 1.2.1 → 1.3.0

package/dist/lib/front_end/core/root/Runtime.d.ts

@@ -0,0 +1,339 @@
+import * as Platform from '../platform/platform.js';
+import type { ExperimentName } from './ExperimentNames.js';
+/**
+ * Returns the base URL (similar to `<base>`).
+ * Used to resolve the relative URLs of any additional DevTools files (locale strings, etc) needed.
+ * See: https://cs.chromium.org/remoteBase+f:devtools_window
+ */
+export declare function getRemoteBase(location?: string): {
+    base: string;
+    version: string;
+} | null;
+export declare function getPathName(): string;
+export declare function isNodeEntry(pathname: string): boolean;
+export declare const getChromeVersion: () => string;
+export declare class Runtime {
+    #private;
+    private constructor();
+    static instance(opts?: {
+        forceNew: boolean | null;
+    } | undefined): Runtime;
+    static removeInstance(): void;
+    static queryParam(name: string): string | null;
+    static setQueryParamForTesting(name: string, value: string): void;
+    static isNode(): boolean;
+    /**
+     * Returns true if viewing the slimmed-down devtools meant for just viewing a
+     * performance trace, e.g. devtools://devtools/bundled/trace_app.html?traceURL=http://...
+     */
+    static isTraceApp(): boolean;
+    static setPlatform(platform: string): void;
+    static platform(): string;
+    static isDescriptorEnabled(descriptor: {
+        experiment?: string | null;
+        condition?: Condition;
+    }): boolean;
+    loadLegacyModule(modulePath: string): Promise<unknown>;
+}
+export interface Option {
+    title: string;
+    value: string | boolean;
+    raw?: boolean;
+    text?: string;
+}
+export declare class ExperimentsSupport {
+    #private;
+    allConfigurableExperiments(): Array<Experiment | HostExperiment>;
+    registerHostExperiment(params: {
+        name: ExperimentName;
+        title: string;
+        aboutFlag: string;
+        isEnabled: boolean;
+        requiresChromeRestart: boolean;
+        docLink?: Platform.DevToolsPath.UrlString;
+        readonly feedbackLink?: Platform.DevToolsPath.UrlString;
+    }): HostExperiment;
+    register(experimentName: ExperimentName, experimentTitle: string, docLink?: string, feedbackLink?: string): void;
+    isEnabled(experimentName: ExperimentName): boolean;
+    getValueFromStorage(experimentName: ExperimentName): boolean | undefined;
+    setEnabled(experimentName: ExperimentName, enabled: boolean): void;
+    enableExperimentsByDefault(experimentNames: ExperimentName[]): void;
+    setServerEnabledExperiments(experiments: string[]): void;
+    enableForTest(experimentName: ExperimentName): void;
+    disableForTest(experimentName: ExperimentName): void;
+    isEnabledForTest(experimentName: ExperimentName): boolean;
+    clearForTest(): void;
+    cleanUpStaleExperiments(): void;
+}
+/**
+ * @deprecated Experiments should not be used anymore, instead use base::Feature.
+ * See docs/contributing/settings-experiments-features.md
+ */
+export declare class Experiment {
+    #private;
+    name: ExperimentName;
+    title: string;
+    docLink?: Platform.DevToolsPath.UrlString;
+    readonly feedbackLink?: Platform.DevToolsPath.UrlString;
+    constructor(experiments: ExperimentsSupport, name: ExperimentName, title: string, docLink: Platform.DevToolsPath.UrlString, feedbackLink: Platform.DevToolsPath.UrlString);
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+}
+export declare class HostExperiment {
+    #private;
+    name: ExperimentName;
+    title: string;
+    aboutFlag: string;
+    readonly requiresChromeRestart: boolean;
+    docLink?: Platform.DevToolsPath.UrlString;
+    readonly feedbackLink?: Platform.DevToolsPath.UrlString;
+    constructor(params: {
+        name: ExperimentName;
+        title: string;
+        experiments: ExperimentsSupport;
+        aboutFlag: string;
+        isEnabled: boolean;
+        requiresChromeRestart: boolean;
+        docLink?: Platform.DevToolsPath.UrlString;
+        feedbackLink?: Platform.DevToolsPath.UrlString;
+    });
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+}
+/** This must be constructed after the query parameters have been parsed. **/
+export declare const experiments: ExperimentsSupport;
+export declare enum GenAiEnterprisePolicyValue {
+    ALLOW = 0,
+    ALLOW_WITHOUT_LOGGING = 1,
+    DISABLE = 2
+}
+export interface AidaAvailability {
+    enabled: boolean;
+    blockedByAge: boolean;
+    blockedByEnterprisePolicy: boolean;
+    blockedByGeo: boolean;
+    disallowLogging: boolean;
+    enterprisePolicyValue: number;
+}
+type Channel = 'stable' | 'beta' | 'dev' | 'canary';
+export interface HostConfigConsoleInsights {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+}
+export declare enum HostConfigFreestylerExecutionMode {
+    ALL_SCRIPTS = "ALL_SCRIPTS",
+    SIDE_EFFECT_FREE_SCRIPTS_ONLY = "SIDE_EFFECT_FREE_SCRIPTS_ONLY",
+    NO_SCRIPTS = "NO_SCRIPTS"
+}
+export interface HostConfigFreestyler {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+    executionMode?: HostConfigFreestylerExecutionMode;
+    patching?: boolean;
+    multimodal?: boolean;
+    multimodalUploadInput?: boolean;
+    functionCalling?: boolean;
+}
+export interface HostConfigAiAssistanceNetworkAgent {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigAiAssistancePerformanceAgent {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigAiAssistanceFileAgent {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigAiAssistanceAccessibilityAgent {
+    enabled: boolean;
+}
+export interface HostConfigAiCodeCompletion {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigAiCodeGeneration {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigAiCodeCompletionStyles {
+    modelId: string;
+    temperature: number;
+    enabled: boolean;
+    userTier: string;
+}
+export interface HostConfigDeepLinksViaExtensibilityApi {
+    enabled: boolean;
+}
+export interface HostConfigGreenDevUi {
+    enabled: boolean;
+}
+export interface HostConfigGeminiRebranding {
+    enabled: boolean;
+}
+export interface HostConfigVeLogging {
+    enabled: boolean;
+    testing: boolean;
+}
+/**
+ * @see https://goo.gle/devtools-json-design
+ */
+export interface HostConfigWellKnown {
+    enabled: boolean;
+}
+export interface HostConfigPrivacyUI {
+    enabled: boolean;
+}
+export interface HostConfigEnableOriginBoundCookies {
+    portBindingEnabled: boolean;
+    schemeBindingEnabled: boolean;
+}
+export interface HostConfigAnimationStylesInStylesTab {
+    enabled: boolean;
+}
+export interface HostConfigJpegXlImageFormat {
+    enabled: boolean;
+}
+export interface HostConfigAiAssistanceV2 {
+    enabled: boolean;
+}
+interface AiGeneratedTimelineLabels {
+    enabled: boolean;
+}
+interface AllowPopoverForcing {
+    enabled: boolean;
+}
+interface GlobalAiButton {
+    enabled: boolean;
+    promotionEnabled: boolean;
+}
+interface GdpProfiles {
+    enabled: boolean;
+    badgesEnabled: boolean;
+    starterBadgeEnabled: boolean;
+}
+export declare enum GdpProfilesEnterprisePolicyValue {
+    ENABLED = 0,
+    ENABLED_WITHOUT_BADGES = 1,
+    DISABLED = 2
+}
+interface GdpProfilesAvailability {
+    enabled: boolean;
+    enterprisePolicyValue: GdpProfilesEnterprisePolicyValue;
+}
+interface LiveEdit {
+    enabled: boolean;
+}
+interface DevToolsFlexibleLayout {
+    verticalDrawerEnabled: boolean;
+}
+interface DeviceBoundSessionsDebugging {
+    enabled: boolean;
+}
+export interface DevToolsEnableDurableMessages {
+    enabled: boolean;
+}
+interface HostConfigAiAssistanceContextSelectionAgent {
+    enabled: boolean;
+}
+interface ConsoleInsightsTeasers {
+    enabled: boolean;
+    allowWithoutGpu: boolean;
+}
+interface DevToolsProtocolMonitor {
+    enabled: boolean;
+}
+interface DevToolsWebMCPSupport {
+    enabled: boolean;
+}
+/**
+ * The host configuration that we expect from the DevTools back-end.
+ *
+ * We use `RecursivePartial` here to enforce that DevTools code is able to
+ * handle `HostConfig` objects of an unexpected shape. This can happen if
+ * the implementation in the Chromium backend is changed without correctly
+ * updating the DevTools frontend. Or if remote debugging a different version
+ * of Chrome, resulting in the local browser window and the local DevTools
+ * window being of different versions, and consequently potentially having
+ * differently shaped `HostConfig`s.
+ *
+ * @see hostConfig
+ */
+export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
+    aidaAvailability: AidaAvailability;
+    channel: Channel;
+    devToolsConsoleInsights: HostConfigConsoleInsights;
+    devToolsDeepLinksViaExtensibilityApi: HostConfigDeepLinksViaExtensibilityApi;
+    devToolsFreestyler: HostConfigFreestyler;
+    devToolsGreenDevUi: HostConfigGreenDevUi;
+    devToolsAiAssistanceNetworkAgent: HostConfigAiAssistanceNetworkAgent;
+    devToolsAiAssistanceFileAgent: HostConfigAiAssistanceFileAgent;
+    devToolsAiAssistancePerformanceAgent: HostConfigAiAssistancePerformanceAgent;
+    devToolsAiAssistanceAccessibilityAgent: HostConfigAiAssistanceAccessibilityAgent;
+    devToolsAiAssistanceV2: HostConfigAiAssistanceV2;
+    devToolsAiCodeCompletion: HostConfigAiCodeCompletion;
+    devToolsAiCodeGeneration: HostConfigAiCodeGeneration;
+    devToolsAiCodeCompletionStyles: HostConfigAiCodeCompletionStyles;
+    devToolsVeLogging: HostConfigVeLogging;
+    devToolsWellKnown: HostConfigWellKnown;
+    /**
+     * OffTheRecord here indicates that the user's profile is either incognito,
+     * or guest mode, rather than a "normal" profile.
+     */
+    isOffTheRecord: boolean;
+    devToolsEnableOriginBoundCookies: HostConfigEnableOriginBoundCookies;
+    devToolsAnimationStylesInStylesTab: HostConfigAnimationStylesInStylesTab;
+    devToolsJpegXlImageFormat: HostConfigJpegXlImageFormat;
+    devToolsAiGeneratedTimelineLabels: AiGeneratedTimelineLabels;
+    devToolsAllowPopoverForcing: AllowPopoverForcing;
+    devToolsGlobalAiButton: GlobalAiButton;
+    devToolsGdpProfiles: GdpProfiles;
+    devToolsGdpProfilesAvailability: GdpProfilesAvailability;
+    devToolsLiveEdit: LiveEdit;
+    devToolsFlexibleLayout: DevToolsFlexibleLayout;
+    deviceBoundSessionsDebugging: DeviceBoundSessionsDebugging;
+    devToolsEnableDurableMessages: DevToolsEnableDurableMessages;
+    devToolsAiAssistanceContextSelectionAgent: HostConfigAiAssistanceContextSelectionAgent;
+    devToolsConsoleInsightsTeasers: ConsoleInsightsTeasers;
+    devToolsGeminiRebranding: HostConfigGeminiRebranding;
+    devToolsProtocolMonitor: DevToolsProtocolMonitor;
+    devToolsWebMCPSupport: DevToolsWebMCPSupport;
+}>;
+/**
+ * The host configuration for this DevTools instance.
+ *
+ * This is initialized early during app startup and should not be modified
+ * afterwards. In some cases it can be necessary to re-request the host
+ * configuration from Chrome while DevTools is already running. In these
+ * cases, the new host configuration should be reflected here, e.g.:
+ *
+ * ```js
+ * const config = await new Promise<Root.Runtime.HostConfig>(
+ *   resolve => InspectorFrontendHostInstance.getHostConfig(resolve));
+ * Object.assign(Root.runtime.hostConfig, config);
+ * ```
+ */
+export declare const hostConfig: Platform.TypeScriptUtilities.RecursiveReadonly<HostConfig>;
+/**
+ * When defining conditions make sure that objects used by the function have
+ * been instantiated.
+ */
+export type Condition = (config?: HostConfig) => boolean;
+export declare const conditions: {
+    canDock: () => boolean;
+};
+export {};

package/dist/lib/front_end/core/root/root.d.ts

@@ -0,0 +1,4 @@
+import * as DevToolsContext from './DevToolsContext.js';
+import * as ExperimentNames from './ExperimentNames.js';
+import * as Runtime from './Runtime.js';
+export { DevToolsContext, ExperimentNames, Runtime, };

package/dist/lib/front_end/core/sdk/AccessibilityModel.d.ts

@@ -0,0 +1,68 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { DeferredDOMNode, type DOMNode } from './DOMModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare const enum CoreAxPropertyName {
+    NAME = "name",
+    DESCRIPTION = "description",
+    VALUE = "value",
+    ROLE = "role"
+}
+export interface CoreOrProtocolAxProperty {
+    name: CoreAxPropertyName | Protocol.Accessibility.AXPropertyName;
+    value: Protocol.Accessibility.AXValue;
+}
+export declare class AccessibilityNode {
+    #private;
+    constructor(accessibilityModel: AccessibilityModel, payload: Protocol.Accessibility.AXNode);
+    id(): Protocol.Accessibility.AXNodeId;
+    accessibilityModel(): AccessibilityModel;
+    ignored(): boolean;
+    ignoredReasons(): Protocol.Accessibility.AXProperty[] | null;
+    role(): Protocol.Accessibility.AXValue | null;
+    coreProperties(): CoreOrProtocolAxProperty[];
+    name(): Protocol.Accessibility.AXValue | null;
+    description(): Protocol.Accessibility.AXValue | null;
+    value(): Protocol.Accessibility.AXValue | null;
+    properties(): Protocol.Accessibility.AXProperty[] | null;
+    parentNode(): AccessibilityNode | null;
+    isDOMNode(): boolean;
+    backendDOMNodeId(): Protocol.DOM.BackendNodeId | null;
+    deferredDOMNode(): DeferredDOMNode | null;
+    highlightDOMNode(): void;
+    children(): AccessibilityNode[];
+    numChildren(): number;
+    hasOnlyUnloadedChildren(): boolean;
+    hasUnloadedChildren(): boolean;
+    getFrameId(): Protocol.Page.FrameId | null;
+}
+export declare const enum Events {
+    TREE_UPDATED = "TreeUpdated"
+}
+export interface EventTypes {
+    [Events.TREE_UPDATED]: {
+        root?: AccessibilityNode;
+    };
+}
+export declare class AccessibilityModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AccessibilityDispatcher {
+    #private;
+    agent: ProtocolProxyApi.AccessibilityApi;
+    constructor(target: Target);
+    clear(): void;
+    resumeModel(): Promise<void>;
+    suspendModel(): Promise<void>;
+    requestPartialAXTree(node: DOMNode): Promise<void>;
+    loadComplete({ root }: Protocol.Accessibility.LoadCompleteEvent): void;
+    nodesUpdated({ nodes }: Protocol.Accessibility.NodesUpdatedEvent): void;
+    private createNodesFromPayload;
+    requestRootNode(frameId?: Protocol.Page.FrameId): Promise<AccessibilityNode | undefined>;
+    requestAXChildren(nodeId: Protocol.Accessibility.AXNodeId, frameId?: Protocol.Page.FrameId): Promise<AccessibilityNode[]>;
+    requestAndLoadSubTreeToNode(node: DOMNode): Promise<AccessibilityNode[] | null>;
+    axNodeForId(axId: Protocol.Accessibility.AXNodeId): AccessibilityNode | null;
+    setRootAXNodeForFrameId(frameId: Protocol.Page.FrameId, axNode: AccessibilityNode): void;
+    setAXNodeForAXId(axId: string, axNode: AccessibilityNode): void;
+    axNodeForDOMNode(domNode: DOMNode | null): AccessibilityNode | null;
+    setAXNodeForBackendDOMNodeId(backendDOMNodeId: Protocol.DOM.BackendNodeId, axNode: AccessibilityNode): void;
+    getAgent(): ProtocolProxyApi.AccessibilityApi;
+}

package/dist/lib/front_end/core/sdk/AnimationModel.d.ts

@@ -0,0 +1,161 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import { DeferredDOMNode, type DOMNode } from './DOMModel.js';
+import { RemoteObject } from './RemoteObject.js';
+import { RuntimeModel } from './RuntimeModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+/**
+ * Provides an extension over `DOMNode` that gives it additional
+ * capabilities for animation debugging, mainly:
+ * - getting a node's scroll information (scroll offsets and scroll range).
+ * - updating a node's scroll offset.
+ * - tracking the node's scroll offsets with event listeners.
+ *
+ * It works by running functions on the target page, see `DOMNode`s `callFunction` method
+ * for more details on how a function is called on the target page.
+ *
+ * For listening to events on the target page and getting notified on the devtools frontend
+ * side, we're adding a binding to the page `__devtools_report_scroll_position__` in a world `devtools_animation`
+ * we've created. Then, we're setting scroll listeners of the `node` in the same world which calls the binding
+ * itself with the scroll offsets.
+ */
+export declare class AnimationDOMNode {
+    #private;
+    static lastAddedListenerId: number;
+    constructor(domNode: DOMNode);
+    addScrollEventListener(onScroll: ({ scrollLeft, scrollTop }: {
+        scrollLeft: number;
+        scrollTop: number;
+    }) => void): Promise<number | null>;
+    removeScrollEventListener(id: number): Promise<void>;
+    scrollTop(): Promise<number | null>;
+    scrollLeft(): Promise<number | null>;
+    setScrollTop(offset: number): Promise<void>;
+    setScrollLeft(offset: number): Promise<void>;
+    verticalScrollRange(): Promise<number | null>;
+    horizontalScrollRange(): Promise<number | null>;
+}
+export declare class AnimationModel extends SDKModel<EventTypes> {
+    #private;
+    readonly runtimeModel: RuntimeModel;
+    readonly agent: ProtocolProxyApi.AnimationApi;
+    readonly animationGroups: Map<string, AnimationGroup>;
+    playbackRate: number;
+    constructor(target: Target);
+    private reset;
+    devicePixelRatio(): Promise<number>;
+    getAnimationGroupForAnimation(name: string, nodeId: Protocol.DOM.NodeId): Promise<AnimationGroup | null>;
+    animationCanceled(id: string): void;
+    animationUpdated(payload: Protocol.Animation.Animation): Promise<void>;
+    animationStarted(payload: Protocol.Animation.Animation): Promise<void>;
+    private matchExistingGroups;
+    private createGroupFromPendingAnimations;
+    setPlaybackRate(playbackRate: number): void;
+    releaseAnimations(animations: string[]): void;
+    suspendModel(): Promise<void>;
+    resumeModel(): Promise<void>;
+}
+export declare enum Events {
+    AnimationGroupStarted = "AnimationGroupStarted",
+    AnimationGroupUpdated = "AnimationGroupUpdated",
+    ModelReset = "ModelReset"
+}
+export interface EventTypes {
+    [Events.AnimationGroupStarted]: AnimationGroup;
+    [Events.AnimationGroupUpdated]: AnimationGroup;
+    [Events.ModelReset]: void;
+}
+export declare class AnimationImpl {
+    #private;
+    private constructor();
+    static parsePayload(animationModel: AnimationModel, payload: Protocol.Animation.Animation): Promise<AnimationImpl>;
+    setPayload(payload: Protocol.Animation.Animation): Promise<void>;
+    private percentageToPixels;
+    viewOrScrollTimeline(): Protocol.Animation.ViewOrScrollTimeline | undefined;
+    id(): string;
+    name(): string;
+    paused(): boolean;
+    playState(): string;
+    playbackRate(): number;
+    startTime(): number;
+    iterationDuration(): number;
+    endTime(): number;
+    finiteDuration(): number;
+    currentTime(): number;
+    source(): AnimationEffect;
+    type(): Protocol.Animation.AnimationType;
+    overlaps(animation: AnimationImpl): boolean;
+    delayOrStartTime(): number;
+    setTiming(duration: number, delay: number): void;
+    private updateNodeStyle;
+    remoteObjectPromise(): Promise<RemoteObject | null>;
+    cssId(): string;
+}
+export declare class AnimationEffect {
+    #private;
+    delayInternal: number;
+    durationInternal: number;
+    constructor(animationModel: AnimationModel, payload: Protocol.Animation.AnimationEffect);
+    setPayload(payload: Protocol.Animation.AnimationEffect): void;
+    delay(): number;
+    endDelay(): number;
+    iterations(): number;
+    duration(): number;
+    direction(): string;
+    fill(): string;
+    node(): Promise<DOMNode | null>;
+    deferredNode(): DeferredDOMNode;
+    backendNodeId(): Protocol.DOM.BackendNodeId;
+    keyframesRule(): KeyframesRule | null;
+    easing(): string;
+}
+export declare class KeyframesRule {
+    #private;
+    constructor(payload: Protocol.Animation.KeyframesRule);
+    setPayload(payload: Protocol.Animation.KeyframesRule): void;
+    name(): string | undefined;
+    keyframes(): KeyframeStyle[];
+}
+export declare class KeyframeStyle {
+    #private;
+    constructor(payload: Protocol.Animation.KeyframeStyle);
+    setPayload(payload: Protocol.Animation.KeyframeStyle): void;
+    offset(): string;
+    setOffset(offset: number): void;
+    offsetAsNumber(): number;
+    easing(): string;
+}
+export declare class AnimationGroup {
+    #private;
+    constructor(animationModel: AnimationModel, id: string, animations: AnimationImpl[]);
+    isScrollDriven(): boolean;
+    id(): string;
+    animations(): AnimationImpl[];
+    release(): void;
+    private animationIds;
+    startTime(): number;
+    groupDuration(): number;
+    finiteDuration(): number;
+    scrollOrientation(): Protocol.DOM.ScrollOrientation | null;
+    scrollNode(): Promise<AnimationDOMNode | null>;
+    seekTo(currentTime: number): void;
+    paused(): boolean;
+    togglePause(paused: boolean): void;
+    currentTimePromise(): Promise<number>;
+    matches(group: AnimationGroup): boolean;
+    shouldInclude(group: AnimationGroup): boolean;
+    appendAnimations(animations: AnimationImpl[]): void;
+    rebaseTo(group: AnimationGroup): void;
+}
+export declare class AnimationDispatcher implements ProtocolProxyApi.AnimationDispatcher {
+    #private;
+    constructor(animationModel: AnimationModel);
+    animationCreated(_event: Protocol.Animation.AnimationCreatedEvent): void;
+    animationCanceled({ id }: Protocol.Animation.AnimationCanceledEvent): void;
+    animationStarted({ animation }: Protocol.Animation.AnimationStartedEvent): void;
+    animationUpdated({ animation }: Protocol.Animation.AnimationUpdatedEvent): void;
+}
+export interface Request {
+    endTime: number;
+}

package/dist/lib/front_end/core/sdk/AutofillModel.d.ts

@@ -0,0 +1,23 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class AutofillModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AutofillDispatcher {
+    #private;
+    readonly agent: ProtocolProxyApi.AutofillApi;
+    constructor(target: Target);
+    dispose(): void;
+    enable(): void;
+    disable(): void;
+    addressFormFilled(addressFormFilledEvent: Protocol.Autofill.AddressFormFilledEvent): void;
+}
+export declare const enum Events {
+    ADDRESS_FORM_FILLED = "AddressFormFilled"
+}
+export interface AddressFormFilledEvent {
+    autofillModel: AutofillModel;
+    event: Protocol.Autofill.AddressFormFilledEvent;
+}
+export interface EventTypes {
+    [Events.ADDRESS_FORM_FILLED]: AddressFormFilledEvent;
+}

package/dist/lib/front_end/core/sdk/CPUProfilerModel.d.ts

@@ -0,0 +1,42 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { DebuggerModel, Location } from './DebuggerModel.js';
+import type { RuntimeModel } from './RuntimeModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolProxyApi.ProfilerDispatcher {
+    #private;
+    readonly registeredConsoleProfileMessages: ProfileFinishedData[];
+    constructor(target: Target);
+    runtimeModel(): RuntimeModel;
+    debuggerModel(): DebuggerModel;
+    consoleProfileStarted({ id, location, title }: Protocol.Profiler.ConsoleProfileStartedEvent): void;
+    consoleProfileFinished({ id, location, profile, title }: Protocol.Profiler.ConsoleProfileFinishedEvent): void;
+    private createEventDataFrom;
+    startRecording(): Promise<unknown>;
+    stopRecording(): Promise<Protocol.Profiler.Profile | null>;
+    startPreciseCoverage(jsCoveragePerBlock: boolean, preciseCoverageDeltaUpdateCallback: ((arg0: number, arg2: Protocol.Profiler.ScriptCoverage[]) => Promise<void>) | null): Promise<unknown>;
+    takePreciseCoverage(): Promise<{
+        timestamp: number;
+        coverage: Protocol.Profiler.ScriptCoverage[];
+    }>;
+    stopPreciseCoverage(): Promise<unknown>;
+    preciseCoverageDeltaUpdate({ timestamp, result }: Protocol.Profiler.PreciseCoverageDeltaUpdateEvent): void;
+}
+export declare const enum Events {
+    CONSOLE_PROFILE_STARTED = "ConsoleProfileStarted",
+    CONSOLE_PROFILE_FINISHED = "ConsoleProfileFinished"
+}
+export interface EventTypes {
+    [Events.CONSOLE_PROFILE_STARTED]: EventData;
+    [Events.CONSOLE_PROFILE_FINISHED]: ProfileFinishedData;
+}
+export interface EventData {
+    id: string;
+    scriptLocation: Location;
+    title: string;
+    cpuProfilerModel: CPUProfilerModel;
+}
+export interface ProfileFinishedData extends EventData {
+    cpuProfile: Protocol.Profiler.Profile;
+}