platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Passwordless cross-device authentication

Browse Source 
- Arkitektur: docs/auth/passwordless-architecture.md
- Backend: iom/quixzoom-auth-service/ (FastAPI + Redis)
- Webb: quixzoom-market-pages/se/login/ (QR-kod + polling)
- App: iom/quixzoom-app/src/features/auth/ (push + deep links)

Flöde: QR-kod → app-godkännande → webb-inloggad
This commit is contained in:
Bernt
2026-07-07 07:11:50 +00:00
parent 4aa984ad74
commit 6989a98d75
61843 changed files with 5491611 additions and 872231 deletions
Download Patch File Download Diff File Expand all files Collapse all files
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/main.d.ts
Generated Vendored
+3007
View File
@@ -0,0 +1,3007 @@
export type Command = {
id: JsUint;
} & CommandData &
Extensible;
export type CommandData =
| BrowserCommand
| BrowsingContextCommand
| EmulationCommand
| InputCommand
| NetworkCommand
| ScriptCommand
| SessionCommand
| StorageCommand
| WebExtensionCommand;
export type EmptyParams = Extensible;
export type Message = CommandResponse | ErrorResponse | Event;
export type CommandResponse = {
type: 'success';
id: JsUint;
result: ResultData;
} & Extensible;
export type ErrorResponse = {
type: 'error';
id: JsUint | null;
error: ErrorCode;
message: string;
stacktrace?: string;
} & Extensible;
export type ResultData =
| BrowserResult
| BrowsingContextResult
| EmulationResult
| InputResult
| NetworkResult
| ScriptResult
| SessionResult
| StorageResult
| WebExtensionResult;
export type EmptyResult = Extensible;
export type Event = {
type: 'event';
} & EventData &
Extensible;
export type EventData =
| BrowsingContextEvent
| InputEvent
| LogEvent
| NetworkEvent
| ScriptEvent;
export type Extensible = {
[key: string]: any;
};
/**
* Must be between `-9007199254740991` and `9007199254740991`, inclusive.
*/
export type JsInt = number;
/**
* Must be between `0` and `9007199254740991`, inclusive.
*/
export type JsUint = number;
export declare const enum ErrorCode {
InvalidArgument = 'invalid argument',
InvalidSelector = 'invalid selector',
InvalidSessionId = 'invalid session id',
InvalidWebExtension = 'invalid web extension',
MoveTargetOutOfBounds = 'move target out of bounds',
NoSuchAlert = 'no such alert',
NoSuchNetworkCollector = 'no such network collector',
NoSuchElement = 'no such element',
NoSuchFrame = 'no such frame',
NoSuchHandle = 'no such handle',
NoSuchHistoryEntry = 'no such history entry',
NoSuchIntercept = 'no such intercept',
NoSuchNetworkData = 'no such network data',
NoSuchNode = 'no such node',
NoSuchRequest = 'no such request',
NoSuchScript = 'no such script',
NoSuchStoragePartition = 'no such storage partition',
NoSuchUserContext = 'no such user context',
NoSuchWebExtension = 'no such web extension',
SessionNotCreated = 'session not created',
UnableToCaptureScreen = 'unable to capture screen',
UnableToCloseBrowser = 'unable to close browser',
UnableToSetCookie = 'unable to set cookie',
UnableToSetFileInput = 'unable to set file input',
UnavailableNetworkData = 'unavailable network data',
UnderspecifiedStoragePartition = 'underspecified storage partition',
UnknownCommand = 'unknown command',
UnknownError = 'unknown error',
UnsupportedOperation = 'unsupported operation',
}
export type SessionCommand =
| Session.End
| Session.New
| Session.Status
| Session.Subscribe
| Session.Unsubscribe;
export type SessionResult =
| Session.EndResult
| Session.NewResult
| Session.StatusResult
| Session.SubscribeResult
| Session.UnsubscribeResult;
export declare namespace Session {
type CapabilitiesRequest = {
alwaysMatch?: Session.CapabilityRequest;
firstMatch?: [...Session.CapabilityRequest[]];
};
}
export declare namespace Session {
type CapabilityRequest = {
acceptInsecureCerts?: boolean;
browserName?: string;
browserVersion?: string;
platformName?: string;
proxy?: Session.ProxyConfiguration;
unhandledPromptBehavior?: Session.UserPromptHandler;
} & Extensible;
}
export declare namespace Session {
type ProxyConfiguration =
| Session.AutodetectProxyConfiguration
| Session.DirectProxyConfiguration
| Session.ManualProxyConfiguration
| Session.PacProxyConfiguration
| Session.SystemProxyConfiguration;
}
export declare namespace Session {
type AutodetectProxyConfiguration = {
proxyType: 'autodetect';
} & Extensible;
}
export declare namespace Session {
type DirectProxyConfiguration = {
proxyType: 'direct';
} & Extensible;
}
export declare namespace Session {
type ManualProxyConfiguration = {
proxyType: 'manual';
httpProxy?: string;
sslProxy?: string;
} & ({} | Session.SocksProxyConfiguration) & {
noProxy?: [...string[]];
} & Extensible;
}
export declare namespace Session {
type SocksProxyConfiguration = {
socksProxy: string;
/**
* Must be between `0` and `255`, inclusive.
*/
socksVersion: number;
};
}
export declare namespace Session {
type PacProxyConfiguration = {
proxyType: 'pac';
proxyAutoconfigUrl: string;
} & Extensible;
}
export declare namespace Session {
type SystemProxyConfiguration = {
proxyType: 'system';
} & Extensible;
}
export declare namespace Session {
type UserPromptHandler = {
alert?: Session.UserPromptHandlerType;
beforeUnload?: Session.UserPromptHandlerType;
confirm?: Session.UserPromptHandlerType;
default?: Session.UserPromptHandlerType;
file?: Session.UserPromptHandlerType;
prompt?: Session.UserPromptHandlerType;
};
}
export declare namespace Session {
const enum UserPromptHandlerType {
Accept = 'accept',
Dismiss = 'dismiss',
Ignore = 'ignore',
}
}
export declare namespace Session {
type Subscription = string;
}
export declare namespace Session {
type SubscribeParameters = {
events: [string, ...string[]];
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Session {
type UnsubscribeByIdRequest = {
subscriptions: [Session.Subscription, ...Session.Subscription[]];
};
}
export declare namespace Session {
type UnsubscribeByAttributesRequest = {
events: [string, ...string[]];
};
}
export declare namespace Session {
type Status = {
method: 'session.status';
params: EmptyParams;
};
}
export declare namespace Session {
type StatusResult = {
ready: boolean;
message: string;
};
}
export declare namespace Session {
type New = {
method: 'session.new';
params: Session.NewParameters;
};
}
export declare namespace Session {
type NewParameters = {
capabilities: Session.CapabilitiesRequest;
};
}
export declare namespace Session {
type NewResult = {
sessionId: string;
capabilities: {
acceptInsecureCerts: boolean;
browserName: string;
browserVersion: string;
platformName: string;
setWindowRect: boolean;
userAgent: string;
proxy?: Session.ProxyConfiguration;
unhandledPromptBehavior?: Session.UserPromptHandler;
webSocketUrl?: string;
} & Extensible;
};
}
export declare namespace Session {
type End = {
method: 'session.end';
params: EmptyParams;
};
}
export declare namespace Session {
type EndResult = EmptyResult;
}
export declare namespace Session {
type Subscribe = {
method: 'session.subscribe';
params: Session.SubscribeParameters;
};
}
export declare namespace Session {
type SubscribeResult = {
subscription: Session.Subscription;
};
}
export declare namespace Session {
type Unsubscribe = {
method: 'session.unsubscribe';
params: Session.UnsubscribeParameters;
};
}
export declare namespace Session {
type UnsubscribeParameters =
| Session.UnsubscribeByAttributesRequest
| Session.UnsubscribeByIdRequest;
}
export declare namespace Session {
type UnsubscribeResult = EmptyResult;
}
export type BrowserCommand =
| Browser.Close
| Browser.CreateUserContext
| Browser.GetClientWindows
| Browser.GetUserContexts
| Browser.RemoveUserContext
| Browser.SetClientWindowState
| Browser.SetDownloadBehavior;
export type BrowserResult =
| Browser.CloseResult
| Browser.CreateUserContextResult
| Browser.GetClientWindowsResult
| Browser.GetUserContextsResult
| Browser.RemoveUserContextResult
| Browser.SetClientWindowStateResult
| Browser.SetDownloadBehaviorResult;
export declare namespace Browser {
type ClientWindow = string;
}
export declare namespace Browser {
type ClientWindowInfo = {
active: boolean;
clientWindow: Browser.ClientWindow;
height: JsUint;
state: 'fullscreen' | 'maximized' | 'minimized' | 'normal';
width: JsUint;
x: JsInt;
y: JsInt;
};
}
export declare namespace Browser {
type UserContext = string;
}
export declare namespace Browser {
type UserContextInfo = {
userContext: Browser.UserContext;
};
}
export declare namespace Browser {
type Close = {
method: 'browser.close';
params: EmptyParams;
};
}
export declare namespace Browser {
type CloseResult = EmptyResult;
}
export declare namespace Browser {
type CreateUserContext = {
method: 'browser.createUserContext';
params: Browser.CreateUserContextParameters;
};
}
export declare namespace Browser {
type CreateUserContextParameters = {
acceptInsecureCerts?: boolean;
proxy?: Session.ProxyConfiguration;
unhandledPromptBehavior?: Session.UserPromptHandler;
};
}
export declare namespace Browser {
type CreateUserContextResult = Browser.UserContextInfo;
}
export declare namespace Browser {
type GetClientWindows = {
method: 'browser.getClientWindows';
params: EmptyParams;
};
}
export declare namespace Browser {
type GetClientWindowsResult = {
clientWindows: [...Browser.ClientWindowInfo[]];
};
}
export declare namespace Browser {
type GetUserContexts = {
method: 'browser.getUserContexts';
params: EmptyParams;
};
}
export declare namespace Browser {
type GetUserContextsResult = {
userContexts: [Browser.UserContextInfo, ...Browser.UserContextInfo[]];
};
}
export declare namespace Browser {
type RemoveUserContext = {
method: 'browser.removeUserContext';
params: Browser.RemoveUserContextParameters;
};
}
export declare namespace Browser {
type RemoveUserContextParameters = {
userContext: Browser.UserContext;
};
}
export declare namespace Browser {
type RemoveUserContextResult = EmptyResult;
}
export declare namespace Browser {
type SetClientWindowState = {
method: 'browser.setClientWindowState';
params: Browser.SetClientWindowStateParameters;
};
}
export declare namespace Browser {
type SetClientWindowStateParameters = {
clientWindow: Browser.ClientWindow;
} & (Browser.ClientWindowNamedState | Browser.ClientWindowRectState);
}
export declare namespace Browser {
type ClientWindowNamedState = {
state: 'fullscreen' | 'maximized' | 'minimized';
};
}
export declare namespace Browser {
type ClientWindowRectState = {
state: 'normal';
width?: JsUint;
height?: JsUint;
x?: JsInt;
y?: JsInt;
};
}
export declare namespace Browser {
type SetClientWindowStateResult = Browser.ClientWindowInfo;
}
export declare namespace Browser {
type SetDownloadBehavior = {
method: 'browser.setDownloadBehavior';
params: Browser.SetDownloadBehaviorParameters;
};
}
export declare namespace Browser {
type SetDownloadBehaviorParameters = {
downloadBehavior: Browser.DownloadBehavior | null;
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Browser {
type DownloadBehavior =
| Browser.DownloadBehaviorAllowed
| Browser.DownloadBehaviorDenied;
}
export declare namespace Browser {
type DownloadBehaviorAllowed = {
type: 'allowed';
destinationFolder: string;
};
}
export declare namespace Browser {
type DownloadBehaviorDenied = {
type: 'denied';
};
}
export declare namespace Browser {
type SetDownloadBehaviorResult = EmptyResult;
}
export type BrowsingContextCommand =
| BrowsingContext.Activate
| BrowsingContext.CaptureScreenshot
| BrowsingContext.Close
| BrowsingContext.Create
| BrowsingContext.GetTree
| BrowsingContext.HandleUserPrompt
| BrowsingContext.LocateNodes
| BrowsingContext.Navigate
| BrowsingContext.Print
| BrowsingContext.Reload
| BrowsingContext.SetViewport
| BrowsingContext.TraverseHistory;
export type BrowsingContextResult =
| BrowsingContext.ActivateResult
| BrowsingContext.CaptureScreenshotResult
| BrowsingContext.CloseResult
| BrowsingContext.CreateResult
| BrowsingContext.GetTreeResult
| BrowsingContext.HandleUserPromptResult
| BrowsingContext.LocateNodesResult
| BrowsingContext.NavigateResult
| BrowsingContext.PrintResult
| BrowsingContext.ReloadResult
| BrowsingContext.SetViewportResult
| BrowsingContext.TraverseHistoryResult;
export type BrowsingContextEvent =
| BrowsingContext.ContextCreated
| BrowsingContext.ContextDestroyed
| BrowsingContext.DomContentLoaded
| BrowsingContext.DownloadEnd
| BrowsingContext.DownloadWillBegin
| BrowsingContext.FragmentNavigated
| BrowsingContext.HistoryUpdated
| BrowsingContext.Load
| BrowsingContext.NavigationAborted
| BrowsingContext.NavigationCommitted
| BrowsingContext.NavigationFailed
| BrowsingContext.NavigationStarted
| BrowsingContext.UserPromptClosed
| BrowsingContext.UserPromptOpened;
export declare namespace BrowsingContext {
type BrowsingContext = string;
}
export declare namespace BrowsingContext {
type InfoList = [...BrowsingContext.Info[]];
}
export declare namespace BrowsingContext {
type Info = {
children: BrowsingContext.InfoList | null;
clientWindow: Browser.ClientWindow;
context: BrowsingContext.BrowsingContext;
originalOpener: BrowsingContext.BrowsingContext | null;
url: string;
userContext: Browser.UserContext;
parent?: BrowsingContext.BrowsingContext | null;
};
}
export declare namespace BrowsingContext {
type Locator =
| BrowsingContext.AccessibilityLocator
| BrowsingContext.CssLocator
| BrowsingContext.ContextLocator
| BrowsingContext.InnerTextLocator
| BrowsingContext.XPathLocator;
}
export declare namespace BrowsingContext {
type AccessibilityLocator = {
type: 'accessibility';
value: {
name?: string;
role?: string;
};
};
}
export declare namespace BrowsingContext {
type CssLocator = {
type: 'css';
value: string;
};
}
export declare namespace BrowsingContext {
type ContextLocator = {
type: 'context';
value: {
context: BrowsingContext.BrowsingContext;
};
};
}
export declare namespace BrowsingContext {
type InnerTextLocator = {
type: 'innerText';
value: string;
ignoreCase?: boolean;
matchType?: 'full' | 'partial';
maxDepth?: JsUint;
};
}
export declare namespace BrowsingContext {
type XPathLocator = {
type: 'xpath';
value: string;
};
}
export declare namespace BrowsingContext {
type Navigation = string;
}
export declare namespace BrowsingContext {
type BaseNavigationInfo = {
context: BrowsingContext.BrowsingContext;
navigation: BrowsingContext.Navigation | null;
timestamp: JsUint;
url: string;
userContext?: Browser.UserContext;
};
}
export declare namespace BrowsingContext {
type NavigationInfo = BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
const enum ReadinessState {
None = 'none',
Interactive = 'interactive',
Complete = 'complete',
}
}
export declare namespace BrowsingContext {
const enum UserPromptType {
Alert = 'alert',
Beforeunload = 'beforeunload',
Confirm = 'confirm',
Prompt = 'prompt',
}
}
export declare namespace BrowsingContext {
type Activate = {
method: 'browsingContext.activate';
params: BrowsingContext.ActivateParameters;
};
}
export declare namespace BrowsingContext {
type ActivateParameters = {
context: BrowsingContext.BrowsingContext;
};
}
export declare namespace BrowsingContext {
type ActivateResult = EmptyResult;
}
export declare namespace BrowsingContext {
type CaptureScreenshot = {
method: 'browsingContext.captureScreenshot';
params: BrowsingContext.CaptureScreenshotParameters;
};
}
export declare namespace BrowsingContext {
type CaptureScreenshotParameters = {
context: BrowsingContext.BrowsingContext;
/**
* @defaultValue `"viewport"`
*/
origin?: 'viewport' | 'document';
format?: BrowsingContext.ImageFormat;
clip?: BrowsingContext.ClipRectangle;
};
}
export declare namespace BrowsingContext {
type ImageFormat = {
type: string;
/**
* Must be between `0` and `1`, inclusive.
*/
quality?: number;
};
}
export declare namespace BrowsingContext {
type ClipRectangle =
| BrowsingContext.BoxClipRectangle
| BrowsingContext.ElementClipRectangle;
}
export declare namespace BrowsingContext {
type ElementClipRectangle = {
type: 'element';
element: Script.SharedReference;
};
}
export declare namespace BrowsingContext {
type BoxClipRectangle = {
type: 'box';
x: number;
y: number;
width: number;
height: number;
};
}
export declare namespace BrowsingContext {
type CaptureScreenshotResult = {
data: string;
};
}
export declare namespace BrowsingContext {
type Close = {
method: 'browsingContext.close';
params: BrowsingContext.CloseParameters;
};
}
export declare namespace BrowsingContext {
type CloseParameters = {
context: BrowsingContext.BrowsingContext;
/**
* @defaultValue `false`
*/
promptUnload?: boolean;
};
}
export declare namespace BrowsingContext {
type CloseResult = EmptyResult;
}
export declare namespace BrowsingContext {
type Create = {
method: 'browsingContext.create';
params: BrowsingContext.CreateParameters;
};
}
export declare namespace BrowsingContext {
const enum CreateType {
Tab = 'tab',
Window = 'window',
}
}
export declare namespace BrowsingContext {
type CreateParameters = {
type: BrowsingContext.CreateType;
referenceContext?: BrowsingContext.BrowsingContext;
/**
* @defaultValue `false`
*/
background?: boolean;
userContext?: Browser.UserContext;
};
}
export declare namespace BrowsingContext {
type CreateResult = {
context: BrowsingContext.BrowsingContext;
userContext?: Browser.UserContext;
};
}
export declare namespace BrowsingContext {
type GetTree = {
method: 'browsingContext.getTree';
params: BrowsingContext.GetTreeParameters;
};
}
export declare namespace BrowsingContext {
type GetTreeParameters = {
maxDepth?: JsUint;
root?: BrowsingContext.BrowsingContext;
};
}
export declare namespace BrowsingContext {
type GetTreeResult = {
contexts: BrowsingContext.InfoList;
};
}
export declare namespace BrowsingContext {
type HandleUserPrompt = {
method: 'browsingContext.handleUserPrompt';
params: BrowsingContext.HandleUserPromptParameters;
};
}
export declare namespace BrowsingContext {
type HandleUserPromptParameters = {
context: BrowsingContext.BrowsingContext;
accept?: boolean;
userText?: string;
};
}
export declare namespace BrowsingContext {
type HandleUserPromptResult = EmptyResult;
}
export declare namespace BrowsingContext {
type LocateNodes = {
method: 'browsingContext.locateNodes';
params: BrowsingContext.LocateNodesParameters;
};
}
export declare namespace BrowsingContext {
type LocateNodesParameters = {
context: BrowsingContext.BrowsingContext;
locator: BrowsingContext.Locator;
/**
* Must be greater than or equal to `1`.
*/
maxNodeCount?: JsUint;
serializationOptions?: Script.SerializationOptions;
startNodes?: [Script.SharedReference, ...Script.SharedReference[]];
};
}
export declare namespace BrowsingContext {
type LocateNodesResult = {
nodes: [...Script.NodeRemoteValue[]];
};
}
export declare namespace BrowsingContext {
type Navigate = {
method: 'browsingContext.navigate';
params: BrowsingContext.NavigateParameters;
};
}
export declare namespace BrowsingContext {
type NavigateParameters = {
context: BrowsingContext.BrowsingContext;
url: string;
wait?: BrowsingContext.ReadinessState;
};
}
export declare namespace BrowsingContext {
type NavigateResult = {
navigation: BrowsingContext.Navigation | null;
url: string;
};
}
export declare namespace BrowsingContext {
type Print = {
method: 'browsingContext.print';
params: BrowsingContext.PrintParameters;
};
}
export declare namespace BrowsingContext {
type PrintParameters = {
context: BrowsingContext.BrowsingContext;
/**
* @defaultValue `false`
*/
background?: boolean;
margin?: BrowsingContext.PrintMarginParameters;
/**
* @defaultValue `"portrait"`
*/
orientation?: 'portrait' | 'landscape';
page?: BrowsingContext.PrintPageParameters;
pageRanges?: [...(JsUint | string)[]];
/**
* Must be between `0.1` and `2`, inclusive.
*
* @defaultValue `1`
*/
scale?: number;
/**
* @defaultValue `true`
*/
shrinkToFit?: boolean;
};
}
export declare namespace BrowsingContext {
type PrintMarginParameters = {
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `1`
*/
bottom?: number;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `1`
*/
left?: number;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `1`
*/
right?: number;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `1`
*/
top?: number;
};
}
export declare namespace BrowsingContext {
type PrintPageParameters = {
/**
* Must be greater than or equal to `0.0352`.
*
* @defaultValue `27.94`
*/
height?: number;
/**
* Must be greater than or equal to `0.0352`.
*
* @defaultValue `21.59`
*/
width?: number;
};
}
export declare namespace BrowsingContext {
type PrintResult = {
data: string;
};
}
export declare namespace BrowsingContext {
type Reload = {
method: 'browsingContext.reload';
params: BrowsingContext.ReloadParameters;
};
}
export declare namespace BrowsingContext {
type ReloadParameters = {
context: BrowsingContext.BrowsingContext;
ignoreCache?: boolean;
wait?: BrowsingContext.ReadinessState;
};
}
export declare namespace BrowsingContext {
type ReloadResult = BrowsingContext.NavigateResult;
}
export declare namespace BrowsingContext {
type SetViewport = {
method: 'browsingContext.setViewport';
params: BrowsingContext.SetViewportParameters;
};
}
export declare namespace BrowsingContext {
type SetViewportParameters = {
context?: BrowsingContext.BrowsingContext;
viewport?: BrowsingContext.Viewport | null;
/**
* Must be greater than `0`.
*/
devicePixelRatio?: number | null;
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace BrowsingContext {
type Viewport = {
width: JsUint;
height: JsUint;
};
}
export declare namespace BrowsingContext {
type SetViewportResult = EmptyResult;
}
export declare namespace BrowsingContext {
type TraverseHistory = {
method: 'browsingContext.traverseHistory';
params: BrowsingContext.TraverseHistoryParameters;
};
}
export declare namespace BrowsingContext {
type TraverseHistoryParameters = {
context: BrowsingContext.BrowsingContext;
delta: JsInt;
};
}
export declare namespace BrowsingContext {
type TraverseHistoryResult = EmptyResult;
}
export declare namespace BrowsingContext {
type ContextCreated = {
method: 'browsingContext.contextCreated';
params: BrowsingContext.Info;
};
}
export declare namespace BrowsingContext {
type ContextDestroyed = {
method: 'browsingContext.contextDestroyed';
params: BrowsingContext.Info;
};
}
export declare namespace BrowsingContext {
type NavigationStarted = {
method: 'browsingContext.navigationStarted';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type FragmentNavigated = {
method: 'browsingContext.fragmentNavigated';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type HistoryUpdated = {
method: 'browsingContext.historyUpdated';
params: BrowsingContext.HistoryUpdatedParameters;
};
}
export declare namespace BrowsingContext {
type HistoryUpdatedParameters = {
context: BrowsingContext.BrowsingContext;
timestamp: JsUint;
url: string;
userContext?: Browser.UserContext;
};
}
export declare namespace BrowsingContext {
type DomContentLoaded = {
method: 'browsingContext.domContentLoaded';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type Load = {
method: 'browsingContext.load';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type DownloadWillBegin = {
method: 'browsingContext.downloadWillBegin';
params: BrowsingContext.DownloadWillBeginParams;
};
}
export declare namespace BrowsingContext {
type DownloadWillBeginParams = {
suggestedFilename: string;
} & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
type DownloadEnd = {
method: 'browsingContext.downloadEnd';
params: BrowsingContext.DownloadEndParams;
};
}
export declare namespace BrowsingContext {
type DownloadEndParams =
| BrowsingContext.DownloadCanceledParams
| BrowsingContext.DownloadCompleteParams;
}
export declare namespace BrowsingContext {
type DownloadCanceledParams = {
status: 'canceled';
} & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
type DownloadCompleteParams = {
status: 'complete';
filepath: string | null;
} & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
type NavigationAborted = {
method: 'browsingContext.navigationAborted';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type NavigationCommitted = {
method: 'browsingContext.navigationCommitted';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type NavigationFailed = {
method: 'browsingContext.navigationFailed';
params: BrowsingContext.NavigationInfo;
};
}
export declare namespace BrowsingContext {
type UserPromptClosed = {
method: 'browsingContext.userPromptClosed';
params: BrowsingContext.UserPromptClosedParameters;
};
}
export declare namespace BrowsingContext {
type UserPromptClosedParameters = {
context: BrowsingContext.BrowsingContext;
accepted: boolean;
type: BrowsingContext.UserPromptType;
userContext?: Browser.UserContext;
userText?: string;
};
}
export declare namespace BrowsingContext {
type UserPromptOpened = {
method: 'browsingContext.userPromptOpened';
params: BrowsingContext.UserPromptOpenedParameters;
};
}
export declare namespace BrowsingContext {
type UserPromptOpenedParameters = {
context: BrowsingContext.BrowsingContext;
handler: Session.UserPromptHandlerType;
message: string;
type: BrowsingContext.UserPromptType;
userContext?: Browser.UserContext;
defaultValue?: string;
};
}
export type EmulationCommand =
| Emulation.SetForcedColorsModeThemeOverride
| Emulation.SetGeolocationOverride
| Emulation.SetLocaleOverride
| Emulation.SetNetworkConditions
| Emulation.SetScreenOrientationOverride
| Emulation.SetScreenSettingsOverride
| Emulation.SetScriptingEnabled
| Emulation.SetScrollbarTypeOverride
| Emulation.SetTimezoneOverride
| Emulation.SetTouchOverride
| Emulation.SetUserAgentOverride;
export type EmulationResult =
| Emulation.SetForcedColorsModeThemeOverrideResult
| Emulation.SetGeolocationOverrideResult
| Emulation.SetLocaleOverrideResult
| Emulation.SetScreenOrientationOverrideResult
| Emulation.SetScriptingEnabledResult
| Emulation.SetScrollbarTypeOverrideResult
| Emulation.SetTimezoneOverrideResult
| Emulation.SetTouchOverrideResult
| Emulation.SetUserAgentOverrideResult;
export declare namespace Emulation {
type SetForcedColorsModeThemeOverride = {
method: 'emulation.setForcedColorsModeThemeOverride';
params: Emulation.SetForcedColorsModeThemeOverrideParameters;
};
}
export declare namespace Emulation {
type SetForcedColorsModeThemeOverrideParameters = {
theme: Emulation.ForcedColorsModeTheme | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
const enum ForcedColorsModeTheme {
Light = 'light',
Dark = 'dark',
}
}
export declare namespace Emulation {
type SetForcedColorsModeThemeOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetGeolocationOverride = {
method: 'emulation.setGeolocationOverride';
params: Emulation.SetGeolocationOverrideParameters;
};
}
export declare namespace Emulation {
type SetGeolocationOverrideParameters = (
| {
coordinates: Emulation.GeolocationCoordinates | null;
}
| {
error: Emulation.GeolocationPositionError;
}
) & {
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type GeolocationCoordinates = {
/**
* Must be between `-90` and `90`, inclusive.
*/
latitude: number;
/**
* Must be between `-180` and `180`, inclusive.
*/
longitude: number;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `1`
*/
accuracy?: number;
/**
* @defaultValue `null`
*/
altitude?: number | null;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `null`
*/
altitudeAccuracy?: number | null;
/**
* Must be between `0` and `360`.
*
* @defaultValue `null`
*/
heading?: number | null;
/**
* Must be greater than or equal to `0`.
*
* @defaultValue `null`
*/
speed?: number | null;
};
}
export declare namespace Emulation {
type GeolocationPositionError = {
type: 'positionUnavailable';
};
}
export declare namespace Emulation {
type SetGeolocationOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetLocaleOverride = {
method: 'emulation.setLocaleOverride';
params: Emulation.SetLocaleOverrideParameters;
};
}
export declare namespace Emulation {
type SetLocaleOverrideParameters = {
locale: string | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetLocaleOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetNetworkConditions = {
method: 'emulation.setNetworkConditions';
params: Emulation.SetNetworkConditionsParameters;
};
}
export declare namespace Emulation {
type SetNetworkConditionsParameters = {
networkConditions: Emulation.NetworkConditions | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type NetworkConditions = Emulation.NetworkConditionsOffline;
}
export declare namespace Emulation {
type NetworkConditionsOffline = {
type: 'offline';
};
}
export declare namespace Emulation {
type SetNetworkConditionsResult = EmptyResult;
}
export declare namespace Emulation {
type SetScreenSettingsOverride = {
method: 'emulation.setScreenSettingsOverride';
params: Emulation.SetScreenSettingsOverrideParameters;
};
}
export declare namespace Emulation {
type ScreenArea = {
width: JsUint;
height: JsUint;
};
}
export declare namespace Emulation {
type SetScreenSettingsOverrideParameters = {
screenArea: Emulation.ScreenArea | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetScreenSettingsOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetScreenOrientationOverride = {
method: 'emulation.setScreenOrientationOverride';
params: Emulation.SetScreenOrientationOverrideParameters;
};
}
export declare namespace Emulation {
const enum ScreenOrientationNatural {
Portrait = 'portrait',
Landscape = 'landscape',
}
}
export declare namespace Emulation {
type ScreenOrientationType =
| 'portrait-primary'
| 'portrait-secondary'
| 'landscape-primary'
| 'landscape-secondary';
}
export declare namespace Emulation {
type ScreenOrientation = {
natural: Emulation.ScreenOrientationNatural;
type: Emulation.ScreenOrientationType;
};
}
export declare namespace Emulation {
type SetScreenOrientationOverrideParameters = {
screenOrientation: Emulation.ScreenOrientation | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetScreenOrientationOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetUserAgentOverride = {
method: 'emulation.setUserAgentOverride';
params: Emulation.SetUserAgentOverrideParameters;
};
}
export declare namespace Emulation {
type SetUserAgentOverrideParameters = {
userAgent: string | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetUserAgentOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetScriptingEnabled = {
method: 'emulation.setScriptingEnabled';
params: Emulation.SetScriptingEnabledParameters;
};
}
export declare namespace Emulation {
type SetScriptingEnabledParameters = {
enabled: false | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetScriptingEnabledResult = EmptyResult;
}
export declare namespace Emulation {
type SetScrollbarTypeOverride = {
method: 'emulation.setScrollbarTypeOverride';
params: Emulation.SetScrollbarTypeOverrideParameters;
};
}
export declare namespace Emulation {
type SetScrollbarTypeOverrideParameters = {
scrollbarType: 'classic' | 'overlay' | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetScrollbarTypeOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetTimezoneOverride = {
method: 'emulation.setTimezoneOverride';
params: Emulation.SetTimezoneOverrideParameters;
};
}
export declare namespace Emulation {
type SetTimezoneOverrideParameters = {
timezone: string | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetTimezoneOverrideResult = EmptyResult;
}
export declare namespace Emulation {
type SetTouchOverride = {
method: 'emulation.setTouchOverride';
params: Emulation.SetTouchOverrideParameters;
};
}
export declare namespace Emulation {
type SetTouchOverrideParameters = {
/**
* Must be greater than or equal to `1`.
*/
maxTouchPoints: JsUint | null;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Emulation {
type SetTouchOverrideResult = EmptyResult;
}
export type NetworkCommand =
| Network.AddDataCollector
| Network.AddIntercept
| Network.ContinueRequest
| Network.ContinueResponse
| Network.ContinueWithAuth
| Network.DisownData
| Network.FailRequest
| Network.GetData
| Network.ProvideResponse
| Network.RemoveDataCollector
| Network.RemoveIntercept
| Network.SetCacheBehavior
| Network.SetExtraHeaders;
export type NetworkResult =
| Network.AddDataCollectorResult
| Network.AddInterceptResult
| Network.ContinueRequestResult
| Network.ContinueResponseResult
| Network.ContinueWithAuthResult
| Network.DisownDataResult
| Network.FailRequestResult
| Network.GetDataResult
| Network.ProvideResponseResult
| Network.RemoveDataCollectorResult
| Network.RemoveInterceptResult
| Network.SetCacheBehaviorResult
| Network.SetExtraHeadersResult;
export type NetworkEvent =
| Network.AuthRequired
| Network.BeforeRequestSent
| Network.FetchError
| Network.ResponseCompleted
| Network.ResponseStarted;
export declare namespace Network {
type AuthChallenge = {
scheme: string;
realm: string;
};
}
export declare namespace Network {
type AuthCredentials = {
type: 'password';
username: string;
password: string;
};
}
export declare namespace Network {
type BaseParameters = {
context: BrowsingContext.BrowsingContext | null;
isBlocked: boolean;
navigation: BrowsingContext.Navigation | null;
redirectCount: JsUint;
request: Network.RequestData;
timestamp: JsUint;
userContext?: Browser.UserContext | null;
intercepts?: [Network.Intercept, ...Network.Intercept[]];
};
}
export declare namespace Network {
type BytesValue = Network.StringValue | Network.Base64Value;
}
export declare namespace Network {
type StringValue = {
type: 'string';
value: string;
};
}
export declare namespace Network {
type Base64Value = {
type: 'base64';
value: string;
};
}
export declare namespace Network {
type Collector = string;
}
export declare namespace Network {
const enum CollectorType {
Blob = 'blob',
}
}
export declare namespace Network {
const enum SameSite {
Strict = 'strict',
Lax = 'lax',
None = 'none',
Default = 'default',
}
}
export declare namespace Network {
type Cookie = {
name: string;
value: Network.BytesValue;
domain: string;
path: string;
size: JsUint;
httpOnly: boolean;
secure: boolean;
sameSite: Network.SameSite;
expiry?: JsUint;
} & Extensible;
}
export declare namespace Network {
type CookieHeader = {
name: string;
value: Network.BytesValue;
};
}
export declare namespace Network {
const enum DataType {
Request = 'request',
Response = 'response',
}
}
export declare namespace Network {
type FetchTimingInfo = {
timeOrigin: number;
requestTime: number;
redirectStart: number;
redirectEnd: number;
fetchStart: number;
dnsStart: number;
dnsEnd: number;
connectStart: number;
connectEnd: number;
tlsStart: number;
requestStart: number;
responseStart: number;
responseEnd: number;
};
}
export declare namespace Network {
type Header = {
name: string;
value: Network.BytesValue;
};
}
export declare namespace Network {
type Initiator = {
columnNumber?: JsUint;
lineNumber?: JsUint;
request?: Network.Request;
stackTrace?: Script.StackTrace;
type?: 'parser' | 'script' | 'preflight' | 'other';
};
}
export declare namespace Network {
type Intercept = string;
}
export declare namespace Network {
type Request = string;
}
export declare namespace Network {
type RequestData = {
request: Network.Request;
url: string;
method: string;
headers: [...Network.Header[]];
cookies: [...Network.Cookie[]];
headersSize: JsUint;
bodySize: JsUint | null;
destination: string;
initiatorType: string | null;
timings: Network.FetchTimingInfo;
};
}
export declare namespace Network {
type ResponseContent = {
size: JsUint;
};
}
export declare namespace Network {
type ResponseData = {
url: string;
protocol: string;
status: JsUint;
statusText: string;
fromCache: boolean;
headers: [...Network.Header[]];
mimeType: string;
bytesReceived: JsUint;
headersSize: JsUint | null;
bodySize: JsUint | null;
content: Network.ResponseContent;
authChallenges?: [...Network.AuthChallenge[]];
};
}
export declare namespace Network {
type SetCookieHeader = {
name: string;
value: Network.BytesValue;
domain?: string;
httpOnly?: boolean;
expiry?: string;
maxAge?: JsInt;
path?: string;
sameSite?: Network.SameSite;
secure?: boolean;
};
}
export declare namespace Network {
type UrlPattern = Network.UrlPatternPattern | Network.UrlPatternString;
}
export declare namespace Network {
type UrlPatternPattern = {
type: 'pattern';
protocol?: string;
hostname?: string;
port?: string;
pathname?: string;
search?: string;
};
}
export declare namespace Network {
type UrlPatternString = {
type: 'string';
pattern: string;
};
}
export declare namespace Network {
type AddDataCollector = {
method: 'network.addDataCollector';
params: Network.AddDataCollectorParameters;
};
}
export declare namespace Network {
type AddDataCollectorParameters = {
dataTypes: [Network.DataType, ...Network.DataType[]];
maxEncodedDataSize: JsUint;
/**
* @defaultValue `"blob"`
*/
collectorType?: Network.CollectorType;
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Network {
type AddDataCollectorResult = {
collector: Network.Collector;
};
}
export declare namespace Network {
type AddIntercept = {
method: 'network.addIntercept';
params: Network.AddInterceptParameters;
};
}
export declare namespace Network {
type AddInterceptParameters = {
phases: [Network.InterceptPhase, ...Network.InterceptPhase[]];
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
urlPatterns?: [...Network.UrlPattern[]];
};
}
export declare namespace Network {
const enum InterceptPhase {
BeforeRequestSent = 'beforeRequestSent',
ResponseStarted = 'responseStarted',
AuthRequired = 'authRequired',
}
}
export declare namespace Network {
type AddInterceptResult = {
intercept: Network.Intercept;
};
}
export declare namespace Network {
type ContinueRequest = {
method: 'network.continueRequest';
params: Network.ContinueRequestParameters;
};
}
export declare namespace Network {
type ContinueRequestParameters = {
request: Network.Request;
body?: Network.BytesValue;
cookies?: [...Network.CookieHeader[]];
headers?: [...Network.Header[]];
method?: string;
url?: string;
};
}
export declare namespace Network {
type ContinueRequestResult = EmptyResult;
}
export declare namespace Network {
type ContinueResponse = {
method: 'network.continueResponse';
params: Network.ContinueResponseParameters;
};
}
export declare namespace Network {
type ContinueResponseParameters = {
request: Network.Request;
cookies?: [...Network.SetCookieHeader[]];
credentials?: Network.AuthCredentials;
headers?: [...Network.Header[]];
reasonPhrase?: string;
statusCode?: JsUint;
};
}
export declare namespace Network {
type ContinueResponseResult = EmptyResult;
}
export declare namespace Network {
type ContinueWithAuth = {
method: 'network.continueWithAuth';
params: Network.ContinueWithAuthParameters;
};
}
export declare namespace Network {
type ContinueWithAuthParameters = {
request: Network.Request;
} & (
| Network.ContinueWithAuthCredentials
| Network.ContinueWithAuthNoCredentials
);
}
export declare namespace Network {
type ContinueWithAuthCredentials = {
action: 'provideCredentials';
credentials: Network.AuthCredentials;
};
}
export declare namespace Network {
type ContinueWithAuthNoCredentials = {
action: 'default' | 'cancel';
};
}
export declare namespace Network {
type ContinueWithAuthResult = EmptyResult;
}
export declare namespace Network {
type DisownData = {
method: 'network.disownData';
params: Network.DisownDataParameters;
};
}
export declare namespace Network {
type DisownDataParameters = {
dataType: Network.DataType;
collector: Network.Collector;
request: Network.Request;
};
}
export declare namespace Network {
type DisownDataResult = EmptyResult;
}
export declare namespace Network {
type FailRequest = {
method: 'network.failRequest';
params: Network.FailRequestParameters;
};
}
export declare namespace Network {
type FailRequestParameters = {
request: Network.Request;
};
}
export declare namespace Network {
type FailRequestResult = EmptyResult;
}
export declare namespace Network {
type GetData = {
method: 'network.getData';
params: Network.GetDataParameters;
};
}
export declare namespace Network {
type GetDataParameters = {
dataType: Network.DataType;
collector?: Network.Collector;
/**
* @defaultValue `false`
*/
disown?: boolean;
request: Network.Request;
};
}
export declare namespace Network {
type GetDataResult = {
bytes: Network.BytesValue;
};
}
export declare namespace Network {
type ProvideResponse = {
method: 'network.provideResponse';
params: Network.ProvideResponseParameters;
};
}
export declare namespace Network {
type ProvideResponseParameters = {
request: Network.Request;
body?: Network.BytesValue;
cookies?: [...Network.SetCookieHeader[]];
headers?: [...Network.Header[]];
reasonPhrase?: string;
statusCode?: JsUint;
};
}
export declare namespace Network {
type ProvideResponseResult = EmptyResult;
}
export declare namespace Network {
type RemoveDataCollector = {
method: 'network.removeDataCollector';
params: Network.RemoveDataCollectorParameters;
};
}
export declare namespace Network {
type RemoveDataCollectorParameters = {
collector: Network.Collector;
};
}
export declare namespace Network {
type RemoveDataCollectorResult = EmptyResult;
}
export declare namespace Network {
type RemoveIntercept = {
method: 'network.removeIntercept';
params: Network.RemoveInterceptParameters;
};
}
export declare namespace Network {
type RemoveInterceptParameters = {
intercept: Network.Intercept;
};
}
export declare namespace Network {
type RemoveInterceptResult = EmptyResult;
}
export declare namespace Network {
type SetCacheBehavior = {
method: 'network.setCacheBehavior';
params: Network.SetCacheBehaviorParameters;
};
}
export declare namespace Network {
type SetCacheBehaviorParameters = {
cacheBehavior: 'default' | 'bypass';
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
};
}
export declare namespace Network {
type SetCacheBehaviorResult = EmptyResult;
}
export declare namespace Network {
type SetExtraHeaders = {
method: 'network.setExtraHeaders';
params: Network.SetExtraHeadersParameters;
};
}
export declare namespace Network {
type SetExtraHeadersParameters = {
headers: [...Network.Header[]];
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
};
}
export declare namespace Network {
type SetExtraHeadersResult = EmptyResult;
}
export declare namespace Network {
type AuthRequired = {
method: 'network.authRequired';
params: Network.AuthRequiredParameters;
};
}
export declare namespace Network {
type AuthRequiredParameters = Network.BaseParameters & {
response: Network.ResponseData;
};
}
export declare namespace Network {
type BeforeRequestSent = {
method: 'network.beforeRequestSent';
params: Network.BeforeRequestSentParameters;
};
}
export declare namespace Network {
type BeforeRequestSentParameters = Network.BaseParameters & {
initiator?: Network.Initiator;
};
}
export declare namespace Network {
type FetchError = {
method: 'network.fetchError';
params: Network.FetchErrorParameters;
};
}
export declare namespace Network {
type FetchErrorParameters = Network.BaseParameters & {
errorText: string;
};
}
export declare namespace Network {
type ResponseCompleted = {
method: 'network.responseCompleted';
params: Network.ResponseCompletedParameters;
};
}
export declare namespace Network {
type ResponseCompletedParameters = Network.BaseParameters & {
response: Network.ResponseData;
};
}
export declare namespace Network {
type ResponseStarted = {
method: 'network.responseStarted';
params: Network.ResponseStartedParameters;
};
}
export declare namespace Network {
type ResponseStartedParameters = Network.BaseParameters & {
response: Network.ResponseData;
};
}
export type ScriptCommand =
| Script.AddPreloadScript
| Script.CallFunction
| Script.Disown
| Script.Evaluate
| Script.GetRealms
| Script.RemovePreloadScript;
export type ScriptResult =
| Script.AddPreloadScriptResult
| Script.CallFunctionResult
| Script.DisownResult
| Script.EvaluateResult
| Script.GetRealmsResult
| Script.RemovePreloadScriptResult;
export type ScriptEvent =
| Script.Message
| Script.RealmCreated
| Script.RealmDestroyed;
export declare namespace Script {
type Channel = string;
}
export declare namespace Script {
type ChannelValue = {
type: 'channel';
value: Script.ChannelProperties;
};
}
export declare namespace Script {
type ChannelProperties = {
channel: Script.Channel;
serializationOptions?: Script.SerializationOptions;
ownership?: Script.ResultOwnership;
};
}
export declare namespace Script {
type EvaluateResult =
| Script.EvaluateResultSuccess
| Script.EvaluateResultException;
}
export declare namespace Script {
type EvaluateResultSuccess = {
type: 'success';
result: Script.RemoteValue;
realm: Script.Realm;
};
}
export declare namespace Script {
type EvaluateResultException = {
type: 'exception';
exceptionDetails: Script.ExceptionDetails;
realm: Script.Realm;
};
}
export declare namespace Script {
type ExceptionDetails = {
columnNumber: JsUint;
exception: Script.RemoteValue;
lineNumber: JsUint;
stackTrace: Script.StackTrace;
text: string;
};
}
export declare namespace Script {
type Handle = string;
}
export declare namespace Script {
type InternalId = string;
}
export declare namespace Script {
type LocalValue =
| Script.RemoteReference
| Script.PrimitiveProtocolValue
| Script.ChannelValue
| Script.ArrayLocalValue
| Script.DateLocalValue
| Script.MapLocalValue
| Script.ObjectLocalValue
| Script.RegExpLocalValue
| Script.SetLocalValue;
}
export declare namespace Script {
type ListLocalValue = [...Script.LocalValue[]];
}
export declare namespace Script {
type ArrayLocalValue = {
type: 'array';
value: Script.ListLocalValue;
};
}
export declare namespace Script {
type DateLocalValue = {
type: 'date';
value: string;
};
}
export declare namespace Script {
type MappingLocalValue = [
...[Script.LocalValue | string, Script.LocalValue][],
];
}
export declare namespace Script {
type MapLocalValue = {
type: 'map';
value: Script.MappingLocalValue;
};
}
export declare namespace Script {
type ObjectLocalValue = {
type: 'object';
value: Script.MappingLocalValue;
};
}
export declare namespace Script {
type RegExpValue = {
pattern: string;
flags?: string;
};
}
export declare namespace Script {
type RegExpLocalValue = {
type: 'regexp';
value: Script.RegExpValue;
};
}
export declare namespace Script {
type SetLocalValue = {
type: 'set';
value: Script.ListLocalValue;
};
}
export declare namespace Script {
type PreloadScript = string;
}
export declare namespace Script {
type Realm = string;
}
export declare namespace Script {
type PrimitiveProtocolValue =
| Script.UndefinedValue
| Script.NullValue
| Script.StringValue
| Script.NumberValue
| Script.BooleanValue
| Script.BigIntValue;
}
export declare namespace Script {
type UndefinedValue = {
type: 'undefined';
};
}
export declare namespace Script {
type NullValue = {
type: 'null';
};
}
export declare namespace Script {
type StringValue = {
type: 'string';
value: string;
};
}
export declare namespace Script {
type SpecialNumber = 'NaN' | '-0' | 'Infinity' | '-Infinity';
}
export declare namespace Script {
type NumberValue = {
type: 'number';
value: number | Script.SpecialNumber;
};
}
export declare namespace Script {
type BooleanValue = {
type: 'boolean';
value: boolean;
};
}
export declare namespace Script {
type BigIntValue = {
type: 'bigint';
value: string;
};
}
export declare namespace Script {
type RealmInfo =
| Script.WindowRealmInfo
| Script.DedicatedWorkerRealmInfo
| Script.SharedWorkerRealmInfo
| Script.ServiceWorkerRealmInfo
| Script.WorkerRealmInfo
| Script.PaintWorkletRealmInfo
| Script.AudioWorkletRealmInfo
| Script.WorkletRealmInfo;
}
export declare namespace Script {
type BaseRealmInfo = {
realm: Script.Realm;
origin: string;
};
}
export declare namespace Script {
type WindowRealmInfo = Script.BaseRealmInfo & {
type: 'window';
context: BrowsingContext.BrowsingContext;
userContext?: Browser.UserContext;
sandbox?: string;
};
}
export declare namespace Script {
type DedicatedWorkerRealmInfo = Script.BaseRealmInfo & {
type: 'dedicated-worker';
owners: [Script.Realm];
};
}
export declare namespace Script {
type SharedWorkerRealmInfo = Script.BaseRealmInfo & {
type: 'shared-worker';
};
}
export declare namespace Script {
type ServiceWorkerRealmInfo = Script.BaseRealmInfo & {
type: 'service-worker';
};
}
export declare namespace Script {
type WorkerRealmInfo = Script.BaseRealmInfo & {
type: 'worker';
};
}
export declare namespace Script {
type PaintWorkletRealmInfo = Script.BaseRealmInfo & {
type: 'paint-worklet';
};
}
export declare namespace Script {
type AudioWorkletRealmInfo = Script.BaseRealmInfo & {
type: 'audio-worklet';
};
}
export declare namespace Script {
type WorkletRealmInfo = Script.BaseRealmInfo & {
type: 'worklet';
};
}
export declare namespace Script {
type RealmType =
| 'window'
| 'dedicated-worker'
| 'shared-worker'
| 'service-worker'
| 'worker'
| 'paint-worklet'
| 'audio-worklet'
| 'worklet';
}
export declare namespace Script {
type RemoteReference = Script.SharedReference | Script.RemoteObjectReference;
}
export declare namespace Script {
type SharedReference = {
sharedId: Script.SharedId;
handle?: Script.Handle;
} & Extensible;
}
export declare namespace Script {
type RemoteObjectReference = {
handle: Script.Handle;
sharedId?: Script.SharedId;
} & Extensible;
}
export declare namespace Script {
type RemoteValue =
| Script.PrimitiveProtocolValue
| Script.SymbolRemoteValue
| Script.ArrayRemoteValue
| Script.ObjectRemoteValue
| Script.FunctionRemoteValue
| Script.RegExpRemoteValue
| Script.DateRemoteValue
| Script.MapRemoteValue
| Script.SetRemoteValue
| Script.WeakMapRemoteValue
| Script.WeakSetRemoteValue
| Script.GeneratorRemoteValue
| Script.ErrorRemoteValue
| Script.ProxyRemoteValue
| Script.PromiseRemoteValue
| Script.TypedArrayRemoteValue
| Script.ArrayBufferRemoteValue
| Script.NodeListRemoteValue
| Script.HtmlCollectionRemoteValue
| Script.NodeRemoteValue
| Script.WindowProxyRemoteValue;
}
export declare namespace Script {
type ListRemoteValue = [...Script.RemoteValue[]];
}
export declare namespace Script {
type MappingRemoteValue = [
...[Script.RemoteValue | string, Script.RemoteValue][],
];
}
export declare namespace Script {
type SymbolRemoteValue = {
type: 'symbol';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type ArrayRemoteValue = {
type: 'array';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.ListRemoteValue;
};
}
export declare namespace Script {
type ObjectRemoteValue = {
type: 'object';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.MappingRemoteValue;
};
}
export declare namespace Script {
type FunctionRemoteValue = {
type: 'function';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type RegExpRemoteValue = Script.RegExpLocalValue & {
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type DateRemoteValue = Script.DateLocalValue & {
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type MapRemoteValue = {
type: 'map';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.MappingRemoteValue;
};
}
export declare namespace Script {
type SetRemoteValue = {
type: 'set';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.ListRemoteValue;
};
}
export declare namespace Script {
type WeakMapRemoteValue = {
type: 'weakmap';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type WeakSetRemoteValue = {
type: 'weakset';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type GeneratorRemoteValue = {
type: 'generator';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type ErrorRemoteValue = {
type: 'error';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type ProxyRemoteValue = {
type: 'proxy';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type PromiseRemoteValue = {
type: 'promise';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type TypedArrayRemoteValue = {
type: 'typedarray';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type ArrayBufferRemoteValue = {
type: 'arraybuffer';
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type NodeListRemoteValue = {
type: 'nodelist';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.ListRemoteValue;
};
}
export declare namespace Script {
type HtmlCollectionRemoteValue = {
type: 'htmlcollection';
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.ListRemoteValue;
};
}
export declare namespace Script {
type NodeRemoteValue = {
type: 'node';
sharedId?: Script.SharedId;
handle?: Script.Handle;
internalId?: Script.InternalId;
value?: Script.NodeProperties;
};
}
export declare namespace Script {
type NodeProperties = {
nodeType: JsUint;
childNodeCount: JsUint;
attributes?: {
[key: string]: string;
};
children?: [...Script.NodeRemoteValue[]];
localName?: string;
mode?: 'open' | 'closed';
namespaceURI?: string;
nodeValue?: string;
shadowRoot?: Script.NodeRemoteValue | null;
};
}
export declare namespace Script {
type WindowProxyRemoteValue = {
type: 'window';
value: Script.WindowProxyProperties;
handle?: Script.Handle;
internalId?: Script.InternalId;
};
}
export declare namespace Script {
type WindowProxyProperties = {
context: BrowsingContext.BrowsingContext;
};
}
export declare namespace Script {
const enum ResultOwnership {
Root = 'root',
None = 'none',
}
}
export declare namespace Script {
type SerializationOptions = {
/**
* @defaultValue `0`
*/
maxDomDepth?: JsUint | null;
/**
* @defaultValue `null`
*/
maxObjectDepth?: JsUint | null;
/**
* @defaultValue `"none"`
*/
includeShadowTree?: 'none' | 'open' | 'all';
};
}
export declare namespace Script {
type SharedId = string;
}
export declare namespace Script {
type StackFrame = {
columnNumber: JsUint;
functionName: string;
lineNumber: JsUint;
url: string;
};
}
export declare namespace Script {
type StackTrace = {
callFrames: [...Script.StackFrame[]];
};
}
export declare namespace Script {
type Source = {
realm: Script.Realm;
context?: BrowsingContext.BrowsingContext;
userContext?: Browser.UserContext;
};
}
export declare namespace Script {
type RealmTarget = {
realm: Script.Realm;
};
}
export declare namespace Script {
type ContextTarget = {
context: BrowsingContext.BrowsingContext;
sandbox?: string;
};
}
export declare namespace Script {
type Target = Script.ContextTarget | Script.RealmTarget;
}
export declare namespace Script {
type AddPreloadScript = {
method: 'script.addPreloadScript';
params: Script.AddPreloadScriptParameters;
};
}
export declare namespace Script {
type AddPreloadScriptParameters = {
functionDeclaration: string;
arguments?: [...Script.ChannelValue[]];
contexts?: [
BrowsingContext.BrowsingContext,
...BrowsingContext.BrowsingContext[],
];
userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
sandbox?: string;
};
}
export declare namespace Script {
type AddPreloadScriptResult = {
script: Script.PreloadScript;
};
}
export declare namespace Script {
type Disown = {
method: 'script.disown';
params: Script.DisownParameters;
};
}
export declare namespace Script {
type DisownParameters = {
handles: [...Script.Handle[]];
target: Script.Target;
};
}
export declare namespace Script {
type DisownResult = EmptyResult;
}
export declare namespace Script {
type CallFunction = {
method: 'script.callFunction';
params: Script.CallFunctionParameters;
};
}
export declare namespace Script {
type CallFunctionParameters = {
functionDeclaration: string;
awaitPromise: boolean;
target: Script.Target;
arguments?: [...Script.LocalValue[]];
resultOwnership?: Script.ResultOwnership;
serializationOptions?: Script.SerializationOptions;
this?: Script.LocalValue;
/**
* @defaultValue `false`
*/
userActivation?: boolean;
};
}
export declare namespace Script {
type CallFunctionResult = Script.EvaluateResult;
}
export declare namespace Script {
type Evaluate = {
method: 'script.evaluate';
params: Script.EvaluateParameters;
};
}
export declare namespace Script {
type EvaluateParameters = {
expression: string;
target: Script.Target;
awaitPromise: boolean;
resultOwnership?: Script.ResultOwnership;
serializationOptions?: Script.SerializationOptions;
/**
* @defaultValue `false`
*/
userActivation?: boolean;
};
}
export declare namespace Script {
type GetRealms = {
method: 'script.getRealms';
params: Script.GetRealmsParameters;
};
}
export declare namespace Script {
type GetRealmsParameters = {
context?: BrowsingContext.BrowsingContext;
type?: Script.RealmType;
};
}
export declare namespace Script {
type GetRealmsResult = {
realms: [...Script.RealmInfo[]];
};
}
export declare namespace Script {
type RemovePreloadScript = {
method: 'script.removePreloadScript';
params: Script.RemovePreloadScriptParameters;
};
}
export declare namespace Script {
type RemovePreloadScriptParameters = {
script: Script.PreloadScript;
};
}
export declare namespace Script {
type RemovePreloadScriptResult = EmptyResult;
}
export declare namespace Script {
type Message = {
method: 'script.message';
params: Script.MessageParameters;
};
}
export declare namespace Script {
type MessageParameters = {
channel: Script.Channel;
data: Script.RemoteValue;
source: Script.Source;
};
}
export declare namespace Script {
type RealmCreated = {
method: 'script.realmCreated';
params: Script.RealmInfo;
};
}
export declare namespace Script {
type RealmDestroyed = {
method: 'script.realmDestroyed';
params: Script.RealmDestroyedParameters;
};
}
export declare namespace Script {
type RealmDestroyedParameters = {
realm: Script.Realm;
};
}
export type StorageCommand =
| Storage.DeleteCookies
| Storage.GetCookies
| Storage.SetCookie;
export type StorageResult =
| Storage.DeleteCookiesResult
| Storage.GetCookiesResult
| Storage.SetCookieResult;
export declare namespace Storage {
type PartitionKey = {
userContext?: string;
sourceOrigin?: string;
} & Extensible;
}
export declare namespace Storage {
type GetCookies = {
method: 'storage.getCookies';
params: Storage.GetCookiesParameters;
};
}
export declare namespace Storage {
type CookieFilter = {
name?: string;
value?: Network.BytesValue;
domain?: string;
path?: string;
size?: JsUint;
httpOnly?: boolean;
secure?: boolean;
sameSite?: Network.SameSite;
expiry?: JsUint;
} & Extensible;
}
export declare namespace Storage {
type BrowsingContextPartitionDescriptor = {
type: 'context';
context: BrowsingContext.BrowsingContext;
};
}
export declare namespace Storage {
type StorageKeyPartitionDescriptor = {
type: 'storageKey';
userContext?: string;
sourceOrigin?: string;
} & Extensible;
}
export declare namespace Storage {
type PartitionDescriptor =
| Storage.BrowsingContextPartitionDescriptor
| Storage.StorageKeyPartitionDescriptor;
}
export declare namespace Storage {
type GetCookiesParameters = {
filter?: Storage.CookieFilter;
partition?: Storage.PartitionDescriptor;
};
}
export declare namespace Storage {
type GetCookiesResult = {
cookies: [...Network.Cookie[]];
partitionKey: Storage.PartitionKey;
};
}
export declare namespace Storage {
type SetCookie = {
method: 'storage.setCookie';
params: Storage.SetCookieParameters;
};
}
export declare namespace Storage {
type PartialCookie = {
name: string;
value: Network.BytesValue;
domain: string;
path?: string;
httpOnly?: boolean;
secure?: boolean;
sameSite?: Network.SameSite;
expiry?: JsUint;
} & Extensible;
}
export declare namespace Storage {
type SetCookieParameters = {
cookie: Storage.PartialCookie;
partition?: Storage.PartitionDescriptor;
};
}
export declare namespace Storage {
type SetCookieResult = {
partitionKey: Storage.PartitionKey;
};
}
export declare namespace Storage {
type DeleteCookies = {
method: 'storage.deleteCookies';
params: Storage.DeleteCookiesParameters;
};
}
export declare namespace Storage {
type DeleteCookiesParameters = {
filter?: Storage.CookieFilter;
partition?: Storage.PartitionDescriptor;
};
}
export declare namespace Storage {
type DeleteCookiesResult = {
partitionKey: Storage.PartitionKey;
};
}
export type LogEvent = Log.EntryAdded;
export declare namespace Log {
const enum Level {
Debug = 'debug',
Info = 'info',
Warn = 'warn',
Error = 'error',
}
}
export declare namespace Log {
type Entry =
| Log.GenericLogEntry
| Log.ConsoleLogEntry
| Log.JavascriptLogEntry;
}
export declare namespace Log {
type BaseLogEntry = {
level: Log.Level;
source: Script.Source;
text: string | null;
timestamp: JsUint;
stackTrace?: Script.StackTrace;
};
}
export declare namespace Log {
type GenericLogEntry = Log.BaseLogEntry & {
type: string;
};
}
export declare namespace Log {
type ConsoleLogEntry = Log.BaseLogEntry & {
type: 'console';
method: string;
args: [...Script.RemoteValue[]];
};
}
export declare namespace Log {
type JavascriptLogEntry = Log.BaseLogEntry & {
type: 'javascript';
};
}
export declare namespace Log {
type EntryAdded = {
method: 'log.entryAdded';
params: Log.Entry;
};
}
export type InputCommand =
| Input.PerformActions
| Input.ReleaseActions
| Input.SetFiles;
export type InputResult =
| Input.PerformActionsResult
| Input.ReleaseActionsResult
| Input.SetFilesResult;
export type InputEvent = Input.FileDialogOpened;
export declare namespace Input {
type ElementOrigin = {
type: 'element';
element: Script.SharedReference;
};
}
export declare namespace Input {
type PerformActions = {
method: 'input.performActions';
params: Input.PerformActionsParameters;
};
}
export declare namespace Input {
type PerformActionsParameters = {
context: BrowsingContext.BrowsingContext;
actions: [...Input.SourceActions[]];
};
}
export declare namespace Input {
type SourceActions =
| Input.NoneSourceActions
| Input.KeySourceActions
| Input.PointerSourceActions
| Input.WheelSourceActions;
}
export declare namespace Input {
type NoneSourceActions = {
type: 'none';
id: string;
actions: [...Input.NoneSourceAction[]];
};
}
export declare namespace Input {
type NoneSourceAction = Input.PauseAction;
}
export declare namespace Input {
type KeySourceActions = {
type: 'key';
id: string;
actions: [...Input.KeySourceAction[]];
};
}
export declare namespace Input {
type KeySourceAction =
| Input.PauseAction
| Input.KeyDownAction
| Input.KeyUpAction;
}
export declare namespace Input {
type PointerSourceActions = {
type: 'pointer';
id: string;
parameters?: Input.PointerParameters;
actions: [...Input.PointerSourceAction[]];
};
}
export declare namespace Input {
const enum PointerType {
Mouse = 'mouse',
Pen = 'pen',
Touch = 'touch',
}
}
export declare namespace Input {
type PointerParameters = {
/**
* @defaultValue `"mouse"`
*/
pointerType?: Input.PointerType;
};
}
export declare namespace Input {
type PointerSourceAction =
| Input.PauseAction
| Input.PointerDownAction
| Input.PointerUpAction
| Input.PointerMoveAction;
}
export declare namespace Input {
type WheelSourceActions = {
type: 'wheel';
id: string;
actions: [...Input.WheelSourceAction[]];
};
}
export declare namespace Input {
type WheelSourceAction = Input.PauseAction | Input.WheelScrollAction;
}
export declare namespace Input {
type PauseAction = {
type: 'pause';
duration?: JsUint;
};
}
export declare namespace Input {
type KeyDownAction = {
type: 'keyDown';
value: string;
};
}
export declare namespace Input {
type KeyUpAction = {
type: 'keyUp';
value: string;
};
}
export declare namespace Input {
type PointerUpAction = {
type: 'pointerUp';
button: JsUint;
};
}
export declare namespace Input {
type PointerDownAction = {
type: 'pointerDown';
button: JsUint;
} & Input.PointerCommonProperties;
}
export declare namespace Input {
type PointerMoveAction = {
type: 'pointerMove';
x: number;
y: number;
duration?: JsUint;
origin?: Input.Origin;
} & Input.PointerCommonProperties;
}
export declare namespace Input {
type WheelScrollAction = {
type: 'scroll';
x: JsInt;
y: JsInt;
deltaX: JsInt;
deltaY: JsInt;
duration?: JsUint;
/**
* @defaultValue `"viewport"`
*/
origin?: Input.Origin;
};
}
export declare namespace Input {
type PointerCommonProperties = {
/**
* @defaultValue `1`
*/
width?: JsUint;
/**
* @defaultValue `1`
*/
height?: JsUint;
/**
* @defaultValue `0`
*/
pressure?: number;
/**
* @defaultValue `0`
*/
tangentialPressure?: number;
/**
* Must be between `0` and `359`, inclusive.
*
* @defaultValue `0`
*/
twist?: number;
/**
* Must be between `0` and `1.5707963267948966`, inclusive.
*
* @defaultValue `0`
*/
altitudeAngle?: number;
/**
* Must be between `0` and `6.283185307179586`, inclusive.
*
* @defaultValue `0`
*/
azimuthAngle?: number;
};
}
export declare namespace Input {
type Origin = 'viewport' | 'pointer' | Input.ElementOrigin;
}
export declare namespace Input {
type PerformActionsResult = EmptyResult;
}
export declare namespace Input {
type ReleaseActions = {
method: 'input.releaseActions';
params: Input.ReleaseActionsParameters;
};
}
export declare namespace Input {
type ReleaseActionsParameters = {
context: BrowsingContext.BrowsingContext;
};
}
export declare namespace Input {
type ReleaseActionsResult = EmptyResult;
}
export declare namespace Input {
type SetFiles = {
method: 'input.setFiles';
params: Input.SetFilesParameters;
};
}
export declare namespace Input {
type SetFilesParameters = {
context: BrowsingContext.BrowsingContext;
element: Script.SharedReference;
files: [...string[]];
};
}
export declare namespace Input {
type SetFilesResult = EmptyResult;
}
export declare namespace Input {
type FileDialogOpened = {
method: 'input.fileDialogOpened';
params: Input.FileDialogInfo;
};
}
export declare namespace Input {
type FileDialogInfo = {
context: BrowsingContext.BrowsingContext;
userContext?: Browser.UserContext;
element?: Script.SharedReference;
multiple: boolean;
};
}
export type WebExtensionCommand = WebExtension.Install | WebExtension.Uninstall;
export type WebExtensionResult =
| WebExtension.InstallResult
| WebExtension.UninstallResult;
export declare namespace WebExtension {
type Extension = string;
}
export declare namespace WebExtension {
type Install = {
method: 'webExtension.install';
params: WebExtension.InstallParameters;
};
}
export declare namespace WebExtension {
type InstallParameters = {
extensionData: WebExtension.ExtensionData;
};
}
export declare namespace WebExtension {
type ExtensionData =
| WebExtension.ExtensionArchivePath
| WebExtension.ExtensionBase64Encoded
| WebExtension.ExtensionPath;
}
export declare namespace WebExtension {
type ExtensionPath = {
type: 'path';
path: string;
};
}
export declare namespace WebExtension {
type ExtensionArchivePath = {
type: 'archivePath';
path: string;
};
}
export declare namespace WebExtension {
type ExtensionBase64Encoded = {
type: 'base64';
value: string;
};
}
export declare namespace WebExtension {
type InstallResult = {
extension: WebExtension.Extension;
};
}
export declare namespace WebExtension {
type Uninstall = {
method: 'webExtension.uninstall';
params: WebExtension.UninstallParameters;
};
}
export declare namespace WebExtension {
type UninstallParameters = {
extension: WebExtension.Extension;
};
}
export declare namespace WebExtension {
type UninstallResult = EmptyResult;
}
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/main.js
Generated Vendored
+2
View File
@@ -0,0 +1,2 @@
'use strict';
Object.defineProperty(exports, '__esModule', {value: true});
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/mapping.d.ts
Generated Vendored
+314
View File
@@ -0,0 +1,314 @@
import type * as Bidi from './main.js';
import type * as BidiPermissions from './permissions.js';
import type * as BidiBluetooth from './web-bluetooth.js';
import type * as BidiUaClientHints from './ua-client-hints.js';
export interface Commands {
'bluetooth.disableSimulation': {
params: BidiBluetooth.Bluetooth.DisableSimulationParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.handleRequestDevicePrompt': {
params: BidiBluetooth.Bluetooth.HandleRequestDevicePromptParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateAdapter': {
params: BidiBluetooth.Bluetooth.SimulateAdapterParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateAdvertisement': {
params: BidiBluetooth.Bluetooth.SimulateAdvertisementParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateCharacteristic': {
params: BidiBluetooth.Bluetooth.SimulateCharacteristicParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateCharacteristicResponse': {
params: BidiBluetooth.Bluetooth.SimulateCharacteristicResponseParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateDescriptor': {
params: BidiBluetooth.Bluetooth.SimulateDescriptorParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateDescriptorResponse': {
params: BidiBluetooth.Bluetooth.SimulateDescriptorResponseParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateGattConnectionResponse': {
params: BidiBluetooth.Bluetooth.SimulateGattConnectionResponseParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateGattDisconnection': {
params: BidiBluetooth.Bluetooth.SimulateGattDisconnectionParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulatePreconnectedPeripheral': {
params: BidiBluetooth.Bluetooth.SimulatePreconnectedPeripheralParameters;
returnType: Bidi.EmptyResult;
};
'bluetooth.simulateService': {
params: BidiBluetooth.Bluetooth.SimulateServiceParameters;
returnType: Bidi.EmptyResult;
};
'browser.close': {
params: Bidi.Extensible;
returnType: Bidi.Browser.CloseResult;
};
'browser.createUserContext': {
params: Bidi.Browser.CreateUserContextParameters;
returnType: Bidi.Browser.CreateUserContextResult;
};
'browser.getClientWindows': {
params: Bidi.Extensible;
returnType: Bidi.Browser.GetClientWindowsResult;
};
'browser.getUserContexts': {
params: Bidi.Extensible;
returnType: Bidi.Browser.GetUserContextsResult;
};
'browser.removeUserContext': {
params: Bidi.Browser.RemoveUserContextParameters;
returnType: Bidi.Browser.RemoveUserContextResult;
};
'browser.setClientWindowState': {
params: Bidi.Browser.SetClientWindowStateParameters;
returnType: Bidi.Browser.SetClientWindowStateResult;
};
'browser.setDownloadBehavior': {
params: Bidi.Browser.SetDownloadBehaviorParameters;
returnType: Bidi.Browser.SetDownloadBehaviorResult;
};
'browsingContext.activate': {
params: Bidi.BrowsingContext.ActivateParameters;
returnType: Bidi.BrowsingContext.ActivateResult;
};
'browsingContext.captureScreenshot': {
params: Bidi.BrowsingContext.CaptureScreenshotParameters;
returnType: Bidi.BrowsingContext.CaptureScreenshotResult;
};
'browsingContext.close': {
params: Bidi.BrowsingContext.CloseParameters;
returnType: Bidi.BrowsingContext.CloseResult;
};
'browsingContext.create': {
params: Bidi.BrowsingContext.CreateParameters;
returnType: Bidi.BrowsingContext.CreateResult;
};
'browsingContext.getTree': {
params: Bidi.BrowsingContext.GetTreeParameters;
returnType: Bidi.BrowsingContext.GetTreeResult;
};
'browsingContext.handleUserPrompt': {
params: Bidi.BrowsingContext.HandleUserPromptParameters;
returnType: Bidi.BrowsingContext.HandleUserPromptResult;
};
'browsingContext.locateNodes': {
params: Bidi.BrowsingContext.LocateNodesParameters;
returnType: Bidi.BrowsingContext.LocateNodesResult;
};
'browsingContext.navigate': {
params: Bidi.BrowsingContext.NavigateParameters;
returnType: Bidi.BrowsingContext.NavigateResult;
};
'browsingContext.print': {
params: Bidi.BrowsingContext.PrintParameters;
returnType: Bidi.BrowsingContext.PrintResult;
};
'browsingContext.reload': {
params: Bidi.BrowsingContext.ReloadParameters;
returnType: Bidi.BrowsingContext.ReloadResult;
};
'browsingContext.setViewport': {
params: Bidi.BrowsingContext.SetViewportParameters;
returnType: Bidi.BrowsingContext.SetViewportResult;
};
'browsingContext.traverseHistory': {
params: Bidi.BrowsingContext.TraverseHistoryParameters;
returnType: Bidi.BrowsingContext.TraverseHistoryResult;
};
'emulation.setForcedColorsModeThemeOverride': {
params: Bidi.Emulation.SetForcedColorsModeThemeOverrideParameters;
returnType: Bidi.Emulation.SetForcedColorsModeThemeOverrideResult;
};
'emulation.setGeolocationOverride': {
params: Bidi.Emulation.SetGeolocationOverrideParameters;
returnType: Bidi.Emulation.SetGeolocationOverrideResult;
};
'emulation.setLocaleOverride': {
params: Bidi.Emulation.SetLocaleOverrideParameters;
returnType: Bidi.Emulation.SetLocaleOverrideResult;
};
'emulation.setNetworkConditions': {
params: Bidi.Emulation.SetNetworkConditionsParameters;
returnType: Bidi.Emulation.SetNetworkConditionsResult;
};
'emulation.setScreenOrientationOverride': {
params: Bidi.Emulation.SetScreenOrientationOverrideParameters;
returnType: Bidi.Emulation.SetScreenOrientationOverrideResult;
};
'emulation.setScreenSettingsOverride': {
params: Bidi.Emulation.SetScreenSettingsOverrideParameters;
returnType: Bidi.Emulation.SetScreenSettingsOverrideResult;
};
'emulation.setScriptingEnabled': {
params: Bidi.Emulation.SetScriptingEnabledParameters;
returnType: Bidi.Emulation.SetScriptingEnabledResult;
};
'emulation.setScrollbarTypeOverride': {
params: Bidi.Emulation.SetScrollbarTypeOverrideParameters;
returnType: Bidi.Emulation.SetScrollbarTypeOverrideResult;
};
'emulation.setTimezoneOverride': {
params: Bidi.Emulation.SetTimezoneOverrideParameters;
returnType: Bidi.Emulation.SetTimezoneOverrideResult;
};
'emulation.setTouchOverride': {
params: Bidi.Emulation.SetTouchOverrideParameters;
returnType: Bidi.Emulation.SetTouchOverrideResult;
};
'emulation.setUserAgentOverride': {
params: Bidi.Emulation.SetUserAgentOverrideParameters;
returnType: Bidi.Emulation.SetUserAgentOverrideResult;
};
'input.performActions': {
params: Bidi.Input.PerformActionsParameters;
returnType: Bidi.Input.PerformActionsResult;
};
'input.releaseActions': {
params: Bidi.Input.ReleaseActionsParameters;
returnType: Bidi.Input.ReleaseActionsResult;
};
'input.setFiles': {
params: Bidi.Input.SetFilesParameters;
returnType: Bidi.Input.SetFilesResult;
};
'network.addDataCollector': {
params: Bidi.Network.AddDataCollectorParameters;
returnType: Bidi.Network.AddDataCollectorResult;
};
'network.addIntercept': {
params: Bidi.Network.AddInterceptParameters;
returnType: Bidi.Network.AddInterceptResult;
};
'network.continueRequest': {
params: Bidi.Network.ContinueRequestParameters;
returnType: Bidi.Network.ContinueRequestResult;
};
'network.continueResponse': {
params: Bidi.Network.ContinueResponseParameters;
returnType: Bidi.Network.ContinueResponseResult;
};
'network.continueWithAuth': {
params: Bidi.Network.ContinueWithAuthParameters;
returnType: Bidi.Network.ContinueWithAuthResult;
};
'network.disownData': {
params: Bidi.Network.DisownDataParameters;
returnType: Bidi.Network.DisownDataResult;
};
'network.failRequest': {
params: Bidi.Network.FailRequestParameters;
returnType: Bidi.Network.FailRequestResult;
};
'network.getData': {
params: Bidi.Network.GetDataParameters;
returnType: Bidi.Network.GetDataResult;
};
'network.provideResponse': {
params: Bidi.Network.ProvideResponseParameters;
returnType: Bidi.Network.ProvideResponseResult;
};
'network.removeDataCollector': {
params: Bidi.Network.RemoveDataCollectorParameters;
returnType: Bidi.Network.RemoveDataCollectorResult;
};
'network.removeIntercept': {
params: Bidi.Network.RemoveInterceptParameters;
returnType: Bidi.Network.RemoveInterceptResult;
};
'network.setCacheBehavior': {
params: Bidi.Network.SetCacheBehaviorParameters;
returnType: Bidi.Network.SetCacheBehaviorResult;
};
'network.setExtraHeaders': {
params: Bidi.Network.SetExtraHeadersParameters;
returnType: Bidi.Network.SetExtraHeadersResult;
};
'permissions.setPermission': {
params: BidiPermissions.Permissions.SetPermissionParameters;
returnType: Bidi.EmptyResult;
};
'script.addPreloadScript': {
params: Bidi.Script.AddPreloadScriptParameters;
returnType: Bidi.Script.AddPreloadScriptResult;
};
'script.callFunction': {
params: Bidi.Script.CallFunctionParameters;
returnType: Bidi.Script.CallFunctionResult;
};
'script.disown': {
params: Bidi.Script.DisownParameters;
returnType: Bidi.Script.DisownResult;
};
'script.evaluate': {
params: Bidi.Script.EvaluateParameters;
returnType: Bidi.Script.EvaluateResult;
};
'script.getRealms': {
params: Bidi.Script.GetRealmsParameters;
returnType: Bidi.Script.GetRealmsResult;
};
'script.removePreloadScript': {
params: Bidi.Script.RemovePreloadScriptParameters;
returnType: Bidi.Script.RemovePreloadScriptResult;
};
'session.end': {
params: Bidi.Extensible;
returnType: Bidi.Session.EndResult;
};
'session.new': {
params: Bidi.Session.NewParameters;
returnType: Bidi.Session.NewResult;
};
'session.status': {
params: Bidi.Extensible;
returnType: Bidi.Session.StatusResult;
};
'session.subscribe': {
params: Bidi.Session.SubscribeParameters;
returnType: Bidi.Session.SubscribeResult;
};
'session.unsubscribe': {
params: Bidi.Session.UnsubscribeParameters;
returnType: Bidi.Session.UnsubscribeResult;
};
'storage.deleteCookies': {
params: Bidi.Storage.DeleteCookiesParameters;
returnType: Bidi.Storage.DeleteCookiesResult;
};
'storage.getCookies': {
params: Bidi.Storage.GetCookiesParameters;
returnType: Bidi.Storage.GetCookiesResult;
};
'storage.setCookie': {
params: Bidi.Storage.SetCookieParameters;
returnType: Bidi.Storage.SetCookieResult;
};
'userAgentClientHints.setClientHintsOverride': {
params: {
clientHints: BidiUaClientHints.UserAgentClientHints.ClientHintsMetadata | null;
contexts?: [string, ...string[]];
userContexts?: [string, ...string[]];
};
returnType: BidiUaClientHints.UserAgentClientHints.SetClientHintsOverrideResult;
};
'webExtension.install': {
params: Bidi.WebExtension.InstallParameters;
returnType: Bidi.WebExtension.InstallResult;
};
'webExtension.uninstall': {
params: Bidi.WebExtension.UninstallParameters;
returnType: Bidi.WebExtension.UninstallResult;
};
}
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/mapping.js
Generated Vendored
+2
View File
@@ -0,0 +1,2 @@
'use strict';
Object.defineProperty(exports, '__esModule', {value: true});
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/permissions.d.ts
Generated Vendored
+28
View File
@@ -0,0 +1,28 @@
export type PermissionsCommand = Permissions.SetPermission;
export declare namespace Permissions {
type PermissionDescriptor = {
name: string;
};
}
export declare namespace Permissions {
const enum PermissionState {
Granted = 'granted',
Denied = 'denied',
Prompt = 'prompt',
}
}
export declare namespace Permissions {
type SetPermission = {
method: 'permissions.setPermission';
params: Permissions.SetPermissionParameters;
};
}
export declare namespace Permissions {
type SetPermissionParameters = {
descriptor: Permissions.PermissionDescriptor;
state: Permissions.PermissionState;
origin: string;
embeddedOrigin?: string;
userContext?: string;
};
}
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/permissions.js
Generated Vendored
+2
View File
@@ -0,0 +1,2 @@
'use strict';
Object.defineProperty(exports, '__esModule', {value: true});
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/ua-client-hints.d.ts
Generated Vendored
+35
View File
@@ -0,0 +1,35 @@
export type UserAgentClientHintsCommand =
UserAgentClientHints.SetClientHintsOverrideCommand;
export declare namespace UserAgentClientHints {
type SetClientHintsOverrideCommand = {
method: 'userAgentClientHints.setClientHintsOverride';
params: {
clientHints: UserAgentClientHints.ClientHintsMetadata | null;
contexts?: [string, ...string[]];
userContexts?: [string, ...string[]];
};
};
}
export declare namespace UserAgentClientHints {
type ClientHintsMetadata = {
brands?: [...UserAgentClientHints.BrandVersion[]];
fullVersionList?: [...UserAgentClientHints.BrandVersion[]];
platform?: string;
platformVersion?: string;
architecture?: string;
model?: string;
mobile?: boolean;
bitness?: string;
wow64?: boolean;
formFactors?: [...string[]];
};
}
export declare namespace UserAgentClientHints {
type BrandVersion = {
brand: string;
version: string;
};
}
export declare namespace UserAgentClientHints {
type SetClientHintsOverrideResult = Record<string, never>;
}
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/ua-client-hints.js
Generated Vendored
+2
View File
@@ -0,0 +1,2 @@
'use strict';
Object.defineProperty(exports, '__esModule', {value: true});
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/web-bluetooth.d.ts
Generated Vendored
+314
View File
@@ -0,0 +1,314 @@
export declare namespace Bluetooth {
type BluetoothUuid = string;
}
export declare namespace Bluetooth {
type BluetoothManufacturerData = {
key: number;
data: string;
};
}
export declare namespace Bluetooth {
type CharacteristicProperties = {
broadcast?: boolean;
read?: boolean;
writeWithoutResponse?: boolean;
write?: boolean;
notify?: boolean;
indicate?: boolean;
authenticatedSignedWrites?: boolean;
extendedProperties?: boolean;
};
}
export declare namespace Bluetooth {
type RequestDevice = string;
}
export declare namespace Bluetooth {
type RequestDeviceInfo = {
id: Bluetooth.RequestDevice;
name: string | null;
};
}
export declare namespace Bluetooth {
type RequestDevicePrompt = string;
}
export declare namespace Bluetooth {
type ScanRecord = {
name?: string;
uuids?: [...Bluetooth.BluetoothUuid[]];
appearance?: number;
manufacturerData?: [...Bluetooth.BluetoothManufacturerData[]];
};
}
export type BluetoothCommand =
| Bluetooth.HandleRequestDevicePrompt
| Bluetooth.SimulateAdapter
| Bluetooth.DisableSimulation
| Bluetooth.SimulatePreconnectedPeripheral
| Bluetooth.SimulateAdvertisement
| Bluetooth.SimulateGattConnectionResponse
| Bluetooth.SimulateGattDisconnection
| Bluetooth.SimulateService
| Bluetooth.SimulateCharacteristic
| Bluetooth.SimulateCharacteristicResponse
| Bluetooth.SimulateDescriptor
| Bluetooth.SimulateDescriptorResponse;
export declare namespace Bluetooth {
type HandleRequestDevicePrompt = {
method: 'bluetooth.handleRequestDevicePrompt';
params: Bluetooth.HandleRequestDevicePromptParameters;
};
}
export declare namespace Bluetooth {
type HandleRequestDevicePromptParameters = {
context: string;
prompt: Bluetooth.RequestDevicePrompt;
} & (
| Bluetooth.HandleRequestDevicePromptAcceptParameters
| Bluetooth.HandleRequestDevicePromptCancelParameters
);
}
export declare namespace Bluetooth {
type HandleRequestDevicePromptAcceptParameters = {
accept: true;
device: Bluetooth.RequestDevice;
};
}
export declare namespace Bluetooth {
type HandleRequestDevicePromptCancelParameters = {
accept: false;
};
}
export declare namespace Bluetooth {
type SimulateAdapter = {
method: 'bluetooth.simulateAdapter';
params: Bluetooth.SimulateAdapterParameters;
};
}
export declare namespace Bluetooth {
type SimulateAdapterParameters = {
context: string;
leSupported?: boolean;
state: 'absent' | 'powered-off' | 'powered-on';
};
}
export declare namespace Bluetooth {
type DisableSimulation = {
method: 'bluetooth.disableSimulation';
params: Bluetooth.DisableSimulationParameters;
};
}
export declare namespace Bluetooth {
type DisableSimulationParameters = {
context: string;
};
}
export declare namespace Bluetooth {
type SimulatePreconnectedPeripheral = {
method: 'bluetooth.simulatePreconnectedPeripheral';
params: Bluetooth.SimulatePreconnectedPeripheralParameters;
};
}
export declare namespace Bluetooth {
type SimulatePreconnectedPeripheralParameters = {
context: string;
address: string;
name: string;
manufacturerData: [...Bluetooth.BluetoothManufacturerData[]];
knownServiceUuids: [...Bluetooth.BluetoothUuid[]];
};
}
export declare namespace Bluetooth {
type SimulateAdvertisement = {
method: 'bluetooth.simulateAdvertisement';
params: Bluetooth.SimulateAdvertisementParameters;
};
}
export declare namespace Bluetooth {
type SimulateAdvertisementParameters = {
context: string;
scanEntry: Bluetooth.SimulateAdvertisementScanEntryParameters;
};
}
export declare namespace Bluetooth {
type SimulateAdvertisementScanEntryParameters = {
deviceAddress: string;
rssi: number;
scanRecord: Bluetooth.ScanRecord;
};
}
export declare namespace Bluetooth {
type SimulateGattConnectionResponse = {
method: 'bluetooth.simulateGattConnectionResponse';
params: Bluetooth.SimulateGattConnectionResponseParameters;
};
}
export declare namespace Bluetooth {
type SimulateGattConnectionResponseParameters = {
context: string;
address: string;
code: number;
};
}
export declare namespace Bluetooth {
type SimulateGattDisconnection = {
method: 'bluetooth.simulateGattDisconnection';
params: Bluetooth.SimulateGattDisconnectionParameters;
};
}
export declare namespace Bluetooth {
type SimulateGattDisconnectionParameters = {
context: string;
address: string;
};
}
export declare namespace Bluetooth {
type SimulateService = {
method: 'bluetooth.simulateService';
params: Bluetooth.SimulateServiceParameters;
};
}
export declare namespace Bluetooth {
type SimulateServiceParameters = {
context: string;
address: string;
uuid: Bluetooth.BluetoothUuid;
type: 'add' | 'remove';
};
}
export declare namespace Bluetooth {
type SimulateCharacteristic = {
method: 'bluetooth.simulateCharacteristic';
params: Bluetooth.SimulateCharacteristicParameters;
};
}
export declare namespace Bluetooth {
type SimulateCharacteristicParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
characteristicProperties?: Bluetooth.CharacteristicProperties;
type: 'add' | 'remove';
};
}
export declare namespace Bluetooth {
type SimulateCharacteristicResponse = {
method: 'bluetooth.simulateCharacteristicResponse';
params: Bluetooth.SimulateCharacteristicResponseParameters;
};
}
export declare namespace Bluetooth {
type SimulateCharacteristicResponseParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
type:
| 'read'
| 'write'
| 'subscribe-to-notifications'
| 'unsubscribe-from-notifications';
code: number;
data?: [...number[]];
};
}
export declare namespace Bluetooth {
type SimulateDescriptor = {
method: 'bluetooth.simulateDescriptor';
params: Bluetooth.SimulateDescriptorParameters;
};
}
export declare namespace Bluetooth {
type SimulateDescriptorParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
descriptorUuid: Bluetooth.BluetoothUuid;
type: 'add' | 'remove';
};
}
export declare namespace Bluetooth {
type SimulateDescriptorResponse = {
method: 'bluetooth.simulateDescriptorResponse';
params: Bluetooth.SimulateDescriptorResponseParameters;
};
}
export declare namespace Bluetooth {
type SimulateDescriptorResponseParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
descriptorUuid: Bluetooth.BluetoothUuid;
type: 'read' | 'write';
code: number;
data?: [...number[]];
};
}
export type BluetoothEvent =
| Bluetooth.RequestDevicePromptUpdated
| Bluetooth.GattConnectionAttempted;
export declare namespace Bluetooth {
type RequestDevicePromptUpdated = {
method: 'bluetooth.requestDevicePromptUpdated';
params: Bluetooth.RequestDevicePromptUpdatedParameters;
};
}
export declare namespace Bluetooth {
type RequestDevicePromptUpdatedParameters = {
context: string;
prompt: Bluetooth.RequestDevicePrompt;
devices: [...Bluetooth.RequestDeviceInfo[]];
};
}
export declare namespace Bluetooth {
type GattConnectionAttempted = {
method: 'bluetooth.gattConnectionAttempted';
params: Bluetooth.GattConnectionAttemptedParameters;
};
}
export declare namespace Bluetooth {
type GattConnectionAttemptedParameters = {
context: string;
address: string;
};
}
export declare namespace Bluetooth {
type CharacteristicEventGenerated = {
method: 'bluetooth.characteristicEventGenerated';
params: Bluetooth.CharacteristicEventGeneratedParameters;
};
}
export declare namespace Bluetooth {
type CharacteristicEventGeneratedParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
type:
| 'read'
| 'write-with-response'
| 'write-without-response'
| 'subscribe-to-notifications'
| 'unsubscribe-from-notifications';
data?: [...number[]];
};
}
export declare namespace Bluetooth {
type DescriptorEventGenerated = {
method: 'bluetooth.descriptorEventGenerated';
params: Bluetooth.DescriptorEventGeneratedParameters;
};
}
export declare namespace Bluetooth {
type DescriptorEventGeneratedParameters = {
context: string;
address: string;
serviceUuid: Bluetooth.BluetoothUuid;
characteristicUuid: Bluetooth.BluetoothUuid;
descriptorUuid: Bluetooth.BluetoothUuid;
type: 'read' | 'write';
data?: [...number[]];
};
}
landvex-report-system/node_modules/webdriver-bidi-protocol/out/gen/web-bluetooth.js
Generated Vendored
+2
View File
@@ -0,0 +1,2 @@
'use strict';
Object.defineProperty(exports, '__esModule', {value: true});
landvex-report-system/node_modules/webdriver-bidi-protocol/out/index.d.ts
Generated Vendored
+31
View File
@@ -0,0 +1,31 @@
/**
* @license
* Copyright 2024 Google Inc.
* SPDX-License-Identifier: Apache-2.0
*/
import * as Bidi from './gen/main.js';
import * as BidiPermissions from './gen/permissions.js';
import * as BidiBluetooth from './gen/web-bluetooth.js';
import * as BidiUaClientHints from './gen/ua-client-hints.js';
export * from './gen/main.js';
export * from './gen/permissions.js';
export * from './gen/web-bluetooth.js';
export {UserAgentClientHintsCommand} from './gen/ua-client-hints.js';
export {BidiUaClientHints};
export * from './gen/mapping.js';
type ExternalSpecCommand<T> = {
id: Bidi.JsUint;
} & T;
export type Result = Bidi.ResultData;
export type Command =
| Bidi.Command
| ExternalSpecCommand<BidiPermissions.PermissionsCommand>
| ExternalSpecCommand<BidiBluetooth.BluetoothCommand>
| ExternalSpecCommand<BidiUaClientHints.UserAgentClientHintsCommand>;
type ExternalSpecEvent<T> = {
type: 'event';
} & T &
Bidi.Extensible;
export type Event =
| Bidi.Event
| ExternalSpecEvent<BidiBluetooth.BluetoothEvent>;
landvex-report-system/node_modules/webdriver-bidi-protocol/out/index.js
Generated Vendored
+77
View File
@@ -0,0 +1,77 @@
'use strict';
/**
* @license
* Copyright 2024 Google Inc.
* SPDX-License-Identifier: Apache-2.0
*/
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (
!desc ||
('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
) {
desc = {
enumerable: true,
get: function () {
return m[k];
},
};
}
Object.defineProperty(o, k2, desc);
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {enumerable: true, value: v});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
(function () {
var ownKeys = function (o) {
ownKeys =
Object.getOwnPropertyNames ||
function (o) {
var ar = [];
for (var k in o)
if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k = ownKeys(mod), i = 0; i < k.length; i++)
if (k[i] !== 'default') __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __exportStar =
(this && this.__exportStar) ||
function (m, exports) {
for (var p in m)
if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
__createBinding(exports, m, p);
};
Object.defineProperty(exports, '__esModule', {value: true});
exports.BidiUaClientHints = void 0;
const BidiUaClientHints = __importStar(require('./gen/ua-client-hints.js'));
exports.BidiUaClientHints = BidiUaClientHints;
__exportStar(require('./gen/main.js'), exports);
__exportStar(require('./gen/permissions.js'), exports);
__exportStar(require('./gen/web-bluetooth.js'), exports);
__exportStar(require('./gen/mapping.js'), exports);