mimic-browser 0.1.0

data/lib/mimic_sdk/generated.rb

@@ -0,0 +1,878 @@
+# Generated by generator/generate.py; DO NOT EDIT.
+# Schema SHA-256: ea792e2f194bf831f5494bedd65a7112881e45695b3af3d504367c317684e7a6
+
+module MimicSDK
+  module Generated
+    SCHEMA_SHA256 = "ea792e2f194bf831f5494bedd65a7112881e45695b3af3d504367c317684e7a6"
+
+    UNSET = Object.new.freeze
+    def self.to_wire(value)
+      case value
+      when Model then value.to_wire
+      when Hash then value.each_with_object({}) { |(key, child), result| result[key] = to_wire(child) unless child.equal?(UNSET) }
+      when Array then value.map { |child| raise ArgumentError, 'UNSET in array' if child.equal?(UNSET); to_wire(child) }
+      else value
+      end
+    end
+    class Model
+      def self.from_wire(value)
+        raise ArgumentError, 'Expected object' unless value.is_a?(Hash)
+        options = {}
+        self::FIELDS.each do |name, wire|
+          next unless value.key?(wire)
+          options[name] = Generated.decode(self::TYPES[name], value[wire])
+        end
+        new(**options)
+      end
+      def initialize(**options)
+        unknown = options.keys - self.class::FIELDS.keys
+        raise ArgumentError, "Unknown fields: #{unknown}" unless unknown.empty?
+        self.class::FIELDS.each { |name, _wire| instance_variable_set("@#{name}", options.fetch(name, UNSET)) }
+      end
+      def to_wire
+        self.class::FIELDS.each_with_object({}) do |(name, wire), result|
+          value = instance_variable_get("@#{name}")
+          raise ArgumentError, "Missing required field: #{name}" if value.equal?(UNSET) && self.class::REQUIRED.include?(name)
+          result[wire] = Generated.to_wire(value) unless value.equal?(UNSET)
+        end
+      end
+    end
+    def self.decode(type, value)
+      return nil if value.nil?
+      if type.is_a?(Array)
+        return value.map { |child| decode(type[1], child) } if type[0] == :array
+        return value.transform_values { |child| decode(type[1], child) } if type[0] == :map
+      end
+      return const_get(type).from_wire(value) if type.is_a?(String) && const_defined?(type) && const_get(type).is_a?(Class) && const_get(type) < Model
+      value
+    end
+
+    class CameraFormat < Model
+      FIELDS = {width: "width", height: "height", frame_rate: "frameRate"}.freeze
+      TYPES = {width: nil, height: nil, frame_rate: nil}.freeze
+      REQUIRED = [:width, :height, :frame_rate].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CancelExecutionParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CancelExecutionResult < Model
+      FIELDS = {cancelled: "cancelled"}.freeze
+      TYPES = {cancelled: nil}.freeze
+      REQUIRED = [:cancelled].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CaptureSnapshotParams < Model
+      FIELDS = {interrupt: "interrupt"}.freeze
+      TYPES = {interrupt: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CaptureSnapshotResult < Model
+      FIELDS = {url: "url", files: "files", warnings: "warnings", timings_ms: "timingsMs"}.freeze
+      TYPES = {url: nil, files: [:map, nil], warnings: [:array, nil], timings_ms: [:map, nil]}.freeze
+      REQUIRED = [:url, :files, :warnings, :timings_ms].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ClearTraceParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ClearTraceResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ConfigureContextParams < Model
+      FIELDS = {profile: "profile", proxy: "proxy", resource_policy: "resourcePolicy", media: "media", browser_context_id: "browserContextId"}.freeze
+      TYPES = {profile: "ProfileSelection", proxy: "Proxy", resource_policy: "ResourcePolicy", media: "MediaConfiguration", browser_context_id: nil}.freeze
+      REQUIRED = [:browser_context_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ConfigureContextResult < Model
+      FIELDS = {profile: "profile", profile_id: "profileId", mode: "mode", warnings: "warnings", browser_context_id: "browserContextId", media: "media"}.freeze
+      TYPES = {profile: nil, profile_id: nil, mode: nil, warnings: [:array, nil], browser_context_id: nil, media: "MediaProfile"}.freeze
+      REQUIRED = [:profile, :profile_id, :mode, :warnings, :browser_context_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CreateContextParams < Model
+      FIELDS = {profile: "profile", proxy: "proxy", resource_policy: "resourcePolicy", dispose_on_detach: "disposeOnDetach", media: "media"}.freeze
+      TYPES = {profile: "ProfileSelection", proxy: "Proxy", resource_policy: "ResourcePolicy", dispose_on_detach: nil, media: "MediaConfiguration"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class CreateContextResult < Model
+      FIELDS = {profile: "profile", profile_id: "profileId", mode: "mode", warnings: "warnings", browser_context_id: "browserContextId", media: "media"}.freeze
+      TYPES = {profile: nil, profile_id: nil, mode: nil, warnings: [:array, nil], browser_context_id: nil, media: "MediaProfile"}.freeze
+      REQUIRED = [:profile, :profile_id, :mode, :warnings, :browser_context_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class DiagnosticCost < Model
+      FIELDS = {count: "count", ns: "ns"}.freeze
+      TYPES = {count: nil, ns: nil}.freeze
+      REQUIRED = [:count, :ns].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class Diagnostics < Model
+      FIELDS = {enabled: "enabled", host_only: "hostOnly", costs: "costs", cpu_profiles: "cpu_profiles", realms: "realms"}.freeze
+      TYPES = {enabled: nil, host_only: nil, costs: [:map, "DiagnosticCost"], cpu_profiles: [:map, nil], realms: [:array, "RealmDiagnostics"]}.freeze
+      REQUIRED = [:enabled].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class Empty < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentAudio < Model
+      FIELDS = {sample_rate: "sampleRate", channels: "channels", buffer_duration: "bufferDuration", max_buffer_frames: "maxBufferFrames"}.freeze
+      TYPES = {sample_rate: nil, channels: nil, buffer_duration: nil, max_buffer_frames: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentCapabilities < Model
+      FIELDS = {storage_quota_bytes: "storageQuotaBytes", devices: "devices", media: "media", keyboard_layout: "keyboardLayout"}.freeze
+      TYPES = {storage_quota_bytes: nil, devices: "EnvironmentDeviceCapabilities", media: "EnvironmentMediaCapabilities", keyboard_layout: [:map, nil]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentDeviceCapabilities < Model
+      FIELDS = {bluetooth_available: "bluetoothAvailable", posture: "posture"}.freeze
+      TYPES = {bluetooth_available: nil, posture: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentDisplay < Model
+      FIELDS = {width: "width", height: "height", available_width: "availableWidth", available_height: "availableHeight", device_scale_factor: "deviceScaleFactor", color_depth: "colorDepth", orientation: "orientation"}.freeze
+      TYPES = {width: nil, height: nil, available_width: nil, available_height: nil, device_scale_factor: nil, color_depth: nil, orientation: "EnvironmentScreenOrientation"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentFonts < Model
+      FIELDS = {serif: "serif", sans_serif: "sansSerif", monospace: "monospace", system_u_i: "systemUI", system: "system", fallback: "fallback"}.freeze
+      TYPES = {serif: nil, sans_serif: nil, monospace: nil, system_u_i: nil, system: [:map, nil], fallback: [:array, nil]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentGPUAdapter < Model
+      FIELDS = {vendor: "vendor", architecture: "architecture", device: "device", description: "description", subgroup_min_size: "subgroupMinSize", subgroup_max_size: "subgroupMaxSize", is_fallback_adapter: "isFallbackAdapter", features: "features", limits: "limits", wgsl_language_features: "wgslLanguageFeatures", initialization_delay_millis: "initializationDelayMillis"}.freeze
+      TYPES = {vendor: nil, architecture: nil, device: nil, description: nil, subgroup_min_size: nil, subgroup_max_size: nil, is_fallback_adapter: nil, features: [:array, nil], limits: [:map, nil], wgsl_language_features: [:array, nil], initialization_delay_millis: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentGraphics < Model
+      FIELDS = {vendor: "vendor", renderer: "renderer", max_texture_size: "maxTextureSize", web_g_l_capabilities_j_s_o_n: "webGLCapabilitiesJSON", web_g_p_u: "webGPU", web_g_p_u_adapters: "webGPUAdapters"}.freeze
+      TYPES = {vendor: nil, renderer: nil, max_texture_size: nil, web_g_l_capabilities_j_s_o_n: nil, web_g_p_u: "EnvironmentGPUAdapter", web_g_p_u_adapters: [:map, "EnvironmentGPUAdapter"]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentHardware < Model
+      FIELDS = {cpu_performance: "cpuPerformance", cpu_performance_known: "cpuPerformanceKnown", logical_processors: "logicalProcessors", device_memory_g_b: "deviceMemoryGB"}.freeze
+      TYPES = {cpu_performance: nil, cpu_performance_known: nil, logical_processors: nil, device_memory_g_b: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentICEProfile < Model
+      FIELDS = {host_candidate_count: "hostCandidateCount", reflexive_candidate_count: "reflexiveCandidateCount", port_offsets: "portOffsets", reflexive_port_offsets: "reflexivePortOffsets", public_address: "publicAddress", network_cost: "networkCost", host_delay_millis: "hostDelayMillis", reflexive_delay_millis: "reflexiveDelayMillis", end_delay_millis: "endDelayMillis"}.freeze
+      TYPES = {host_candidate_count: nil, reflexive_candidate_count: nil, port_offsets: [:array, nil], reflexive_port_offsets: [:array, nil], public_address: nil, network_cost: nil, host_delay_millis: nil, reflexive_delay_millis: nil, end_delay_millis: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentIdentity < Model
+      FIELDS = {user_agent: "userAgent", platform: "platform", metadata: "metadata"}.freeze
+      TYPES = {user_agent: nil, platform: nil, metadata: "EnvironmentUserAgentMetadata"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentLocale < Model
+      FIELDS = {reduce_accept_language: "reduceAcceptLanguage", languages: "languages", intl_locale: "intlLocale", timezone: "timezone"}.freeze
+      TYPES = {reduce_accept_language: nil, languages: [:array, nil], intl_locale: nil, timezone: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentMediaCapabilities < Model
+      FIELDS = {rtp: "rtp", formats: "formats", kinds: "kinds", supported_constraints: "supportedConstraints"}.freeze
+      TYPES = {rtp: [:map, "EnvironmentRTPMediaCatalog"], formats: "EnvironmentMediaFormatCatalog", kinds: [:array, nil], supported_constraints: [:array, nil]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentMediaContainerPolicy < Model
+      FIELDS = {codecs: "codecs", default_codec: "defaultCodec", media_source: "mediaSource"}.freeze
+      TYPES = {codecs: [:array, nil], default_codec: nil, media_source: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentMediaFormatCatalog < Model
+      FIELDS = {containers: "containers", efficient_video: "efficientVideo"}.freeze
+      TYPES = {containers: [:map, "EnvironmentMediaContainerPolicy"], efficient_video: [:array, nil]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentNetwork < Model
+      FIELDS = {save_data: "saveData", online: "online", effective_type: "effectiveType", downlink_mbps: "downlinkMbps", rtt_millis: "rttMillis", cookies_enabled: "cookiesEnabled", wire_profile: "wireProfile", ice: "ice", proxy: "proxy"}.freeze
+      TYPES = {save_data: nil, online: nil, effective_type: nil, downlink_mbps: nil, rtt_millis: nil, cookies_enabled: nil, wire_profile: nil, ice: "EnvironmentICEProfile", proxy: "EnvironmentProxy"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentPreferences < Model
+      FIELDS = {color_scheme: "colorScheme", system_colors: "systemColors", reduced_motion: "reducedMotion", do_not_track: "doNotTrack"}.freeze
+      TYPES = {color_scheme: nil, system_colors: [:map, [:map, nil]], reduced_motion: nil, do_not_track: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentProfile < Model
+      FIELDS = {schema_version: "schemaVersion", base_profile: "baseProfile", identity: "identity", display: "display", window: "window", hardware: "hardware", locale: "locale", graphics: "graphics", audio: "audio", fonts: "fonts", preferences: "preferences", network: "network", permissions: "permissions", capabilities: "capabilities", features: "features", timing: "timing"}.freeze
+      TYPES = {schema_version: nil, base_profile: nil, identity: "EnvironmentIdentity", display: "EnvironmentDisplay", window: "EnvironmentWindow", hardware: "EnvironmentHardware", locale: "EnvironmentLocale", graphics: "EnvironmentGraphics", audio: "EnvironmentAudio", fonts: "EnvironmentFonts", preferences: "EnvironmentPreferences", network: "EnvironmentNetwork", permissions: [:map, nil], capabilities: "EnvironmentCapabilities", features: [:map, nil], timing: "EnvironmentTiming"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentProxy < Model
+      FIELDS = {server: "server", username: "username", password: "password"}.freeze
+      TYPES = {server: nil, username: nil, password: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentRTPCodec < Model
+      FIELDS = {name: "name", clock_rate: "clockRate", channels: "channels", parameters: "parameters", sender_parameters: "senderParameters", feedback: "feedback", payload: "payload", rtx_payload: "rtxPayload", redundant: "redundant"}.freeze
+      TYPES = {name: nil, clock_rate: nil, channels: nil, parameters: nil, sender_parameters: nil, feedback: [:array, nil], payload: nil, rtx_payload: nil, redundant: [:array, nil]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentRTPMediaCatalog < Model
+      FIELDS = {codecs: "codecs", sender_order: "senderOrder", receiver_order: "receiverOrder", offer_order: "offerOrder", header_extensions: "headerExtensions", receiver_r_t_t: "receiverRTT"}.freeze
+      TYPES = {codecs: [:map, "EnvironmentRTPCodec"], sender_order: [:array, nil], receiver_order: [:array, nil], offer_order: [:array, nil], header_extensions: [:array, nil], receiver_r_t_t: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentScreenOrientation < Model
+      FIELDS = {type: "type", angle: "angle"}.freeze
+      TYPES = {type: nil, angle: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentTiming < Model
+      FIELDS = {execution_scale: "executionScale", navigation_scale: "navigationScale", network_scale: "networkScale"}.freeze
+      TYPES = {execution_scale: nil, navigation_scale: nil, network_scale: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentUserAgentBrand < Model
+      FIELDS = {brand: "brand", version: "version", full_version: "fullVersion"}.freeze
+      TYPES = {brand: nil, version: nil, full_version: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentUserAgentMetadata < Model
+      FIELDS = {brands: "brands", full_version_list: "fullVersionList", form_factors: "formFactors", full_version: "fullVersion", platform: "platform", platform_version: "platformVersion", architecture: "architecture", model: "model", bitness: "bitness", mobile: "mobile", wow64: "wow64"}.freeze
+      TYPES = {brands: [:array, "EnvironmentUserAgentBrand"], full_version_list: [:array, "EnvironmentUserAgentBrand"], form_factors: [:array, nil], full_version: nil, platform: nil, platform_version: nil, architecture: nil, model: nil, bitness: nil, mobile: nil, wow64: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class EnvironmentWindow < Model
+      FIELDS = {x: "x", y: "y", outer_width: "outerWidth", outer_height: "outerHeight", viewport_width: "viewportWidth", viewport_height: "viewportHeight"}.freeze
+      TYPES = {x: nil, y: nil, outer_width: nil, outer_height: nil, viewport_width: nil, viewport_height: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ExecutionStatus < Model
+      FIELDS = {running: "running", task_id: "taskId", source: "source", phase: "phase", elapsed_ms: "elapsedMs"}.freeze
+      TYPES = {running: nil, task_id: nil, source: nil, phase: nil, elapsed_ms: nil}.freeze
+      REQUIRED = [:running, :task_id, :source, :phase, :elapsed_ms].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ExportProfileParams < Model
+      FIELDS = {profile: "profile"}.freeze
+      TYPES = {profile: nil}.freeze
+      REQUIRED = [:profile].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ExportProfileResult < Model
+      FIELDS = {profile: "profile", warnings: "warnings"}.freeze
+      TYPES = {profile: "ProfileDescriptor", warnings: [:array, nil]}.freeze
+      REQUIRED = [:profile, :warnings].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GenerateProfileOptions < Model
+      FIELDS = {browser: "browser", version: "version", platform: "platform", seed: "seed"}.freeze
+      TYPES = {browser: nil, version: nil, platform: nil, seed: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GenerateProfileParams < Model
+      FIELDS = {browser: "browser", version: "version", platform: "platform", seed: "seed"}.freeze
+      TYPES = {browser: nil, version: nil, platform: nil, seed: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GenerateProfileResult < Model
+      FIELDS = {profile: "profile", profile_id: "profileId", mode: "mode", warnings: "warnings"}.freeze
+      TYPES = {profile: nil, profile_id: nil, mode: nil, warnings: [:array, nil]}.freeze
+      REQUIRED = [:profile, :profile_id, :mode, :warnings].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GenerateProfileSelection < Model
+      FIELDS = {generate: "generate"}.freeze
+      TYPES = {generate: "GenerateProfileOptions"}.freeze
+      REQUIRED = [:generate].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetCompatibilityMatrixParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetCompatibilityMatrixResult < Model
+      FIELDS = {chrome_version: "chromeVersion", protocol: "protocol", extensions: "extensions"}.freeze
+      TYPES = {chrome_version: nil, protocol: [:array, "ProtocolCoverage"], extensions: [:array, "ProtocolCoverage"]}.freeze
+      REQUIRED = [:chrome_version, :protocol, :extensions].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetDiagnosticsParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetDiagnosticsResult < Model
+      FIELDS = {enabled: "enabled", host_only: "hostOnly", costs: "costs", cpu_profiles: "cpu_profiles", realms: "realms"}.freeze
+      TYPES = {enabled: nil, host_only: nil, costs: [:map, "DiagnosticCost"], cpu_profiles: [:map, nil], realms: [:array, "RealmDiagnostics"]}.freeze
+      REQUIRED = [:enabled].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaPresetsParams < Model
+      FIELDS = {browser_context_id: "browserContextId"}.freeze
+      TYPES = {browser_context_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaPresetsResult < Model
+      FIELDS = {presets: "presets"}.freeze
+      TYPES = {presets: [:array, "MediaPreset"]}.freeze
+      REQUIRED = [:presets].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaProfileParams < Model
+      FIELDS = {browser_context_id: "browserContextId"}.freeze
+      TYPES = {browser_context_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaProfileResult < Model
+      FIELDS = {profile: "profile", diagnostics: "diagnostics"}.freeze
+      TYPES = {profile: "MediaProfile", diagnostics: [:map, nil]}.freeze
+      REQUIRED = [:profile, :diagnostics].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaSourcesParams < Model
+      FIELDS = {browser_context_id: "browserContextId"}.freeze
+      TYPES = {browser_context_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetMediaSourcesResult < Model
+      FIELDS = {sources: "sources", diagnostics: "diagnostics"}.freeze
+      TYPES = {sources: [:array, "MediaSource"], diagnostics: [:map, nil]}.freeze
+      REQUIRED = [:sources, :diagnostics].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetProfileParams < Model
+      FIELDS = {browser_context_id: "browserContextId", target_id: "targetId"}.freeze
+      TYPES = {browser_context_id: nil, target_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetProfileResult < Model
+      FIELDS = {profile: "profile", limitations: "limitations"}.freeze
+      TYPES = {profile: "EnvironmentProfile", limitations: [:array, nil]}.freeze
+      REQUIRED = [:profile, :limitations].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetProfileSchemaParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetProfileSchemaResult < Model
+      FIELDS = {schema: "schema", base_profiles: "baseProfiles", limitations: "limitations"}.freeze
+      TYPES = {schema: [:map, nil], base_profiles: [:array, nil], limitations: [:array, nil]}.freeze
+      REQUIRED = [:schema, :base_profiles, :limitations].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicyParams < Model
+      FIELDS = {browser_context_id: "browserContextId"}.freeze
+      TYPES = {browser_context_id: nil}.freeze
+      REQUIRED = [:browser_context_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicyResult < Model
+      FIELDS = {policy: "policy", enabled: "enabled", generation: "generation"}.freeze
+      TYPES = {policy: "ResourcePolicy", enabled: nil, generation: nil}.freeze
+      REQUIRED = [:policy, :enabled, :generation].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicySchemaParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicySchemaResult < Model
+      FIELDS = {schema: "schema"}.freeze
+      TYPES = {schema: [:map, nil]}.freeze
+      REQUIRED = [:schema].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicyStatsParams < Model
+      FIELDS = {browser_context_id: "browserContextId"}.freeze
+      TYPES = {browser_context_id: nil}.freeze
+      REQUIRED = [:browser_context_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetResourcePolicyStatsResult < Model
+      FIELDS = {stats: "stats"}.freeze
+      TYPES = {stats: "ResourcePolicyStats"}.freeze
+      REQUIRED = [:stats].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetStatusParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetStatusResult < Model
+      FIELDS = {execution: "execution"}.freeze
+      TYPES = {execution: "ExecutionStatus"}.freeze
+      REQUIRED = [:execution].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetTraceParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetTraceResult < Model
+      FIELDS = {events: "events", crash_reports: "crashReports"}.freeze
+      TYPES = {events: [:array, "TraceEvent"], crash_reports: [:map, nil]}.freeze
+      REQUIRED = [:events, :crash_reports].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetVersionParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class GetVersionResult < Model
+      FIELDS = {version: "version", chrome_version: "chromeVersion", base_profile: "baseProfile"}.freeze
+      TYPES = {version: nil, chrome_version: nil, base_profile: nil}.freeze
+      REQUIRED = [:version, :chrome_version, :base_profile].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ImportProfileParams < Model
+      FIELDS = {profile: "profile", mode: "mode"}.freeze
+      TYPES = {profile: nil, mode: nil}.freeze
+      REQUIRED = [:profile].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ImportProfileResult < Model
+      FIELDS = {profile: "profile", profile_id: "profileId", mode: "mode", warnings: "warnings"}.freeze
+      TYPES = {profile: nil, profile_id: nil, mode: nil, warnings: [:array, nil]}.freeze
+      REQUIRED = [:profile, :profile_id, :mode, :warnings].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ManualNetwork < Model
+      FIELDS = {save_data: "saveData", online: "online", effective_type: "effectiveType", downlink_mbps: "downlinkMbps", rtt_millis: "rttMillis", cookies_enabled: "cookiesEnabled", wire_profile: "wireProfile", ice: "ice"}.freeze
+      TYPES = {save_data: nil, online: nil, effective_type: nil, downlink_mbps: nil, rtt_millis: nil, cookies_enabled: nil, wire_profile: nil, ice: "EnvironmentICEProfile"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ManualProfile < Model
+      FIELDS = {identity: "identity", display: "display", window: "window", hardware: "hardware", locale: "locale", graphics: "graphics", audio: "audio", fonts: "fonts", preferences: "preferences", network: "network", permissions: "permissions", capabilities: "capabilities", features: "features", timing: "timing"}.freeze
+      TYPES = {identity: "EnvironmentIdentity", display: "EnvironmentDisplay", window: "EnvironmentWindow", hardware: "EnvironmentHardware", locale: "EnvironmentLocale", graphics: "EnvironmentGraphics", audio: "EnvironmentAudio", fonts: "EnvironmentFonts", preferences: "EnvironmentPreferences", network: "ManualNetwork", permissions: [:map, nil], capabilities: "EnvironmentCapabilities", features: [:map, nil], timing: "EnvironmentTiming"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaCameraRequest < Model
+      FIELDS = {source: "source", profile: "profile", overrides: "overrides"}.freeze
+      TYPES = {source: "MediaSourceSelector", profile: nil, overrides: "MediaDeviceOverride"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaConfiguration < Model
+      FIELDS = {seed: "seed", camera: "camera", microphone: "microphone", devices: "devices"}.freeze
+      TYPES = {seed: nil, camera: "MediaCameraRequest", microphone: "MediaMicrophoneRequest", devices: [:array, "MediaDeviceProfile"]}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaDeviceOverride < Model
+      FIELDS = {label: "label", modes: "modes", default_mode: "defaultMode", processing: "processing"}.freeze
+      TYPES = {label: nil, modes: [:array, "CameraFormat"], default_mode: "CameraFormat", processing: "MediaProcessing"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaDeviceProfile < Model
+      FIELDS = {key: "key", kind: "kind", source: "source", profile: "profile", label: "label", group: "group", modes: "modes", default_mode: "defaultMode", processing: "processing"}.freeze
+      TYPES = {key: nil, kind: nil, source: "MediaSourceSelector", profile: nil, label: nil, group: nil, modes: [:array, "CameraFormat"], default_mode: "CameraFormat", processing: "MediaProcessing"}.freeze
+      REQUIRED = [:key, :kind, :source, :label].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaMicrophoneRequest < Model
+      FIELDS = {source: "source", profile: "profile"}.freeze
+      TYPES = {source: "MediaSourceSelector", profile: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaPreset < Model
+      FIELDS = {id: "id", label: "label", class_: "class", variants: "variants"}.freeze
+      TYPES = {id: nil, label: nil, class_: nil, variants: [:array, nil]}.freeze
+      REQUIRED = [:id, :label, :class_, :variants].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaProcessing < Model
+      FIELDS = {resize: "resize", noise: "noise"}.freeze
+      TYPES = {resize: nil, noise: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaProfile < Model
+      FIELDS = {seed: "seed", devices: "devices"}.freeze
+      TYPES = {seed: nil, devices: [:array, "MediaDeviceProfile"]}.freeze
+      REQUIRED = [:seed, :devices].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MediaSource < Model
+      FIELDS = {source_id: "sourceId", kind: "kind", label: "label", default: "default"}.freeze
+      TYPES = {source_id: nil, kind: nil, label: nil, default: nil}.freeze
+      REQUIRED = [:source_id, :kind, :label, :default].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class PauseParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class PauseResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ProfileDescriptor < Model
+      FIELDS = {mode: "mode", base_profile: "baseProfile", seed: "seed", profile_id: "profileId", environment: "environment"}.freeze
+      TYPES = {mode: nil, base_profile: nil, seed: nil, profile_id: nil, environment: "ManualProfile"}.freeze
+      REQUIRED = [:mode, :base_profile, :profile_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ProfileErrorData < Model
+      FIELDS = {path: "path", reason: "reason", message: "message"}.freeze
+      TYPES = {path: nil, reason: nil, message: nil}.freeze
+      REQUIRED = [:path, :reason, :message].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ProfilePatch < Model
+      FIELDS = {identity: "identity", display: "display", window: "window", hardware: "hardware", locale: "locale", graphics: "graphics", audio: "audio", fonts: "fonts", preferences: "preferences", network: "network", permissions: "permissions", capabilities: "capabilities", features: "features", timing: "timing"}.freeze
+      TYPES = {identity: "EnvironmentIdentity", display: "EnvironmentDisplay", window: "EnvironmentWindow", hardware: "EnvironmentHardware", locale: "EnvironmentLocale", graphics: "EnvironmentGraphics", audio: "EnvironmentAudio", fonts: "EnvironmentFonts", preferences: "EnvironmentPreferences", network: "ManualNetwork", permissions: [:map, nil], capabilities: "EnvironmentCapabilities", features: [:map, nil], timing: "EnvironmentTiming"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ProtocolCoverage < Model
+      FIELDS = {name: "name", kind: "kind", surface_registered: "surfaceRegistered", wire_schema_generated: "wireSchemaGenerated", status: "status", notes: "notes", tests: "tests", semantics_implemented: "semanticsImplemented", semantics_verified: "semanticsVerified"}.freeze
+      TYPES = {name: nil, kind: nil, surface_registered: nil, wire_schema_generated: nil, status: nil, notes: nil, tests: [:array, nil], semantics_implemented: nil, semantics_verified: nil}.freeze
+      REQUIRED = [:name, :kind, :surface_registered, :wire_schema_generated, :status, :semantics_implemented, :semantics_verified].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ProtocolError < Model
+      FIELDS = {code: "code", message: "message", data: "data"}.freeze
+      TYPES = {code: nil, message: nil, data: nil}.freeze
+      REQUIRED = [:code, :message].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class Proxy < Model
+      FIELDS = {server: "server", username: "username", password: "password"}.freeze
+      TYPES = {server: nil, username: nil, password: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class RealmDiagnostics < Model
+      FIELDS = {realm: "realm", diagnostics: "diagnostics"}.freeze
+      TYPES = {realm: nil, diagnostics: "Diagnostics"}.freeze
+      REQUIRED = [:realm, :diagnostics].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResetProfileOverridesParams < Model
+      FIELDS = {target_id: "targetId"}.freeze
+      TYPES = {target_id: nil}.freeze
+      REQUIRED = [:target_id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResetProfileOverridesResult < Model
+      FIELDS = {profile: "profile"}.freeze
+      TYPES = {profile: "EnvironmentProfile"}.freeze
+      REQUIRED = [:profile].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourceBudgets < Model
+      FIELDS = {max_requests: "maxRequests", max_concurrent: "maxConcurrent", max_wire_bytes: "maxWireBytes", max_body_bytes: "maxBodyBytes", max_response_bytes: "maxResponseBytes", max_decoded_bytes: "maxDecodedBytes", max_retained_bytes: "maxRetainedBytes"}.freeze
+      TYPES = {max_requests: nil, max_concurrent: nil, max_wire_bytes: nil, max_body_bytes: nil, max_response_bytes: nil, max_decoded_bytes: nil, max_retained_bytes: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourceMatch < Model
+      FIELDS = {kinds: "kinds", hosts: "hosts", origins: "origins", url_glob: "urlGlob", owners: "owners", mechanisms: "mechanisms", top_level_site: "topLevelSite"}.freeze
+      TYPES = {kinds: [:array, nil], hosts: [:array, nil], origins: [:array, nil], url_glob: nil, owners: [:array, nil], mechanisms: [:array, nil], top_level_site: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourcePolicy < Model
+      FIELDS = {report_only: "reportOnly", presets: "presets", rules: "rules", budgets: "budgets"}.freeze
+      TYPES = {report_only: nil, presets: [:array, nil], rules: [:array, "ResourceRule"], budgets: "ResourceBudgets"}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourcePolicyStats < Model
+      FIELDS = {generation: "generation", requests: "requests", network_acquisitions: "networkAcquisitions", cache_hits: "cacheHits", blocked: "blocked", header_only: "headerOnly", prefixes: "prefixes", wire_bytes_known: "wireBytesKnown", encoded_network_body_bytes: "encodedNetworkBodyBytes", body_bytes_consumed: "bodyBytesConsumed", retained_body_bytes: "retainedBodyBytes", decoded_pixel_work_bytes: "decodedPixelWorkBytes", known_avoided_body_read_bytes: "knownAvoidedBodyReadBytes", unknown_avoided_body_requests: "unknownAvoidedBodyRequests", would_block: "wouldBlock", would_bypass_cache: "wouldBypassCache", budget_denied: "budgetDenied", by_rule: "byRule"}.freeze
+      TYPES = {generation: nil, requests: nil, network_acquisitions: nil, cache_hits: nil, blocked: nil, header_only: nil, prefixes: nil, wire_bytes_known: nil, encoded_network_body_bytes: nil, body_bytes_consumed: nil, retained_body_bytes: nil, decoded_pixel_work_bytes: nil, known_avoided_body_read_bytes: nil, unknown_avoided_body_requests: nil, would_block: nil, would_bypass_cache: nil, budget_denied: nil, by_rule: [:map, nil]}.freeze
+      REQUIRED = [:generation, :requests, :network_acquisitions, :cache_hits, :blocked, :header_only, :prefixes, :wire_bytes_known, :encoded_network_body_bytes, :body_bytes_consumed, :retained_body_bytes, :decoded_pixel_work_bytes, :known_avoided_body_read_bytes, :unknown_avoided_body_requests, :would_block, :would_bypass_cache, :budget_denied, :by_rule].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourceRule < Model
+      FIELDS = {id: "id", match: "match", work: "work"}.freeze
+      TYPES = {id: nil, match: "ResourceMatch", work: "ResourceWork"}.freeze
+      REQUIRED = [:id].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResourceWork < Model
+      FIELDS = {cache_read: "cacheRead", network: "network", body: "body", prefix_bytes: "prefixBytes", decode: "decode", cache_retain: "cacheRetain", debug_retain: "debugRetain"}.freeze
+      TYPES = {cache_read: nil, network: nil, body: nil, prefix_bytes: nil, decode: nil, cache_retain: nil, debug_retain: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResumeParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ResumeResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class SetMediaProfileParams < Model
+      FIELDS = {seed: "seed", camera: "camera", microphone: "microphone", devices: "devices", browser_context_id: "browserContextId"}.freeze
+      TYPES = {seed: nil, camera: "MediaCameraRequest", microphone: "MediaMicrophoneRequest", devices: [:array, "MediaDeviceProfile"], browser_context_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class SetMediaProfileResult < Model
+      FIELDS = {profile: "profile", native_modes_verified: "nativeModesVerified"}.freeze
+      TYPES = {profile: "MediaProfile", native_modes_verified: nil}.freeze
+      REQUIRED = [:profile, :native_modes_verified].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class SetViewportParams < Model
+      FIELDS = {width: "width", height: "height"}.freeze
+      TYPES = {width: nil, height: nil}.freeze
+      REQUIRED = [:width, :height].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class SetViewportResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class StartTraceParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class StartTraceResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class StopTraceParams < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class StopTraceResult < Model
+      FIELDS = {}.freeze
+      TYPES = {}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class TraceEvent < Model
+      FIELDS = {sequence: "sequence", time: "time", kind: "kind", name: "name", data: "data"}.freeze
+      TYPES = {sequence: nil, time: nil, kind: nil, name: nil, data: [:map, nil]}.freeze
+      REQUIRED = [:sequence, :time, :kind, :name].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class UpdateProfileParams < Model
+      FIELDS = {target_id: "targetId", patch: "patch"}.freeze
+      TYPES = {target_id: nil, patch: "ProfilePatch"}.freeze
+      REQUIRED = [:target_id, :patch].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class UpdateProfileResult < Model
+      FIELDS = {profile: "profile"}.freeze
+      TYPES = {profile: "EnvironmentProfile"}.freeze
+      REQUIRED = [:profile].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class UpdateResourcePolicyParams < Model
+      FIELDS = {browser_context_id: "browserContextId", policy: "policy"}.freeze
+      TYPES = {browser_context_id: nil, policy: "ResourcePolicy"}.freeze
+      REQUIRED = [:browser_context_id, :policy].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class UpdateResourcePolicyResult < Model
+      FIELDS = {generation: "generation"}.freeze
+      TYPES = {generation: nil}.freeze
+      REQUIRED = [:generation].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ValidateMediaProfileParams < Model
+      FIELDS = {seed: "seed", camera: "camera", microphone: "microphone", devices: "devices", browser_context_id: "browserContextId"}.freeze
+      TYPES = {seed: nil, camera: "MediaCameraRequest", microphone: "MediaMicrophoneRequest", devices: [:array, "MediaDeviceProfile"], browser_context_id: nil}.freeze
+      REQUIRED = [].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ValidateMediaProfileResult < Model
+      FIELDS = {profile: "profile", native_modes_verified: "nativeModesVerified"}.freeze
+      TYPES = {profile: "MediaProfile", native_modes_verified: nil}.freeze
+      REQUIRED = [:profile, :native_modes_verified].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ValidateResourcePolicyParams < Model
+      FIELDS = {policy: "policy"}.freeze
+      TYPES = {policy: "ResourcePolicy"}.freeze
+      REQUIRED = [:policy].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class ValidateResourcePolicyResult < Model
+      FIELDS = {policy: "policy"}.freeze
+      TYPES = {policy: "ResourcePolicy"}.freeze
+      REQUIRED = [:policy].freeze
+      attr_accessor(*FIELDS.keys)
+    end
+    class MimicCommands
+      def initialize(sender)
+        @sender = sender
+      end
+      def cancel_execution(params = {})
+        CancelExecutionResult.from_wire(@sender.call("Mimic.cancelExecution", Generated.to_wire(params)))
+      end
+      def capture_snapshot(params = {})
+        CaptureSnapshotResult.from_wire(@sender.call("Mimic.captureSnapshot", Generated.to_wire(params)))
+      end
+      def clear_trace(params = {})
+        ClearTraceResult.from_wire(@sender.call("Mimic.clearTrace", Generated.to_wire(params)))
+      end
+      def configure_context(params)
+        ConfigureContextResult.from_wire(@sender.call("Mimic.configureContext", Generated.to_wire(params)))
+      end
+      def create_context(params = {})
+        CreateContextResult.from_wire(@sender.call("Mimic.createContext", Generated.to_wire(params)))
+      end
+      def export_profile(params)
+        ExportProfileResult.from_wire(@sender.call("Mimic.exportProfile", Generated.to_wire(params)))
+      end
+      def generate_profile(params = {})
+        GenerateProfileResult.from_wire(@sender.call("Mimic.generateProfile", Generated.to_wire(params)))
+      end
+      def get_compatibility_matrix(params = {})
+        GetCompatibilityMatrixResult.from_wire(@sender.call("Mimic.getCompatibilityMatrix", Generated.to_wire(params)))
+      end
+      def get_diagnostics(params = {})
+        GetDiagnosticsResult.from_wire(@sender.call("Mimic.getDiagnostics", Generated.to_wire(params)))
+      end
+      def get_media_presets(params = {})
+        GetMediaPresetsResult.from_wire(@sender.call("Mimic.getMediaPresets", Generated.to_wire(params)))
+      end
+      def get_media_profile(params = {})
+        GetMediaProfileResult.from_wire(@sender.call("Mimic.getMediaProfile", Generated.to_wire(params)))
+      end
+      def get_media_sources(params = {})
+        GetMediaSourcesResult.from_wire(@sender.call("Mimic.getMediaSources", Generated.to_wire(params)))
+      end
+      def get_profile(params)
+        GetProfileResult.from_wire(@sender.call("Mimic.getProfile", Generated.to_wire(params)))
+      end
+      def get_profile_schema(params = {})
+        GetProfileSchemaResult.from_wire(@sender.call("Mimic.getProfileSchema", Generated.to_wire(params)))
+      end
+      def get_resource_policy(params)
+        GetResourcePolicyResult.from_wire(@sender.call("Mimic.getResourcePolicy", Generated.to_wire(params)))
+      end
+      def get_resource_policy_schema(params = {})
+        GetResourcePolicySchemaResult.from_wire(@sender.call("Mimic.getResourcePolicySchema", Generated.to_wire(params)))
+      end
+      def get_resource_policy_stats(params)
+        GetResourcePolicyStatsResult.from_wire(@sender.call("Mimic.getResourcePolicyStats", Generated.to_wire(params)))
+      end
+      def get_status(params = {})
+        GetStatusResult.from_wire(@sender.call("Mimic.getStatus", Generated.to_wire(params)))
+      end
+      def get_trace(params = {})
+        GetTraceResult.from_wire(@sender.call("Mimic.getTrace", Generated.to_wire(params)))
+      end
+      def get_version(params = {})
+        GetVersionResult.from_wire(@sender.call("Mimic.getVersion", Generated.to_wire(params)))
+      end
+      def import_profile(params)
+        ImportProfileResult.from_wire(@sender.call("Mimic.importProfile", Generated.to_wire(params)))
+      end
+      def pause(params = {})
+        PauseResult.from_wire(@sender.call("Mimic.pause", Generated.to_wire(params)))
+      end
+      def reset_profile_overrides(params)
+        ResetProfileOverridesResult.from_wire(@sender.call("Mimic.resetProfileOverrides", Generated.to_wire(params)))
+      end
+      def resume(params = {})
+        ResumeResult.from_wire(@sender.call("Mimic.resume", Generated.to_wire(params)))
+      end
+      def set_media_profile(params)
+        SetMediaProfileResult.from_wire(@sender.call("Mimic.setMediaProfile", Generated.to_wire(params)))
+      end
+      def set_viewport(params)
+        SetViewportResult.from_wire(@sender.call("Mimic.setViewport", Generated.to_wire(params)))
+      end
+      def start_trace(params = {})
+        StartTraceResult.from_wire(@sender.call("Mimic.startTrace", Generated.to_wire(params)))
+      end
+      def stop_trace(params = {})
+        StopTraceResult.from_wire(@sender.call("Mimic.stopTrace", Generated.to_wire(params)))
+      end
+      def update_profile(params)
+        UpdateProfileResult.from_wire(@sender.call("Mimic.updateProfile", Generated.to_wire(params)))
+      end
+      def update_resource_policy(params)
+        UpdateResourcePolicyResult.from_wire(@sender.call("Mimic.updateResourcePolicy", Generated.to_wire(params)))
+      end
+      def validate_media_profile(params)
+        ValidateMediaProfileResult.from_wire(@sender.call("Mimic.validateMediaProfile", Generated.to_wire(params)))
+      end
+      def validate_resource_policy(params)
+        ValidateResourcePolicyResult.from_wire(@sender.call("Mimic.validateResourcePolicy", Generated.to_wire(params)))
+      end
+    end
+  end
+end