@remotion/renderer
Version:
Render Remotion videos using Node.js or Bun
1,264 lines (1,263 loc) • 35.5 kB
TypeScript
type RemoteObjectId = string;
interface WebDriverValue {
/**
* (WebDriverValueType enum)
*/
type: 'undefined' | 'null' | 'string' | 'number' | 'boolean' | 'bigint' | 'regexp' | 'date' | 'symbol' | 'array' | 'object' | 'function' | 'map' | 'set' | 'weakmap' | 'weakset' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'node' | 'window';
value?: any;
objectId?: string;
}
type UnserializableValue = string;
export interface DevtoolsRemoteObject {
/**
* Object type. (RemoteObjectType enum)
*/
type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint';
/**
* Object subtype hint. Specified for `object` type values only.
* NOTE: If you change anything here, make sure to also update
* `subtype` in `ObjectPreview` and `PropertyPreview` below. (RemoteObjectSubtype enum)
*/
subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'dataview' | 'webassemblymemory' | 'wasmvalue';
/**
* Object class (constructor) name. Specified for `object` type values only.
*/
className?: string;
/**
* Remote object value in case of primitive values or JSON values (if it was requested).
*/
value?: any;
/**
* Primitive value which can not be JSON-stringified does not have `value`, but gets this
* property.
*/
unserializableValue?: UnserializableValue;
/**
* String representation of the object.
*/
description?: string;
/**
* WebDriver BiDi representation of the value.
*/
webDriverValue?: WebDriverValue;
/**
* Unique object identifier (for non-primitive values).
*/
objectId?: RemoteObjectId;
preview?: ObjectPreview;
}
export interface ObjectPreview {
/**
* Object type. (ObjectPreviewType enum)
*/
type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint';
/**
* Object subtype hint. Specified for `object` type values only. (ObjectPreviewSubtype enum)
*/
subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'dataview' | 'webassemblymemory' | 'wasmvalue';
/**
* String representation of the object.
*/
description?: string;
/**
* True iff some of the properties or entries of the original object did not fit.
*/
overflow: boolean;
/**
* List of the properties.
*/
properties: PropertyPreview[];
/**
* List of the entries. Specified for `map` and `set` subtype values only.
*/
entries?: EntryPreview[];
}
export interface EntryPreview {
/**
* Preview of the key. Specified for map-like collection entries.
*/
key?: ObjectPreview;
/**
* Preview of the value.
*/
value: ObjectPreview;
}
export interface PropertyPreview {
/**
* Property name.
*/
name: string;
/**
* Object type. Accessor means that the property itself is an accessor property. (PropertyPreviewType enum)
*/
type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'accessor' | 'bigint';
/**
* User-friendly property value string.
*/
value?: string;
/**
* Nested value preview.
*/
valuePreview?: ObjectPreview;
/**
* Object subtype hint. Specified for `object` type values only. (PropertyPreviewSubtype enum)
*/
subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'dataview' | 'webassemblymemory' | 'wasmvalue';
}
type TargetID = string;
export interface TargetInfo {
targetId: TargetID;
type: string;
title: string;
url: string;
/**
* Whether the target has an attached client.
*/
attached: boolean;
/**
* Opener target Id
*/
openerId?: TargetID;
/**
* Whether the target has access to the originating window.
*/
canAccessOpener: boolean;
browserContextId?: string;
}
export interface DevtoolsTargetCreatedEvent {
targetInfo: TargetInfo;
}
export interface ExecutionContextDescription {
/**
* Unique id of the execution context. It can be used to specify in which execution context
* script evaluation should be performed.
*/
id: number;
/**
* Execution context origin.
*/
origin: string;
/**
* Human readable name describing given context.
*/
name: string;
/**
* A system-unique execution context identifier. Unlike the id, this is unique across
* multiple processes, so can be reliably used to identify specific context while backend
* performs a cross-process navigation.
*/
uniqueId: string;
/**
* Embedder-specific auxiliary data.
*/
auxData?: any;
}
export interface ExceptionDetails {
/**
* Exception id.
*/
exceptionId: number;
/**
* Exception text, which should be used together with exception object when available.
*/
text: string;
/**
* Line number of the exception location (0-based).
*/
lineNumber: number;
/**
* Column number of the exception location (0-based).
*/
columnNumber: number;
/**
* Script ID of the exception location.
*/
scriptId?: string;
/**
* URL of the exception location, to be used when the script was not reported.
*/
url?: string;
/**
* JavaScript stack trace if available.
*/
stackTrace?: StackTrace;
/**
* Exception object if available.
*/
exception?: DevtoolsRemoteObject;
/**
* Identifier of the context where exception happened.
*/
executionContextId?: number;
/**
* Dictionary with entries of meta data that the client associated
* with this exception, such as information about associated network
* requests, etc.
*/
exceptionMetaData?: any;
}
export interface StackTrace {
/**
* String label of this stack trace. For async traces this may be a name of the function that
* initiated the async call.
*/
description?: string;
/**
* JavaScript function name.
*/
callFrames: CallFrame[];
/**
* Asynchronous JavaScript stack trace that preceded this stack, if available.
*/
parent?: StackTrace;
/**
* Asynchronous JavaScript stack trace that preceded this stack, if available.
*/
parentId?: StackTraceId;
}
export interface CallFrame {
/**
* JavaScript function name.
*/
functionName: string;
/**
* JavaScript script id.
*/
scriptId: number;
/**
* JavaScript script name or url.
*/
url: string;
/**
* JavaScript script line number (0-based).
*/
lineNumber: number;
/**
* JavaScript script column number (0-based).
*/
columnNumber: number;
}
interface StackTraceId {
id: string;
debuggerId?: string;
}
export interface CallFunctionOnRequest {
/**
* Declaration of the function to call.
*/
functionDeclaration: string;
/**
* Identifier of the object to call function on. Either objectId or executionContextId should
* be specified.
*/
objectId?: RemoteObjectId;
/**
* Call arguments. All call arguments must belong to the same JavaScript world as the target
* object.
*/
arguments?: CallArgument[];
/**
* In silent mode exceptions thrown during evaluation are not reported and do not pause
* execution. Overrides `setPauseOnException` state.
*/
silent?: boolean;
/**
* Whether the result is expected to be a JSON object which should be sent by value.
*/
returnByValue?: boolean;
/**
* Whether preview should be generated for the result.
*/
generatePreview?: boolean;
/**
* Whether execution should be treated as initiated by user in the UI.
*/
userGesture?: boolean;
/**
* Whether execution should `await` for resulting value and return once awaited promise is
* resolved.
*/
awaitPromise?: boolean;
/**
* Specifies execution context which global object will be used to call function on. Either
* executionContextId or objectId should be specified.
*/
executionContextId?: ExecutionContextId;
/**
* Symbolic group name that can be used to release multiple objects. If objectGroup is not
* specified and objectId is, objectGroup will be inherited from object.
*/
objectGroup?: string;
/**
* Whether to throw an exception if side effect cannot be ruled out during evaluation.
*/
throwOnSideEffect?: boolean;
/**
* Whether the result should contain `webDriverValue`, serialized according to
* https://w3c.github.io/webdriver-bidi. This is mutually exclusive with `returnByValue`, but
* resulting `objectId` is still provided.
*/
generateWebDriverValue?: boolean;
}
export interface CallArgument {
/**
* Primitive value or serializable javascript object.
*/
value?: any;
/**
* Primitive value which can not be JSON-stringified.
*/
unserializableValue?: UnserializableValue;
/**
* Remote object handle.
*/
objectId?: RemoteObjectId;
}
export interface CallFunctionOnResponse {
/**
* Call result.
*/
result: DevtoolsRemoteObject;
/**
* Exception details.
*/
exceptionDetails?: ExceptionDetails;
}
type ExecutionContextId = number;
export interface EvaluateResponse {
/**
* Evaluation result.
*/
result: DevtoolsRemoteObject;
/**
* Exception details.
*/
exceptionDetails?: ExceptionDetails;
}
export interface GetFrameTreeResponse {
/**
* Present frame tree structure.
*/
frameTree: FrameTree;
}
export interface FrameTree {
/**
* Frame information for this tree item.
*/
frame: Frame;
/**
* Child frames.
*/
childFrames?: FrameTree[];
}
type FrameId = string;
type LoaderId = string;
export interface Frame {
/**
* Frame unique identifier.
*/
id: FrameId;
/**
* Parent frame identifier.
*/
parentId?: FrameId;
/**
* Identifier of the loader associated with this frame.
*/
loaderId: LoaderId;
/**
* Frame's name as specified in the tag.
*/
name?: string;
/**
* Frame document's URL without fragment.
*/
url: string;
/**
* Frame document's URL fragment including the '#'.
*/
urlFragment?: string;
/**
* Frame document's registered domain, taking the public suffixes list into account.
* Extracted from the Frame's url.
* Example URLs: http://www.google.com/file.html -> "google.com"
* http://a.b.co.uk/file.html -> "b.co.uk"
*/
domainAndRegistry: string;
/**
* Frame document's security origin.
*/
securityOrigin: string;
/**
* Frame document's mimeType as determined by the browser.
*/
mimeType: string;
/**
* If the frame failed to load, this contains the URL that could not be loaded. Note that unlike url above, this URL may contain a fragment.
*/
unreachableUrl?: string;
}
export interface SetAutoAttachRequest {
/**
* Whether to auto-attach to related targets.
*/
autoAttach: boolean;
/**
* Whether to pause new targets when attaching to them. Use `Runtime.runIfWaitingForDebugger`
* to run paused targets.
*/
waitForDebuggerOnStart: boolean;
/**
* Enables "flat" access to the session via specifying sessionId attribute in the commands.
* We plan to make this the default, deprecate non-flattened mode,
* and eventually retire it. See crbug.com/991325.
*/
flatten?: boolean;
}
/**
* Fired when frame has been detached from its parent.
*/
export interface FrameDetachedEvent {
/**
* Id of the frame that has been detached.
*/
frameId: FrameId;
/**
* (FrameDetachedEventReason enum)
*/
reason: 'remove' | 'swap';
}
export interface SetLifecycleEventsEnabledRequest {
/**
* If true, starts emitting lifecycle events.
*/
enabled: boolean;
}
export interface NavigateRequest {
/**
* URL to navigate the page to.
*/
url: string;
/**
* Referrer URL.
*/
referrer?: string;
/**
* Frame id to navigate, if not specified navigates the top frame.
*/
frameId?: FrameId;
/**
* Referrer-policy used for the navigation.
*/
referrerPolicy?: ReferrerPolicy;
}
export interface NavigateResponse {
/**
* Frame id that has navigated (or failed to navigate)
*/
frameId: FrameId;
/**
* Loader identifier. This is omitted in case of same-document navigation,
* as the previously committed loaderId would not change.
*/
loaderId?: LoaderId;
/**
* User friendly error message, present if and only if navigation has failed.
*/
errorText?: string;
}
export declare const enum FrameDetachedEventReason {
Remove = "remove",
Swap = "swap"
}
export interface AttachedToTargetEvent {
/**
* Identifier assigned to the session used to send/receive messages.
*/
sessionId: SessionID;
targetInfo: TargetInfo;
waitingForDebugger: boolean;
}
type SessionID = string;
export interface DetachedFromTargetEvent {
/**
* Detached session identifier.
*/
sessionId: SessionID;
/**
* Deprecated.
*/
targetId?: TargetID;
}
export interface LifecycleEventEvent {
/**
* Id of the frame.
*/
frameId: FrameId;
/**
* Loader identifier. Empty string if the request is fetched from worker.
*/
loaderId: LoaderId;
name: string;
timestamp: number;
}
export interface AddScriptToEvaluateOnNewDocumentRequest {
source: string;
/**
* If specified, creates an isolated world with the given name and evaluates given script in it.
* This world name will be used as the ExecutionContextDescription::name when the corresponding
* event is emitted.
*/
worldName?: string;
/**
* Specifies whether command line API should be available to the script, defaults
* to false.
*/
includeCommandLineAPI?: boolean;
}
export interface AddScriptToEvaluateOnNewDocumentResponse {
/**
* Identifier of the added script.
*/
identifier: ScriptIdentifier;
}
type ScriptIdentifier = string;
export interface CreateIsolatedWorldRequest {
/**
* Id of the frame in which the isolated world should be created.
*/
frameId: FrameId;
/**
* An optional name which is reported in the Execution Context.
*/
worldName?: string;
/**
* Whether or not universal access should be granted to the isolated world. This is a powerful
* option, use with caution.
*/
grantUniveralAccess?: boolean;
}
export interface CreateIsolatedWorldResponse {
/**
* Execution context of the isolated world.
*/
executionContextId: ExecutionContextId;
}
export interface CaptureScreenshotRequest {
/**
* Image compression format (defaults to png). (CaptureScreenshotRequestFormat enum)
*/
format?: 'jpeg' | 'png' | 'webp';
/**
* Compression quality from range [0..100] (jpeg only).
*/
quality?: number;
/**
* Capture the screenshot of a given region only.
*/
clip?: {
/**
* X offset in device independent pixels (dip).
*/
x: number;
/**
* Y offset in device independent pixels (dip).
*/
y: number;
/**
* Rectangle width in device independent pixels (dip).
*/
width: number;
/**
* Rectangle height in device independent pixels (dip).
*/
height: number;
/**
* Page scale factor.
*/
scale: number;
};
/**
* Capture the screenshot from the surface, rather than the view. Defaults to true.
*/
fromSurface?: boolean;
/**
* Capture the screenshot beyond the viewport. Defaults to false.
*/
captureBeyondViewport?: boolean;
/**
* Optimize image encoding for speed, not for resulting size (defaults to false) EXPERIMENTAL
*/
optimizeForSpeed?: boolean;
}
export interface CaptureScreenshotResponse {
/**
* Base64-encoded image data. (Encoded as a base64 string when passed over JSON)
*/
data: string;
}
export interface PrintPDFRequest {
/**
* Paper orientation. Defaults to false.
*/
landscape?: boolean;
/**
* Display header and footer. Defaults to false.
*/
displayHeaderFooter?: boolean;
/**
* Print background graphics. Defaults to false.
*/
printBackground?: boolean;
/**
* Scale of the webpage rendering. Defaults to 1.
*/
scale?: number;
/**
* Paper width in inches. Defaults to 8.5 inches.
*/
paperWidth?: number;
/**
* Paper height in inches. Defaults to 11 inches.
*/
paperHeight?: number;
/**
* Top margin in inches. Defaults to 1cm (~0.4 inches).
*/
marginTop?: number;
/**
* Bottom margin in inches. Defaults to 1cm (~0.4 inches).
*/
marginBottom?: number;
/**
* Left margin in inches. Defaults to 1cm (~0.4 inches).
*/
marginLeft?: number;
/**
* Right margin in inches. Defaults to 1cm (~0.4 inches).
*/
marginRight?: number;
/**
* Paper ranges to print, one based, e.g., '1-5, 8, 11-13'.
* Pages are printed in the document order, not in the order specified,
* and no more than once. Defaults to empty string,
* which implies the entire document is printed.
* The page numbers are quietly capped to actual page count of the document,
* and ranges beyond the end of the document are ignored.
* If this results in no pages to print, an error is reported.
* It is an error to specify a range with start greater than end.
*/
pageRanges?: string;
/**
* HTML template for the print header.
* Should be valid HTML markup with following classes used to inject printing values into them:
* date: formatted print date
* title: document title
* url: document location
* pageNumber: current page number
* totalPages: total pages in the document
* For example, <span class=title></span> would generate span containing the title.
*/
headerTemplate?: string;
/**
* HTML template for the print footer. Should use the same format as the headerTemplate.
*/
footerTemplate?: string;
/**
* Whether or not to prefer page size as defined by css. Defaults to false, in which case the content will be scaled to fit the paper size.
*/
preferCSSPageSize?: boolean;
}
export interface PrintPDFResponse {
/**
* Base64-encoded pdf data. Empty if |returnAsStream| is specified. (Encoded as a base64 string when passed over JSON)
*/
data: string;
}
export interface RequestWillBeSentEvent {
/**
* Request identifier.
*/
requestId: RequestId;
/**
* Loader identifier. Empty string if the request is fetched from worker.
*/
loaderId: LoaderId;
/**
* URL of the document this request is loaded for.
*/
documentURL: string;
/**
* Request data.
*/
request: Request;
/**
* Timestamp.
*/
timestamp: number;
/**
* Timestamp.
*/
wallTime: number;
/**
* Request initiator.
*/
initiator: Initiator;
/**
* In the case that redirectResponse is populated, this flag indicates whether
* requestWillBeSentExtraInfo and responseReceivedExtraInfo events will be or were emitted
* for the request which was just redirected.
*/
redirectHasExtraInfo: boolean;
/**
* Redirect response data.
*/
redirectResponse?: Response;
/**
* Type of this resource.
*/
type?: ResourceType;
/**
* Frame identifier.
*/
frameId?: FrameId;
/**
* Whether the request is initiated by a user gesture. Defaults to false.
*/
hasUserGesture?: boolean;
}
interface Initiator {
/**
* Type of this initiator. (InitiatorType enum)
*/
type: 'parser' | 'script' | 'preload' | 'SignedExchange' | 'preflight' | 'other';
/**
* Initiator JavaScript stack trace, set for Script only.
*/
stack?: StackTrace;
/**
* Initiator URL, set for Parser type or for Script type (when script is importing module) or for SignedExchange type.
*/
url?: string;
/**
* Initiator line number, set for Parser type or for Script type (when script is importing
* module) (0-based).
*/
lineNumber?: number;
/**
* Initiator column number, set for Parser type or for Script type (when script is importing
* module) (0-based).
*/
columnNumber?: number;
/**
* Set if another request triggered this request (e.g. preflight).
*/
requestId?: RequestId;
}
type ResourceType = 'Document' | 'Stylesheet' | 'Image' | 'Media' | 'Font' | 'Script' | 'TextTrack' | 'XHR' | 'Fetch' | 'EventSource' | 'WebSocket' | 'Manifest' | 'SignedExchange' | 'Ping' | 'CSPViolationReport' | 'Preflight' | 'Other';
type RequestId = string;
export interface ActivateTargetRequest {
targetId: TargetID;
}
export interface SetDefaultBackgroundColorOverrideRequest {
/**
* RGBA of the default background color. If not specified, any existing override will be
* cleared.
*/
color?: RGBA;
}
interface RGBA {
/**
* The red component, in the [0-255] range.
*/
r: number;
/**
* The green component, in the [0-255] range.
*/
g: number;
/**
* The blue component, in the [0-255] range.
*/
b: number;
/**
* The alpha component, in the [0-1] range (default: 1).
*/
a?: number;
}
export interface Response {
/**
* Response URL. This URL can be different from CachedResource.url in case of redirect.
*/
url: string;
/**
* HTTP response status code.
*/
status: number;
/**
* HTTP response status text.
*/
statusText: string;
/**
* HTTP response headers.
*/
headers: Headers;
/**
* HTTP response headers text. This has been replaced by the headers in Network.responseReceivedExtraInfo.
*/
headersText?: string;
/**
* Resource mimeType as determined by the browser.
*/
mimeType: string;
/**
* Refined HTTP request headers that were actually transmitted over the network.
*/
requestHeaders?: Headers;
/**
* HTTP request headers text. This has been replaced by the headers in Network.requestWillBeSentExtraInfo.
*/
requestHeadersText?: string;
/**
* Specifies whether physical connection was actually reused for this request.
*/
connectionReused: boolean;
/**
* Physical connection id that was actually used for this request.
*/
connectionId: number;
/**
* Remote IP address.
*/
remoteIPAddress?: string;
/**
* Remote port.
*/
remotePort?: number;
/**
* Specifies that the request was served from the disk cache.
*/
fromDiskCache?: boolean;
/**
* Specifies that the request was served from the ServiceWorker.
*/
fromServiceWorker?: boolean;
/**
* Specifies that the request was served from the prefetch cache.
*/
fromPrefetchCache?: boolean;
/**
* Total number of bytes received for this request so far.
*/
encodedDataLength: number;
/**
* The time at which the returned response was generated.
*/
responseTime?: number;
/**
* Cache Storage Cache Name.
*/
cacheStorageCacheName?: string;
/**
* Protocol used to fetch this request.
*/
protocol?: string;
}
export interface ResponseReceivedExtraInfoEvent {
/**
* Request identifier. Used to match this information to another responseReceived event.
*/
requestId: RequestId;
/**
* Raw response headers as they were received over the wire.
*/
headers: Headers;
/**
* The status code of the response. This is useful in cases the request failed and no responseReceived
* event is triggered, which is the case for, e.g., CORS errors. This is also the correct status code
* for cached requests, where the status in responseReceived is a 200 and this will be 304.
*/
statusCode: number;
/**
* Raw response header text as it was received over the wire. The raw text may not always be
* available, such as in the case of HTTP/2 or QUIC.
*/
headersText?: string;
}
interface Request {
/**
* Request URL (without fragment).
*/
url: string;
/**
* Fragment of the requested URL starting with hash, if present.
*/
urlFragment?: string;
/**
* HTTP request method.
*/
method: string;
/**
* HTTP request headers.
*/
headers: Headers;
/**
* HTTP POST request data.
*/
postData?: string;
/**
* True when the request has POST data. Note that postData might still be omitted when this flag is true when the data is too long.
*/
hasPostData?: boolean;
/**
* The referrer policy of the request, as defined in https://www.w3.org/TR/referrer-policy/ (RequestReferrerPolicy enum)
*/
referrerPolicy: 'unsafe-url' | 'no-referrer-when-downgrade' | 'no-referrer' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin';
/**
* Whether is loaded via link preload.
*/
isLinkPreload?: boolean;
/**
* True if this resource request is considered to be the 'same site' as the
* request correspondinfg to the main frame.
*/
isSameSite?: boolean;
}
export interface RequestPausedEvent {
/**
* Each request the page makes will have a unique id.
*/
requestId: RequestId;
/**
* The details of the request.
*/
request: Request;
/**
* The id of the frame that initiated the request.
*/
frameId: FrameId;
/**
* How the requested resource will be used.
*/
resourceType: ResourceType;
/**
* Response status text if intercepted at response stage.
*/
responseStatusText?: string;
/**
* If the intercepted request had a corresponding Network.requestWillBeSent event fired for it,
* then this networkId will be the same as the requestId present in the requestWillBeSent event.
*/
networkId?: RequestId;
}
export interface ResponseReceivedEvent {
/**
* Request identifier.
*/
requestId: RequestId;
/**
* Loader identifier. Empty string if the request is fetched from worker.
*/
loaderId: LoaderId;
/**
* Timestamp.
*/
timestamp: number;
/**
* Resource type.
*/
type: ResourceType;
/**
* Response data.
*/
response: Response;
/**
* Indicates whether requestWillBeSentExtraInfo and responseReceivedExtraInfo events will be
* or were emitted for this request.
*/
hasExtraInfo: boolean;
/**
* Frame identifier.
*/
frameId?: FrameId;
}
export interface LoadingFinishedEvent {
/**
* Request identifier.
*/
requestId: RequestId;
/**
* Timestamp.
*/
timestamp: number;
/**
* Total number of bytes received for this request.
*/
encodedDataLength: number;
/**
* Set when 1) response was blocked by Cross-Origin Read Blocking and also
* 2) this needs to be reported to the DevTools console.
*/
shouldReportCorbBlocking?: boolean;
}
export interface LoadingFailedEvent {
/**
* Request identifier.
*/
requestId: RequestId;
/**
* Timestamp.
*/
timestamp: number;
/**
* Resource type.
*/
type: ResourceType;
/**
* User friendly error message.
*/
errorText: string;
/**
* True if loading was canceled.
*/
canceled?: boolean;
}
export interface EnableRequest {
/**
* Time domain to use for collecting and reporting duration metrics. (EnableRequestTimeDomain enum)
*/
timeDomain?: 'timeTicks' | 'threadTicks';
}
export interface RequestServedFromCacheEvent {
/**
* Request identifier.
*/
requestId: RequestId;
}
export interface DetachFromTargetRequest {
/**
* Session to detach.
*/
sessionId?: SessionID;
/**
* Deprecated.
*/
targetId?: TargetID;
}
export interface SetDeviceMetricsOverrideRequest {
/**
* Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.
*/
width: number;
/**
* Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.
*/
height: number;
/**
* Overriding device scale factor value. 0 disables the override.
*/
deviceScaleFactor: number;
/**
* Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text
* autosizing and more.
*/
mobile: boolean;
/**
* Scale to apply to resulting view image.
*/
scale?: number;
/**
* Overriding screen width value in pixels (minimum 0, maximum 10000000).
*/
screenWidth?: number;
/**
* Overriding screen height value in pixels (minimum 0, maximum 10000000).
*/
screenHeight?: number;
/**
* Overriding view X position on screen in pixels (minimum 0, maximum 10000000).
*/
positionX?: number;
/**
* Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).
*/
positionY?: number;
/**
* Do not set visible view size, rely upon explicit setVisibleSize call.
*/
dontSetVisibleSize?: boolean;
/**
* Screen orientation override.
*/
screenOrientation?: ScreenOrientation;
/**
* If set, the visible area of the page will be overridden to this viewport. This viewport
* change is not observed by the page, e.g. viewport-relative elements do not change positions.
*/
viewport?: {
/**
* X offset in device independent pixels (dip).
*/
x: number;
/**
* Y offset in device independent pixels (dip).
*/
y: number;
/**
* Rectangle width in device independent pixels (dip).
*/
width: number;
/**
* Rectangle height in device independent pixels (dip).
*/
height: number;
/**
* Page scale factor.
*/
scale: number;
};
/**
* If set, the display feature of a multi-segment screen. If not set, multi-segment support
* is turned-off.
*/
displayFeature?: DisplayFeature;
}
interface DisplayFeature {
/**
* Orientation of a display feature in relation to screen (DisplayFeatureOrientation enum)
*/
orientation: 'vertical' | 'horizontal';
/**
* The offset from the screen origin in either the x (for vertical
* orientation) or y (for horizontal orientation) direction.
*/
offset: number;
/**
* A display feature may mask content such that it is not physically
* displayed - this length along with the offset describes this area.
* A display feature that only splits content will have a 0 mask_length.
*/
maskLength: number;
}
export interface EntryAddedEvent {
/**
* The entry.
*/
entry: LogEntry;
}
interface LogEntry {
/**
* Log entry source. (LogEntrySource enum)
*/
source: 'xml' | 'javascript' | 'network' | 'storage' | 'appcache' | 'rendering' | 'security' | 'deprecation' | 'worker' | 'violation' | 'intervention' | 'recommendation' | 'other';
/**
* Log entry severity. (LogEntryLevel enum)
*/
level: 'verbose' | 'info' | 'warning' | 'error';
/**
* Logged text.
*/
text: string;
/**
* (LogEntryCategory enum)
*/
category?: 'cors';
/**
* Timestamp when this entry was added.
*/
timestamp: number;
/**
* URL of the resource if known.
*/
url?: string;
/**
* Line number in the resource.
*/
lineNumber?: number;
/**
* JavaScript stack trace.
*/
stackTrace?: StackTrace;
/**
* Identifier of the network request associated with this entry.
*/
networkRequestId?: RequestId;
/**
* Identifier of the worker associated with this entry.
*/
workerId?: string;
/**
* Call arguments.
*/
args?: DevtoolsRemoteObject[];
}
export interface ConsoleAPICalledEvent {
/**
* Type of the call. (ConsoleAPICalledEventType enum)
*/
type: 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
/**
* Call arguments.
*/
args: DevtoolsRemoteObject[];
/**
* Identifier of the context where the call was made.
*/
executionContextId: ExecutionContextId;
/**
* Call timestamp.
*/
timestamp: number;
/**
* Stack trace captured when the call was made. The async stack chain is automatically reported for
* the following call types: `assert`, `error`, `trace`, `warning`. For other types the async call
* chain can be retrieved using `Debugger.getStackTrace` and `stackTrace.parentId` field.
*/
stackTrace?: StackTrace;
/**
* Console context descriptor for calls on non-default console context (not console.*):
* 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call
* on named context.
*/
context?: string;
}
export interface BindingCalledEvent {
name: string;
payload: string;
/**
* Identifier of the context where the call was made.
*/
executionContextId: ExecutionContextId;
}
interface ScreenOrientation {
/**
* Orientation type. (ScreenOrientationType enum)
*/
type: 'portraitPrimary' | 'portraitSecondary' | 'landscapePrimary' | 'landscapeSecondary';
/**
* Orientation angle.
*/
angle: number;
}
export interface CloseTargetRequest {
targetId: TargetID;
}
export interface CloseTargetResponse {
/**
* Always set to true. If an error occurs, the response indicates protocol error.
*/
success: boolean;
}
export interface ExceptionThrownEvent {
/**
* Timestamp of the exception.
*/
timestamp: number;
exceptionDetails: ExceptionDetails;
}
export interface ReleaseObjectRequest {
/**
* Identifier of the object to release.
*/
objectId: RemoteObjectId;
}
export {};