Filip/playwright
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

chore: use client wall time in traces (#21163)

Browse source
This commit is contained in:
Pavel Feldman 2023-02-23 14:37:53 -08:00 committed by GitHub
parent f3ec29e6ad
commit 8ccc02a9d3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
22 changed files with 301 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
packages/playwright-core/src/client/channelOwner.ts
View file

@ -140,9 +140,10 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
return this._wrapApiCall(apiZone => { return this._wrapApiCall(apiZone => {
const { stackTrace, csi, callCookie } = apiZone.reported ? { csi: undefined, callCookie: undefined, stackTrace: null } : apiZone; const { stackTrace, csi, callCookie } = apiZone.reported ? { csi: undefined, callCookie: undefined, stackTrace: null } : apiZone;
apiZone.reported = true; apiZone.reported = true;
const wallTime = Date.now();
if (csi && stackTrace && stackTrace.apiName) if (csi && stackTrace && stackTrace.apiName)
csi.onApiCallBegin(renderCallWithParams(stackTrace.apiName, params), stackTrace, callCookie); csi.onApiCallBegin(renderCallWithParams(stackTrace.apiName, params), stackTrace, wallTime, callCookie);
return this._connection.sendMessageToServer(this, this._type, prop, validator(params, '', { tChannelImpl: tChannelImplToWire, binary: this._connection.isRemote() ? 'toBase64' : 'buffer' }), stackTrace); return this._connection.sendMessageToServer(this, this._type, prop, validator(params, '', { tChannelImpl: tChannelImplToWire, binary: this._connection.isRemote() ? 'toBase64' : 'buffer' }), stackTrace, wallTime);
}); });
}; };
} }

4
packages/playwright-core/src/client/clientInstrumentation.ts
View file

@ -20,12 +20,12 @@ export interface ClientInstrumentation {
addListener(listener: ClientInstrumentationListener): void; addListener(listener: ClientInstrumentationListener): void;
removeListener(listener: ClientInstrumentationListener): void; removeListener(listener: ClientInstrumentationListener): void;
removeAllListeners(): void; removeAllListeners(): void;
onApiCallBegin(apiCall: string, stackTrace: ParsedStackTrace | null, userData: any): void; onApiCallBegin(apiCall: string, stackTrace: ParsedStackTrace | null, wallTime: number, userData: any): void;
onApiCallEnd(userData: any, error?: Error): any; onApiCallEnd(userData: any, error?: Error): any;
} }
export interface ClientInstrumentationListener { export interface ClientInstrumentationListener {
onApiCallBegin?(apiCall: string, stackTrace: ParsedStackTrace | null, userData: any): any; onApiCallBegin?(apiCall: string, stackTrace: ParsedStackTrace | null, wallTime: number, userData: any): any;
onApiCallEnd?(userData: any, error?: Error): any; onApiCallEnd?(userData: any, error?: Error): any;
} }

4
packages/playwright-core/src/client/connection.ts
View file

@ -111,7 +111,7 @@ export class Connection extends EventEmitter {
this._stackCollectors.delete(collector); this._stackCollectors.delete(collector);
} }
async sendMessageToServer(object: ChannelOwner, type: string, method: string, params: any, stackTrace: ParsedStackTrace | null): Promise<any> { async sendMessageToServer(object: ChannelOwner, type: string, method: string, params: any, stackTrace: ParsedStackTrace | null, wallTime: number): Promise<any> {
if (this._closedErrorMessage) if (this._closedErrorMessage)
throw new Error(this._closedErrorMessage); throw new Error(this._closedErrorMessage);
@ -124,7 +124,7 @@ export class Connection extends EventEmitter {
for (const collector of this._stackCollectors) for (const collector of this._stackCollectors)
collector.push({ stack: frames, id: id }); collector.push({ stack: frames, id: id });
const location = frames[0] ? { file: frames[0].file, line: frames[0].line, column: frames[0].column } : undefined; const location = frames[0] ? { file: frames[0].file, line: frames[0].line, column: frames[0].column } : undefined;
const metadata: channels.Metadata = { apiName, location, internal: !apiName }; const metadata: channels.Metadata = { wallTime, apiName, location, internal: !apiName };
this.onmessage({ ...converted, metadata }); this.onmessage({ ...converted, metadata });
return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, stackTrace, type, method })); return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, stackTrace, type, method }));

1
packages/playwright-core/src/protocol/validator.ts
View file

@ -34,6 +34,7 @@ scheme.Metadata = tObject({
})), })),
apiName: tOptional(tString), apiName: tOptional(tString),
internal: tOptional(tBoolean), internal: tOptional(tBoolean),
wallTime: tOptional(tNumber),
}); });
scheme.ClientSideCallMetadata = tObject({ scheme.ClientSideCallMetadata = tObject({
id: tNumber, id: tNumber,

4
packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
View file

@ -146,7 +146,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
return false; return false;
} }
async createTempFile(params: channels.BrowserContextCreateTempFileParams, metadata?: channels.Metadata): Promise<channels.BrowserContextCreateTempFileResult> { async createTempFile(params: channels.BrowserContextCreateTempFileParams): Promise<channels.BrowserContextCreateTempFileResult> {
const dir = this._context._browser.options.artifactsDir; const dir = this._context._browser.options.artifactsDir;
const tmpDir = path.join(dir, 'upload-' + createGuid()); const tmpDir = path.join(dir, 'upload-' + createGuid());
await fs.promises.mkdir(tmpDir); await fs.promises.mkdir(tmpDir);
@ -268,7 +268,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
return { artifact: ArtifactDispatcher.from(this, artifact) }; return { artifact: ArtifactDispatcher.from(this, artifact) };
} }
async updateSubscription(params: channels.BrowserContextUpdateSubscriptionParams, metadata?: channels.Metadata | undefined): Promise<void> { async updateSubscription(params: channels.BrowserContextUpdateSubscriptionParams): Promise<void> {
if (params.enabled) if (params.enabled)
this._subscriptions.add(params.event); this._subscriptions.add(params.event);
else else

3
packages/playwright-core/src/server/dispatchers/dispatcher.ts
View file

@ -191,7 +191,6 @@ export class DispatcherConnection {
objectId: sdkObject?.guid, objectId: sdkObject?.guid,
pageId: sdkObject?.attribution?.page?.guid, pageId: sdkObject?.attribution?.page?.guid,
frameId: sdkObject?.attribution?.frame?.guid, frameId: sdkObject?.attribution?.frame?.guid,
wallTime: Date.now(),
startTime: monotonicTime(), startTime: monotonicTime(),
endTime: 0, endTime: 0,
type, type,
@ -251,13 +250,13 @@ export class DispatcherConnection {
const sdkObject = dispatcher._object instanceof SdkObject ? dispatcher._object : undefined; const sdkObject = dispatcher._object instanceof SdkObject ? dispatcher._object : undefined;
const callMetadata: CallMetadata = { const callMetadata: CallMetadata = {
id: `call@${id}`, id: `call@${id}`,
wallTime: validMetadata.wallTime,
location: validMetadata.location, location: validMetadata.location,
apiName: validMetadata.apiName, apiName: validMetadata.apiName,
internal: validMetadata.internal, internal: validMetadata.internal,
objectId: sdkObject?.guid, objectId: sdkObject?.guid,
pageId: sdkObject?.attribution?.page?.guid, pageId: sdkObject?.attribution?.page?.guid,
frameId: sdkObject?.attribution?.frame?.guid, frameId: sdkObject?.attribution?.frame?.guid,
wallTime: Date.now(),
startTime: monotonicTime(), startTime: monotonicTime(),
endTime: 0, endTime: 0,
type: dispatcher._type, type: dispatcher._type,

6
packages/playwright-core/src/server/dispatchers/networkDispatchers.ts
View file

@ -212,16 +212,16 @@ export class APIRequestContextDispatcher extends Dispatcher<APIRequestContext, c
}; };
} }
async fetchResponseBody(params: channels.APIRequestContextFetchResponseBodyParams, metadata?: channels.Metadata): Promise<channels.APIRequestContextFetchResponseBodyResult> { async fetchResponseBody(params: channels.APIRequestContextFetchResponseBodyParams): Promise<channels.APIRequestContextFetchResponseBodyResult> {
return { binary: this._object.fetchResponses.get(params.fetchUid) }; return { binary: this._object.fetchResponses.get(params.fetchUid) };
} }
async fetchLog(params: channels.APIRequestContextFetchLogParams, metadata?: channels.Metadata): Promise<channels.APIRequestContextFetchLogResult> { async fetchLog(params: channels.APIRequestContextFetchLogParams): Promise<channels.APIRequestContextFetchLogResult> {
const log = this._object.fetchLog.get(params.fetchUid) || []; const log = this._object.fetchLog.get(params.fetchUid) || [];
return { log }; return { log };
} }
async disposeAPIResponse(params: channels.APIRequestContextDisposeAPIResponseParams, metadata?: channels.Metadata): Promise<void> { async disposeAPIResponse(params: channels.APIRequestContextDisposeAPIResponseParams): Promise<void> {
this._object.disposeResponse(params.fetchUid); this._object.disposeResponse(params.fetchUid);
} }
} }

2
packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
View file

@ -204,7 +204,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
await this._page.close(metadata, params); await this._page.close(metadata, params);
} }
async updateSubscription(params: channels.PageUpdateSubscriptionParams, metadata?: channels.Metadata | undefined): Promise<void> { async updateSubscription(params: channels.PageUpdateSubscriptionParams): Promise<void> {
if (params.event === 'fileChooser') if (params.event === 'fileChooser')
await this._page.setFileChooserIntercepted(params.enabled); await this._page.setFileChooserIntercepted(params.enabled);
if (params.enabled) if (params.enabled)

2
packages/playwright-core/src/server/dispatchers/playwrightDispatcher.ts
View file

@ -63,7 +63,7 @@ export class PlaywrightDispatcher extends Dispatcher<Playwright, channels.Playwr
this._browserDispatcher = browserDispatcher; this._browserDispatcher = browserDispatcher;
} }
async newRequest(params: channels.PlaywrightNewRequestParams, metadata?: channels.Metadata): Promise<channels.PlaywrightNewRequestResult> { async newRequest(params: channels.PlaywrightNewRequestParams): Promise<channels.PlaywrightNewRequestResult> {
const request = new GlobalAPIRequestContext(this._object, params); const request = new GlobalAPIRequestContext(this._object, params);
return { request: APIRequestContextDispatcher.from(this.parentScope(), request) }; return { request: APIRequestContextDispatcher.from(this.parentScope(), request) };
} }

2
packages/playwright-core/src/server/dispatchers/selectorsDispatcher.ts
View file

@ -30,7 +30,7 @@ export class SelectorsDispatcher extends Dispatcher<Selectors, channels.Selector
await this._object.register(params.name, params.source, params.contentScript); await this._object.register(params.name, params.source, params.contentScript);
} }
async setTestIdAttributeName(params: channels.SelectorsSetTestIdAttributeNameParams, metadata?: channels.Metadata | undefined): Promise<void> { async setTestIdAttributeName(params: channels.SelectorsSetTestIdAttributeNameParams): Promise<void> {
this._object.setTestIdAttributeName(params.testIdAttributeName); this._object.setTestIdAttributeName(params.testIdAttributeName);
} }
} }

1
packages/playwright-core/src/server/instrumentation.ts
View file

@ -103,7 +103,6 @@ export function createInstrumentation(): Instrumentation {
export function serverSideCallMetadata(): CallMetadata { export function serverSideCallMetadata(): CallMetadata {
return { return {
id: '', id: '',
wallTime: 0,
startTime: 0, startTime: 0,
endTime: 0, endTime: 0,
type: 'Internal', type: 'Internal',

1
packages/playwright-core/src/server/recorder.ts
View file

@ -569,7 +569,6 @@ class ContextRecorder extends EventEmitter {
objectId: frame.guid, objectId: frame.guid,
pageId: frame._page.guid, pageId: frame._page.guid,
frameId: frame.guid, frameId: frame.guid,
wallTime: Date.now(),
startTime: monotonicTime(), startTime: monotonicTime(),
endTime: 0, endTime: 0,
type: 'Frame', type: 'Frame',

3
packages/playwright-test/src/common/testType.ts
View file

@ -217,7 +217,8 @@ export class TestTypeImpl {
title, title,
location, location,
canHaveChildren: true, canHaveChildren: true,
forceNoParent: false forceNoParent: false,
wallTime: Date.now(),
}); });
try { try {
const result = await body(); const result = await body();

5
packages/playwright-test/src/index.ts
View file

@ -250,7 +250,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures> = ({
const createInstrumentationListener = (context?: BrowserContext) => { const createInstrumentationListener = (context?: BrowserContext) => {
return { return {
onApiCallBegin: (apiCall: string, stackTrace: ParsedStackTrace | null, userData: any) => { onApiCallBegin: (apiCall: string, stackTrace: ParsedStackTrace | null, wallTime: number, userData: any) => {
if (apiCall.startsWith('expect.')) if (apiCall.startsWith('expect.'))
return { userObject: null }; return { userObject: null };
if (apiCall === 'page.pause') { if (apiCall === 'page.pause') {
@ -263,7 +263,8 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures> = ({
category: 'pw:api', category: 'pw:api',
title: apiCall, title: apiCall,
canHaveChildren: false, canHaveChildren: false,
forceNoParent: false forceNoParent: false,
wallTime,
}); });
userData.userObject = step; userData.userObject = step;
}, },

3
packages/playwright-test/src/matchers/expect.ts
View file

@ -205,7 +205,8 @@ class ExpectMetaInfoProxyHandler {
category: 'expect', category: 'expect',
title: trimLongString(customMessage || defaultTitle, 1024), title: trimLongString(customMessage || defaultTitle, 1024),
canHaveChildren: true, canHaveChildren: true,
forceNoParent: false forceNoParent: false,
wallTime: Date.now()
}); });
testInfo.currentStep = step; testInfo.currentStep = step;

5
packages/playwright-test/src/worker/testInfo.ts
View file

@ -36,6 +36,7 @@ interface TestStepInternal {
category: string; category: string;
canHaveChildren: boolean; canHaveChildren: boolean;
forceNoParent: boolean; forceNoParent: boolean;
wallTime: number;
location?: Location; location?: Location;
refinedTitle?: string; refinedTitle?: string;
} }
@ -278,8 +279,8 @@ export class TestInfoImpl implements TestInfo {
this._hasHardError = state.hasHardError; this._hasHardError = state.hasHardError;
} }
async _runAsStep<T>(cb: () => Promise<T>, stepInfo: Omit<TestStepInternal, 'complete'>): Promise<T> { async _runAsStep<T>(cb: () => Promise<T>, stepInfo: Omit<TestStepInternal, 'complete' | 'wallTime'>): Promise<T> {
const step = this._addStep(stepInfo); const step = this._addStep({ ...stepInfo, wallTime: Date.now() });
try { try {
const result = await cb(); const result = await cb();
step.complete({}); step.complete({});

6
packages/playwright-test/src/worker/workerMain.ts
View file

@ -329,7 +329,8 @@ export class WorkerMain extends ProcessRunner {
category: 'hook', category: 'hook',
title: 'Before Hooks', title: 'Before Hooks',
canHaveChildren: true, canHaveChildren: true,
forceNoParent: true forceNoParent: true,
wallTime: Date.now(),
}); });
// Note: wrap all preparation steps together, because failure/skip in any of them // Note: wrap all preparation steps together, because failure/skip in any of them
@ -394,7 +395,8 @@ export class WorkerMain extends ProcessRunner {
category: 'hook', category: 'hook',
title: 'After Hooks', title: 'After Hooks',
canHaveChildren: true, canHaveChildren: true,
forceNoParent: true forceNoParent: true,
wallTime: Date.now(),
}); });
let firstAfterHooksError: TestInfoError | undefined; let firstAfterHooksError: TestInfoError | undefined;

3
packages/protocol/src/callMetadata.ts
View file

@ -18,7 +18,6 @@ import type { Point, SerializedError } from './channels';
export type CallMetadata = { export type CallMetadata = {
id: string; id: string;
wallTime: number;
startTime: number; startTime: number;
endTime: number; endTime: number;
pauseStartTime?: number; pauseStartTime?: number;
@ -33,6 +32,8 @@ export type CallMetadata = {
// Service-side is making a call to itself, this metadata does not go // Service-side is making a call to itself, this metadata does not go
// through the dispatcher, so is always excluded from inspector / tracing. // through the dispatcher, so is always excluded from inspector / tracing.
isServerSide?: boolean; isServerSide?: boolean;
// Client wall time.
wallTime?: number;
location?: { file: string, line?: number, column?: number }; location?: { file: string, line?: number, column?: number };
log: string[]; log: string[];
afterSnapshot?: string; afterSnapshot?: string;

519
packages/protocol/src/channels.ts
View file

@ -16,6 +16,8 @@
// This file is generated by generate_channels.js, do not edit manually. // This file is generated by generate_channels.js, do not edit manually.
import type { CallMetadata } from './callMetadata';
export type Binary = Buffer; export type Binary = Buffer;
export interface Channel { export interface Channel {
@ -150,6 +152,7 @@ export type Metadata = {
}, },
apiName?: string, apiName?: string,
internal?: boolean, internal?: boolean,
wallTime?: number,
}; };
export type ClientSideCallMetadata = { export type ClientSideCallMetadata = {
@ -303,12 +306,12 @@ export interface APIRequestContextEventTarget {
} }
export interface APIRequestContextChannel extends APIRequestContextEventTarget, Channel { export interface APIRequestContextChannel extends APIRequestContextEventTarget, Channel {
_type_APIRequestContext: boolean; _type_APIRequestContext: boolean;
fetch(params: APIRequestContextFetchParams, metadata?: Metadata): Promise<APIRequestContextFetchResult>; fetch(params: APIRequestContextFetchParams, metadata?: CallMetadata): Promise<APIRequestContextFetchResult>;
fetchResponseBody(params: APIRequestContextFetchResponseBodyParams, metadata?: Metadata): Promise<APIRequestContextFetchResponseBodyResult>; fetchResponseBody(params: APIRequestContextFetchResponseBodyParams, metadata?: CallMetadata): Promise<APIRequestContextFetchResponseBodyResult>;
fetchLog(params: APIRequestContextFetchLogParams, metadata?: Metadata): Promise<APIRequestContextFetchLogResult>; fetchLog(params: APIRequestContextFetchLogParams, metadata?: CallMetadata): Promise<APIRequestContextFetchLogResult>;
storageState(params?: APIRequestContextStorageStateParams, metadata?: Metadata): Promise<APIRequestContextStorageStateResult>; storageState(params?: APIRequestContextStorageStateParams, metadata?: CallMetadata): Promise<APIRequestContextStorageStateResult>;
disposeAPIResponse(params: APIRequestContextDisposeAPIResponseParams, metadata?: Metadata): Promise<APIRequestContextDisposeAPIResponseResult>; disposeAPIResponse(params: APIRequestContextDisposeAPIResponseParams, metadata?: CallMetadata): Promise<APIRequestContextDisposeAPIResponseResult>;
dispose(params?: APIRequestContextDisposeParams, metadata?: Metadata): Promise<APIRequestContextDisposeResult>; dispose(params?: APIRequestContextDisposeParams, metadata?: CallMetadata): Promise<APIRequestContextDisposeResult>;
} }
export type APIRequestContextFetchParams = { export type APIRequestContextFetchParams = {
url: string, url: string,
@ -393,12 +396,12 @@ export interface LocalUtilsEventTarget {
} }
export interface LocalUtilsChannel extends LocalUtilsEventTarget, Channel { export interface LocalUtilsChannel extends LocalUtilsEventTarget, Channel {
_type_LocalUtils: boolean; _type_LocalUtils: boolean;
zip(params: LocalUtilsZipParams, metadata?: Metadata): Promise<LocalUtilsZipResult>; zip(params: LocalUtilsZipParams, metadata?: CallMetadata): Promise<LocalUtilsZipResult>;
harOpen(params: LocalUtilsHarOpenParams, metadata?: Metadata): Promise<LocalUtilsHarOpenResult>; harOpen(params: LocalUtilsHarOpenParams, metadata?: CallMetadata): Promise<LocalUtilsHarOpenResult>;
harLookup(params: LocalUtilsHarLookupParams, metadata?: Metadata): Promise<LocalUtilsHarLookupResult>; harLookup(params: LocalUtilsHarLookupParams, metadata?: CallMetadata): Promise<LocalUtilsHarLookupResult>;
harClose(params: LocalUtilsHarCloseParams, metadata?: Metadata): Promise<LocalUtilsHarCloseResult>; harClose(params: LocalUtilsHarCloseParams, metadata?: CallMetadata): Promise<LocalUtilsHarCloseResult>;
harUnzip(params: LocalUtilsHarUnzipParams, metadata?: Metadata): Promise<LocalUtilsHarUnzipResult>; harUnzip(params: LocalUtilsHarUnzipParams, metadata?: CallMetadata): Promise<LocalUtilsHarUnzipResult>;
connect(params: LocalUtilsConnectParams, metadata?: Metadata): Promise<LocalUtilsConnectResult>; connect(params: LocalUtilsConnectParams, metadata?: CallMetadata): Promise<LocalUtilsConnectResult>;
} }
export type LocalUtilsZipParams = { export type LocalUtilsZipParams = {
zipFile: string, zipFile: string,
@ -483,7 +486,7 @@ export interface RootEventTarget {
} }
export interface RootChannel extends RootEventTarget, Channel { export interface RootChannel extends RootEventTarget, Channel {
_type_Root: boolean; _type_Root: boolean;
initialize(params: RootInitializeParams, metadata?: Metadata): Promise<RootInitializeResult>; initialize(params: RootInitializeParams, metadata?: CallMetadata): Promise<RootInitializeResult>;
} }
export type RootInitializeParams = { export type RootInitializeParams = {
sdkLanguage: 'javascript' | 'python' | 'java' | 'csharp', sdkLanguage: 'javascript' | 'python' | 'java' | 'csharp',
@ -533,7 +536,7 @@ export interface PlaywrightEventTarget {
} }
export interface PlaywrightChannel extends PlaywrightEventTarget, Channel { export interface PlaywrightChannel extends PlaywrightEventTarget, Channel {
_type_Playwright: boolean; _type_Playwright: boolean;
newRequest(params: PlaywrightNewRequestParams, metadata?: Metadata): Promise<PlaywrightNewRequestResult>; newRequest(params: PlaywrightNewRequestParams, metadata?: CallMetadata): Promise<PlaywrightNewRequestResult>;
} }
export type PlaywrightNewRequestParams = { export type PlaywrightNewRequestParams = {
baseURL?: string, baseURL?: string,
@ -611,16 +614,16 @@ export interface DebugControllerEventTarget {
} }
export interface DebugControllerChannel extends DebugControllerEventTarget, Channel { export interface DebugControllerChannel extends DebugControllerEventTarget, Channel {
_type_DebugController: boolean; _type_DebugController: boolean;
initialize(params: DebugControllerInitializeParams, metadata?: Metadata): Promise<DebugControllerInitializeResult>; initialize(params: DebugControllerInitializeParams, metadata?: CallMetadata): Promise<DebugControllerInitializeResult>;
setReportStateChanged(params: DebugControllerSetReportStateChangedParams, metadata?: Metadata): Promise<DebugControllerSetReportStateChangedResult>; setReportStateChanged(params: DebugControllerSetReportStateChangedParams, metadata?: CallMetadata): Promise<DebugControllerSetReportStateChangedResult>;
resetForReuse(params?: DebugControllerResetForReuseParams, metadata?: Metadata): Promise<DebugControllerResetForReuseResult>; resetForReuse(params?: DebugControllerResetForReuseParams, metadata?: CallMetadata): Promise<DebugControllerResetForReuseResult>;
navigate(params: DebugControllerNavigateParams, metadata?: Metadata): Promise<DebugControllerNavigateResult>; navigate(params: DebugControllerNavigateParams, metadata?: CallMetadata): Promise<DebugControllerNavigateResult>;
setRecorderMode(params: DebugControllerSetRecorderModeParams, metadata?: Metadata): Promise<DebugControllerSetRecorderModeResult>; setRecorderMode(params: DebugControllerSetRecorderModeParams, metadata?: CallMetadata): Promise<DebugControllerSetRecorderModeResult>;
highlight(params: DebugControllerHighlightParams, metadata?: Metadata): Promise<DebugControllerHighlightResult>; highlight(params: DebugControllerHighlightParams, metadata?: CallMetadata): Promise<DebugControllerHighlightResult>;
hideHighlight(params?: DebugControllerHideHighlightParams, metadata?: Metadata): Promise<DebugControllerHideHighlightResult>; hideHighlight(params?: DebugControllerHideHighlightParams, metadata?: CallMetadata): Promise<DebugControllerHideHighlightResult>;
resume(params?: DebugControllerResumeParams, metadata?: Metadata): Promise<DebugControllerResumeResult>; resume(params?: DebugControllerResumeParams, metadata?: CallMetadata): Promise<DebugControllerResumeResult>;
kill(params?: DebugControllerKillParams, metadata?: Metadata): Promise<DebugControllerKillResult>; kill(params?: DebugControllerKillParams, metadata?: CallMetadata): Promise<DebugControllerKillResult>;
closeAllBrowsers(params?: DebugControllerCloseAllBrowsersParams, metadata?: Metadata): Promise<DebugControllerCloseAllBrowsersResult>; closeAllBrowsers(params?: DebugControllerCloseAllBrowsersParams, metadata?: CallMetadata): Promise<DebugControllerCloseAllBrowsersResult>;
} }
export type DebugControllerInspectRequestedEvent = { export type DebugControllerInspectRequestedEvent = {
selector: string, selector: string,
@ -715,11 +718,11 @@ export interface SocksSupportEventTarget {
} }
export interface SocksSupportChannel extends SocksSupportEventTarget, Channel { export interface SocksSupportChannel extends SocksSupportEventTarget, Channel {
_type_SocksSupport: boolean; _type_SocksSupport: boolean;
socksConnected(params: SocksSupportSocksConnectedParams, metadata?: Metadata): Promise<SocksSupportSocksConnectedResult>; socksConnected(params: SocksSupportSocksConnectedParams, metadata?: CallMetadata): Promise<SocksSupportSocksConnectedResult>;
socksFailed(params: SocksSupportSocksFailedParams, metadata?: Metadata): Promise<SocksSupportSocksFailedResult>; socksFailed(params: SocksSupportSocksFailedParams, metadata?: CallMetadata): Promise<SocksSupportSocksFailedResult>;
socksData(params: SocksSupportSocksDataParams, metadata?: Metadata): Promise<SocksSupportSocksDataResult>; socksData(params: SocksSupportSocksDataParams, metadata?: CallMetadata): Promise<SocksSupportSocksDataResult>;
socksError(params: SocksSupportSocksErrorParams, metadata?: Metadata): Promise<SocksSupportSocksErrorResult>; socksError(params: SocksSupportSocksErrorParams, metadata?: CallMetadata): Promise<SocksSupportSocksErrorResult>;
socksEnd(params: SocksSupportSocksEndParams, metadata?: Metadata): Promise<SocksSupportSocksEndResult>; socksEnd(params: SocksSupportSocksEndParams, metadata?: CallMetadata): Promise<SocksSupportSocksEndResult>;
} }
export type SocksSupportSocksRequestedEvent = { export type SocksSupportSocksRequestedEvent = {
uid: string, uid: string,
@ -786,8 +789,8 @@ export interface SelectorsEventTarget {
} }
export interface SelectorsChannel extends SelectorsEventTarget, Channel { export interface SelectorsChannel extends SelectorsEventTarget, Channel {
_type_Selectors: boolean; _type_Selectors: boolean;
register(params: SelectorsRegisterParams, metadata?: Metadata): Promise<SelectorsRegisterResult>; register(params: SelectorsRegisterParams, metadata?: CallMetadata): Promise<SelectorsRegisterResult>;
setTestIdAttributeName(params: SelectorsSetTestIdAttributeNameParams, metadata?: Metadata): Promise<SelectorsSetTestIdAttributeNameResult>; setTestIdAttributeName(params: SelectorsSetTestIdAttributeNameParams, metadata?: CallMetadata): Promise<SelectorsSetTestIdAttributeNameResult>;
} }
export type SelectorsRegisterParams = { export type SelectorsRegisterParams = {
name: string, name: string,
@ -818,9 +821,9 @@ export interface BrowserTypeEventTarget {
} }
export interface BrowserTypeChannel extends BrowserTypeEventTarget, Channel { export interface BrowserTypeChannel extends BrowserTypeEventTarget, Channel {
_type_BrowserType: boolean; _type_BrowserType: boolean;
launch(params: BrowserTypeLaunchParams, metadata?: Metadata): Promise<BrowserTypeLaunchResult>; launch(params: BrowserTypeLaunchParams, metadata?: CallMetadata): Promise<BrowserTypeLaunchResult>;
launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, metadata?: Metadata): Promise<BrowserTypeLaunchPersistentContextResult>; launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, metadata?: CallMetadata): Promise<BrowserTypeLaunchPersistentContextResult>;
connectOverCDP(params: BrowserTypeConnectOverCDPParams, metadata?: Metadata): Promise<BrowserTypeConnectOverCDPResult>; connectOverCDP(params: BrowserTypeConnectOverCDPParams, metadata?: CallMetadata): Promise<BrowserTypeConnectOverCDPResult>;
} }
export type BrowserTypeLaunchParams = { export type BrowserTypeLaunchParams = {
channel?: string, channel?: string,
@ -1046,13 +1049,13 @@ export interface BrowserEventTarget {
} }
export interface BrowserChannel extends BrowserEventTarget, Channel { export interface BrowserChannel extends BrowserEventTarget, Channel {
_type_Browser: boolean; _type_Browser: boolean;
close(params?: BrowserCloseParams, metadata?: Metadata): Promise<BrowserCloseResult>; close(params?: BrowserCloseParams, metadata?: CallMetadata): Promise<BrowserCloseResult>;
killForTests(params?: BrowserKillForTestsParams, metadata?: Metadata): Promise<BrowserKillForTestsResult>; killForTests(params?: BrowserKillForTestsParams, metadata?: CallMetadata): Promise<BrowserKillForTestsResult>;
newContext(params: BrowserNewContextParams, metadata?: Metadata): Promise<BrowserNewContextResult>; newContext(params: BrowserNewContextParams, metadata?: CallMetadata): Promise<BrowserNewContextResult>;
newContextForReuse(params: BrowserNewContextForReuseParams, metadata?: Metadata): Promise<BrowserNewContextForReuseResult>; newContextForReuse(params: BrowserNewContextForReuseParams, metadata?: CallMetadata): Promise<BrowserNewContextForReuseResult>;
newBrowserCDPSession(params?: BrowserNewBrowserCDPSessionParams, metadata?: Metadata): Promise<BrowserNewBrowserCDPSessionResult>; newBrowserCDPSession(params?: BrowserNewBrowserCDPSessionParams, metadata?: CallMetadata): Promise<BrowserNewBrowserCDPSessionResult>;
startTracing(params: BrowserStartTracingParams, metadata?: Metadata): Promise<BrowserStartTracingResult>; startTracing(params: BrowserStartTracingParams, metadata?: CallMetadata): Promise<BrowserStartTracingResult>;
stopTracing(params?: BrowserStopTracingParams, metadata?: Metadata): Promise<BrowserStopTracingResult>; stopTracing(params?: BrowserStopTracingParams, metadata?: CallMetadata): Promise<BrowserStopTracingResult>;
} }
export type BrowserCloseEvent = {}; export type BrowserCloseEvent = {};
export type BrowserCloseParams = {}; export type BrowserCloseParams = {};
@ -1329,7 +1332,7 @@ export interface EventTargetEventTarget {
} }
export interface EventTargetChannel extends EventTargetEventTarget, Channel { export interface EventTargetChannel extends EventTargetEventTarget, Channel {
_type_EventTarget: boolean; _type_EventTarget: boolean;
waitForEventInfo(params: EventTargetWaitForEventInfoParams, metadata?: Metadata): Promise<EventTargetWaitForEventInfoResult>; waitForEventInfo(params: EventTargetWaitForEventInfoParams, metadata?: CallMetadata): Promise<EventTargetWaitForEventInfoResult>;
} }
export type EventTargetWaitForEventInfoParams = { export type EventTargetWaitForEventInfoParams = {
info: { info: {
@ -1369,30 +1372,30 @@ export interface BrowserContextEventTarget {
} }
export interface BrowserContextChannel extends BrowserContextEventTarget, EventTargetChannel { export interface BrowserContextChannel extends BrowserContextEventTarget, EventTargetChannel {
_type_BrowserContext: boolean; _type_BrowserContext: boolean;
addCookies(params: BrowserContextAddCookiesParams, metadata?: Metadata): Promise<BrowserContextAddCookiesResult>; addCookies(params: BrowserContextAddCookiesParams, metadata?: CallMetadata): Promise<BrowserContextAddCookiesResult>;
addInitScript(params: BrowserContextAddInitScriptParams, metadata?: Metadata): Promise<BrowserContextAddInitScriptResult>; addInitScript(params: BrowserContextAddInitScriptParams, metadata?: CallMetadata): Promise<BrowserContextAddInitScriptResult>;
clearCookies(params?: BrowserContextClearCookiesParams, metadata?: Metadata): Promise<BrowserContextClearCookiesResult>; clearCookies(params?: BrowserContextClearCookiesParams, metadata?: CallMetadata): Promise<BrowserContextClearCookiesResult>;
clearPermissions(params?: BrowserContextClearPermissionsParams, metadata?: Metadata): Promise<BrowserContextClearPermissionsResult>; clearPermissions(params?: BrowserContextClearPermissionsParams, metadata?: CallMetadata): Promise<BrowserContextClearPermissionsResult>;
close(params?: BrowserContextCloseParams, metadata?: Metadata): Promise<BrowserContextCloseResult>; close(params?: BrowserContextCloseParams, metadata?: CallMetadata): Promise<BrowserContextCloseResult>;
cookies(params: BrowserContextCookiesParams, metadata?: Metadata): Promise<BrowserContextCookiesResult>; cookies(params: BrowserContextCookiesParams, metadata?: CallMetadata): Promise<BrowserContextCookiesResult>;
exposeBinding(params: BrowserContextExposeBindingParams, metadata?: Metadata): Promise<BrowserContextExposeBindingResult>; exposeBinding(params: BrowserContextExposeBindingParams, metadata?: CallMetadata): Promise<BrowserContextExposeBindingResult>;
grantPermissions(params: BrowserContextGrantPermissionsParams, metadata?: Metadata): Promise<BrowserContextGrantPermissionsResult>; grantPermissions(params: BrowserContextGrantPermissionsParams, metadata?: CallMetadata): Promise<BrowserContextGrantPermissionsResult>;
newPage(params?: BrowserContextNewPageParams, metadata?: Metadata): Promise<BrowserContextNewPageResult>; newPage(params?: BrowserContextNewPageParams, metadata?: CallMetadata): Promise<BrowserContextNewPageResult>;
setDefaultNavigationTimeoutNoReply(params: BrowserContextSetDefaultNavigationTimeoutNoReplyParams, metadata?: Metadata): Promise<BrowserContextSetDefaultNavigationTimeoutNoReplyResult>; setDefaultNavigationTimeoutNoReply(params: BrowserContextSetDefaultNavigationTimeoutNoReplyParams, metadata?: CallMetadata): Promise<BrowserContextSetDefaultNavigationTimeoutNoReplyResult>;
setDefaultTimeoutNoReply(params: BrowserContextSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<BrowserContextSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: BrowserContextSetDefaultTimeoutNoReplyParams, metadata?: CallMetadata): Promise<BrowserContextSetDefaultTimeoutNoReplyResult>;
setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, metadata?: Metadata): Promise<BrowserContextSetExtraHTTPHeadersResult>; setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, metadata?: CallMetadata): Promise<BrowserContextSetExtraHTTPHeadersResult>;
setGeolocation(params: BrowserContextSetGeolocationParams, metadata?: Metadata): Promise<BrowserContextSetGeolocationResult>; setGeolocation(params: BrowserContextSetGeolocationParams, metadata?: CallMetadata): Promise<BrowserContextSetGeolocationResult>;
setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, metadata?: Metadata): Promise<BrowserContextSetHTTPCredentialsResult>; setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, metadata?: CallMetadata): Promise<BrowserContextSetHTTPCredentialsResult>;
setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, metadata?: Metadata): Promise<BrowserContextSetNetworkInterceptionPatternsResult>; setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, metadata?: CallMetadata): Promise<BrowserContextSetNetworkInterceptionPatternsResult>;
setOffline(params: BrowserContextSetOfflineParams, metadata?: Metadata): Promise<BrowserContextSetOfflineResult>; setOffline(params: BrowserContextSetOfflineParams, metadata?: CallMetadata): Promise<BrowserContextSetOfflineResult>;
storageState(params?: BrowserContextStorageStateParams, metadata?: Metadata): Promise<BrowserContextStorageStateResult>; storageState(params?: BrowserContextStorageStateParams, metadata?: CallMetadata): Promise<BrowserContextStorageStateResult>;
pause(params?: BrowserContextPauseParams, metadata?: Metadata): Promise<BrowserContextPauseResult>; pause(params?: BrowserContextPauseParams, metadata?: CallMetadata): Promise<BrowserContextPauseResult>;
recorderSupplementEnable(params: BrowserContextRecorderSupplementEnableParams, metadata?: Metadata): Promise<BrowserContextRecorderSupplementEnableResult>; recorderSupplementEnable(params: BrowserContextRecorderSupplementEnableParams, metadata?: CallMetadata): Promise<BrowserContextRecorderSupplementEnableResult>;
newCDPSession(params: BrowserContextNewCDPSessionParams, metadata?: Metadata): Promise<BrowserContextNewCDPSessionResult>; newCDPSession(params: BrowserContextNewCDPSessionParams, metadata?: CallMetadata): Promise<BrowserContextNewCDPSessionResult>;
harStart(params: BrowserContextHarStartParams, metadata?: Metadata): Promise<BrowserContextHarStartResult>; harStart(params: BrowserContextHarStartParams, metadata?: CallMetadata): Promise<BrowserContextHarStartResult>;
harExport(params: BrowserContextHarExportParams, metadata?: Metadata): Promise<BrowserContextHarExportResult>; harExport(params: BrowserContextHarExportParams, metadata?: CallMetadata): Promise<BrowserContextHarExportResult>;
createTempFile(params: BrowserContextCreateTempFileParams, metadata?: Metadata): Promise<BrowserContextCreateTempFileResult>; createTempFile(params: BrowserContextCreateTempFileParams, metadata?: CallMetadata): Promise<BrowserContextCreateTempFileResult>;
updateSubscription(params: BrowserContextUpdateSubscriptionParams, metadata?: Metadata): Promise<BrowserContextUpdateSubscriptionResult>; updateSubscription(params: BrowserContextUpdateSubscriptionParams, metadata?: CallMetadata): Promise<BrowserContextUpdateSubscriptionResult>;
} }
export type BrowserContextBindingCallEvent = { export type BrowserContextBindingCallEvent = {
binding: BindingCallChannel, binding: BindingCallChannel,
@ -1677,39 +1680,39 @@ export interface PageEventTarget {
} }
export interface PageChannel extends PageEventTarget, EventTargetChannel { export interface PageChannel extends PageEventTarget, EventTargetChannel {
_type_Page: boolean; _type_Page: boolean;
setDefaultNavigationTimeoutNoReply(params: PageSetDefaultNavigationTimeoutNoReplyParams, metadata?: Metadata): Promise<PageSetDefaultNavigationTimeoutNoReplyResult>; setDefaultNavigationTimeoutNoReply(params: PageSetDefaultNavigationTimeoutNoReplyParams, metadata?: CallMetadata): Promise<PageSetDefaultNavigationTimeoutNoReplyResult>;
setDefaultTimeoutNoReply(params: PageSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<PageSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: PageSetDefaultTimeoutNoReplyParams, metadata?: CallMetadata): Promise<PageSetDefaultTimeoutNoReplyResult>;
addInitScript(params: PageAddInitScriptParams, metadata?: Metadata): Promise<PageAddInitScriptResult>; addInitScript(params: PageAddInitScriptParams, metadata?: CallMetadata): Promise<PageAddInitScriptResult>;
close(params: PageCloseParams, metadata?: Metadata): Promise<PageCloseResult>; close(params: PageCloseParams, metadata?: CallMetadata): Promise<PageCloseResult>;
emulateMedia(params: PageEmulateMediaParams, metadata?: Metadata): Promise<PageEmulateMediaResult>; emulateMedia(params: PageEmulateMediaParams, metadata?: CallMetadata): Promise<PageEmulateMediaResult>;
exposeBinding(params: PageExposeBindingParams, metadata?: Metadata): Promise<PageExposeBindingResult>; exposeBinding(params: PageExposeBindingParams, metadata?: CallMetadata): Promise<PageExposeBindingResult>;
goBack(params: PageGoBackParams, metadata?: Metadata): Promise<PageGoBackResult>; goBack(params: PageGoBackParams, metadata?: CallMetadata): Promise<PageGoBackResult>;
goForward(params: PageGoForwardParams, metadata?: Metadata): Promise<PageGoForwardResult>; goForward(params: PageGoForwardParams, metadata?: CallMetadata): Promise<PageGoForwardResult>;
reload(params: PageReloadParams, metadata?: Metadata): Promise<PageReloadResult>; reload(params: PageReloadParams, metadata?: CallMetadata): Promise<PageReloadResult>;
expectScreenshot(params: PageExpectScreenshotParams, metadata?: Metadata): Promise<PageExpectScreenshotResult>; expectScreenshot(params: PageExpectScreenshotParams, metadata?: CallMetadata): Promise<PageExpectScreenshotResult>;
screenshot(params: PageScreenshotParams, metadata?: Metadata): Promise<PageScreenshotResult>; screenshot(params: PageScreenshotParams, metadata?: CallMetadata): Promise<PageScreenshotResult>;
setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, metadata?: Metadata): Promise<PageSetExtraHTTPHeadersResult>; setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, metadata?: CallMetadata): Promise<PageSetExtraHTTPHeadersResult>;
setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, metadata?: Metadata): Promise<PageSetNetworkInterceptionPatternsResult>; setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, metadata?: CallMetadata): Promise<PageSetNetworkInterceptionPatternsResult>;
setViewportSize(params: PageSetViewportSizeParams, metadata?: Metadata): Promise<PageSetViewportSizeResult>; setViewportSize(params: PageSetViewportSizeParams, metadata?: CallMetadata): Promise<PageSetViewportSizeResult>;
keyboardDown(params: PageKeyboardDownParams, metadata?: Metadata): Promise<PageKeyboardDownResult>; keyboardDown(params: PageKeyboardDownParams, metadata?: CallMetadata): Promise<PageKeyboardDownResult>;
keyboardUp(params: PageKeyboardUpParams, metadata?: Metadata): Promise<PageKeyboardUpResult>; keyboardUp(params: PageKeyboardUpParams, metadata?: CallMetadata): Promise<PageKeyboardUpResult>;
keyboardInsertText(params: PageKeyboardInsertTextParams, metadata?: Metadata): Promise<PageKeyboardInsertTextResult>; keyboardInsertText(params: PageKeyboardInsertTextParams, metadata?: CallMetadata): Promise<PageKeyboardInsertTextResult>;
keyboardType(params: PageKeyboardTypeParams, metadata?: Metadata): Promise<PageKeyboardTypeResult>; keyboardType(params: PageKeyboardTypeParams, metadata?: CallMetadata): Promise<PageKeyboardTypeResult>;
keyboardPress(params: PageKeyboardPressParams, metadata?: Metadata): Promise<PageKeyboardPressResult>; keyboardPress(params: PageKeyboardPressParams, metadata?: CallMetadata): Promise<PageKeyboardPressResult>;
mouseMove(params: PageMouseMoveParams, metadata?: Metadata): Promise<PageMouseMoveResult>; mouseMove(params: PageMouseMoveParams, metadata?: CallMetadata): Promise<PageMouseMoveResult>;
mouseDown(params: PageMouseDownParams, metadata?: Metadata): Promise<PageMouseDownResult>; mouseDown(params: PageMouseDownParams, metadata?: CallMetadata): Promise<PageMouseDownResult>;
mouseUp(params: PageMouseUpParams, metadata?: Metadata): Promise<PageMouseUpResult>; mouseUp(params: PageMouseUpParams, metadata?: CallMetadata): Promise<PageMouseUpResult>;
mouseClick(params: PageMouseClickParams, metadata?: Metadata): Promise<PageMouseClickResult>; mouseClick(params: PageMouseClickParams, metadata?: CallMetadata): Promise<PageMouseClickResult>;
mouseWheel(params: PageMouseWheelParams, metadata?: Metadata): Promise<PageMouseWheelResult>; mouseWheel(params: PageMouseWheelParams, metadata?: CallMetadata): Promise<PageMouseWheelResult>;
touchscreenTap(params: PageTouchscreenTapParams, metadata?: Metadata): Promise<PageTouchscreenTapResult>; touchscreenTap(params: PageTouchscreenTapParams, metadata?: CallMetadata): Promise<PageTouchscreenTapResult>;
accessibilitySnapshot(params: PageAccessibilitySnapshotParams, metadata?: Metadata): Promise<PageAccessibilitySnapshotResult>; accessibilitySnapshot(params: PageAccessibilitySnapshotParams, metadata?: CallMetadata): Promise<PageAccessibilitySnapshotResult>;
pdf(params: PagePdfParams, metadata?: Metadata): Promise<PagePdfResult>; pdf(params: PagePdfParams, metadata?: CallMetadata): Promise<PagePdfResult>;
startJSCoverage(params: PageStartJSCoverageParams, metadata?: Metadata): Promise<PageStartJSCoverageResult>; startJSCoverage(params: PageStartJSCoverageParams, metadata?: CallMetadata): Promise<PageStartJSCoverageResult>;
stopJSCoverage(params?: PageStopJSCoverageParams, metadata?: Metadata): Promise<PageStopJSCoverageResult>; stopJSCoverage(params?: PageStopJSCoverageParams, metadata?: CallMetadata): Promise<PageStopJSCoverageResult>;
startCSSCoverage(params: PageStartCSSCoverageParams, metadata?: Metadata): Promise<PageStartCSSCoverageResult>; startCSSCoverage(params: PageStartCSSCoverageParams, metadata?: CallMetadata): Promise<PageStartCSSCoverageResult>;
stopCSSCoverage(params?: PageStopCSSCoverageParams, metadata?: Metadata): Promise<PageStopCSSCoverageResult>; stopCSSCoverage(params?: PageStopCSSCoverageParams, metadata?: CallMetadata): Promise<PageStopCSSCoverageResult>;
bringToFront(params?: PageBringToFrontParams, metadata?: Metadata): Promise<PageBringToFrontResult>; bringToFront(params?: PageBringToFrontParams, metadata?: CallMetadata): Promise<PageBringToFrontResult>;
updateSubscription(params: PageUpdateSubscriptionParams, metadata?: Metadata): Promise<PageUpdateSubscriptionResult>; updateSubscription(params: PageUpdateSubscriptionParams, metadata?: CallMetadata): Promise<PageUpdateSubscriptionResult>;
} }
export type PageBindingCallEvent = { export type PageBindingCallEvent = {
binding: BindingCallChannel, binding: BindingCallChannel,
@ -2188,52 +2191,52 @@ export interface FrameEventTarget {
} }
export interface FrameChannel extends FrameEventTarget, Channel { export interface FrameChannel extends FrameEventTarget, Channel {
_type_Frame: boolean; _type_Frame: boolean;
evalOnSelector(params: FrameEvalOnSelectorParams, metadata?: Metadata): Promise<FrameEvalOnSelectorResult>; evalOnSelector(params: FrameEvalOnSelectorParams, metadata?: CallMetadata): Promise<FrameEvalOnSelectorResult>;
evalOnSelectorAll(params: FrameEvalOnSelectorAllParams, metadata?: Metadata): Promise<FrameEvalOnSelectorAllResult>; evalOnSelectorAll(params: FrameEvalOnSelectorAllParams, metadata?: CallMetadata): Promise<FrameEvalOnSelectorAllResult>;
addScriptTag(params: FrameAddScriptTagParams, metadata?: Metadata): Promise<FrameAddScriptTagResult>; addScriptTag(params: FrameAddScriptTagParams, metadata?: CallMetadata): Promise<FrameAddScriptTagResult>;
addStyleTag(params: FrameAddStyleTagParams, metadata?: Metadata): Promise<FrameAddStyleTagResult>; addStyleTag(params: FrameAddStyleTagParams, metadata?: CallMetadata): Promise<FrameAddStyleTagResult>;
blur(params: FrameBlurParams, metadata?: Metadata): Promise<FrameBlurResult>; blur(params: FrameBlurParams, metadata?: CallMetadata): Promise<FrameBlurResult>;
check(params: FrameCheckParams, metadata?: Metadata): Promise<FrameCheckResult>; check(params: FrameCheckParams, metadata?: CallMetadata): Promise<FrameCheckResult>;
click(params: FrameClickParams, metadata?: Metadata): Promise<FrameClickResult>; click(params: FrameClickParams, metadata?: CallMetadata): Promise<FrameClickResult>;
content(params?: FrameContentParams, metadata?: Metadata): Promise<FrameContentResult>; content(params?: FrameContentParams, metadata?: CallMetadata): Promise<FrameContentResult>;
dragAndDrop(params: FrameDragAndDropParams, metadata?: Metadata): Promise<FrameDragAndDropResult>; dragAndDrop(params: FrameDragAndDropParams, metadata?: CallMetadata): Promise<FrameDragAndDropResult>;
dblclick(params: FrameDblclickParams, metadata?: Metadata): Promise<FrameDblclickResult>; dblclick(params: FrameDblclickParams, metadata?: CallMetadata): Promise<FrameDblclickResult>;
dispatchEvent(params: FrameDispatchEventParams, metadata?: Metadata): Promise<FrameDispatchEventResult>; dispatchEvent(params: FrameDispatchEventParams, metadata?: CallMetadata): Promise<FrameDispatchEventResult>;
evaluateExpression(params: FrameEvaluateExpressionParams, metadata?: Metadata): Promise<FrameEvaluateExpressionResult>; evaluateExpression(params: FrameEvaluateExpressionParams, metadata?: CallMetadata): Promise<FrameEvaluateExpressionResult>;
evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams, metadata?: Metadata): Promise<FrameEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams, metadata?: CallMetadata): Promise<FrameEvaluateExpressionHandleResult>;
fill(params: FrameFillParams, metadata?: Metadata): Promise<FrameFillResult>; fill(params: FrameFillParams, metadata?: CallMetadata): Promise<FrameFillResult>;
focus(params: FrameFocusParams, metadata?: Metadata): Promise<FrameFocusResult>; focus(params: FrameFocusParams, metadata?: CallMetadata): Promise<FrameFocusResult>;
frameElement(params?: FrameFrameElementParams, metadata?: Metadata): Promise<FrameFrameElementResult>; frameElement(params?: FrameFrameElementParams, metadata?: CallMetadata): Promise<FrameFrameElementResult>;
highlight(params: FrameHighlightParams, metadata?: Metadata): Promise<FrameHighlightResult>; highlight(params: FrameHighlightParams, metadata?: CallMetadata): Promise<FrameHighlightResult>;
getAttribute(params: FrameGetAttributeParams, metadata?: Metadata): Promise<FrameGetAttributeResult>; getAttribute(params: FrameGetAttributeParams, metadata?: CallMetadata): Promise<FrameGetAttributeResult>;
goto(params: FrameGotoParams, metadata?: Metadata): Promise<FrameGotoResult>; goto(params: FrameGotoParams, metadata?: CallMetadata): Promise<FrameGotoResult>;
hover(params: FrameHoverParams, metadata?: Metadata): Promise<FrameHoverResult>; hover(params: FrameHoverParams, metadata?: CallMetadata): Promise<FrameHoverResult>;
innerHTML(params: FrameInnerHTMLParams, metadata?: Metadata): Promise<FrameInnerHTMLResult>; innerHTML(params: FrameInnerHTMLParams, metadata?: CallMetadata): Promise<FrameInnerHTMLResult>;
innerText(params: FrameInnerTextParams, metadata?: Metadata): Promise<FrameInnerTextResult>; innerText(params: FrameInnerTextParams, metadata?: CallMetadata): Promise<FrameInnerTextResult>;
inputValue(params: FrameInputValueParams, metadata?: Metadata): Promise<FrameInputValueResult>; inputValue(params: FrameInputValueParams, metadata?: CallMetadata): Promise<FrameInputValueResult>;
isChecked(params: FrameIsCheckedParams, metadata?: Metadata): Promise<FrameIsCheckedResult>; isChecked(params: FrameIsCheckedParams, metadata?: CallMetadata): Promise<FrameIsCheckedResult>;
isDisabled(params: FrameIsDisabledParams, metadata?: Metadata): Promise<FrameIsDisabledResult>; isDisabled(params: FrameIsDisabledParams, metadata?: CallMetadata): Promise<FrameIsDisabledResult>;
isEnabled(params: FrameIsEnabledParams, metadata?: Metadata): Promise<FrameIsEnabledResult>; isEnabled(params: FrameIsEnabledParams, metadata?: CallMetadata): Promise<FrameIsEnabledResult>;
isHidden(params: FrameIsHiddenParams, metadata?: Metadata): Promise<FrameIsHiddenResult>; isHidden(params: FrameIsHiddenParams, metadata?: CallMetadata): Promise<FrameIsHiddenResult>;
isVisible(params: FrameIsVisibleParams, metadata?: Metadata): Promise<FrameIsVisibleResult>; isVisible(params: FrameIsVisibleParams, metadata?: CallMetadata): Promise<FrameIsVisibleResult>;
isEditable(params: FrameIsEditableParams, metadata?: Metadata): Promise<FrameIsEditableResult>; isEditable(params: FrameIsEditableParams, metadata?: CallMetadata): Promise<FrameIsEditableResult>;
press(params: FramePressParams, metadata?: Metadata): Promise<FramePressResult>; press(params: FramePressParams, metadata?: CallMetadata): Promise<FramePressResult>;
querySelector(params: FrameQuerySelectorParams, metadata?: Metadata): Promise<FrameQuerySelectorResult>; querySelector(params: FrameQuerySelectorParams, metadata?: CallMetadata): Promise<FrameQuerySelectorResult>;
querySelectorAll(params: FrameQuerySelectorAllParams, metadata?: Metadata): Promise<FrameQuerySelectorAllResult>; querySelectorAll(params: FrameQuerySelectorAllParams, metadata?: CallMetadata): Promise<FrameQuerySelectorAllResult>;
queryCount(params: FrameQueryCountParams, metadata?: Metadata): Promise<FrameQueryCountResult>; queryCount(params: FrameQueryCountParams, metadata?: CallMetadata): Promise<FrameQueryCountResult>;
selectOption(params: FrameSelectOptionParams, metadata?: Metadata): Promise<FrameSelectOptionResult>; selectOption(params: FrameSelectOptionParams, metadata?: CallMetadata): Promise<FrameSelectOptionResult>;
setContent(params: FrameSetContentParams, metadata?: Metadata): Promise<FrameSetContentResult>; setContent(params: FrameSetContentParams, metadata?: CallMetadata): Promise<FrameSetContentResult>;
setInputFiles(params: FrameSetInputFilesParams, metadata?: Metadata): Promise<FrameSetInputFilesResult>; setInputFiles(params: FrameSetInputFilesParams, metadata?: CallMetadata): Promise<FrameSetInputFilesResult>;
setInputFilePaths(params: FrameSetInputFilePathsParams, metadata?: Metadata): Promise<FrameSetInputFilePathsResult>; setInputFilePaths(params: FrameSetInputFilePathsParams, metadata?: CallMetadata): Promise<FrameSetInputFilePathsResult>;
tap(params: FrameTapParams, metadata?: Metadata): Promise<FrameTapResult>; tap(params: FrameTapParams, metadata?: CallMetadata): Promise<FrameTapResult>;
textContent(params: FrameTextContentParams, metadata?: Metadata): Promise<FrameTextContentResult>; textContent(params: FrameTextContentParams, metadata?: CallMetadata): Promise<FrameTextContentResult>;
title(params?: FrameTitleParams, metadata?: Metadata): Promise<FrameTitleResult>; title(params?: FrameTitleParams, metadata?: CallMetadata): Promise<FrameTitleResult>;
type(params: FrameTypeParams, metadata?: Metadata): Promise<FrameTypeResult>; type(params: FrameTypeParams, metadata?: CallMetadata): Promise<FrameTypeResult>;
uncheck(params: FrameUncheckParams, metadata?: Metadata): Promise<FrameUncheckResult>; uncheck(params: FrameUncheckParams, metadata?: CallMetadata): Promise<FrameUncheckResult>;
waitForTimeout(params: FrameWaitForTimeoutParams, metadata?: Metadata): Promise<FrameWaitForTimeoutResult>; waitForTimeout(params: FrameWaitForTimeoutParams, metadata?: CallMetadata): Promise<FrameWaitForTimeoutResult>;
waitForFunction(params: FrameWaitForFunctionParams, metadata?: Metadata): Promise<FrameWaitForFunctionResult>; waitForFunction(params: FrameWaitForFunctionParams, metadata?: CallMetadata): Promise<FrameWaitForFunctionResult>;
waitForSelector(params: FrameWaitForSelectorParams, metadata?: Metadata): Promise<FrameWaitForSelectorResult>; waitForSelector(params: FrameWaitForSelectorParams, metadata?: CallMetadata): Promise<FrameWaitForSelectorResult>;
expect(params: FrameExpectParams, metadata?: Metadata): Promise<FrameExpectResult>; expect(params: FrameExpectParams, metadata?: CallMetadata): Promise<FrameExpectResult>;
} }
export type FrameLoadstateEvent = { export type FrameLoadstateEvent = {
add?: LifecycleEvent, add?: LifecycleEvent,
@ -2889,8 +2892,8 @@ export interface WorkerEventTarget {
} }
export interface WorkerChannel extends WorkerEventTarget, Channel { export interface WorkerChannel extends WorkerEventTarget, Channel {
_type_Worker: boolean; _type_Worker: boolean;
evaluateExpression(params: WorkerEvaluateExpressionParams, metadata?: Metadata): Promise<WorkerEvaluateExpressionResult>; evaluateExpression(params: WorkerEvaluateExpressionParams, metadata?: CallMetadata): Promise<WorkerEvaluateExpressionResult>;
evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, metadata?: Metadata): Promise<WorkerEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, metadata?: CallMetadata): Promise<WorkerEvaluateExpressionHandleResult>;
} }
export type WorkerCloseEvent = {}; export type WorkerCloseEvent = {};
export type WorkerEvaluateExpressionParams = { export type WorkerEvaluateExpressionParams = {
@ -2929,12 +2932,12 @@ export interface JSHandleEventTarget {
} }
export interface JSHandleChannel extends JSHandleEventTarget, Channel { export interface JSHandleChannel extends JSHandleEventTarget, Channel {
_type_JSHandle: boolean; _type_JSHandle: boolean;
dispose(params?: JSHandleDisposeParams, metadata?: Metadata): Promise<JSHandleDisposeResult>; dispose(params?: JSHandleDisposeParams, metadata?: CallMetadata): Promise<JSHandleDisposeResult>;
evaluateExpression(params: JSHandleEvaluateExpressionParams, metadata?: Metadata): Promise<JSHandleEvaluateExpressionResult>; evaluateExpression(params: JSHandleEvaluateExpressionParams, metadata?: CallMetadata): Promise<JSHandleEvaluateExpressionResult>;
evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams, metadata?: Metadata): Promise<JSHandleEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams, metadata?: CallMetadata): Promise<JSHandleEvaluateExpressionHandleResult>;
getPropertyList(params?: JSHandleGetPropertyListParams, metadata?: Metadata): Promise<JSHandleGetPropertyListResult>; getPropertyList(params?: JSHandleGetPropertyListParams, metadata?: CallMetadata): Promise<JSHandleGetPropertyListResult>;
getProperty(params: JSHandleGetPropertyParams, metadata?: Metadata): Promise<JSHandleGetPropertyResult>; getProperty(params: JSHandleGetPropertyParams, metadata?: CallMetadata): Promise<JSHandleGetPropertyResult>;
jsonValue(params?: JSHandleJsonValueParams, metadata?: Metadata): Promise<JSHandleJsonValueResult>; jsonValue(params?: JSHandleJsonValueParams, metadata?: CallMetadata): Promise<JSHandleJsonValueResult>;
} }
export type JSHandlePreviewUpdatedEvent = { export type JSHandlePreviewUpdatedEvent = {
preview: string, preview: string,
@ -2997,43 +3000,43 @@ export interface ElementHandleEventTarget {
} }
export interface ElementHandleChannel extends ElementHandleEventTarget, JSHandleChannel { export interface ElementHandleChannel extends ElementHandleEventTarget, JSHandleChannel {
_type_ElementHandle: boolean; _type_ElementHandle: boolean;
evalOnSelector(params: ElementHandleEvalOnSelectorParams, metadata?: Metadata): Promise<ElementHandleEvalOnSelectorResult>; evalOnSelector(params: ElementHandleEvalOnSelectorParams, metadata?: CallMetadata): Promise<ElementHandleEvalOnSelectorResult>;
evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams, metadata?: Metadata): Promise<ElementHandleEvalOnSelectorAllResult>; evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams, metadata?: CallMetadata): Promise<ElementHandleEvalOnSelectorAllResult>;
boundingBox(params?: ElementHandleBoundingBoxParams, metadata?: Metadata): Promise<ElementHandleBoundingBoxResult>; boundingBox(params?: ElementHandleBoundingBoxParams, metadata?: CallMetadata): Promise<ElementHandleBoundingBoxResult>;
check(params: ElementHandleCheckParams, metadata?: Metadata): Promise<ElementHandleCheckResult>; check(params: ElementHandleCheckParams, metadata?: CallMetadata): Promise<ElementHandleCheckResult>;
click(params: ElementHandleClickParams, metadata?: Metadata): Promise<ElementHandleClickResult>; click(params: ElementHandleClickParams, metadata?: CallMetadata): Promise<ElementHandleClickResult>;
contentFrame(params?: ElementHandleContentFrameParams, metadata?: Metadata): Promise<ElementHandleContentFrameResult>; contentFrame(params?: ElementHandleContentFrameParams, metadata?: CallMetadata): Promise<ElementHandleContentFrameResult>;
dblclick(params: ElementHandleDblclickParams, metadata?: Metadata): Promise<ElementHandleDblclickResult>; dblclick(params: ElementHandleDblclickParams, metadata?: CallMetadata): Promise<ElementHandleDblclickResult>;
dispatchEvent(params: ElementHandleDispatchEventParams, metadata?: Metadata): Promise<ElementHandleDispatchEventResult>; dispatchEvent(params: ElementHandleDispatchEventParams, metadata?: CallMetadata): Promise<ElementHandleDispatchEventResult>;
fill(params: ElementHandleFillParams, metadata?: Metadata): Promise<ElementHandleFillResult>; fill(params: ElementHandleFillParams, metadata?: CallMetadata): Promise<ElementHandleFillResult>;
focus(params?: ElementHandleFocusParams, metadata?: Metadata): Promise<ElementHandleFocusResult>; focus(params?: ElementHandleFocusParams, metadata?: CallMetadata): Promise<ElementHandleFocusResult>;
getAttribute(params: ElementHandleGetAttributeParams, metadata?: Metadata): Promise<ElementHandleGetAttributeResult>; getAttribute(params: ElementHandleGetAttributeParams, metadata?: CallMetadata): Promise<ElementHandleGetAttributeResult>;
hover(params: ElementHandleHoverParams, metadata?: Metadata): Promise<ElementHandleHoverResult>; hover(params: ElementHandleHoverParams, metadata?: CallMetadata): Promise<ElementHandleHoverResult>;
innerHTML(params?: ElementHandleInnerHTMLParams, metadata?: Metadata): Promise<ElementHandleInnerHTMLResult>; innerHTML(params?: ElementHandleInnerHTMLParams, metadata?: CallMetadata): Promise<ElementHandleInnerHTMLResult>;
innerText(params?: ElementHandleInnerTextParams, metadata?: Metadata): Promise<ElementHandleInnerTextResult>; innerText(params?: ElementHandleInnerTextParams, metadata?: CallMetadata): Promise<ElementHandleInnerTextResult>;
inputValue(params?: ElementHandleInputValueParams, metadata?: Metadata): Promise<ElementHandleInputValueResult>; inputValue(params?: ElementHandleInputValueParams, metadata?: CallMetadata): Promise<ElementHandleInputValueResult>;
isChecked(params?: ElementHandleIsCheckedParams, metadata?: Metadata): Promise<ElementHandleIsCheckedResult>; isChecked(params?: ElementHandleIsCheckedParams, metadata?: CallMetadata): Promise<ElementHandleIsCheckedResult>;
isDisabled(params?: ElementHandleIsDisabledParams, metadata?: Metadata): Promise<ElementHandleIsDisabledResult>; isDisabled(params?: ElementHandleIsDisabledParams, metadata?: CallMetadata): Promise<ElementHandleIsDisabledResult>;
isEditable(params?: ElementHandleIsEditableParams, metadata?: Metadata): Promise<ElementHandleIsEditableResult>; isEditable(params?: ElementHandleIsEditableParams, metadata?: CallMetadata): Promise<ElementHandleIsEditableResult>;
isEnabled(params?: ElementHandleIsEnabledParams, metadata?: Metadata): Promise<ElementHandleIsEnabledResult>; isEnabled(params?: ElementHandleIsEnabledParams, metadata?: CallMetadata): Promise<ElementHandleIsEnabledResult>;
isHidden(params?: ElementHandleIsHiddenParams, metadata?: Metadata): Promise<ElementHandleIsHiddenResult>; isHidden(params?: ElementHandleIsHiddenParams, metadata?: CallMetadata): Promise<ElementHandleIsHiddenResult>;
isVisible(params?: ElementHandleIsVisibleParams, metadata?: Metadata): Promise<ElementHandleIsVisibleResult>; isVisible(params?: ElementHandleIsVisibleParams, metadata?: CallMetadata): Promise<ElementHandleIsVisibleResult>;
ownerFrame(params?: ElementHandleOwnerFrameParams, metadata?: Metadata): Promise<ElementHandleOwnerFrameResult>; ownerFrame(params?: ElementHandleOwnerFrameParams, metadata?: CallMetadata): Promise<ElementHandleOwnerFrameResult>;
press(params: ElementHandlePressParams, metadata?: Metadata): Promise<ElementHandlePressResult>; press(params: ElementHandlePressParams, metadata?: CallMetadata): Promise<ElementHandlePressResult>;
querySelector(params: ElementHandleQuerySelectorParams, metadata?: Metadata): Promise<ElementHandleQuerySelectorResult>; querySelector(params: ElementHandleQuerySelectorParams, metadata?: CallMetadata): Promise<ElementHandleQuerySelectorResult>;
querySelectorAll(params: ElementHandleQuerySelectorAllParams, metadata?: Metadata): Promise<ElementHandleQuerySelectorAllResult>; querySelectorAll(params: ElementHandleQuerySelectorAllParams, metadata?: CallMetadata): Promise<ElementHandleQuerySelectorAllResult>;
screenshot(params: ElementHandleScreenshotParams, metadata?: Metadata): Promise<ElementHandleScreenshotResult>; screenshot(params: ElementHandleScreenshotParams, metadata?: CallMetadata): Promise<ElementHandleScreenshotResult>;
scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams, metadata?: Metadata): Promise<ElementHandleScrollIntoViewIfNeededResult>; scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams, metadata?: CallMetadata): Promise<ElementHandleScrollIntoViewIfNeededResult>;
selectOption(params: ElementHandleSelectOptionParams, metadata?: Metadata): Promise<ElementHandleSelectOptionResult>; selectOption(params: ElementHandleSelectOptionParams, metadata?: CallMetadata): Promise<ElementHandleSelectOptionResult>;
selectText(params: ElementHandleSelectTextParams, metadata?: Metadata): Promise<ElementHandleSelectTextResult>; selectText(params: ElementHandleSelectTextParams, metadata?: CallMetadata): Promise<ElementHandleSelectTextResult>;
setInputFiles(params: ElementHandleSetInputFilesParams, metadata?: Metadata): Promise<ElementHandleSetInputFilesResult>; setInputFiles(params: ElementHandleSetInputFilesParams, metadata?: CallMetadata): Promise<ElementHandleSetInputFilesResult>;
setInputFilePaths(params: ElementHandleSetInputFilePathsParams, metadata?: Metadata): Promise<ElementHandleSetInputFilePathsResult>; setInputFilePaths(params: ElementHandleSetInputFilePathsParams, metadata?: CallMetadata): Promise<ElementHandleSetInputFilePathsResult>;
tap(params: ElementHandleTapParams, metadata?: Metadata): Promise<ElementHandleTapResult>; tap(params: ElementHandleTapParams, metadata?: CallMetadata): Promise<ElementHandleTapResult>;
textContent(params?: ElementHandleTextContentParams, metadata?: Metadata): Promise<ElementHandleTextContentResult>; textContent(params?: ElementHandleTextContentParams, metadata?: CallMetadata): Promise<ElementHandleTextContentResult>;
type(params: ElementHandleTypeParams, metadata?: Metadata): Promise<ElementHandleTypeResult>; type(params: ElementHandleTypeParams, metadata?: CallMetadata): Promise<ElementHandleTypeResult>;
uncheck(params: ElementHandleUncheckParams, metadata?: Metadata): Promise<ElementHandleUncheckResult>; uncheck(params: ElementHandleUncheckParams, metadata?: CallMetadata): Promise<ElementHandleUncheckResult>;
waitForElementState(params: ElementHandleWaitForElementStateParams, metadata?: Metadata): Promise<ElementHandleWaitForElementStateResult>; waitForElementState(params: ElementHandleWaitForElementStateParams, metadata?: CallMetadata): Promise<ElementHandleWaitForElementStateResult>;
waitForSelector(params: ElementHandleWaitForSelectorParams, metadata?: Metadata): Promise<ElementHandleWaitForSelectorResult>; waitForSelector(params: ElementHandleWaitForSelectorParams, metadata?: CallMetadata): Promise<ElementHandleWaitForSelectorResult>;
} }
export type ElementHandleEvalOnSelectorParams = { export type ElementHandleEvalOnSelectorParams = {
selector: string, selector: string,
@ -3450,8 +3453,8 @@ export interface RequestEventTarget {
} }
export interface RequestChannel extends RequestEventTarget, Channel { export interface RequestChannel extends RequestEventTarget, Channel {
_type_Request: boolean; _type_Request: boolean;
response(params?: RequestResponseParams, metadata?: Metadata): Promise<RequestResponseResult>; response(params?: RequestResponseParams, metadata?: CallMetadata): Promise<RequestResponseResult>;
rawRequestHeaders(params?: RequestRawRequestHeadersParams, metadata?: Metadata): Promise<RequestRawRequestHeadersResult>; rawRequestHeaders(params?: RequestRawRequestHeadersParams, metadata?: CallMetadata): Promise<RequestRawRequestHeadersResult>;
} }
export type RequestResponseParams = {}; export type RequestResponseParams = {};
export type RequestResponseOptions = {}; export type RequestResponseOptions = {};
@ -3475,10 +3478,10 @@ export interface RouteEventTarget {
} }
export interface RouteChannel extends RouteEventTarget, Channel { export interface RouteChannel extends RouteEventTarget, Channel {
_type_Route: boolean; _type_Route: boolean;
redirectNavigationRequest(params: RouteRedirectNavigationRequestParams, metadata?: Metadata): Promise<RouteRedirectNavigationRequestResult>; redirectNavigationRequest(params: RouteRedirectNavigationRequestParams, metadata?: CallMetadata): Promise<RouteRedirectNavigationRequestResult>;
abort(params: RouteAbortParams, metadata?: Metadata): Promise<RouteAbortResult>; abort(params: RouteAbortParams, metadata?: CallMetadata): Promise<RouteAbortResult>;
continue(params: RouteContinueParams, metadata?: Metadata): Promise<RouteContinueResult>; continue(params: RouteContinueParams, metadata?: CallMetadata): Promise<RouteContinueResult>;
fulfill(params: RouteFulfillParams, metadata?: Metadata): Promise<RouteFulfillResult>; fulfill(params: RouteFulfillParams, metadata?: CallMetadata): Promise<RouteFulfillResult>;
} }
export type RouteRedirectNavigationRequestParams = { export type RouteRedirectNavigationRequestParams = {
url: string, url: string,
@ -3551,11 +3554,11 @@ export interface ResponseEventTarget {
} }
export interface ResponseChannel extends ResponseEventTarget, Channel { export interface ResponseChannel extends ResponseEventTarget, Channel {
_type_Response: boolean; _type_Response: boolean;
body(params?: ResponseBodyParams, metadata?: Metadata): Promise<ResponseBodyResult>; body(params?: ResponseBodyParams, metadata?: CallMetadata): Promise<ResponseBodyResult>;
securityDetails(params?: ResponseSecurityDetailsParams, metadata?: Metadata): Promise<ResponseSecurityDetailsResult>; securityDetails(params?: ResponseSecurityDetailsParams, metadata?: CallMetadata): Promise<ResponseSecurityDetailsResult>;
serverAddr(params?: ResponseServerAddrParams, metadata?: Metadata): Promise<ResponseServerAddrResult>; serverAddr(params?: ResponseServerAddrParams, metadata?: CallMetadata): Promise<ResponseServerAddrResult>;
rawResponseHeaders(params?: ResponseRawResponseHeadersParams, metadata?: Metadata): Promise<ResponseRawResponseHeadersResult>; rawResponseHeaders(params?: ResponseRawResponseHeadersParams, metadata?: CallMetadata): Promise<ResponseRawResponseHeadersResult>;
sizes(params?: ResponseSizesParams, metadata?: Metadata): Promise<ResponseSizesResult>; sizes(params?: ResponseSizesParams, metadata?: CallMetadata): Promise<ResponseSizesResult>;
} }
export type ResponseBodyParams = {}; export type ResponseBodyParams = {};
export type ResponseBodyOptions = {}; export type ResponseBodyOptions = {};
@ -3673,8 +3676,8 @@ export interface BindingCallEventTarget {
} }
export interface BindingCallChannel extends BindingCallEventTarget, Channel { export interface BindingCallChannel extends BindingCallEventTarget, Channel {
_type_BindingCall: boolean; _type_BindingCall: boolean;
reject(params: BindingCallRejectParams, metadata?: Metadata): Promise<BindingCallRejectResult>; reject(params: BindingCallRejectParams, metadata?: CallMetadata): Promise<BindingCallRejectResult>;
resolve(params: BindingCallResolveParams, metadata?: Metadata): Promise<BindingCallResolveResult>; resolve(params: BindingCallResolveParams, metadata?: CallMetadata): Promise<BindingCallResolveResult>;
} }
export type BindingCallRejectParams = { export type BindingCallRejectParams = {
error: SerializedError, error: SerializedError,
@ -3704,8 +3707,8 @@ export interface DialogEventTarget {
} }
export interface DialogChannel extends DialogEventTarget, Channel { export interface DialogChannel extends DialogEventTarget, Channel {
_type_Dialog: boolean; _type_Dialog: boolean;
accept(params: DialogAcceptParams, metadata?: Metadata): Promise<DialogAcceptResult>; accept(params: DialogAcceptParams, metadata?: CallMetadata): Promise<DialogAcceptResult>;
dismiss(params?: DialogDismissParams, metadata?: Metadata): Promise<DialogDismissResult>; dismiss(params?: DialogDismissParams, metadata?: CallMetadata): Promise<DialogDismissResult>;
} }
export type DialogAcceptParams = { export type DialogAcceptParams = {
promptText?: string, promptText?: string,
@ -3727,10 +3730,10 @@ export interface TracingEventTarget {
} }
export interface TracingChannel extends TracingEventTarget, Channel { export interface TracingChannel extends TracingEventTarget, Channel {
_type_Tracing: boolean; _type_Tracing: boolean;
tracingStart(params: TracingTracingStartParams, metadata?: Metadata): Promise<TracingTracingStartResult>; tracingStart(params: TracingTracingStartParams, metadata?: CallMetadata): Promise<TracingTracingStartResult>;
tracingStartChunk(params: TracingTracingStartChunkParams, metadata?: Metadata): Promise<TracingTracingStartChunkResult>; tracingStartChunk(params: TracingTracingStartChunkParams, metadata?: CallMetadata): Promise<TracingTracingStartChunkResult>;
tracingStopChunk(params: TracingTracingStopChunkParams, metadata?: Metadata): Promise<TracingTracingStopChunkResult>; tracingStopChunk(params: TracingTracingStopChunkParams, metadata?: CallMetadata): Promise<TracingTracingStopChunkResult>;
tracingStop(params?: TracingTracingStopParams, metadata?: Metadata): Promise<TracingTracingStopResult>; tracingStop(params?: TracingTracingStopParams, metadata?: CallMetadata): Promise<TracingTracingStopResult>;
} }
export type TracingTracingStartParams = { export type TracingTracingStartParams = {
name?: string, name?: string,
@ -3777,13 +3780,13 @@ export interface ArtifactEventTarget {
} }
export interface ArtifactChannel extends ArtifactEventTarget, Channel { export interface ArtifactChannel extends ArtifactEventTarget, Channel {
_type_Artifact: boolean; _type_Artifact: boolean;
pathAfterFinished(params?: ArtifactPathAfterFinishedParams, metadata?: Metadata): Promise<ArtifactPathAfterFinishedResult>; pathAfterFinished(params?: ArtifactPathAfterFinishedParams, metadata?: CallMetadata): Promise<ArtifactPathAfterFinishedResult>;
saveAs(params: ArtifactSaveAsParams, metadata?: Metadata): Promise<ArtifactSaveAsResult>; saveAs(params: ArtifactSaveAsParams, metadata?: CallMetadata): Promise<ArtifactSaveAsResult>;
saveAsStream(params?: ArtifactSaveAsStreamParams, metadata?: Metadata): Promise<ArtifactSaveAsStreamResult>; saveAsStream(params?: ArtifactSaveAsStreamParams, metadata?: CallMetadata): Promise<ArtifactSaveAsStreamResult>;
failure(params?: ArtifactFailureParams, metadata?: Metadata): Promise<ArtifactFailureResult>; failure(params?: ArtifactFailureParams, metadata?: CallMetadata): Promise<ArtifactFailureResult>;
stream(params?: ArtifactStreamParams, metadata?: Metadata): Promise<ArtifactStreamResult>; stream(params?: ArtifactStreamParams, metadata?: CallMetadata): Promise<ArtifactStreamResult>;
cancel(params?: ArtifactCancelParams, metadata?: Metadata): Promise<ArtifactCancelResult>; cancel(params?: ArtifactCancelParams, metadata?: CallMetadata): Promise<ArtifactCancelResult>;
delete(params?: ArtifactDeleteParams, metadata?: Metadata): Promise<ArtifactDeleteResult>; delete(params?: ArtifactDeleteParams, metadata?: CallMetadata): Promise<ArtifactDeleteResult>;
} }
export type ArtifactPathAfterFinishedParams = {}; export type ArtifactPathAfterFinishedParams = {};
export type ArtifactPathAfterFinishedOptions = {}; export type ArtifactPathAfterFinishedOptions = {};
@ -3828,8 +3831,8 @@ export interface StreamEventTarget {
} }
export interface StreamChannel extends StreamEventTarget, Channel { export interface StreamChannel extends StreamEventTarget, Channel {
_type_Stream: boolean; _type_Stream: boolean;
read(params: StreamReadParams, metadata?: Metadata): Promise<StreamReadResult>; read(params: StreamReadParams, metadata?: CallMetadata): Promise<StreamReadResult>;
close(params?: StreamCloseParams, metadata?: Metadata): Promise<StreamCloseResult>; close(params?: StreamCloseParams, metadata?: CallMetadata): Promise<StreamCloseResult>;
} }
export type StreamReadParams = { export type StreamReadParams = {
size?: number, size?: number,
@ -3853,8 +3856,8 @@ export interface WritableStreamEventTarget {
} }
export interface WritableStreamChannel extends WritableStreamEventTarget, Channel { export interface WritableStreamChannel extends WritableStreamEventTarget, Channel {
_type_WritableStream: boolean; _type_WritableStream: boolean;
write(params: WritableStreamWriteParams, metadata?: Metadata): Promise<WritableStreamWriteResult>; write(params: WritableStreamWriteParams, metadata?: CallMetadata): Promise<WritableStreamWriteResult>;
close(params?: WritableStreamCloseParams, metadata?: Metadata): Promise<WritableStreamCloseResult>; close(params?: WritableStreamCloseParams, metadata?: CallMetadata): Promise<WritableStreamCloseResult>;
} }
export type WritableStreamWriteParams = { export type WritableStreamWriteParams = {
binary: Binary, binary: Binary,
@ -3877,8 +3880,8 @@ export interface CDPSessionEventTarget {
} }
export interface CDPSessionChannel extends CDPSessionEventTarget, Channel { export interface CDPSessionChannel extends CDPSessionEventTarget, Channel {
_type_CDPSession: boolean; _type_CDPSession: boolean;
send(params: CDPSessionSendParams, metadata?: Metadata): Promise<CDPSessionSendResult>; send(params: CDPSessionSendParams, metadata?: CallMetadata): Promise<CDPSessionSendResult>;
detach(params?: CDPSessionDetachParams, metadata?: Metadata): Promise<CDPSessionDetachResult>; detach(params?: CDPSessionDetachParams, metadata?: CallMetadata): Promise<CDPSessionDetachResult>;
} }
export type CDPSessionEventEvent = { export type CDPSessionEventEvent = {
method: string, method: string,
@ -3908,7 +3911,7 @@ export interface ElectronEventTarget {
} }
export interface ElectronChannel extends ElectronEventTarget, Channel { export interface ElectronChannel extends ElectronEventTarget, Channel {
_type_Electron: boolean; _type_Electron: boolean;
launch(params: ElectronLaunchParams, metadata?: Metadata): Promise<ElectronLaunchResult>; launch(params: ElectronLaunchParams, metadata?: CallMetadata): Promise<ElectronLaunchResult>;
} }
export type ElectronLaunchParams = { export type ElectronLaunchParams = {
executablePath?: string, executablePath?: string,
@ -3992,10 +3995,10 @@ export interface ElectronApplicationEventTarget {
} }
export interface ElectronApplicationChannel extends ElectronApplicationEventTarget, EventTargetChannel { export interface ElectronApplicationChannel extends ElectronApplicationEventTarget, EventTargetChannel {
_type_ElectronApplication: boolean; _type_ElectronApplication: boolean;
browserWindow(params: ElectronApplicationBrowserWindowParams, metadata?: Metadata): Promise<ElectronApplicationBrowserWindowResult>; browserWindow(params: ElectronApplicationBrowserWindowParams, metadata?: CallMetadata): Promise<ElectronApplicationBrowserWindowResult>;
evaluateExpression(params: ElectronApplicationEvaluateExpressionParams, metadata?: Metadata): Promise<ElectronApplicationEvaluateExpressionResult>; evaluateExpression(params: ElectronApplicationEvaluateExpressionParams, metadata?: CallMetadata): Promise<ElectronApplicationEvaluateExpressionResult>;
evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams, metadata?: Metadata): Promise<ElectronApplicationEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams, metadata?: CallMetadata): Promise<ElectronApplicationEvaluateExpressionHandleResult>;
close(params?: ElectronApplicationCloseParams, metadata?: Metadata): Promise<ElectronApplicationCloseResult>; close(params?: ElectronApplicationCloseParams, metadata?: CallMetadata): Promise<ElectronApplicationCloseResult>;
} }
export type ElectronApplicationCloseEvent = {}; export type ElectronApplicationCloseEvent = {};
export type ElectronApplicationBrowserWindowParams = { export type ElectronApplicationBrowserWindowParams = {
@ -4043,8 +4046,8 @@ export interface AndroidEventTarget {
} }
export interface AndroidChannel extends AndroidEventTarget, Channel { export interface AndroidChannel extends AndroidEventTarget, Channel {
_type_Android: boolean; _type_Android: boolean;
devices(params: AndroidDevicesParams, metadata?: Metadata): Promise<AndroidDevicesResult>; devices(params: AndroidDevicesParams, metadata?: CallMetadata): Promise<AndroidDevicesResult>;
setDefaultTimeoutNoReply(params: AndroidSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<AndroidSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: AndroidSetDefaultTimeoutNoReplyParams, metadata?: CallMetadata): Promise<AndroidSetDefaultTimeoutNoReplyResult>;
} }
export type AndroidDevicesParams = { export type AndroidDevicesParams = {
host?: string, host?: string,
@ -4078,8 +4081,8 @@ export interface AndroidSocketEventTarget {
} }
export interface AndroidSocketChannel extends AndroidSocketEventTarget, Channel { export interface AndroidSocketChannel extends AndroidSocketEventTarget, Channel {
_type_AndroidSocket: boolean; _type_AndroidSocket: boolean;
write(params: AndroidSocketWriteParams, metadata?: Metadata): Promise<AndroidSocketWriteResult>; write(params: AndroidSocketWriteParams, metadata?: CallMetadata): Promise<AndroidSocketWriteResult>;
close(params?: AndroidSocketCloseParams, metadata?: Metadata): Promise<AndroidSocketCloseResult>; close(params?: AndroidSocketCloseParams, metadata?: CallMetadata): Promise<AndroidSocketCloseResult>;
} }
export type AndroidSocketDataEvent = { export type AndroidSocketDataEvent = {
data: Binary, data: Binary,
@ -4113,31 +4116,31 @@ export interface AndroidDeviceEventTarget {
} }
export interface AndroidDeviceChannel extends AndroidDeviceEventTarget, EventTargetChannel { export interface AndroidDeviceChannel extends AndroidDeviceEventTarget, EventTargetChannel {
_type_AndroidDevice: boolean; _type_AndroidDevice: boolean;
wait(params: AndroidDeviceWaitParams, metadata?: Metadata): Promise<AndroidDeviceWaitResult>; wait(params: AndroidDeviceWaitParams, metadata?: CallMetadata): Promise<AndroidDeviceWaitResult>;
fill(params: AndroidDeviceFillParams, metadata?: Metadata): Promise<AndroidDeviceFillResult>; fill(params: AndroidDeviceFillParams, metadata?: CallMetadata): Promise<AndroidDeviceFillResult>;
tap(params: AndroidDeviceTapParams, metadata?: Metadata): Promise<AndroidDeviceTapResult>; tap(params: AndroidDeviceTapParams, metadata?: CallMetadata): Promise<AndroidDeviceTapResult>;
drag(params: AndroidDeviceDragParams, metadata?: Metadata): Promise<AndroidDeviceDragResult>; drag(params: AndroidDeviceDragParams, metadata?: CallMetadata): Promise<AndroidDeviceDragResult>;
fling(params: AndroidDeviceFlingParams, metadata?: Metadata): Promise<AndroidDeviceFlingResult>; fling(params: AndroidDeviceFlingParams, metadata?: CallMetadata): Promise<AndroidDeviceFlingResult>;
longTap(params: AndroidDeviceLongTapParams, metadata?: Metadata): Promise<AndroidDeviceLongTapResult>; longTap(params: AndroidDeviceLongTapParams, metadata?: CallMetadata): Promise<AndroidDeviceLongTapResult>;
pinchClose(params: AndroidDevicePinchCloseParams, metadata?: Metadata): Promise<AndroidDevicePinchCloseResult>; pinchClose(params: AndroidDevicePinchCloseParams, metadata?: CallMetadata): Promise<AndroidDevicePinchCloseResult>;
pinchOpen(params: AndroidDevicePinchOpenParams, metadata?: Metadata): Promise<AndroidDevicePinchOpenResult>; pinchOpen(params: AndroidDevicePinchOpenParams, metadata?: CallMetadata): Promise<AndroidDevicePinchOpenResult>;
scroll(params: AndroidDeviceScrollParams, metadata?: Metadata): Promise<AndroidDeviceScrollResult>; scroll(params: AndroidDeviceScrollParams, metadata?: CallMetadata): Promise<AndroidDeviceScrollResult>;
swipe(params: AndroidDeviceSwipeParams, metadata?: Metadata): Promise<AndroidDeviceSwipeResult>; swipe(params: AndroidDeviceSwipeParams, metadata?: CallMetadata): Promise<AndroidDeviceSwipeResult>;
info(params: AndroidDeviceInfoParams, metadata?: Metadata): Promise<AndroidDeviceInfoResult>; info(params: AndroidDeviceInfoParams, metadata?: CallMetadata): Promise<AndroidDeviceInfoResult>;
screenshot(params?: AndroidDeviceScreenshotParams, metadata?: Metadata): Promise<AndroidDeviceScreenshotResult>; screenshot(params?: AndroidDeviceScreenshotParams, metadata?: CallMetadata): Promise<AndroidDeviceScreenshotResult>;
inputType(params: AndroidDeviceInputTypeParams, metadata?: Metadata): Promise<AndroidDeviceInputTypeResult>; inputType(params: AndroidDeviceInputTypeParams, metadata?: CallMetadata): Promise<AndroidDeviceInputTypeResult>;
inputPress(params: AndroidDeviceInputPressParams, metadata?: Metadata): Promise<AndroidDeviceInputPressResult>; inputPress(params: AndroidDeviceInputPressParams, metadata?: CallMetadata): Promise<AndroidDeviceInputPressResult>;
inputTap(params: AndroidDeviceInputTapParams, metadata?: Metadata): Promise<AndroidDeviceInputTapResult>; inputTap(params: AndroidDeviceInputTapParams, metadata?: CallMetadata): Promise<AndroidDeviceInputTapResult>;
inputSwipe(params: AndroidDeviceInputSwipeParams, metadata?: Metadata): Promise<AndroidDeviceInputSwipeResult>; inputSwipe(params: AndroidDeviceInputSwipeParams, metadata?: CallMetadata): Promise<AndroidDeviceInputSwipeResult>;
inputDrag(params: AndroidDeviceInputDragParams, metadata?: Metadata): Promise<AndroidDeviceInputDragResult>; inputDrag(params: AndroidDeviceInputDragParams, metadata?: CallMetadata): Promise<AndroidDeviceInputDragResult>;
launchBrowser(params: AndroidDeviceLaunchBrowserParams, metadata?: Metadata): Promise<AndroidDeviceLaunchBrowserResult>; launchBrowser(params: AndroidDeviceLaunchBrowserParams, metadata?: CallMetadata): Promise<AndroidDeviceLaunchBrowserResult>;
open(params: AndroidDeviceOpenParams, metadata?: Metadata): Promise<AndroidDeviceOpenResult>; open(params: AndroidDeviceOpenParams, metadata?: CallMetadata): Promise<AndroidDeviceOpenResult>;
shell(params: AndroidDeviceShellParams, metadata?: Metadata): Promise<AndroidDeviceShellResult>; shell(params: AndroidDeviceShellParams, metadata?: CallMetadata): Promise<AndroidDeviceShellResult>;
installApk(params: AndroidDeviceInstallApkParams, metadata?: Metadata): Promise<AndroidDeviceInstallApkResult>; installApk(params: AndroidDeviceInstallApkParams, metadata?: CallMetadata): Promise<AndroidDeviceInstallApkResult>;
push(params: AndroidDevicePushParams, metadata?: Metadata): Promise<AndroidDevicePushResult>; push(params: AndroidDevicePushParams, metadata?: CallMetadata): Promise<AndroidDevicePushResult>;
setDefaultTimeoutNoReply(params: AndroidDeviceSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<AndroidDeviceSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: AndroidDeviceSetDefaultTimeoutNoReplyParams, metadata?: CallMetadata): Promise<AndroidDeviceSetDefaultTimeoutNoReplyResult>;
connectToWebView(params: AndroidDeviceConnectToWebViewParams, metadata?: Metadata): Promise<AndroidDeviceConnectToWebViewResult>; connectToWebView(params: AndroidDeviceConnectToWebViewParams, metadata?: CallMetadata): Promise<AndroidDeviceConnectToWebViewResult>;
close(params?: AndroidDeviceCloseParams, metadata?: Metadata): Promise<AndroidDeviceCloseResult>; close(params?: AndroidDeviceCloseParams, metadata?: CallMetadata): Promise<AndroidDeviceCloseResult>;
} }
export type AndroidDeviceCloseEvent = {}; export type AndroidDeviceCloseEvent = {};
export type AndroidDeviceWebViewAddedEvent = { export type AndroidDeviceWebViewAddedEvent = {
@ -4535,8 +4538,8 @@ export interface JsonPipeEventTarget {
} }
export interface JsonPipeChannel extends JsonPipeEventTarget, Channel { export interface JsonPipeChannel extends JsonPipeEventTarget, Channel {
_type_JsonPipe: boolean; _type_JsonPipe: boolean;
send(params: JsonPipeSendParams, metadata?: Metadata): Promise<JsonPipeSendResult>; send(params: JsonPipeSendParams, metadata?: CallMetadata): Promise<JsonPipeSendResult>;
close(params?: JsonPipeCloseParams, metadata?: Metadata): Promise<JsonPipeCloseResult>; close(params?: JsonPipeCloseParams, metadata?: CallMetadata): Promise<JsonPipeCloseResult>;
} }
export type JsonPipeMessageEvent = { export type JsonPipeMessageEvent = {
message: any, message: any,

2
packages/protocol/src/protocol.yml
View file

@ -33,6 +33,8 @@ Metadata:
column: number? column: number?
apiName: string? apiName: string?
internal: boolean? internal: boolean?
# The number of milliseconds elapsed since midnight, January 1, 1970 UTC.
wallTime: number?
ClientSideCallMetadata: ClientSideCallMetadata:
type: object type: object

4
packages/trace-viewer/src/ui/callTab.tsx
View file

@ -36,7 +36,7 @@ export const CallTab: React.FunctionComponent<{
// Strip down the waitForEventInfo data, we never need it. // Strip down the waitForEventInfo data, we never need it.
delete params.info; delete params.info;
const paramKeys = Object.keys(params); const paramKeys = Object.keys(params);
const wallTime = new Date(action.metadata.wallTime).toLocaleString(); const wallTime = action.metadata.wallTime ? new Date(action.metadata.wallTime).toLocaleString() : null;
const duration = action.metadata.endTime ? msToString(action.metadata.endTime - action.metadata.startTime) : 'Timed Out'; const duration = action.metadata.endTime ? msToString(action.metadata.endTime - action.metadata.startTime) : 'Timed Out';
return <div className='call-tab'> return <div className='call-tab'>
<div className='call-error' key='error' hidden={!error}> <div className='call-error' key='error' hidden={!error}>
@ -46,7 +46,7 @@ export const CallTab: React.FunctionComponent<{
<div className='call-line'>{action.metadata.apiName}</div> <div className='call-line'>{action.metadata.apiName}</div>
{<> {<>
<div className='call-section'>Time</div> <div className='call-section'>Time</div>
{action.metadata.wallTime && <div className='call-line'>wall time:<span className='call-value datetime' title={wallTime}>{wallTime}</span></div>} {wallTime && <div className='call-line'>wall time:<span className='call-value datetime' title={wallTime}>{wallTime}</span></div>}
<div className='call-line'>duration:<span className='call-value datetime' title={duration}>{duration}</span></div> <div className='call-line'>duration:<span className='call-value datetime' title={duration}>{duration}</span></div>
</>} </>}
{ !!paramKeys.length && <div className='call-section'>Parameters</div> } { !!paramKeys.length && <div className='call-section'>Parameters</div> }

4
utils/generate_channels.js
View file

@ -126,6 +126,8 @@ const channels_ts = [
// This file is generated by ${path.basename(__filename).split(path.sep).join(path.posix.sep)}, do not edit manually. // This file is generated by ${path.basename(__filename).split(path.sep).join(path.posix.sep)}, do not edit manually.
import type { CallMetadata } from './callMetadata';
export type Binary = Buffer; export type Binary = Buffer;
export interface Channel { export interface Channel {
@ -302,7 +304,7 @@ for (const [name, item] of Object.entries(protocol)) {
for (const derived of derivedClasses.get(channelName) || []) for (const derived of derivedClasses.get(channelName) || [])
addScheme(`${derived}${titleCase(methodName)}Result`, `tType('${resultName}')`); addScheme(`${derived}${titleCase(methodName)}Result`, `tType('${resultName}')`);
channels_ts.push(` ${methodName}(params${method.parameters ? '' : '?'}: ${paramsName}, metadata?: Metadata): Promise<${resultName}>;`); channels_ts.push(` ${methodName}(params${method.parameters ? '' : '?'}: ${paramsName}, metadata?: CallMetadata): Promise<${resultName}>;`);
} }
channels_ts.push(`}`); channels_ts.push(`}`);