diff --git a/src/rpc/channels.ts b/src/rpc/channels.ts
index db071ce35d..46dfe7cf2b 100644
--- a/src/rpc/channels.ts
+++ b/src/rpc/channels.ts
@@ -24,10 +24,10 @@ export interface Channel extends EventEmitter {
 
 
 export interface BrowserTypeChannel extends Channel {
-  connect(params: { options: types.ConnectOptions }): Promise<BrowserChannel>;
-  launch(params: { options?: types.LaunchOptions }): Promise<BrowserChannel>;
-  launchServer(params: { options?: types.LaunchServerOptions }): Promise<BrowserServerChannel>;
-  launchPersistentContext(params: { userDataDir: string, options?: types.LaunchOptions & types.BrowserContextOptions }): Promise<BrowserContextChannel>;
+  connect(params: types.ConnectOptions): Promise<BrowserChannel>;
+  launch(params: types.LaunchOptions): Promise<BrowserChannel>;
+  launchServer(params: types.LaunchServerOptions): Promise<BrowserServerChannel>;
+  launchPersistentContext(params: { userDataDir: string } & types.LaunchOptions & types.BrowserContextOptions): Promise<BrowserContextChannel>;
 }
 export type BrowserTypeInitializer = {
   executablePath: string,
@@ -51,7 +51,7 @@ export interface BrowserChannel extends Channel {
   on(event: 'close', callback: () => void): this;
 
   close(): Promise<void>;
-  newContext(params: { options?: types.BrowserContextOptions }): Promise<BrowserContextChannel>;
+  newContext(params: types.BrowserContextOptions): Promise<BrowserContextChannel>;
 }
 export type BrowserInitializer = {};
 
@@ -69,7 +69,7 @@ export interface BrowserContextChannel extends Channel {
   close(): Promise<void>;
   cookies(params: { urls: string[] }): Promise<types.NetworkCookie[]>;
   exposeBinding(params: { name: string }): Promise<void>;
-  grantPermissions(params: { permissions: string[]; options?: { origin?: string } }): Promise<void>;
+  grantPermissions(params: { permissions: string[], origin?: string }): Promise<void>;
   newPage(): Promise<PageChannel>;
   setDefaultNavigationTimeoutNoReply(params: { timeout: number }): void;
   setDefaultTimeoutNoReply(params: { timeout: number }): void;
@@ -113,14 +113,14 @@ export interface PageChannel extends Channel {
   setFileChooserInterceptedNoReply(params: { intercepted: boolean }): Promise<void>;
 
   addInitScript(params: { source: string }): Promise<void>;
-  close(params: { options?: { runBeforeUnload?: boolean } }): Promise<void>;
-  emulateMedia(params: { options: { media?: 'screen' | 'print', colorScheme?: 'dark' | 'light' | 'no-preference' } }): Promise<void>;
+  close(params: { runBeforeUnload?: boolean }): Promise<void>;
+  emulateMedia(params: { media?: 'screen' | 'print', colorScheme?: 'dark' | 'light' | 'no-preference' }): Promise<void>;
   exposeBinding(params: { name: string }): Promise<void>;
-  goBack(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null>;
-  goForward(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null>;
+  goBack(params: types.NavigateOptions): Promise<ResponseChannel | null>;
+  goForward(params: types.NavigateOptions): Promise<ResponseChannel | null>;
   opener(): Promise<PageChannel | null>;
-  reload(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null>;
-  screenshot(params: { options?: types.ScreenshotOptions }): Promise<Binary>;
+  reload(params: types.NavigateOptions): Promise<ResponseChannel | null>;
+  screenshot(params: types.ScreenshotOptions): Promise<Binary>;
   setExtraHTTPHeaders(params: { headers: types.Headers }): Promise<void>;
   setNetworkInterceptionEnabled(params: { enabled: boolean }): Promise<void>;
   setViewportSize(params: { viewportSize: types.Size }): Promise<void>;
@@ -129,16 +129,16 @@ export interface PageChannel extends Channel {
   keyboardDown(params: { key: string }): Promise<void>;
   keyboardUp(params: { key: string }): Promise<void>;
   keyboardInsertText(params: { text: string }): Promise<void>;
-  keyboardType(params: { text: string, options?: { delay?: number } }): Promise<void>;
-  keyboardPress(params: { key: string, options?: { delay?: number } }): Promise<void>;
-  mouseMove(params: { x: number, y: number, options?: { steps?: number } }): Promise<void>;
-  mouseDown(params: { options?: { button?: types.MouseButton, clickCount?: number } }): Promise<void>;
-  mouseUp(params: { options?: { button?: types.MouseButton, clickCount?: number } }): Promise<void>;
-  mouseClick(params: { x: number, y: number, options?: { delay?: number, button?: types.MouseButton, clickCount?: number } }): Promise<void>;
+  keyboardType(params: { text: string, delay?: number }): Promise<void>;
+  keyboardPress(params: { key: string, delay?: number }): Promise<void>;
+  mouseMove(params: { x: number, y: number, steps?: number }): Promise<void>;
+  mouseDown(params: { button?: types.MouseButton, clickCount?: number }): Promise<void>;
+  mouseUp(params: { button?: types.MouseButton, clickCount?: number }): Promise<void>;
+  mouseClick(params: { x: number, y: number, delay?: number, button?: types.MouseButton, clickCount?: number }): Promise<void>;
 
   // A11Y
-  accessibilitySnapshot(params: { options: { interestingOnly?: boolean, root?: ElementHandleChannel } }): Promise<types.SerializedAXNode | null>;
-  pdf: (params: { options?: types.PDFOptions }) => Promise<Binary>;
+  accessibilitySnapshot(params: { interestingOnly?: boolean, root?: ElementHandleChannel }): Promise<types.SerializedAXNode | null>;
+  pdf: (params: types.PDFOptions) => Promise<Binary>;
 }
 
 export type PageInitializer = {
@@ -146,41 +146,42 @@ export type PageInitializer = {
   viewportSize: types.Size | null
 };
 
+export type PageAttribution = { isPage?: boolean };
 
 export interface FrameChannel extends Channel {
-  evalOnSelector(params: { selector: string; expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any>;
-  evalOnSelectorAll(params: { selector: string; expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any>;
-  addScriptTag(params: { options: { url?: string | undefined, path?: string | undefined, content?: string | undefined, type?: string | undefined }, isPage?: boolean }): Promise<ElementHandleChannel>;
-  addStyleTag(params: { options: { url?: string | undefined, path?: string | undefined, content?: string | undefined }, isPage?: boolean }): Promise<ElementHandleChannel>;
-  check(params: { selector: string, options: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void>;
-  click(params: { selector: string, options: types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void>;
+  evalOnSelector(params: { selector: string; expression: string, isFunction: boolean, arg: any} & PageAttribution): Promise<any>;
+  evalOnSelectorAll(params: { selector: string; expression: string, isFunction: boolean, arg: any} & PageAttribution): Promise<any>;
+  addScriptTag(params: { url?: string | undefined, path?: string | undefined, content?: string | undefined, type?: string | undefined} & PageAttribution): Promise<ElementHandleChannel>;
+  addStyleTag(params: { url?: string | undefined, path?: string | undefined, content?: string | undefined} & PageAttribution): Promise<ElementHandleChannel>;
+  check(params: { selector: string, force?: boolean, noWaitAfter?: boolean } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  click(params: { selector: string, force?: boolean, noWaitAfter?: boolean } & types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions & PageAttribution): Promise<void>;
   content(): Promise<string>;
-  dblclick(params: { selector: string, options: types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions & { force?: boolean }, isPage?: boolean}): Promise<void>;
-  dispatchEvent(params: { selector: string, type: string, eventInit: any, options: types.TimeoutOptions, isPage?: boolean }): Promise<void>;
-  evaluateExpression(params: { expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any>;
-  evaluateExpressionHandle(params: { expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<JSHandleChannel>;
-  fill(params: { selector: string, value: string, options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<void>;
-  focus(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<void>;
+  dblclick(params: { selector: string, force?: boolean } & types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions & PageAttribution): Promise<void>;
+  dispatchEvent(params: { selector: string, type: string, eventInit: any } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  evaluateExpression(params: { expression: string, isFunction: boolean, arg: any} & PageAttribution): Promise<any>;
+  evaluateExpressionHandle(params: { expression: string, isFunction: boolean, arg: any} & PageAttribution): Promise<JSHandleChannel>;
+  fill(params: { selector: string, value: string } & types.NavigatingActionWaitOptions & PageAttribution): Promise<void>;
+  focus(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<void>;
   frameElement(): Promise<ElementHandleChannel>;
-  getAttribute(params: { selector: string, name: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string | null>;
-  goto(params: { url: string, options: types.GotoOptions, isPage?: boolean }): Promise<ResponseChannel | null>;
-  hover(params: { selector: string, options: types.PointerActionOptions & types.TimeoutOptions & { force?: boolean }, isPage?: boolean }): Promise<void>;
-  innerHTML(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string>;
-  innerText(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string>;
-  press(params: { selector: string, key: string, options: { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void>;
-  querySelector(params: { selector: string, isPage?: boolean }): Promise<ElementHandleChannel | null>;
-  querySelectorAll(params: { selector: string, isPage?: boolean }): Promise<ElementHandleChannel[]>;
-  selectOption(params: { selector: string, values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null, options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<string[]>;
-  setContent(params: { html: string, options: types.NavigateOptions, isPage?: boolean }): Promise<void>;
-  setInputFiles(params: { selector: string, files: { name: string, mimeType: string, buffer: string }[], options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<void>;
-  textContent(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string | null>;
+  getAttribute(params: { selector: string, name: string } & types.TimeoutOptions & PageAttribution): Promise<string | null>;
+  goto(params: { url: string } & types.GotoOptions & PageAttribution): Promise<ResponseChannel | null>;
+  hover(params: { selector: string, force?: boolean } & types.PointerActionOptions & types.TimeoutOptions & PageAttribution): Promise<void>;
+  innerHTML(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string>;
+  innerText(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string>;
+  press(params: { selector: string, key: string, delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  querySelector(params: { selector: string} & PageAttribution): Promise<ElementHandleChannel | null>;
+  querySelectorAll(params: { selector: string} & PageAttribution): Promise<ElementHandleChannel[]>;
+  selectOption(params: { selector: string, values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null } & types.NavigatingActionWaitOptions & PageAttribution): Promise<string[]>;
+  setContent(params: { html: string } & types.NavigateOptions & PageAttribution): Promise<void>;
+  setInputFiles(params: { selector: string, files: { name: string, mimeType: string, buffer: string }[] } & types.NavigatingActionWaitOptions & PageAttribution): Promise<void>;
+  textContent(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string | null>;
   title(): Promise<string>;
-  type(params: { selector: string, text: string, options: { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void>;
-  uncheck(params: { selector: string, options: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void>;
-  waitForFunction(params: { expression: string, isFunction: boolean, arg: any; options: types.WaitForFunctionOptions, isPage?: boolean }): Promise<JSHandleChannel>;
-  waitForLoadState(params: { state: types.LifecycleEvent, options: types.TimeoutOptions, isPage?: boolean }): Promise<void>;
-  waitForNavigation(params: { options: types.WaitForNavigationOptions, isPage?: boolean }): Promise<ResponseChannel | null>;
-  waitForSelector(params: { selector: string, options: types.WaitForElementOptions, isPage?: boolean }): Promise<ElementHandleChannel | null>;
+  type(params: { selector: string, text: string, delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  uncheck(params: { selector: string, force?: boolean, noWaitAfter?: boolean } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  waitForFunction(params: { expression: string, isFunction: boolean, arg: any } & types.WaitForFunctionOptions & PageAttribution): Promise<JSHandleChannel>;
+  waitForLoadState(params: { state: types.LifecycleEvent } & types.TimeoutOptions & PageAttribution): Promise<void>;
+  waitForNavigation(params: types.WaitForNavigationOptions & PageAttribution): Promise<ResponseChannel | null>;
+  waitForSelector(params: { selector: string } & types.WaitForElementOptions & PageAttribution): Promise<ElementHandleChannel | null>;
 }
 export type FrameInitializer = {
   url: string,
@@ -217,29 +218,29 @@ export interface ElementHandleChannel extends JSHandleChannel {
   evalOnSelector(params: { selector: string; expression: string, isFunction: boolean, arg: any }): Promise<any>;
   evalOnSelectorAll(params: { selector: string; expression: string, isFunction: boolean, arg: any }): Promise<any>;
   boundingBox(): Promise<types.Rect | null>;
-  check(params: { options?: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } }): Promise<void>;
-  click(params: { options?: types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } }): Promise<void>;
+  check(params: { force?: boolean } & { noWaitAfter?: boolean } & types.TimeoutOptions): Promise<void>;
+  click(params: { force?: boolean, noWaitAfter?: boolean } & types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions): Promise<void>;
   contentFrame(): Promise<FrameChannel | null>;
-  dblclick(params: { options?: types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } }): Promise<void>;
+  dblclick(params: { force?: boolean, noWaitAfter?: boolean } & types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions): Promise<void>;
   dispatchEvent(params: { type: string, eventInit: any }): Promise<void>;
-  fill(params: { value: string; options?: types.NavigatingActionWaitOptions }): Promise<void>;
+  fill(params: { value: string } & types.NavigatingActionWaitOptions): Promise<void>;
   focus(): Promise<void>;
   getAttribute(params: { name: string }): Promise<string | null>;
-  hover(params: { options?: types.PointerActionOptions & types.TimeoutOptions & { force?: boolean } }): Promise<void>;
+  hover(params: { force?: boolean } & types.PointerActionOptions & types.TimeoutOptions): Promise<void>;
   innerHTML(): Promise<string>;
   innerText(): Promise<string>;
   ownerFrame(): Promise<FrameChannel | null>;
-  press(params: { key: string; options?: { delay?: number } & types.TimeoutOptions & { noWaitAfter?: boolean } }): Promise<void>;
+  press(params: { key: string, delay?: number } & types.TimeoutOptions & { noWaitAfter?: boolean }): Promise<void>;
   querySelector(params: { selector: string }): Promise<ElementHandleChannel | null>;
   querySelectorAll(params: { selector: string }): Promise<ElementHandleChannel[]>;
-  screenshot(params: { options?: types.ElementScreenshotOptions }): Promise<Binary>;
-  scrollIntoViewIfNeeded(params: { options?: types.TimeoutOptions }): Promise<void>;
-  selectOption(params: { values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null; options?: types.NavigatingActionWaitOptions }): string[] | Promise<string[]>;
-  selectText(params: { options?: types.TimeoutOptions }): Promise<void>;
-  setInputFiles(params: { files: string | string[] | types.FilePayload | types.FilePayload[], options?: types.NavigatingActionWaitOptions }): Promise<void>;
+  screenshot(params: types.ElementScreenshotOptions): Promise<Binary>;
+  scrollIntoViewIfNeeded(params: types.TimeoutOptions): Promise<void>;
+  selectOption(params: { values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null } & types.NavigatingActionWaitOptions): string[] | Promise<string[]>;
+  selectText(params: types.TimeoutOptions): Promise<void>;
+  setInputFiles(params: { files: string | string[] | types.FilePayload | types.FilePayload[] } & types.NavigatingActionWaitOptions): Promise<void>;
   textContent(): Promise<string | null>;
-  type(params: { text: string; options?: { delay?: number } & types.TimeoutOptions & { noWaitAfter?: boolean } }): Promise<void>;
-  uncheck(params: { options?: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } }): Promise<void>;
+  type(params: { text: string, delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions): Promise<void>;
+  uncheck(params: { force?: boolean, noWaitAfter?: boolean } & types.TimeoutOptions): Promise<void>;
 }
 
 
diff --git a/src/rpc/client/accessibility.ts b/src/rpc/client/accessibility.ts
index adf6928dd1..9c33d8f0c0 100644
--- a/src/rpc/client/accessibility.ts
+++ b/src/rpc/client/accessibility.ts
@@ -28,6 +28,6 @@ export class Accessibility {
 
   snapshot(options: { interestingOnly?: boolean; root?: ElementHandle } = {}): Promise<types.SerializedAXNode | null> {
     const root = options.root ? options.root._elementChannel : undefined;
-    return this._channel.accessibilitySnapshot({ options: { interestingOnly: options.interestingOnly, root } });
+    return this._channel.accessibilitySnapshot({ interestingOnly: options.interestingOnly, root });
   }
 }
diff --git a/src/rpc/client/browser.ts b/src/rpc/client/browser.ts
index c295715def..2cfe9f4b92 100644
--- a/src/rpc/client/browser.ts
+++ b/src/rpc/client/browser.ts
@@ -48,7 +48,7 @@ export class Browser extends ChannelOwner<BrowserChannel, BrowserInitializer> {
 
   async newContext(options: types.BrowserContextOptions = {}): Promise<BrowserContext> {
     delete (options as any).logger;
-    const context = BrowserContext.from(await this._channel.newContext({ options }));
+    const context = BrowserContext.from(await this._channel.newContext(options));
     this._contexts.add(context);
     context._browser = this;
     return context;
diff --git a/src/rpc/client/browserContext.ts b/src/rpc/client/browserContext.ts
index fcfeed4d61..e17af9e096 100644
--- a/src/rpc/client/browserContext.ts
+++ b/src/rpc/client/browserContext.ts
@@ -116,7 +116,7 @@ export class BrowserContext extends ChannelOwner<BrowserContextChannel, BrowserC
   }
 
   async grantPermissions(permissions: string[], options?: { origin?: string }): Promise<void> {
-    await this._channel.grantPermissions({ permissions, options });
+    await this._channel.grantPermissions({ permissions, ...options });
   }
 
   async clearPermissions(): Promise<void> {
diff --git a/src/rpc/client/browserType.ts b/src/rpc/client/browserType.ts
index dc3eceb7c0..4b38bf0a57 100644
--- a/src/rpc/client/browserType.ts
+++ b/src/rpc/client/browserType.ts
@@ -37,21 +37,21 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
 
   async launch(options: types.LaunchOptions = {}): Promise<Browser> {
     delete (options as any).logger;
-    return Browser.from(await this._channel.launch({ options }));
+    return Browser.from(await this._channel.launch(options));
   }
 
-  async launchServer(options?: types.LaunchServerOptions): Promise<BrowserServer> {
+  async launchServer(options: types.LaunchServerOptions = {}): Promise<BrowserServer> {
     delete (options as any).logger;
-    return BrowserServer.from(await this._channel.launchServer({ options }));
+    return BrowserServer.from(await this._channel.launchServer(options));
   }
 
   async launchPersistentContext(userDataDir: string, options: types.LaunchOptions & types.BrowserContextOptions = {}): Promise<BrowserContext> {
     delete (options as any).logger;
-    return BrowserContext.from(await this._channel.launchPersistentContext({ userDataDir, options }));
+    return BrowserContext.from(await this._channel.launchPersistentContext({ userDataDir, ...options }));
   }
 
   async connect(options: types.ConnectOptions): Promise<Browser> {
     delete (options as any).logger;
-    return Browser.from(await this._channel.connect({ options }));
+    return Browser.from(await this._channel.connect(options));
   }
 }
diff --git a/src/rpc/client/elementHandle.ts b/src/rpc/client/elementHandle.ts
index 74032f53e5..ad614f7e0d 100644
--- a/src/rpc/client/elementHandle.ts
+++ b/src/rpc/client/elementHandle.ts
@@ -68,36 +68,36 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> {
     await this._elementChannel.dispatchEvent({ type, eventInit });
   }
 
-  async scrollIntoViewIfNeeded(options?: types.TimeoutOptions) {
-    await this._elementChannel.scrollIntoViewIfNeeded({ options });
+  async scrollIntoViewIfNeeded(options: types.TimeoutOptions = {}) {
+    await this._elementChannel.scrollIntoViewIfNeeded(options);
   }
 
   async hover(options: types.PointerActionOptions & types.PointerActionWaitOptions = {}): Promise<void> {
-    await this._elementChannel.hover({ options });
+    await this._elementChannel.hover(options);
   }
 
   async click(options: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}): Promise<void> {
-    return await this._elementChannel.click({ options });
+    return await this._elementChannel.click(options);
   }
 
   async dblclick(options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}): Promise<void> {
-    return await this._elementChannel.dblclick({ options });
+    return await this._elementChannel.dblclick(options);
   }
 
   async selectOption(values: string | ElementHandle | types.SelectOption | string[] | ElementHandle[] | types.SelectOption[] | null, options: types.NavigatingActionWaitOptions = {}): Promise<string[]> {
-    return await this._elementChannel.selectOption({ values: convertSelectOptionValues(values), options });
+    return await this._elementChannel.selectOption({ values: convertSelectOptionValues(values), ...options });
   }
 
   async fill(value: string, options: types.NavigatingActionWaitOptions = {}): Promise<void> {
-    return await this._elementChannel.fill({ value, options });
+    return await this._elementChannel.fill({ value, ...options });
   }
 
   async selectText(options: types.TimeoutOptions): Promise<void> {
-    await this._elementChannel.selectText({ options });
+    await this._elementChannel.selectText(options);
   }
 
   async setInputFiles(files: string | types.FilePayload | string[] | types.FilePayload[], options: types.NavigatingActionWaitOptions = {}) {
-    await this._elementChannel.setInputFiles({ files, options });
+    await this._elementChannel.setInputFiles({ files, ...options });
   }
 
   async focus(): Promise<void> {
@@ -105,27 +105,27 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> {
   }
 
   async type(text: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}): Promise<void> {
-    await this._elementChannel.type({ text, options });
+    await this._elementChannel.type({ text, ...options });
   }
 
   async press(key: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}): Promise<void> {
-    await this._elementChannel.press({ key, options });
+    await this._elementChannel.press({ key, ...options });
   }
 
   async check(options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    return await this._elementChannel.check({ options });
+    return await this._elementChannel.check(options);
   }
 
   async uncheck(options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    return await this._elementChannel.uncheck({ options });
+    return await this._elementChannel.uncheck(options);
   }
 
   async boundingBox(): Promise<types.Rect | null> {
     return await this._elementChannel.boundingBox();
   }
 
-  async screenshot(options?: types.ElementScreenshotOptions): Promise<Buffer> {
-    return Buffer.from(await this._elementChannel.screenshot({ options }), 'base64');
+  async screenshot(options: types.ElementScreenshotOptions = {}): Promise<Buffer> {
+    return Buffer.from(await this._elementChannel.screenshot(options), 'base64');
   }
 
   async $(selector: string): Promise<ElementHandle<Element> | null> {
diff --git a/src/rpc/client/frame.ts b/src/rpc/client/frame.ts
index 931aa1f0df..940fada31e 100644
--- a/src/rpc/client/frame.ts
+++ b/src/rpc/client/frame.ts
@@ -60,15 +60,15 @@ export class Frame extends ChannelOwner<FrameChannel, FrameInitializer> {
   }
 
   async goto(url: string, options: GotoOptions = {}): Promise<network.Response | null> {
-    return Response.fromNullable(await this._channel.goto({ url, options, isPage: this._page!._isPageCall }));
+    return Response.fromNullable(await this._channel.goto({ url, ...options, isPage: this._page!._isPageCall }));
   }
 
   async waitForNavigation(options: types.WaitForNavigationOptions = {}): Promise<network.Response | null> {
-    return Response.fromNullable(await this._channel.waitForNavigation({ options, isPage: this._page!._isPageCall }));
+    return Response.fromNullable(await this._channel.waitForNavigation({ ...options, isPage: this._page!._isPageCall }));
   }
 
   async waitForLoadState(state: types.LifecycleEvent = 'load', options: types.TimeoutOptions = {}): Promise<void> {
-    await this._channel.waitForLoadState({ state, options, isPage: this._page!._isPageCall });
+    await this._channel.waitForLoadState({ state, ...options, isPage: this._page!._isPageCall });
   }
 
   async frameElement(): Promise<ElementHandle> {
@@ -94,11 +94,11 @@ export class Frame extends ChannelOwner<FrameChannel, FrameInitializer> {
   }
 
   async waitForSelector(selector: string, options: types.WaitForElementOptions = {}): Promise<ElementHandle<Element> | null> {
-    return ElementHandle.fromNullable(await this._channel.waitForSelector({ selector, options, isPage: this._page!._isPageCall })) as ElementHandle<Element> | null;
+    return ElementHandle.fromNullable(await this._channel.waitForSelector({ selector, ...options, isPage: this._page!._isPageCall })) as ElementHandle<Element> | null;
   }
 
   async dispatchEvent(selector: string, type: string, eventInit?: any, options: types.TimeoutOptions = {}): Promise<void> {
-    await this._channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), options, isPage: this._page!._isPageCall });
+    await this._channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), ...options, isPage: this._page!._isPageCall });
   }
 
   async $eval<R, Arg>(selector: string, pageFunction: FuncOn<Element, Arg, R>, arg: Arg): Promise<R>;
@@ -125,7 +125,7 @@ export class Frame extends ChannelOwner<FrameChannel, FrameInitializer> {
   }
 
   async setContent(html: string, options: types.NavigateOptions = {}): Promise<void> {
-    await this._channel.setContent({ html, options, isPage: this._page!._isPageCall });
+    await this._channel.setContent({ html, ...options, isPage: this._page!._isPageCall });
   }
 
   name(): string {
@@ -149,72 +149,72 @@ export class Frame extends ChannelOwner<FrameChannel, FrameInitializer> {
   }
 
   async addScriptTag(options: { url?: string, path?: string, content?: string, type?: string }): Promise<ElementHandle> {
-    return ElementHandle.from(await this._channel.addScriptTag({ options, isPage: this._page!._isPageCall }));
+    return ElementHandle.from(await this._channel.addScriptTag({ ...options, isPage: this._page!._isPageCall }));
   }
 
   async addStyleTag(options: { url?: string; path?: string; content?: string; }): Promise<ElementHandle> {
-    return ElementHandle.from(await this._channel.addStyleTag({ options, isPage: this._page!._isPageCall }));
+    return ElementHandle.from(await this._channel.addStyleTag({ ...options, isPage: this._page!._isPageCall }));
   }
 
   async click(selector: string, options: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    return await this._channel.click({ selector, options, isPage: this._page!._isPageCall });
+    return await this._channel.click({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async dblclick(selector: string, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    return await this._channel.dblclick({ selector, options, isPage: this._page!._isPageCall });
+    return await this._channel.dblclick({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async fill(selector: string, value: string, options: types.NavigatingActionWaitOptions = {}) {
-    return await this._channel.fill({ selector, value, options, isPage: this._page!._isPageCall });
+    return await this._channel.fill({ selector, value, ...options, isPage: this._page!._isPageCall });
   }
 
   async focus(selector: string, options: types.TimeoutOptions = {}) {
-    await this._channel.focus({ selector, options, isPage: this._page!._isPageCall });
+    await this._channel.focus({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async textContent(selector: string, options: types.TimeoutOptions = {}): Promise<null|string> {
-    return await this._channel.textContent({ selector, options, isPage: this._page!._isPageCall });
+    return await this._channel.textContent({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async innerText(selector: string, options: types.TimeoutOptions = {}): Promise<string> {
-    return await this._channel.innerText({ selector, options, isPage: this._page!._isPageCall });
+    return await this._channel.innerText({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async innerHTML(selector: string, options: types.TimeoutOptions = {}): Promise<string> {
-    return await this._channel.innerHTML({ selector, options, isPage: this._page!._isPageCall });
+    return await this._channel.innerHTML({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async getAttribute(selector: string, name: string, options: types.TimeoutOptions = {}): Promise<string | null> {
-    return await this._channel.getAttribute({ selector, name, options, isPage: this._page!._isPageCall });
+    return await this._channel.getAttribute({ selector, name, ...options, isPage: this._page!._isPageCall });
   }
 
   async hover(selector: string, options: types.PointerActionOptions & types.PointerActionWaitOptions = {}) {
-    await this._channel.hover({ selector, options, isPage: this._page!._isPageCall });
+    await this._channel.hover({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async selectOption(selector: string, values: string | ElementHandle | types.SelectOption | string[] | ElementHandle[] | types.SelectOption[] | null, options: types.NavigatingActionWaitOptions = {}): Promise<string[]> {
-    return await this._channel.selectOption({ selector, values: convertSelectOptionValues(values), options, isPage: this._page!._isPageCall });
+    return await this._channel.selectOption({ selector, values: convertSelectOptionValues(values), ...options, isPage: this._page!._isPageCall });
   }
 
   async setInputFiles(selector: string, files: string | types.FilePayload | string[] | types.FilePayload[], options: types.NavigatingActionWaitOptions = {}): Promise<void> {
     const filePayloads = await normalizeFilePayloads(files);
-    await this._channel.setInputFiles({ selector, files: filePayloads.map(f => ({ name: f.name, mimeType: f.mimeType, buffer: f.buffer.toString('base64') })), options, isPage: this._page!._isPageCall });
+    await this._channel.setInputFiles({ selector, files: filePayloads.map(f => ({ name: f.name, mimeType: f.mimeType, buffer: f.buffer.toString('base64') })), ...options, isPage: this._page!._isPageCall });
   }
 
   async type(selector: string, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) {
-    await this._channel.type({ selector, text, options, isPage: this._page!._isPageCall });
+    await this._channel.type({ selector, text, ...options, isPage: this._page!._isPageCall });
   }
 
   async press(selector: string, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) {
-    await this._channel.press({ selector, key, options, isPage: this._page!._isPageCall });
+    await this._channel.press({ selector, key, ...options, isPage: this._page!._isPageCall });
   }
 
   async check(selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    await this._channel.check({ selector, options, isPage: this._page!._isPageCall });
+    await this._channel.check({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async uncheck(selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
-    await this._channel.uncheck({ selector, options, isPage: this._page!._isPageCall });
+    await this._channel.uncheck({ selector, ...options, isPage: this._page!._isPageCall });
   }
 
   async waitForTimeout(timeout: number) {
@@ -224,7 +224,7 @@ export class Frame extends ChannelOwner<FrameChannel, FrameInitializer> {
   async waitForFunction<R, Arg>(pageFunction: Func1<Arg, R>, arg: Arg, options?: types.WaitForFunctionOptions): Promise<SmartHandle<R>>;
   async waitForFunction<R>(pageFunction: Func1<void, R>, arg?: any, options?: types.WaitForFunctionOptions): Promise<SmartHandle<R>>;
   async waitForFunction<R, Arg>(pageFunction: Func1<Arg, R>, arg: Arg, options: types.WaitForFunctionOptions = {}): Promise<SmartHandle<R>> {
-    return JSHandle.from(await this._channel.waitForFunction({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), options, isPage: this._page!._isPageCall })) as SmartHandle<R>;
+    return JSHandle.from(await this._channel.waitForFunction({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), ...options, isPage: this._page!._isPageCall })) as SmartHandle<R>;
   }
 
   async title(): Promise<string> {
diff --git a/src/rpc/client/input.ts b/src/rpc/client/input.ts
index 8519133f46..f3b2b35bce 100644
--- a/src/rpc/client/input.ts
+++ b/src/rpc/client/input.ts
@@ -38,11 +38,11 @@ export class Keyboard {
   }
 
   async type(text: string, options: { delay?: number } = {}) {
-    await this._channel.keyboardType({ text, options });
+    await this._channel.keyboardType({ text, ...options });
   }
 
   async press(key: string, options: { delay?: number } = {}) {
-    await this._channel.keyboardPress({ key, options });
+    await this._channel.keyboardPress({ key, ...options });
   }
 }
 
@@ -54,19 +54,19 @@ export class Mouse {
   }
 
   async move(x: number, y: number, options: { steps?: number } = {}) {
-    await this._channel.mouseMove({ x, y, options });
+    await this._channel.mouseMove({ x, y, ...options });
   }
 
   async down(options: { button?: types.MouseButton, clickCount?: number } = {}) {
-    await this._channel.mouseDown({ options });
+    await this._channel.mouseDown({ ...options });
   }
 
   async up(options: { button?: types.MouseButton, clickCount?: number } = {}) {
-    await this._channel.mouseUp({ options });
+    await this._channel.mouseUp(options);
   }
 
   async click(x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number } = {}) {
-    await this._channel.mouseClick({ x, y, options });
+    await this._channel.mouseClick({ x, y, ...options });
   }
 
   async dblclick(x: number, y: number, options: { delay?: number, button?: types.MouseButton } = {}) {
diff --git a/src/rpc/client/page.ts b/src/rpc/client/page.ts
index ebc5a087b9..eb3331ba4d 100644
--- a/src/rpc/client/page.ts
+++ b/src/rpc/client/page.ts
@@ -303,8 +303,8 @@ export class Page extends ChannelOwner<PageChannel, PageInitializer> {
     return this._attributeToPage(() => this._mainFrame.goto(url, options));
   }
 
-  async reload(options?: types.NavigateOptions): Promise<Response | null> {
-    return Response.fromNullable(await this._channel.reload({ options }));
+  async reload(options: types.NavigateOptions = {}): Promise<Response | null> {
+    return Response.fromNullable(await this._channel.reload(options));
   }
 
   async waitForLoadState(state?: types.LifecycleEvent, options?: types.TimeoutOptions): Promise<void> {
@@ -343,16 +343,16 @@ export class Page extends ChannelOwner<PageChannel, PageInitializer> {
     return result;
   }
 
-  async goBack(options?: types.NavigateOptions): Promise<Response | null> {
-    return Response.fromNullable(await this._channel.goBack({ options }));
+  async goBack(options: types.NavigateOptions = {}): Promise<Response | null> {
+    return Response.fromNullable(await this._channel.goBack(options));
   }
 
-  async goForward(options?: types.NavigateOptions): Promise<Response | null> {
-    return Response.fromNullable(await this._channel.goForward({ options }));
+  async goForward(options: types.NavigateOptions = {}): Promise<Response | null> {
+    return Response.fromNullable(await this._channel.goForward(options));
   }
 
   async emulateMedia(options: { media?: types.MediaType, colorScheme?: types.ColorScheme }) {
-    await this._channel.emulateMedia({ options });
+    await this._channel.emulateMedia(options);
   }
 
   async setViewportSize(viewportSize: types.Size) {
@@ -388,8 +388,8 @@ export class Page extends ChannelOwner<PageChannel, PageInitializer> {
       await this._channel.setNetworkInterceptionEnabled({ enabled: false });
   }
 
-  async screenshot(options?: types.ScreenshotOptions): Promise<Buffer> {
-    return Buffer.from(await this._channel.screenshot({ options }), 'base64');
+  async screenshot(options: types.ScreenshotOptions = {}): Promise<Buffer> {
+    return Buffer.from(await this._channel.screenshot(options), 'base64');
   }
 
   async title(): Promise<string> {
@@ -397,7 +397,7 @@ export class Page extends ChannelOwner<PageChannel, PageInitializer> {
   }
 
   async close(options: { runBeforeUnload?: boolean } = {runBeforeUnload: undefined}) {
-    await this._channel.close({ options });
+    await this._channel.close(options);
     if (this._ownedContext)
       await this._ownedContext.close();
   }
@@ -496,8 +496,8 @@ export class Page extends ChannelOwner<PageChannel, PageInitializer> {
     return this;
   }
 
-  async pdf(options?: types.PDFOptions): Promise<Buffer> {
-    const binary = await this._channel.pdf({ options });
+  async pdf(options: types.PDFOptions = {}): Promise<Buffer> {
+    const binary = await this._channel.pdf(options);
     return Buffer.from(binary, 'base64');
   }
 }
diff --git a/src/rpc/server/browserDispatcher.ts b/src/rpc/server/browserDispatcher.ts
index 2dcadfa84b..826a77f2f4 100644
--- a/src/rpc/server/browserDispatcher.ts
+++ b/src/rpc/server/browserDispatcher.ts
@@ -31,8 +31,8 @@ export class BrowserDispatcher extends Dispatcher<Browser, BrowserInitializer> i
     });
   }
 
-  async newContext(params: { options?: types.BrowserContextOptions }): Promise<BrowserContextChannel> {
-    return new BrowserContextDispatcher(this._scope, await this._object.newContext(params.options) as BrowserContextBase);
+  async newContext(params: types.BrowserContextOptions): Promise<BrowserContextChannel> {
+    return new BrowserContextDispatcher(this._scope, await this._object.newContext(params) as BrowserContextBase);
   }
 
   async close(): Promise<void> {
diff --git a/src/rpc/server/browserTypeDispatcher.ts b/src/rpc/server/browserTypeDispatcher.ts
index 1a2bbf975d..91bb05f48f 100644
--- a/src/rpc/server/browserTypeDispatcher.ts
+++ b/src/rpc/server/browserTypeDispatcher.ts
@@ -32,22 +32,22 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, BrowserTypeIn
     }, false, browserType.name());
   }
 
-  async launch(params: { options?: types.LaunchOptions }): Promise<BrowserChannel> {
-    const browser = await this._object.launch(params.options || undefined);
+  async launch(params: types.LaunchOptions): Promise<BrowserChannel> {
+    const browser = await this._object.launch(params);
     return new BrowserDispatcher(this._scope, browser as BrowserBase);
   }
 
-  async launchPersistentContext(params: { userDataDir: string, options?: types.LaunchOptions & types.BrowserContextOptions }): Promise<BrowserContextChannel> {
-    const browserContext = await this._object.launchPersistentContext(params.userDataDir, params.options);
+  async launchPersistentContext(params: { userDataDir: string } & types.LaunchOptions & types.BrowserContextOptions): Promise<BrowserContextChannel> {
+    const browserContext = await this._object.launchPersistentContext(params.userDataDir, params);
     return new BrowserContextDispatcher(this._scope, browserContext as BrowserContextBase);
   }
 
-  async launchServer(params: { options?: types.LaunchServerOptions }): Promise<BrowserServerChannel> {
-    return new BrowserServerDispatcher(this._scope, await this._object.launchServer(params.options));
+  async launchServer(params: types.LaunchServerOptions): Promise<BrowserServerChannel> {
+    return new BrowserServerDispatcher(this._scope, await this._object.launchServer(params));
   }
 
-  async connect(params: { options: types.ConnectOptions }): Promise<BrowserChannel> {
-    const browser = await this._object.connect(params.options);
+  async connect(params: types.ConnectOptions): Promise<BrowserChannel> {
+    const browser = await this._object.connect(params);
     return new BrowserDispatcher(this._scope, browser as BrowserBase);
   }
 }
diff --git a/src/rpc/server/elementHandlerDispatcher.ts b/src/rpc/server/elementHandlerDispatcher.ts
index 2adc083cf8..0a09ec59e0 100644
--- a/src/rpc/server/elementHandlerDispatcher.ts
+++ b/src/rpc/server/elementHandlerDispatcher.ts
@@ -69,64 +69,64 @@ export class ElementHandleDispatcher extends JSHandleDispatcher implements Eleme
     await this._elementHandle.dispatchEvent(params.type, params.eventInit);
   }
 
-  async scrollIntoViewIfNeeded(params: { options?: types.TimeoutOptions }) {
-    await this._elementHandle.scrollIntoViewIfNeeded(params.options);
+  async scrollIntoViewIfNeeded(params: types.TimeoutOptions) {
+    await this._elementHandle.scrollIntoViewIfNeeded(params);
   }
 
-  async hover(params: { options?: types.PointerActionOptions & types.PointerActionWaitOptions }) {
-    await this._elementHandle.hover(params.options);
+  async hover(params: types.PointerActionOptions & types.PointerActionWaitOptions) {
+    await this._elementHandle.hover(params);
   }
 
-  async click(params: { options?: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.click(params.options);
+  async click(params: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.click(params);
   }
 
-  async dblclick(params: { options?: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.dblclick(params.options);
+  async dblclick(params: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.dblclick(params);
   }
 
-  async selectOption(params: { values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null, options: types.NavigatingActionWaitOptions }): Promise<string[]> {
-    return this._elementHandle.selectOption(convertSelectOptionValues(params.values), params.options);
+  async selectOption(params: { values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null } & types.NavigatingActionWaitOptions): Promise<string[]> {
+    return this._elementHandle.selectOption(convertSelectOptionValues(params.values), params);
   }
 
-  async fill(params: { value: string, options: types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.fill(params.value, params.options);
+  async fill(params: { value: string } & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.fill(params.value, params);
   }
 
-  async selectText(params: { options?: types.TimeoutOptions }) {
-    await this._elementHandle.selectText(params.options);
+  async selectText(params: types.TimeoutOptions) {
+    await this._elementHandle.selectText(params);
   }
 
-  async setInputFiles(params: { files: string | types.FilePayload | string[] | types.FilePayload[], options?: types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.setInputFiles(params.files, params.options);
+  async setInputFiles(params: { files: string | types.FilePayload | string[] | types.FilePayload[] } & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.setInputFiles(params.files, params);
   }
 
   async focus() {
     await this._elementHandle.focus();
   }
 
-  async type(params: { text: string, options: { delay?: number } & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.type(params.text, params.options);
+  async type(params: { text: string } & { delay?: number } & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.type(params.text, params);
   }
 
-  async press(params: { key: string, options: { delay?: number } & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.press(params.key, params.options);
+  async press(params: { key: string } & { delay?: number } & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.press(params.key, params);
   }
 
-  async check(params: { options?: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.check(params.options);
+  async check(params: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.check(params);
   }
 
-  async uncheck(params: { options?: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions }) {
-    await this._elementHandle.uncheck(params.options);
+  async uncheck(params: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
+    await this._elementHandle.uncheck(params);
   }
 
   async boundingBox(): Promise<types.Rect | null> {
     return await this._elementHandle.boundingBox();
   }
 
-  async screenshot(params: { options?: types.ElementScreenshotOptions }): Promise<string> {
-    return (await this._elementHandle.screenshot(params.options)).toString('base64');
+  async screenshot(params: types.ElementScreenshotOptions): Promise<string> {
+    return (await this._elementHandle.screenshot(params)).toString('base64');
   }
 
   async querySelector(params: { selector: string }): Promise<ElementHandleChannel | null> {
diff --git a/src/rpc/server/frameDispatcher.ts b/src/rpc/server/frameDispatcher.ts
index b305a264c5..4244d9c896 100644
--- a/src/rpc/server/frameDispatcher.ts
+++ b/src/rpc/server/frameDispatcher.ts
@@ -16,7 +16,7 @@
 
 import { Frame } from '../../frames';
 import * as types from '../../types';
-import { ElementHandleChannel, FrameChannel, FrameInitializer, JSHandleChannel, ResponseChannel } from '../channels';
+import { ElementHandleChannel, FrameChannel, FrameInitializer, JSHandleChannel, ResponseChannel, PageAttribution } from '../channels';
 import { Dispatcher, DispatcherScope, lookupNullableDispatcher, existingDispatcher } from './dispatcher';
 import { convertSelectOptionValues, ElementHandleDispatcher, createHandle } from './elementHandlerDispatcher';
 import { parseArgument, serializeResult } from './jsHandleDispatcher';
@@ -39,61 +39,61 @@ export class FrameDispatcher extends Dispatcher<Frame, FrameInitializer> impleme
     this._frame = frame;
   }
 
-  async goto(params: { url: string, options: types.GotoOptions, isPage?: boolean }): Promise<ResponseChannel | null> {
+  async goto(params: { url: string } & types.GotoOptions & PageAttribution): Promise<ResponseChannel | null> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return lookupNullableDispatcher<ResponseDispatcher>(await target.goto(params.url, params.options));
+    return lookupNullableDispatcher<ResponseDispatcher>(await target.goto(params.url, params));
   }
 
-  async waitForLoadState(params: { state?: 'load' | 'domcontentloaded' | 'networkidle', options?: types.TimeoutOptions, isPage?: boolean }): Promise<void> {
+  async waitForLoadState(params: { state?: 'load' | 'domcontentloaded' | 'networkidle' } & types.TimeoutOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.waitForLoadState(params.state, params.options);
+    await target.waitForLoadState(params.state, params);
   }
 
-  async waitForNavigation(params: { options?: types.WaitForNavigationOptions, isPage?: boolean }): Promise<ResponseChannel | null> {
+  async waitForNavigation(params: types.WaitForNavigationOptions & PageAttribution): Promise<ResponseChannel | null> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return lookupNullableDispatcher<ResponseDispatcher>(await target.waitForNavigation(params.options));
+    return lookupNullableDispatcher<ResponseDispatcher>(await target.waitForNavigation(params));
   }
 
   async frameElement(): Promise<ElementHandleChannel> {
     return new ElementHandleDispatcher(this._scope, await this._frame.frameElement());
   }
 
-  async evaluateExpression(params: { expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any> {
+  async evaluateExpression(params: { expression: string, isFunction: boolean, arg: any } & PageAttribution): Promise<any> {
     const target = params.isPage ? this._frame._page : this._frame;
     return serializeResult(await target._evaluateExpression(params.expression, params.isFunction, parseArgument(params.arg)));
   }
 
-  async evaluateExpressionHandle(params: { expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<JSHandleChannel> {
+  async evaluateExpressionHandle(params: { expression: string, isFunction: boolean, arg: any } & PageAttribution): Promise<JSHandleChannel> {
     const target = params.isPage ? this._frame._page : this._frame;
     return createHandle(this._scope, await target._evaluateExpressionHandle(params.expression, params.isFunction, parseArgument(params.arg)));
   }
 
-  async waitForSelector(params: { selector: string, options: types.WaitForElementOptions, isPage?: boolean }): Promise<ElementHandleChannel | null> {
+  async waitForSelector(params: { selector: string } & types.WaitForElementOptions & PageAttribution): Promise<ElementHandleChannel | null> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return ElementHandleDispatcher.createNullable(this._scope, await target.waitForSelector(params.selector, params.options));
+    return ElementHandleDispatcher.createNullable(this._scope, await target.waitForSelector(params.selector, params));
   }
 
-  async dispatchEvent(params: { selector: string, type: string, eventInit: any, options: types.TimeoutOptions, isPage?: boolean }): Promise<void> {
+  async dispatchEvent(params: { selector: string, type: string, eventInit: any } & types.TimeoutOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return target.dispatchEvent(params.selector, params.type, parseArgument(params.eventInit), params.options);
+    return target.dispatchEvent(params.selector, params.type, parseArgument(params.eventInit), params);
   }
 
-  async evalOnSelector(params: { selector: string, expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any> {
+  async evalOnSelector(params: { selector: string, expression: string, isFunction: boolean, arg: any } & PageAttribution): Promise<any> {
     const target = params.isPage ? this._frame._page : this._frame;
     return serializeResult(await target._$evalExpression(params.selector, params.expression, params.isFunction, parseArgument(params.arg)));
   }
 
-  async evalOnSelectorAll(params: { selector: string, expression: string, isFunction: boolean, arg: any, isPage?: boolean }): Promise<any> {
+  async evalOnSelectorAll(params: { selector: string, expression: string, isFunction: boolean, arg: any } & PageAttribution): Promise<any> {
     const target = params.isPage ? this._frame._page : this._frame;
     return serializeResult(await target._$$evalExpression(params.selector, params.expression, params.isFunction, parseArgument(params.arg)));
   }
 
-  async querySelector(params: { selector: string, isPage?: boolean }): Promise<ElementHandleChannel | null> {
+  async querySelector(params: { selector: string } & PageAttribution): Promise<ElementHandleChannel | null> {
     const target = params.isPage ? this._frame._page : this._frame;
     return ElementHandleDispatcher.createNullable(this._scope, await target.$(params.selector));
   }
 
-  async querySelectorAll(params: { selector: string, isPage?: boolean }): Promise<ElementHandleChannel[]> {
+  async querySelectorAll(params: { selector: string } & PageAttribution): Promise<ElementHandleChannel[]> {
     const target = params.isPage ? this._frame._page : this._frame;
     const elements = await target.$$(params.selector);
     return elements.map(e => new ElementHandleDispatcher(this._scope, e));
@@ -103,99 +103,99 @@ export class FrameDispatcher extends Dispatcher<Frame, FrameInitializer> impleme
     return await this._frame.content();
   }
 
-  async setContent(params: { html: string, options: types.NavigateOptions, isPage?: boolean }): Promise<void> {
+  async setContent(params: { html: string } & types.NavigateOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.setContent(params.html, params.options);
+    await target.setContent(params.html, params);
   }
 
-  async addScriptTag(params: { options: { url?: string | undefined, path?: string | undefined, content?: string | undefined, type?: string | undefined }, isPage?: boolean }): Promise<ElementHandleChannel> {
+  async addScriptTag(params: { url?: string | undefined, path?: string | undefined, content?: string | undefined, type?: string | undefined } & PageAttribution): Promise<ElementHandleChannel> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return new ElementHandleDispatcher(this._scope, await target.addScriptTag(params.options));
+    return new ElementHandleDispatcher(this._scope, await target.addScriptTag(params));
   }
 
-  async addStyleTag(params: { options: { url?: string | undefined, path?: string | undefined, content?: string | undefined }, isPage?: boolean }): Promise<ElementHandleChannel> {
+  async addStyleTag(params: { url?: string | undefined, path?: string | undefined, content?: string | undefined } & PageAttribution): Promise<ElementHandleChannel> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return new ElementHandleDispatcher(this._scope, await target.addStyleTag(params.options));
+    return new ElementHandleDispatcher(this._scope, await target.addStyleTag(params));
   }
 
-  async click(params: { selector: string, options: types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void> {
+  async click(params: { selector: string } & types.PointerActionOptions & types.MouseClickOptions & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.click(params.selector, params.options);
+    await target.click(params.selector, params);
   }
 
-  async dblclick(params: { selector: string, options: types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions & { force?: boolean }, isPage?: boolean }): Promise<void> {
+  async dblclick(params: { selector: string } & types.PointerActionOptions & types.MouseMultiClickOptions & types.TimeoutOptions & { force?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.dblclick(params.selector, params.options);
+    await target.dblclick(params.selector, params);
   }
 
-  async fill(params: { selector: string, value: string, options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<void> {
+  async fill(params: { selector: string, value: string } & types.NavigatingActionWaitOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.fill(params.selector, params.value, params.options);
+    await target.fill(params.selector, params.value, params);
   }
 
-  async focus(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<void> {
+  async focus(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.focus(params.selector, params.options);
+    await target.focus(params.selector, params);
   }
 
-  async textContent(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string | null> {
+  async textContent(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string | null> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return await target.textContent(params.selector, params.options);
+    return await target.textContent(params.selector, params);
   }
 
-  async innerText(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string> {
+  async innerText(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return await target.innerText(params.selector, params.options);
+    return await target.innerText(params.selector, params);
   }
 
-  async innerHTML(params: { selector: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string> {
+  async innerHTML(params: { selector: string } & types.TimeoutOptions & PageAttribution): Promise<string> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return await target.innerHTML(params.selector, params.options);
+    return await target.innerHTML(params.selector, params);
   }
 
-  async getAttribute(params: { selector: string, name: string, options: types.TimeoutOptions, isPage?: boolean }): Promise<string | null> {
+  async getAttribute(params: { selector: string, name: string } & types.TimeoutOptions & PageAttribution): Promise<string | null> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return await target.getAttribute(params.selector, params.name, params.options);
+    return await target.getAttribute(params.selector, params.name, params);
   }
 
-  async hover(params: { selector: string, options: types.PointerActionOptions & types.TimeoutOptions & { force?: boolean }, isPage?: boolean }): Promise<void> {
+  async hover(params: { selector: string } & types.PointerActionOptions & types.TimeoutOptions & { force?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.hover(params.selector, params.options);
+    await target.hover(params.selector, params);
   }
 
-  async selectOption(params: { selector: string, values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null, options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<string[]> {
+  async selectOption(params: { selector: string, values: string | ElementHandleChannel | types.SelectOption | string[] | ElementHandleChannel[] | types.SelectOption[] | null } & types.NavigatingActionWaitOptions & PageAttribution): Promise<string[]> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return target.selectOption(params.selector, convertSelectOptionValues(params.values), params.options);
+    return target.selectOption(params.selector, convertSelectOptionValues(params.values), params);
   }
 
-  async setInputFiles(params: { selector: string, files: { name: string, mimeType: string, buffer: string }[], options: types.NavigatingActionWaitOptions, isPage?: boolean }): Promise<void> {
+  async setInputFiles(params: { selector: string, files: { name: string, mimeType: string, buffer: string }[] } & types.NavigatingActionWaitOptions & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.setInputFiles(params.selector, params.files.map(f => ({ name: f.name, mimeType: f.mimeType, buffer: Buffer.from(f.buffer, 'base64') })), params.options);
+    await target.setInputFiles(params.selector, params.files.map(f => ({ name: f.name, mimeType: f.mimeType, buffer: Buffer.from(f.buffer, 'base64') })), params);
   }
 
-  async type(params: { selector: string, text: string, options: { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void> {
+  async type(params: { selector: string, text: string } & { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.type(params.selector, params.text, params.options);
+    await target.type(params.selector, params.text, params);
   }
 
-  async press(params: { selector: string, key: string, options: { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void> {
+  async press(params: { selector: string, key: string } & { delay?: number | undefined } & types.TimeoutOptions & { noWaitAfter?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.press(params.selector, params.key, params.options);
+    await target.press(params.selector, params.key, params);
   }
 
-  async check(params: { selector: string, options: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void> {
+  async check(params: { selector: string } & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.check(params.selector, params.options);
+    await target.check(params.selector, params);
   }
 
-  async uncheck(params: { selector: string, options: types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean }, isPage?: boolean }): Promise<void> {
+  async uncheck(params: { selector: string } & types.TimeoutOptions & { force?: boolean } & { noWaitAfter?: boolean } & PageAttribution): Promise<void> {
     const target = params.isPage ? this._frame._page : this._frame;
-    await target.uncheck(params.selector, params.options);
+    await target.uncheck(params.selector, params);
   }
 
-  async waitForFunction(params: { expression: string, isFunction: boolean, arg: any; options: types.WaitForFunctionOptions, isPage?: boolean }): Promise<JSHandleChannel> {
+  async waitForFunction(params: { expression: string, isFunction: boolean, arg: any } & types.WaitForFunctionOptions & PageAttribution): Promise<JSHandleChannel> {
     const target = params.isPage ? this._frame._page : this._frame;
-    return createHandle(this._scope, await target._waitForFunctionExpression(params.expression, params.isFunction, parseArgument(params.arg), params.options));
+    return createHandle(this._scope, await target._waitForFunctionExpression(params.expression, params.isFunction, parseArgument(params.arg), params));
   }
 
   async title(): Promise<string> {
diff --git a/src/rpc/server/pageDispatcher.ts b/src/rpc/server/pageDispatcher.ts
index 4c565b44b4..d51f1e1516 100644
--- a/src/rpc/server/pageDispatcher.ts
+++ b/src/rpc/server/pageDispatcher.ts
@@ -91,20 +91,20 @@ export class PageDispatcher extends Dispatcher<Page, PageInitializer> implements
     await this._page.setExtraHTTPHeaders(params.headers);
   }
 
-  async reload(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null> {
-    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.reload(params.options));
+  async reload(params: types.NavigateOptions): Promise<ResponseChannel | null> {
+    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.reload(params));
   }
 
-  async goBack(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null> {
-    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.goBack(params.options));
+  async goBack(params: types.NavigateOptions): Promise<ResponseChannel | null> {
+    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.goBack(params));
   }
 
-  async goForward(params: { options?: types.NavigateOptions }): Promise<ResponseChannel | null> {
-    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.goForward(params.options));
+  async goForward(params: types.NavigateOptions): Promise<ResponseChannel | null> {
+    return lookupNullableDispatcher<ResponseDispatcher>(await this._page.goForward(params));
   }
 
-  async emulateMedia(params: { options: { media?: 'screen' | 'print', colorScheme?: 'dark' | 'light' | 'no-preference' } }): Promise<void> {
-    await this._page.emulateMedia(params.options);
+  async emulateMedia(params: { media?: 'screen' | 'print', colorScheme?: 'dark' | 'light' | 'no-preference' }): Promise<void> {
+    await this._page.emulateMedia(params);
   }
 
   async setViewportSize(params: { viewportSize: types.Size }): Promise<void> {
@@ -125,12 +125,12 @@ export class PageDispatcher extends Dispatcher<Page, PageInitializer> implements
     });
   }
 
-  async screenshot(params: { options?: types.ScreenshotOptions }): Promise<string> {
-    return (await this._page.screenshot(params.options)).toString('base64');
+  async screenshot(params: types.ScreenshotOptions): Promise<string> {
+    return (await this._page.screenshot(params)).toString('base64');
   }
 
-  async close(params: { options?: { runBeforeUnload?: boolean } }): Promise<void> {
-    await this._page.close(params.options);
+  async close(params: { runBeforeUnload?: boolean }): Promise<void> {
+    await this._page.close(params);
   }
 
   async setFileChooserInterceptedNoReply(params: { intercepted: boolean }) {
@@ -152,41 +152,41 @@ export class PageDispatcher extends Dispatcher<Page, PageInitializer> implements
     await this._page.keyboard.insertText(params.text);
   }
 
-  async keyboardType(params: { text: string, options?: { delay?: number } }): Promise<void> {
-    await this._page.keyboard.type(params.text, params.options);
+  async keyboardType(params: { text: string, delay?: number }): Promise<void> {
+    await this._page.keyboard.type(params.text, params);
   }
 
-  async keyboardPress(params: { key: string, options?: { delay?: number } }): Promise<void> {
-    await this._page.keyboard.press(params.key, params.options);
+  async keyboardPress(params: { key: string, delay?: number }): Promise<void> {
+    await this._page.keyboard.press(params.key, params);
   }
 
-  async mouseMove(params: { x: number, y: number, options?: { steps?: number } }): Promise<void> {
-    await this._page.mouse.move(params.x, params.y, params.options);
+  async mouseMove(params: { x: number, y: number, steps?: number }): Promise<void> {
+    await this._page.mouse.move(params.x, params.y, params);
   }
 
-  async mouseDown(params: { options?: { button?: types.MouseButton, clickCount?: number } }): Promise<void> {
-    await this._page.mouse.down(params.options);
+  async mouseDown(params: { button?: types.MouseButton, clickCount?: number }): Promise<void> {
+    await this._page.mouse.down(params);
   }
 
-  async mouseUp(params: { options?: { button?: types.MouseButton, clickCount?: number } }): Promise<void> {
-    await this._page.mouse.up(params.options);
+  async mouseUp(params: { button?: types.MouseButton, clickCount?: number }): Promise<void> {
+    await this._page.mouse.up(params);
   }
 
-  async mouseClick(params: { x: number, y: number, options?: { delay?: number, button?: types.MouseButton, clickCount?: number } }): Promise<void> {
-    await this._page.mouse.click(params.x, params.y, params.options);
+  async mouseClick(params: { x: number, y: number, delay?: number, button?: types.MouseButton, clickCount?: number }): Promise<void> {
+    await this._page.mouse.click(params.x, params.y, params);
   }
 
-  async accessibilitySnapshot(params: { options: { interestingOnly?: boolean, root?: ElementHandleChannel } }): Promise<types.SerializedAXNode | null> {
+  async accessibilitySnapshot(params: { interestingOnly?: boolean, root?: ElementHandleChannel }): Promise<types.SerializedAXNode | null> {
     return await this._page.accessibility.snapshot({
-      interestingOnly: params.options.interestingOnly,
-      root: params.options.root ? (params.options.root as ElementHandleDispatcher)._elementHandle : undefined
+      interestingOnly: params.interestingOnly,
+      root: params.root ? (params.root as ElementHandleDispatcher)._elementHandle : undefined
     });
   }
 
-  async pdf(params: { options?: types.PDFOptions }): Promise<Binary> {
+  async pdf(params: types.PDFOptions): Promise<Binary> {
     if (!this._page.pdf)
       throw new Error('PDF generation is only supported for Headless Chromium');
-    const binary = await this._page.pdf(params.options);
+    const binary = await this._page.pdf(params);
     return binary.toString('base64');
   }