devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,128 @@
+import * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Platform from '../platform/platform.js';
+import { CSSContainerQuery } from './CSSContainerQuery.js';
+import { CSSLayer } from './CSSLayer.js';
+import { CSSMedia } from './CSSMedia.js';
+import type { CSSModel, Edit } from './CSSModel.js';
+import { CSSNavigation } from './CSSNavigation.js';
+import { CSSScope } from './CSSScope.js';
+import { CSSStartingStyle } from './CSSStartingStyle.js';
+import { CSSStyleDeclaration } from './CSSStyleDeclaration.js';
+import type { CSSStyleSheetHeader } from './CSSStyleSheetHeader.js';
+import { CSSSupports } from './CSSSupports.js';
+export declare class CSSRule {
+    readonly cssModelInternal: CSSModel;
+    readonly origin: Protocol.CSS.StyleSheetOrigin;
+    readonly style: CSSStyleDeclaration;
+    readonly header: CSSStyleSheetHeader | null;
+    readonly treeScope: Protocol.DOM.BackendNodeId | undefined;
+    constructor(cssModel: CSSModel, payload: {
+        style: Protocol.CSS.CSSStyle;
+        origin: Protocol.CSS.StyleSheetOrigin;
+        header: CSSStyleSheetHeader | null;
+        originTreeScopeNodeId?: Protocol.DOM.BackendNodeId;
+    });
+    get sourceURL(): string | undefined;
+    rebase(edit: Edit): void;
+    resourceURL(): Platform.DevToolsPath.UrlString;
+    isUserAgent(): boolean;
+    isInjected(): boolean;
+    isViaInspector(): boolean;
+    isRegular(): boolean;
+    isKeyframeRule(): boolean;
+    cssModel(): CSSModel;
+}
+declare class CSSValue {
+    text: string;
+    range?: TextUtils.TextRange.TextRange;
+    specificity?: Protocol.CSS.Specificity;
+    constructor(payload: Protocol.CSS.Value);
+    rebase(edit: Edit): void;
+}
+export declare class CSSStyleRule extends CSSRule {
+    selectors: CSSValue[];
+    nestingSelectors?: string[];
+    media: CSSMedia[];
+    containerQueries: CSSContainerQuery[];
+    supports: CSSSupports[];
+    scopes: CSSScope[];
+    layers: CSSLayer[];
+    ruleTypes: Protocol.CSS.CSSRuleType[];
+    startingStyles: CSSStartingStyle[];
+    navigations: CSSNavigation[];
+    wasUsed: boolean;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSRule, wasUsed?: boolean);
+    static createDummyRule(cssModel: CSSModel, selectorText: string): CSSStyleRule;
+    private reinitializeSelectors;
+    setSelectorText(newSelector: string): Promise<boolean>;
+    selectorText(): string;
+    selectorRange(): TextUtils.TextRange.TextRange | null;
+    lineNumberInSource(selectorIndex: number): number;
+    columnNumberInSource(selectorIndex: number): number | undefined;
+    rebase(edit: Edit): void;
+}
+export declare class CSSPropertyRule extends CSSRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSPropertyRule);
+    propertyName(): CSSValue;
+    initialValue(): string | null;
+    syntax(): string;
+    inherits(): boolean;
+    setPropertyName(newPropertyName: string): Promise<boolean>;
+}
+export declare class CSSAtRule extends CSSRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSAtRule);
+    name(): CSSValue | null;
+    type(): string;
+    subsection(): string | null;
+}
+export declare class CSSKeyframesRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSKeyframesRule);
+    name(): CSSValue;
+    keyframes(): CSSKeyframeRule[];
+}
+export declare class CSSKeyframeRule extends CSSRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSKeyframeRule, parentRuleName: string);
+    parentRuleName(): string;
+    key(): CSSValue;
+    private reinitializeKey;
+    rebase(edit: Edit): void;
+    isKeyframeRule(): boolean;
+    setKeyText(newKeyText: string): Promise<boolean>;
+}
+export declare class CSSPositionTryRule extends CSSRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSPositionTryRule);
+    name(): CSSValue;
+    active(): boolean;
+}
+export interface CSSNestedStyleLeaf {
+    style: CSSStyleDeclaration;
+}
+export type CSSNestedStyleCondition = {
+    children: CSSNestedStyle[];
+} & ({
+    media: CSSMedia;
+} | {
+    container: CSSContainerQuery;
+} | {
+    supports: CSSSupports;
+} | {
+    navigation: CSSNavigation;
+});
+export type CSSNestedStyle = CSSNestedStyleLeaf | CSSNestedStyleCondition;
+export declare class CSSFunctionRule extends CSSRule {
+    #private;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSFunctionRule);
+    functionName(): CSSValue;
+    parameters(): string[];
+    children(): CSSNestedStyle[];
+    nameWithParameters(): string;
+    protocolNodesToNestedStyles(nodes: Protocol.CSS.CSSFunctionNode[]): CSSNestedStyle[];
+    protocolNodeToNestedStyle(node: Protocol.CSS.CSSFunctionNode): CSSNestedStyle | undefined;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSScope extends CSSQuery {
+    static parseScopesPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSScope[]): CSSScope[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSScope);
+    reinitialize(payload: Protocol.CSS.CSSScope): void;
+    active(): boolean;
+}

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

@@ -0,0 +1,9 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSStartingStyle extends CSSQuery {
+    static parseStartingStylePayload(cssModel: CSSModel, payload: Protocol.CSS.CSSStartingStyle[]): CSSStartingStyle[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSStartingStyle);
+    reinitialize(payload: Protocol.CSS.CSSStartingStyle): void;
+    active(): boolean;
+}

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

@@ -0,0 +1,38 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import type { CSSModel, Edit } from './CSSModel.js';
+import { CSSProperty } from './CSSProperty.js';
+import type { CSSRule } from './CSSRule.js';
+import type { Target } from './Target.js';
+export declare class CSSStyleDeclaration {
+    #private;
+    parentRule: CSSRule | null;
+    styleSheetId?: Protocol.DOM.StyleSheetId;
+    range: TextUtils.TextRange.TextRange | null;
+    cssText?: string;
+    type: Type;
+    constructor(cssModel: CSSModel, parentRule: CSSRule | null, payload: Protocol.CSS.CSSStyle, type: Type, animationName?: string);
+    rebase(edit: Edit): void;
+    animationName(): string | undefined;
+    leadingProperties(): CSSProperty[];
+    target(): Target;
+    cssModel(): CSSModel;
+    allProperties(): CSSProperty[];
+    hasActiveProperty(name: string): boolean;
+    getPropertyValue(name: string): string;
+    isPropertyImplicit(name: string): boolean;
+    propertyAt(index: number): CSSProperty | null;
+    pastLastSourcePropertyIndex(): number;
+    newBlankProperty(index?: number): CSSProperty;
+    setText(text: string, majorChange: boolean): Promise<boolean>;
+    insertPropertyAt(index: number, name: string, value: string, userCallback?: ((arg0: boolean) => void)): void;
+    appendProperty(name: string, value: string, userCallback?: ((arg0: boolean) => void)): void;
+}
+export declare enum Type {
+    Regular = "Regular",
+    Inline = "Inline",
+    Attributes = "Attributes",
+    Pseudo = "Pseudo",// This type is for style declarations generated by devtools
+    Transition = "Transition",
+    Animation = "Animation"
+}

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

@@ -0,0 +1,53 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import type { CSSModel } from './CSSModel.js';
+import { DeferredDOMNode } from './DOMModel.js';
+import type { FrameAssociated } from './FrameAssociated.js';
+import type { PageResourceLoadInitiator } from './PageResourceLoader.js';
+import type { DebugId } from './SourceMap.js';
+export declare class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentProvider, FrameAssociated {
+    #private;
+    id: Protocol.DOM.StyleSheetId;
+    frameId: Protocol.Page.FrameId;
+    sourceURL: Platform.DevToolsPath.UrlString;
+    hasSourceURL: boolean;
+    origin: Protocol.CSS.StyleSheetOrigin;
+    title: string;
+    disabled: boolean;
+    isInline: boolean;
+    isMutable: boolean;
+    isConstructed: boolean;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    contentLength: number;
+    ownerNode: DeferredDOMNode | undefined;
+    sourceMapURL: Platform.DevToolsPath.UrlString | undefined;
+    readonly loadingFailed: boolean;
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSStyleSheetHeader);
+    originalContentProvider(): TextUtils.ContentProvider.ContentProvider;
+    setSourceMapURL(sourceMapURL?: Platform.DevToolsPath.UrlString): void;
+    cssModel(): CSSModel;
+    isAnonymousInlineStyleSheet(): boolean;
+    isConstructedByNew(): boolean;
+    resourceURL(): Platform.DevToolsPath.UrlString;
+    private getFrameURLPath;
+    private viaInspectorResourceURL;
+    lineNumberInSource(lineNumberInStyleSheet: number): number;
+    columnNumberInSource(lineNumberInStyleSheet: number, columnNumberInStyleSheet: number): number | undefined;
+    /**
+     * Checks whether the position is in this style sheet. Assumes that the
+     * position's columnNumber is consistent with line endings.
+     */
+    containsLocation(lineNumber: number, columnNumber: number): boolean;
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError>;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<TextUtils.ContentProvider.SearchMatch[]>;
+    isViaInspector(): boolean;
+    createPageResourceLoadInitiator(): PageResourceLoadInitiator;
+    debugId(): DebugId | null;
+}

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

@@ -0,0 +1,10 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSSupports extends CSSQuery {
+    #private;
+    static parseSupportsPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSSupports[]): CSSSupports[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSSupports);
+    reinitialize(payload: Protocol.CSS.CSSSupports): void;
+    active(): boolean;
+}

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

@@ -0,0 +1,43 @@
+export declare const enum Category {
+    ANIMATION = "animation",
+    AUCTION_WORKLET = "auction-worklet",
+    CANVAS = "canvas",
+    CLIPBOARD = "clipboard",
+    CONTROL = "control",
+    DEVICE = "device",
+    DOM_MUTATION = "dom-mutation",
+    DRAG_DROP = "drag-drop",
+    GEOLOCATION = "geolocation",
+    KEYBOARD = "keyboard",
+    LOAD = "load",
+    MEDIA = "media",
+    MOUSE = "mouse",
+    NOTIFICATION = "notification",
+    PARSE = "parse",
+    PICTURE_IN_PICTURE = "picture-in-picture",
+    POINTER = "pointer",
+    SCRIPT = "script",
+    SHARED_STORAGE_WORKLET = "shared-storage-worklet",
+    TIMER = "timer",
+    TOUCH = "touch",
+    TRUSTED_TYPE_VIOLATION = "trusted-type-violation",
+    WEB_AUDIO = "web-audio",
+    WINDOW = "window",
+    WORKER = "worker",
+    XHR = "xhr"
+}
+export declare class CategorizedBreakpoint {
+    #private;
+    /**
+     * The name of this breakpoint as passed to 'setInstrumentationBreakpoint',
+     * 'setEventListenerBreakpoint' and 'setBreakOnCSPViolation'.
+     *
+     * Note that the backend adds a 'listener:' and 'instrumentation:' prefix
+     * to this name in the 'Debugger.paused' CDP event.
+     */
+    readonly name: string;
+    constructor(category: Category, name: string);
+    category(): Category;
+    enabled(): boolean;
+    setEnabled(enabled: boolean): void;
+}

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

@@ -0,0 +1,40 @@
+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 ChildTargetManager extends SDKModel<EventTypes> implements ProtocolProxyApi.TargetDispatcher {
+    #private;
+    constructor(parentTarget: Target);
+    static install(attachCallback?: ((arg0: {
+        target: Target;
+        waitingForDebugger: boolean;
+    }) => Promise<void>)): void;
+    childTargets(): Target[];
+    suspendModel(): Promise<void>;
+    resumeModel(): Promise<void>;
+    dispose(): void;
+    targetCreated({ targetInfo }: Protocol.Target.TargetCreatedEvent): void;
+    targetInfoChanged({ targetInfo }: Protocol.Target.TargetInfoChangedEvent): void;
+    targetDestroyed({ targetId }: Protocol.Target.TargetDestroyedEvent): void;
+    targetCrashed({ targetId }: Protocol.Target.TargetCrashedEvent): void;
+    private fireAvailableTargetsChanged;
+    getParentTargetId(): Promise<Protocol.Target.TargetID>;
+    getTargetInfo(): Promise<Protocol.Target.TargetInfo>;
+    attachedToTarget({ sessionId, targetInfo, waitingForDebugger }: Protocol.Target.AttachedToTargetEvent): Promise<void>;
+    private initializeStorage;
+    detachedFromTarget({ sessionId }: Protocol.Target.DetachedFromTargetEvent): void;
+    receivedMessageFromTarget({}: Protocol.Target.ReceivedMessageFromTargetEvent): void;
+    targetInfos(): Protocol.Target.TargetInfo[];
+    private static lastAnonymousTargetId;
+    private static attachCallback?;
+}
+export declare const enum Events {
+    TARGET_CREATED = "TargetCreated",
+    TARGET_DESTROYED = "TargetDestroyed",
+    TARGET_INFO_CHANGED = "TargetInfoChanged"
+}
+export interface EventTypes {
+    [Events.TARGET_CREATED]: Protocol.Target.TargetInfo;
+    [Events.TARGET_DESTROYED]: Protocol.Target.TargetID;
+    [Events.TARGET_INFO_CHANGED]: Protocol.Target.TargetInfo;
+}

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

@@ -0,0 +1,12 @@
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import type * as Common from '../common/common.js';
+import type * as Platform from '../platform/platform.js';
+import { type PageResourceLoadInitiator } from './PageResourceLoader.js';
+export declare class CompilerSourceMappingContentProvider implements TextUtils.ContentProvider.ContentProvider {
+    #private;
+    constructor(sourceURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType, initiator: PageResourceLoadInitiator);
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError>;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<TextUtils.ContentProvider.SearchMatch[]>;
+}

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

@@ -0,0 +1,36 @@
+import type * as Platform from '../platform/platform.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+export declare class MainConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+    #private;
+    onMessage: ((arg0: Object | string) => void) | null;
+    constructor();
+    setOnMessage(onMessage: (arg0: Object | string) => void): void;
+    setOnDisconnect(onDisconnect: (arg0: string) => void): void;
+    sendRawMessage(message: string): void;
+    private dispatchMessage;
+    private dispatchMessageChunk;
+    disconnect(): Promise<void>;
+}
+export declare class WebSocketTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+    #private;
+    onMessage: ((arg0: Object | string) => void) | null;
+    constructor(url: Platform.DevToolsPath.UrlString, onWebSocketDisconnect: (message: Platform.UIString.LocalizedString) => void);
+    setOnMessage(onMessage: (arg0: Object | string) => void): void;
+    setOnDisconnect(onDisconnect: (arg0: string) => void): void;
+    private onError;
+    private onOpen;
+    private onClose;
+    private close;
+    sendRawMessage(message: string): void;
+    disconnect(): Promise<void>;
+}
+export declare class StubTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+    #private;
+    onMessage: ((arg0: Object | string) => void) | null;
+    setOnMessage(onMessage: (arg0: Object | string) => void): void;
+    setOnDisconnect(onDisconnect: (arg0: string) => void): void;
+    sendRawMessage(message: string): void;
+    private respondWithError;
+    disconnect(): Promise<void>;
+}
+export declare function initMainConnection(createRootTarget: () => Promise<void>, onConnectionLost: (message: Platform.UIString.LocalizedString) => void): Promise<void>;

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

@@ -0,0 +1,124 @@
+import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import { FrontendMessageType } from './ConsoleModelTypes.js';
+import { RemoteObject } from './RemoteObject.js';
+import { type ExecutionContext, RuntimeModel } from './RuntimeModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export { FrontendMessageType } from './ConsoleModelTypes.js';
+export declare class ConsoleModel extends SDKModel<EventTypes> {
+    #private;
+    constructor(target: Target);
+    private initTarget;
+    targetRemoved(target: Target): void;
+    evaluateCommandInConsole(executionContext: ExecutionContext, originatingMessage: ConsoleMessage, expression: string, useCommandLineAPI: boolean): Promise<void>;
+    addCommandMessage(executionContext: ExecutionContext, text: string): ConsoleMessage;
+    addMessage(msg: ConsoleMessage): void;
+    private exceptionThrown;
+    private exceptionRevoked;
+    private consoleAPICalled;
+    private queryObjectRequested;
+    private clearIfNecessary;
+    private primaryPageChanged;
+    private consoleProfileStarted;
+    private consoleProfileFinished;
+    private addConsoleProfileMessage;
+    private incrementErrorWarningCount;
+    messages(): ConsoleMessage[];
+    static allMessagesUnordered(): ConsoleMessage[];
+    static requestClearMessages(): void;
+    private clear;
+    errors(): number;
+    static allErrors(): number;
+    warnings(): number;
+    static allWarnings(): number;
+    violations(): number;
+    saveToTempVariable(currentExecutionContext: ExecutionContext | null, remoteObject: RemoteObject | null): Promise<void>;
+}
+export declare enum Events {
+    ConsoleCleared = "ConsoleCleared",
+    MessageAdded = "MessageAdded",
+    MessageUpdated = "MessageUpdated",
+    CommandEvaluated = "CommandEvaluated"
+}
+export interface CommandEvaluatedEvent {
+    result: RemoteObject;
+    commandMessage: ConsoleMessage;
+    exceptionDetails?: Protocol.Runtime.ExceptionDetails | undefined;
+}
+export interface EventTypes {
+    [Events.ConsoleCleared]: void;
+    [Events.MessageAdded]: ConsoleMessage;
+    [Events.MessageUpdated]: ConsoleMessage;
+    [Events.CommandEvaluated]: CommandEvaluatedEvent;
+}
+export interface AffectedResources {
+    requestId?: Protocol.Network.RequestId;
+    issueId?: Protocol.Audits.IssueId;
+}
+export interface ConsoleMessageDetails {
+    type?: MessageType;
+    url?: Platform.DevToolsPath.UrlString;
+    line?: number;
+    column?: number;
+    parameters?: Array<string | RemoteObject | Protocol.Runtime.RemoteObject>;
+    stackTrace?: Protocol.Runtime.StackTrace;
+    timestamp?: number;
+    executionContextId?: number;
+    scriptId?: Protocol.Runtime.ScriptId;
+    workerId?: string;
+    context?: string;
+    affectedResources?: AffectedResources;
+    category?: Protocol.Log.LogEntryCategory;
+}
+export declare class ConsoleMessage {
+    #private;
+    source: MessageSource;
+    level: Protocol.Log.LogEntryLevel | null;
+    messageText: string;
+    readonly type: MessageType;
+    url: Platform.DevToolsPath.UrlString | undefined;
+    line: number;
+    column: number;
+    parameters: Array<string | RemoteObject | Protocol.Runtime.RemoteObject> | undefined;
+    stackTrace: Protocol.Runtime.StackTrace | undefined;
+    timestamp: number;
+    scriptId?: Protocol.Runtime.ScriptId;
+    workerId?: string;
+    context?: string;
+    category?: Protocol.Log.LogEntryCategory;
+    /**
+     * The parent frame of the `console.log` call of logpoints or conditional breakpoints
+     * if they called `console.*` explicitly. The parent frame is where V8 paused
+     * and consequently where the logpoint is set.
+     *
+     * Is `null` for page console.logs, commands, command results, etc.
+     */
+    readonly stackFrameWithBreakpoint: Protocol.Runtime.CallFrame | null;
+    constructor(runtimeModel: RuntimeModel | null, source: MessageSource, level: Protocol.Log.LogEntryLevel | null, messageText: string, details?: ConsoleMessageDetails);
+    getAffectedResources(): AffectedResources | undefined;
+    setPageLoadSequenceNumber(pageLoadSequenceNumber: number): void;
+    static fromException(runtimeModel: RuntimeModel, exceptionDetails: Protocol.Runtime.ExceptionDetails, messageType?: Protocol.Runtime.ConsoleAPICalledEventType | FrontendMessageType, timestamp?: number, forceUrl?: Platform.DevToolsPath.UrlString, affectedResources?: AffectedResources): ConsoleMessage;
+    runtimeModel(): RuntimeModel | null;
+    target(): Target | null;
+    setOriginatingMessage(originatingMessage: ConsoleMessage): void;
+    originatingMessage(): ConsoleMessage | null;
+    setExecutionContextId(executionContextId: number): void;
+    getExecutionContextId(): number;
+    getExceptionId(): number | undefined;
+    setExceptionId(exceptionId: number): void;
+    isGroupMessage(): boolean;
+    isGroupStartMessage(): boolean;
+    isErrorOrWarning(): boolean;
+    isGroupable(): boolean;
+    groupCategoryKey(): string;
+    isEqual(msg: ConsoleMessage | null): boolean;
+    get originatesFromLogpoint(): boolean;
+    /** @returns true, iff this was a console.* call in a conditional breakpoint */
+    get originatesFromConditionalBreakpoint(): boolean;
+}
+export type MessageSource = Protocol.Log.LogEntrySource | Common.Console.FrontendMessageSource;
+export type MessageLevel = Protocol.Log.LogEntryLevel;
+export type MessageType = Protocol.Runtime.ConsoleAPICalledEventType | FrontendMessageType;
+export declare const MessageSourceDisplayName: Map<MessageSource, string>;

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

@@ -0,0 +1,6 @@
+export declare enum FrontendMessageType {
+    Result = "result",
+    Command = "command",
+    System = "system",
+    QueryObjectResult = "queryObjectResult"
+}

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

@@ -0,0 +1,68 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+export declare class Cookie {
+    #private;
+    constructor(name: string, value: string, type?: Type | null, priority?: Protocol.Network.CookiePriority, partitionKey?: Protocol.Network.CookiePartitionKey);
+    static fromProtocolCookie(protocolCookie: Protocol.Network.Cookie): Cookie;
+    key(): string;
+    name(): string;
+    value(): string;
+    type(): Type | null | undefined;
+    httpOnly(): boolean;
+    secure(): boolean;
+    partitioned(): boolean;
+    sameSite(): Protocol.Network.CookieSameSite;
+    partitionKey(): Protocol.Network.CookiePartitionKey;
+    setPartitionKey(topLevelSite: string, hasCrossSiteAncestor: boolean): void;
+    topLevelSite(): string;
+    setTopLevelSite(topLevelSite: string, hasCrossSiteAncestor: boolean): void;
+    hasCrossSiteAncestor(): boolean;
+    setHasCrossSiteAncestor(hasCrossSiteAncestor: boolean): void;
+    partitionKeyOpaque(): boolean;
+    setPartitionKeyOpaque(): void;
+    priority(): Protocol.Network.CookiePriority;
+    session(): boolean;
+    path(): string;
+    domain(): string;
+    expires(): number;
+    maxAge(): number;
+    sourcePort(): number;
+    sourceScheme(): Protocol.Network.CookieSourceScheme;
+    size(): number;
+    /**
+     * @deprecated
+     */
+    url(): Platform.DevToolsPath.UrlString | null;
+    setSize(size: number): void;
+    expiresDate(requestDate: Date): Date | null;
+    addAttribute(key: Attribute | null, value?: string | number | boolean): void;
+    hasAttribute(key: Attribute): boolean;
+    getAttribute(key: Attribute): string | number | boolean | undefined;
+    setCookieLine(cookieLine: string): void;
+    getCookieLine(): string | null;
+    matchesSecurityOrigin(securityOrigin: string): boolean;
+    static isDomainMatch(domain: string, hostname: string): boolean;
+}
+export declare const enum Type {
+    REQUEST = 0,
+    RESPONSE = 1
+}
+export declare const enum Attribute {
+    NAME = "name",
+    VALUE = "value",
+    SIZE = "size",
+    DOMAIN = "domain",
+    PATH = "path",
+    EXPIRES = "expires",
+    MAX_AGE = "max-age",
+    HTTP_ONLY = "http-only",
+    SECURE = "secure",
+    SAME_SITE = "same-site",
+    SOURCE_SCHEME = "source-scheme",
+    SOURCE_PORT = "source-port",
+    PRIORITY = "priority",
+    PARTITIONED = "partitioned",
+    PARTITION_KEY = "partition-key",
+    PARTITION_KEY_SITE = "partition-key-site",
+    HAS_CROSS_SITE_ANCESTOR = "has-cross-site-ancestor"
+}

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

@@ -0,0 +1,31 @@
+import { type Attribute, Cookie } from './Cookie.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class CookieModel extends SDKModel<EventTypes> {
+    #private;
+    constructor(target: Target);
+    addBlockedCookie(cookie: Cookie, blockedReasons: BlockedReason[] | null): void;
+    removeBlockedCookie(cookie: Cookie): void;
+    getCookieToBlockedReasonsMap(): ReadonlyMap<Cookie, BlockedReason[]>;
+    deleteCookie(cookie: Cookie): Promise<void>;
+    clear(domain?: string, securityOrigin?: string): Promise<void>;
+    saveCookie(cookie: Cookie): Promise<boolean>;
+    /**
+     * Returns cookies needed by current page's frames whose security origins are |domain|.
+     */
+    getCookiesForDomain(domain: string, forceUpdate?: boolean): Promise<Cookie[]>;
+    deleteCookies(cookies: Cookie[]): Promise<void>;
+}
+export interface BlockedReason {
+    uiString: string;
+    attribute: Attribute | null;
+}
+export interface ExemptionReason {
+    uiString: string;
+}
+export declare const enum Events {
+    COOKIE_LIST_UPDATED = "CookieListUpdated"
+}
+export interface EventTypes {
+    [Events.COOKIE_LIST_UPDATED]: void;
+}

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

@@ -0,0 +1,14 @@
+import { Attribute, Cookie } from './Cookie.js';
+export declare class CookieParser {
+    #private;
+    constructor(domain?: string);
+    static parseSetCookie(header: string | undefined, domain?: string): Cookie[] | null;
+    getCookieAttribute(header: string | undefined): Attribute | null;
+    cookies(): Cookie[];
+    parseSetCookie(setCookieHeader: string | undefined): Cookie[] | null;
+    private initialize;
+    private flushCookie;
+    private extractKeyValue;
+    private advanceAndCheckCookieDelimiter;
+    private addCookie;
+}