static css(value) {
+  if (typeof value !== 'string' || value.trim() === '') throw new Error('Value must be a non-empty string.');
   return new Locator(Locator.Type.CSS, value)
 }
 static xpath(value) {
+  if (typeof value !== 'string' || value.trim() === '') throw new Error('Value must be a non-empty string.');
   return new Locator(Locator.Type.XPATH, value)
 }
 static innerText(value, ignoreCase = undefined, matchType = undefined, maxDepth = undefined) {
+  if (typeof value !== 'string' || value.trim() === '') throw new Error('Value must be a non-empty string.');
   return new Locator(Locator.Type.INNER_TEXT, value, ignoreCase, matchType, maxDepth)
 }
 

 async captureScreenshot(captureScreenshotParameters = undefined) {
-  if (
-    captureScreenshotParameters !== undefined &&
+  if (captureScreenshotParameters !== undefined && !(captureScreenshotParameters instanceof CaptureScreenshotParameters)) {
+    throw new InvalidArgumentError('captureScreenshotParameters must be an instance of CaptureScreenshotParameters.');
+  }
 

 async locateNodes(
   locator,
   maxNodeCount = undefined,
+  if (!(locator instanceof Locator)) {
+    throw new Error('locator must be an instance of Locator.');
+  }
 async locateNode(
   locator,
   ownership = undefined,
+  if (!(locator instanceof Locator)) {
+    throw new Error('locator must be an instance of Locator.');
+  }
 

-async reload(ignoreCache = undefined, readinessState = undefined) {
+async reload(ignoreCache = false, readinessState = undefined) {
 

 async setViewport(width, height, devicePixelRatio = undefined) {
+  if (width <= 0 || height <= 0 || (devicePixelRatio !== undefined && devicePixelRatio <= 0)) {
+    throw new Error('Width, height, and devicePixelRatio must be positive numbers.');
+  }
 

-const { RemoteValue, LocalValue } = require('./protocolValue')
-const { ResultOwnership } = require('./resultOwnership')
+const { RemoteValue, LocalValue, ResultOwnership } = require('./values')
 

-let value = []
-Object.entries(map).forEach((entry) => {
-  value.push(entry)
-})
+let value = Object.fromEntries(Object.entries(map))
 

-throw new Error(`Params must be an instance of AddInterceptParameters. Received:'${params}'`)
+throw new Error(`Params must be an instance of AddInterceptParameters. Received type: '${typeof params}'`)
 

 expiry(expiry) {
+  if (!isValidExpiry(expiry)) {
+    throw new Error(`Invalid expiry time: ${expiry}.`);
+  }
   this.#map.set('expiry', expiry)
   return this
 

 if (!(value instanceof BytesValue)) {
-  throw new Error(`Value must be an instance of BytesValue. Received:'${value}'`)
+  throw new Error(`Value must be an instance of BytesValue. Received type: ${typeof value}, value: '${value}'`)
 

 size(size) {
+  if (!Number.isInteger(size) || size < 0) {
+    throw new Error(`Size must be a positive integer. Received: ${size}`);
+  }
   this.#map.set('size', size)
   return this
 

-async disownRealmScript(realmId, handles) {
-async disownBrowsingContextScript(browsingContextId, handles, sandbox = null) {
+async disownRealmScript(options) {
+async disownBrowsingContextScript(options) {
 

 async callFunctionInRealm(realmId, functionDeclaration, awaitPromise, argumentValueList = null, thisParameter = null, resultOwnership = null) {
+    // Validate parameters here
+}
 async callFunctionInBrowsingContext(browsingContextId, functionDeclaration, awaitPromise, argumentValueList = null, thisParameter = null, resultOwnership = null) {
+    // Validate parameters here
+}
 

-await this.bidi.send(params)
+try {
+    await this.bidi.send(params)
+} catch (error) {
+    console.error("Failed to send command:", error);
+    // Handle error appropriately
+}
 

-async evaluateFunctionInRealm(realmId, expression, awaitPromise, resultOwnership = null) {
-async evaluateFunctionInBrowsingContext(browsingContextId, expression, awaitPromise, resultOwnership = null) {
+async evaluateFunction(contextType, contextId, expression, awaitPromise, resultOwnership = null) {
 

+// Grouped event subscription methods
 async beforeRequestSent(callback) {
   await this.subscribeAndHandleEvent('network.beforeRequestSent', callback)
 }
 ...
+// Grouped action methods
 async addIntercept(params) {
   if (!(params instanceof AddInterceptParameters)) {
     throw new Error(`Params must be an instance of AddInterceptParameters. Received:'${params}'`)
 }
 

-throw new Error(`Params must be a value in SameSite. Received:'${sameSite}'`)
+throw new Error(`SameSite value must be an instance of SameSite. Received:'${sameSite}'`)
 

+#setAndReturn(key, value) {
+  this.#map.set(key, value);
+  return this;
+}
 name(name) {
-  this.#map.set('name', name)
-  return this
+  return this.#setAndReturn('name', name);
 }
 

-if (handle === RemoteReferenceType.HANDLE) {
-  this.#handle = sharedId
+if (handle != null) {
+  this.#handle = handle
 }
 

 async cancelAuth(requestId) {
   const command = {
-    method: 'network.continueWithAuth',
+    method: 'network.cancelAuth', // Assuming there's a separate command for canceling auth
 }