// Generated from WebIDL - DO NOT EDIT
// Source: @webref/idl/encrypted-media

///|
/// MediaKeysRequirement enum
pub(all) enum MediaKeysRequirement {
  Required
  Optional
  NotAllowed
} derive(Eq, Show)

///|
/// Convert to string value
pub fn MediaKeysRequirement::to_string(self : MediaKeysRequirement) -> String {
  match self {
    MediaKeysRequirement::Required => "required"
    MediaKeysRequirement::Optional => "optional"
    MediaKeysRequirement::NotAllowed => "not-allowed"
  }
}

///|
/// Parse from string value
pub fn MediaKeysRequirement::from_string(s : String) -> MediaKeysRequirement? {
  match s {
    "required" => Some(MediaKeysRequirement::Required)
    "optional" => Some(MediaKeysRequirement::Optional)
    "not-allowed" => Some(MediaKeysRequirement::NotAllowed)
    _ => None
  }
}

///|
/// MediaKeySessionType enum
pub(all) enum MediaKeySessionType {
  Temporary
  PersistentLicense
} derive(Eq, Show)

///|
/// Convert to string value
pub fn MediaKeySessionType::to_string(self : MediaKeySessionType) -> String {
  match self {
    MediaKeySessionType::Temporary => "temporary"
    MediaKeySessionType::PersistentLicense => "persistent-license"
  }
}

///|
/// Parse from string value
pub fn MediaKeySessionType::from_string(s : String) -> MediaKeySessionType? {
  match s {
    "temporary" => Some(MediaKeySessionType::Temporary)
    "persistent-license" => Some(MediaKeySessionType::PersistentLicense)
    _ => None
  }
}

///|
/// MediaKeySessionClosedReason enum
pub(all) enum MediaKeySessionClosedReason {
  InternalError
  ClosedByApplication
  ReleaseAcknowledged
  HardwareContextReset
  ResourceEvicted
} derive(Eq, Show)

///|
/// Convert to string value
pub fn MediaKeySessionClosedReason::to_string(
  self : MediaKeySessionClosedReason,
) -> String {
  match self {
    MediaKeySessionClosedReason::InternalError => "internal-error"
    MediaKeySessionClosedReason::ClosedByApplication => "closed-by-application"
    MediaKeySessionClosedReason::ReleaseAcknowledged => "release-acknowledged"
    MediaKeySessionClosedReason::HardwareContextReset =>
      "hardware-context-reset"
    MediaKeySessionClosedReason::ResourceEvicted => "resource-evicted"
  }
}

///|
/// Parse from string value
pub fn MediaKeySessionClosedReason::from_string(
  s : String,
) -> MediaKeySessionClosedReason? {
  match s {
    "internal-error" => Some(MediaKeySessionClosedReason::InternalError)
    "closed-by-application" =>
      Some(MediaKeySessionClosedReason::ClosedByApplication)
    "release-acknowledged" =>
      Some(MediaKeySessionClosedReason::ReleaseAcknowledged)
    "hardware-context-reset" =>
      Some(MediaKeySessionClosedReason::HardwareContextReset)
    "resource-evicted" => Some(MediaKeySessionClosedReason::ResourceEvicted)
    _ => None
  }
}

///|
/// MediaKeyStatus enum
pub(all) enum MediaKeyStatus {
  Usable
  Expired
  Released
  OutputRestricted
  OutputDownscaled
  UsableInFuture
  StatusPending
  InternalError
} derive(Eq, Show)

///|
/// Convert to string value
pub fn MediaKeyStatus::to_string(self : MediaKeyStatus) -> String {
  match self {
    MediaKeyStatus::Usable => "usable"
    MediaKeyStatus::Expired => "expired"
    MediaKeyStatus::Released => "released"
    MediaKeyStatus::OutputRestricted => "output-restricted"
    MediaKeyStatus::OutputDownscaled => "output-downscaled"
    MediaKeyStatus::UsableInFuture => "usable-in-future"
    MediaKeyStatus::StatusPending => "status-pending"
    MediaKeyStatus::InternalError => "internal-error"
  }
}

///|
/// Parse from string value
pub fn MediaKeyStatus::from_string(s : String) -> MediaKeyStatus? {
  match s {
    "usable" => Some(MediaKeyStatus::Usable)
    "expired" => Some(MediaKeyStatus::Expired)
    "released" => Some(MediaKeyStatus::Released)
    "output-restricted" => Some(MediaKeyStatus::OutputRestricted)
    "output-downscaled" => Some(MediaKeyStatus::OutputDownscaled)
    "usable-in-future" => Some(MediaKeyStatus::UsableInFuture)
    "status-pending" => Some(MediaKeyStatus::StatusPending)
    "internal-error" => Some(MediaKeyStatus::InternalError)
    _ => None
  }
}

///|
/// MediaKeyMessageType enum
pub(all) enum MediaKeyMessageType {
  LicenseRequest
  LicenseRenewal
  LicenseRelease
  IndividualizationRequest
} derive(Eq, Show)

///|
/// Convert to string value
pub fn MediaKeyMessageType::to_string(self : MediaKeyMessageType) -> String {
  match self {
    MediaKeyMessageType::LicenseRequest => "license-request"
    MediaKeyMessageType::LicenseRenewal => "license-renewal"
    MediaKeyMessageType::LicenseRelease => "license-release"
    MediaKeyMessageType::IndividualizationRequest => "individualization-request"
  }
}

///|
/// Parse from string value
pub fn MediaKeyMessageType::from_string(s : String) -> MediaKeyMessageType? {
  match s {
    "license-request" => Some(MediaKeyMessageType::LicenseRequest)
    "license-renewal" => Some(MediaKeyMessageType::LicenseRenewal)
    "license-release" => Some(MediaKeyMessageType::LicenseRelease)
    "individualization-request" =>
      Some(MediaKeyMessageType::IndividualizationRequest)
    _ => None
  }
}

///|
/// MediaKeySystemConfiguration dictionary
pub(all) struct MediaKeySystemConfiguration {
  label : String?
  initDataTypes : Array[String]?
  audioCapabilities : Array[MediaKeySystemMediaCapability]?
  videoCapabilities : Array[MediaKeySystemMediaCapability]?
  distinctiveIdentifier : MediaKeysRequirement?
  persistentState : MediaKeysRequirement?
  sessionTypes : Array[String]?
}

///|
/// Create a new MediaKeySystemConfiguration with default values
pub fn MediaKeySystemConfiguration::default() -> MediaKeySystemConfiguration {
  MediaKeySystemConfiguration::{
    label: None,
    initDataTypes: None,
    audioCapabilities: None,
    videoCapabilities: None,
    distinctiveIdentifier: None,
    persistentState: None,
    sessionTypes: None,
  }
}

///|
extern "js" fn MediaKeySystemConfiguration::to_js_ffi(
  self : MediaKeySystemConfiguration,
) -> JsValue =
  #| (self) => ({
  #|   label: self.label,
  #|   initDataTypes: ((() => { const v = self.initDataTypes; if (v === undefined || v.$tag !== 1) return undefined; return v._0; })()),
  #|   audioCapabilities: ((() => { const v = self.audioCapabilities; if (v === undefined || v.$tag !== 1) return undefined; return v._0; })()),
  #|   videoCapabilities: ((() => { const v = self.videoCapabilities; if (v === undefined || v.$tag !== 1) return undefined; return v._0; })()),
  #|   distinctiveIdentifier: ((() => { const v = self.distinctiveIdentifier; if (v === undefined) return undefined; return ['required', 'optional', 'not-allowed'][v]; })()),
  #|   persistentState: ((() => { const v = self.persistentState; if (v === undefined) return undefined; return ['required', 'optional', 'not-allowed'][v]; })()),
  #|   sessionTypes: ((() => { const v = self.sessionTypes; if (v === undefined || v.$tag !== 1) return undefined; return v._0; })())
  #| })

///|
/// Convert to JsValue
pub fn MediaKeySystemConfiguration::to_js(
  self : MediaKeySystemConfiguration,
) -> JsValue {
  MediaKeySystemConfiguration::to_js_ffi(self)
}

///|
extern "js" fn MediaKeySystemConfiguration::from_js_ffi(
  value : JsValue,
) -> MediaKeySystemConfiguration =
  #| (v) => ({
  #|   label: v.label,
  #|   initDataTypes: (v.initDataTypes === undefined ? { $tag: 0 } : { $tag: 1, _0: v.initDataTypes }),
  #|   audioCapabilities: (v.audioCapabilities === undefined ? { $tag: 0 } : { $tag: 1, _0: v.audioCapabilities }),
  #|   videoCapabilities: (v.videoCapabilities === undefined ? { $tag: 0 } : { $tag: 1, _0: v.videoCapabilities }),
  #|   distinctiveIdentifier: (v.distinctiveIdentifier === undefined ? undefined : ['required', 'optional', 'not-allowed'].indexOf(v.distinctiveIdentifier)),
  #|   persistentState: (v.persistentState === undefined ? undefined : ['required', 'optional', 'not-allowed'].indexOf(v.persistentState)),
  #|   sessionTypes: (v.sessionTypes === undefined ? { $tag: 0 } : { $tag: 1, _0: v.sessionTypes })
  #| })

///|
/// Convert from JsValue
pub fn MediaKeySystemConfiguration::from_js(
  value : JsValue,
) -> MediaKeySystemConfiguration {
  MediaKeySystemConfiguration::from_js_ffi(value)
}

///|
/// MediaKeySystemMediaCapability dictionary
pub(all) struct MediaKeySystemMediaCapability {
  contentType : String?
  encryptionScheme : Nullable[String]
  robustness : String?
}

///|
/// Create a new MediaKeySystemMediaCapability with default values
pub fn MediaKeySystemMediaCapability::default() -> MediaKeySystemMediaCapability {
  MediaKeySystemMediaCapability::{
    contentType: None,
    encryptionScheme: Nullable::Undefined,
    robustness: None,
  }
}

///|
extern "js" fn MediaKeySystemMediaCapability::to_js_ffi(
  self : MediaKeySystemMediaCapability,
) -> JsValue =
  #| (self) => ({
  #|   contentType: self.contentType,
  #|   encryptionScheme: ((() => { const v = self.encryptionScheme; if (v.$tag === 0) return undefined; if (v.$tag === 1) return null; return v._0; })()),
  #|   robustness: self.robustness
  #| })

///|
/// Convert to JsValue
pub fn MediaKeySystemMediaCapability::to_js(
  self : MediaKeySystemMediaCapability,
) -> JsValue {
  MediaKeySystemMediaCapability::to_js_ffi(self)
}

///|
extern "js" fn MediaKeySystemMediaCapability::from_js_ffi(
  value : JsValue,
) -> MediaKeySystemMediaCapability =
  #| (v) => ({
  #|   contentType: v.contentType,
  #|   encryptionScheme: (v.encryptionScheme === undefined ? { $tag: 0 } : v.encryptionScheme === null ? { $tag: 1 } : { $tag: 2, _0: v.encryptionScheme }),
  #|   robustness: v.robustness
  #| })

///|
/// Convert from JsValue
pub fn MediaKeySystemMediaCapability::from_js(
  value : JsValue,
) -> MediaKeySystemMediaCapability {
  MediaKeySystemMediaCapability::from_js_ffi(value)
}

///|
/// MediaKeysPolicy dictionary
pub(all) struct MediaKeysPolicy {
  minHdcpVersion : String?
}

///|
/// Create a new MediaKeysPolicy with default values
pub fn MediaKeysPolicy::default() -> MediaKeysPolicy {
  MediaKeysPolicy::{ minHdcpVersion: None }
}

///|
extern "js" fn MediaKeysPolicy::to_js_ffi(self : MediaKeysPolicy) -> JsValue =
  #| (self) => ({
  #|   minHdcpVersion: self.minHdcpVersion
  #| })

///|
/// Convert to JsValue
pub fn MediaKeysPolicy::to_js(self : MediaKeysPolicy) -> JsValue {
  MediaKeysPolicy::to_js_ffi(self)
}

///|
extern "js" fn MediaKeysPolicy::from_js_ffi(value : JsValue) -> MediaKeysPolicy =
  #| (v) => ({
  #|   minHdcpVersion: v.minHdcpVersion
  #| })

///|
/// Convert from JsValue
pub fn MediaKeysPolicy::from_js(value : JsValue) -> MediaKeysPolicy {
  MediaKeysPolicy::from_js_ffi(value)
}

///|
/// MediaKeyMessageEventInit dictionary
pub(all) struct MediaKeyMessageEventInit {
  messageType : MediaKeyMessageType
  message : ArrayBuffer
}

///|
/// Create a new MediaKeyMessageEventInit
pub fn MediaKeyMessageEventInit::new(
  messageType~ : MediaKeyMessageType,
  message~ : ArrayBuffer,
) -> MediaKeyMessageEventInit {
  MediaKeyMessageEventInit::{ messageType, message }
}

///|
extern "js" fn MediaKeyMessageEventInit::to_js_ffi(
  self : MediaKeyMessageEventInit,
) -> JsValue =
  #| (self) => ({
  #|   messageType: ['license-request', 'license-renewal', 'license-release', 'individualization-request'][self.messageType],
  #|   message: self.message
  #| })

///|
/// Convert to JsValue
pub fn MediaKeyMessageEventInit::to_js(
  self : MediaKeyMessageEventInit,
) -> JsValue {
  MediaKeyMessageEventInit::to_js_ffi(self)
}

///|
extern "js" fn MediaKeyMessageEventInit::from_js_ffi(
  value : JsValue,
) -> MediaKeyMessageEventInit =
  #| (v) => ({
  #|   messageType: ['license-request', 'license-renewal', 'license-release', 'individualization-request'].indexOf(v.messageType),
  #|   message: v.message
  #| })

///|
/// Convert from JsValue
pub fn MediaKeyMessageEventInit::from_js(
  value : JsValue,
) -> MediaKeyMessageEventInit {
  MediaKeyMessageEventInit::from_js_ffi(value)
}

///|
/// MediaEncryptedEventInit dictionary
pub(all) struct MediaEncryptedEventInit {
  initDataType : String?
  initData : Nullable[ArrayBuffer]
}

///|
/// Create a new MediaEncryptedEventInit with default values
pub fn MediaEncryptedEventInit::default() -> MediaEncryptedEventInit {
  MediaEncryptedEventInit::{ initDataType: None, initData: Nullable::Undefined }
}

///|
extern "js" fn MediaEncryptedEventInit::to_js_ffi(
  self : MediaEncryptedEventInit,
) -> JsValue =
  #| (self) => ({
  #|   initDataType: self.initDataType,
  #|   initData: ((() => { const v = self.initData; if (v.$tag === 0) return undefined; if (v.$tag === 1) return null; return v._0; })())
  #| })

///|
/// Convert to JsValue
pub fn MediaEncryptedEventInit::to_js(
  self : MediaEncryptedEventInit,
) -> JsValue {
  MediaEncryptedEventInit::to_js_ffi(self)
}

///|
extern "js" fn MediaEncryptedEventInit::from_js_ffi(
  value : JsValue,
) -> MediaEncryptedEventInit =
  #| (v) => ({
  #|   initDataType: v.initDataType,
  #|   initData: (v.initData === undefined ? { $tag: 0 } : v.initData === null ? { $tag: 1 } : { $tag: 2, _0: v.initData })
  #| })

///|
/// Convert from JsValue
pub fn MediaEncryptedEventInit::from_js(
  value : JsValue,
) -> MediaEncryptedEventInit {
  MediaEncryptedEventInit::from_js_ffi(value)
}

///|
/// MediaKeySystemAccess interface
pub type MediaKeySystemAccess

///|
pub extern "js" fn MediaKeySystemAccess::to_js_value(
  self : MediaKeySystemAccess,
) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaKeySystemAccess (unchecked)
pub extern "js" fn MediaKeySystemAccess::from_js_value(
  v : JsValue,
) -> MediaKeySystemAccess =
  #| (v) => v

///|
/// Safely cast JsValue to MediaKeySystemAccess (checked with instanceof)
pub extern "js" fn MediaKeySystemAccess::from_js_value_opt(
  v : JsValue,
) -> MediaKeySystemAccess? =
  #| (v) => (v instanceof MediaKeySystemAccess) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaKeySystemAccess (checked with instanceof)
pub extern "js" fn JsValue::as_media_key_system_access(
  self : JsValue,
) -> MediaKeySystemAccess? =
  #| (self) => (self instanceof MediaKeySystemAccess) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaKeySystemAccess (unchecked)
pub extern "js" fn JsValue::to_media_key_system_access(
  self : JsValue,
) -> MediaKeySystemAccess =
  #| (self) => self

///|
pub extern "js" fn MediaKeySystemAccess::get_key_system(
  self : MediaKeySystemAccess,
) -> String =
  #| (self) => self.keySystem

///|
pub extern "js" fn MediaKeySystemAccess::get_configuration(
  self : MediaKeySystemAccess,
) -> MediaKeySystemConfiguration =
  #| (self) => self.getConfiguration()

///|
pub extern "js" fn MediaKeySystemAccess::create_media_keys(
  self : MediaKeySystemAccess,
) -> Promise[MediaKeys] =
  #| (self) => self.createMediaKeys()

///|
/// MediaKeys interface
pub type MediaKeys

///|
pub extern "js" fn MediaKeys::to_js_value(self : MediaKeys) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaKeys (unchecked)
pub extern "js" fn MediaKeys::from_js_value(v : JsValue) -> MediaKeys =
  #| (v) => v

///|
/// Safely cast JsValue to MediaKeys (checked with instanceof)
pub extern "js" fn MediaKeys::from_js_value_opt(v : JsValue) -> MediaKeys? =
  #| (v) => (v instanceof MediaKeys) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaKeys (checked with instanceof)
pub extern "js" fn JsValue::as_media_keys(self : JsValue) -> MediaKeys? =
  #| (self) => (self instanceof MediaKeys) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaKeys (unchecked)
pub extern "js" fn JsValue::to_media_keys(self : JsValue) -> MediaKeys =
  #| (self) => self

///|
/// Error type for throwing methods
pub(all) enum MediaKeysGetStatusForPolicyError {
  TypeError(JsError)
  NotSupportedError(JsError)
  OtherError(JsError)
} derive(Show)

///|
pub extern "js" fn MediaKeys::create_session(
  self : MediaKeys,
) -> MediaKeySession =
  #| (self) => self.createSession()

///|
pub extern "js" fn MediaKeys::create_session_with_session_type(
  self : MediaKeys,
  session_type : MediaKeySessionType,
) -> MediaKeySession =
  #| (self, session_type) => self.createSession(['temporary', 'persistent-license'][session_type])

///|
pub extern "js" fn MediaKeys::get_status_for_policy(
  self : MediaKeys,
) -> Promise[Result[MediaKeyStatus, MediaKeysGetStatusForPolicyError]] =
  #| (self) => self.getStatusForPolicy().then(r => ({ $tag: 1, _0: r })).catch(e => ({ $tag: 0, _0: (() => { const n = (e && e.name) || ''; if (n === 'TypeError') return { $tag: 0, _0: e }; if (n === 'NotSupportedError') return { $tag: 1, _0: e }; return { $tag: 2, _0: e }; })() }))

///|
extern "js" fn MediaKeys::get_status_for_policy_with_policy_ffi(
  self : MediaKeys,
  policy : JsValue,
) -> Promise[Result[MediaKeyStatus, MediaKeysGetStatusForPolicyError]] =
  #| (self, policy) => self.getStatusForPolicy(policy).then(r => ({ $tag: 1, _0: r })).catch(e => ({ $tag: 0, _0: (() => { const n = (e && e.name) || ''; if (n === 'TypeError') return { $tag: 0, _0: e }; if (n === 'NotSupportedError') return { $tag: 1, _0: e }; return { $tag: 2, _0: e }; })() }))

///|
pub fn MediaKeys::get_status_for_policy_with_policy(
  self : MediaKeys,
  policy : MediaKeysPolicy,
) -> Promise[Result[MediaKeyStatus, MediaKeysGetStatusForPolicyError]] {
  MediaKeys::get_status_for_policy_with_policy_ffi(self, policy.to_js())
}

///|
pub extern "js" fn MediaKeys::set_server_certificate(
  self : MediaKeys,
  server_certificate : BufferSource,
) -> Promise[Bool] =
  #| (self, server_certificate) => self.setServerCertificate(server_certificate)

///|
pub extern "js" fn MediaKeys::set_server_certificate_with_array_buffer_view(
  self : MediaKeys,
  server_certificate : ArrayBufferView,
) -> Promise[Bool] =
  #| (self, server_certificate) => self.setServerCertificate(server_certificate)

///|
pub extern "js" fn MediaKeys::set_server_certificate_with_array_buffer(
  self : MediaKeys,
  server_certificate : ArrayBuffer,
) -> Promise[Bool] =
  #| (self, server_certificate) => self.setServerCertificate(server_certificate)

///|
/// MediaKeySession interface
pub type MediaKeySession

///|
pub extern "js" fn MediaKeySession::to_js_value(
  self : MediaKeySession,
) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaKeySession (unchecked)
pub extern "js" fn MediaKeySession::from_js_value(
  v : JsValue,
) -> MediaKeySession =
  #| (v) => v

///|
/// Safely cast JsValue to MediaKeySession (checked with instanceof)
pub extern "js" fn MediaKeySession::from_js_value_opt(
  v : JsValue,
) -> MediaKeySession? =
  #| (v) => (v instanceof MediaKeySession) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaKeySession (checked with instanceof)
pub extern "js" fn JsValue::as_media_key_session(
  self : JsValue,
) -> MediaKeySession? =
  #| (self) => (self instanceof MediaKeySession) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaKeySession (unchecked)
pub extern "js" fn JsValue::to_media_key_session(
  self : JsValue,
) -> MediaKeySession =
  #| (self) => self

///|
pub extern "js" fn MediaKeySession::to_event_target(
  self : MediaKeySession,
) -> EventTarget =
  #| (self) => self

///|
/// Error type for throwing methods
pub(all) enum MediaKeySessionGenerateRequestError {
  TypeError(JsError)
  InvalidStateError(JsError)
  NotSupportedError(JsError)
  QuotaExceededError(JsError)
  OtherError(JsError)
} derive(Show)

///|
pub extern "js" fn MediaKeySession::get_session_id(
  self : MediaKeySession,
) -> String =
  #| (self) => self.sessionId

///|
pub extern "js" fn MediaKeySession::get_expiration(
  self : MediaKeySession,
) -> Double =
  #| (self) => self.expiration

///|
pub extern "js" fn MediaKeySession::get_closed(
  self : MediaKeySession,
) -> Promise[MediaKeySessionClosedReason] =
  #| (self) => self.closed

///|
pub extern "js" fn MediaKeySession::get_key_statuses(
  self : MediaKeySession,
) -> MediaKeyStatusMap =
  #| (self) => self.keyStatuses

///|
pub extern "js" fn MediaKeySession::set_onkeystatuseschange(
  self : MediaKeySession,
  handler : (ExtendableEvent) -> Unit,
) -> Unit =
  #| (self, handler) => { self.onkeystatuseschange = (e) => handler(e) }

///|
pub extern "js" fn MediaKeySession::clear_onkeystatuseschange(
  self : MediaKeySession,
) -> Unit =
  #| (self) => { self.onkeystatuseschange = null }

///|
pub extern "js" fn MediaKeySession::set_onmessage(
  self : MediaKeySession,
  handler : (MediaKeyMessageEvent) -> Unit,
) -> Unit =
  #| (self, handler) => { self.onmessage = (e) => handler(e) }

///|
pub extern "js" fn MediaKeySession::clear_onmessage(
  self : MediaKeySession,
) -> Unit =
  #| (self) => { self.onmessage = null }

///|
pub extern "js" fn MediaKeySession::generate_request(
  self : MediaKeySession,
  init_data_type : String,
  init_data : BufferSource,
) -> Promise[Result[Unit, MediaKeySessionGenerateRequestError]] =
  #| (self, init_data_type, init_data) => self.generateRequest(init_data_type, init_data).then(r => ({ $tag: 1, _0: undefined })).catch(e => ({ $tag: 0, _0: (() => { const n = (e && e.name) || ''; if (n === 'TypeError') return { $tag: 0, _0: e }; if (n === 'InvalidStateError') return { $tag: 1, _0: e }; if (n === 'NotSupportedError') return { $tag: 2, _0: e }; if (n === 'QuotaExceededError') return { $tag: 3, _0: e }; return { $tag: 4, _0: e }; })() }))

///|
pub extern "js" fn MediaKeySession::load(
  self : MediaKeySession,
  session_id : String,
) -> Promise[Bool] =
  #| (self, session_id) => self.load(session_id)

///|
pub extern "js" fn MediaKeySession::update(
  self : MediaKeySession,
  response : BufferSource,
) -> Promise[Unit] =
  #| (self, response) => self.update(response)

///|
pub extern "js" fn MediaKeySession::close(
  self : MediaKeySession,
) -> Promise[Unit] =
  #| (self) => self.close()

///|
pub extern "js" fn MediaKeySession::remove(
  self : MediaKeySession,
) -> Promise[Unit] =
  #| (self) => self.remove()

///|
pub extern "js" fn MediaKeySession::generate_request_with_array_buffer_view(
  self : MediaKeySession,
  init_data_type : String,
  init_data : ArrayBufferView,
) -> Promise[Result[Unit, MediaKeySessionGenerateRequestError]] =
  #| (self, init_data_type, init_data) => self.generateRequest(init_data_type, init_data).then(r => ({ $tag: 1, _0: undefined })).catch(e => ({ $tag: 0, _0: (() => { const n = (e && e.name) || ''; if (n === 'TypeError') return { $tag: 0, _0: e }; if (n === 'InvalidStateError') return { $tag: 1, _0: e }; if (n === 'NotSupportedError') return { $tag: 2, _0: e }; if (n === 'QuotaExceededError') return { $tag: 3, _0: e }; return { $tag: 4, _0: e }; })() }))

///|
pub extern "js" fn MediaKeySession::generate_request_with_array_buffer(
  self : MediaKeySession,
  init_data_type : String,
  init_data : ArrayBuffer,
) -> Promise[Result[Unit, MediaKeySessionGenerateRequestError]] =
  #| (self, init_data_type, init_data) => self.generateRequest(init_data_type, init_data).then(r => ({ $tag: 1, _0: undefined })).catch(e => ({ $tag: 0, _0: (() => { const n = (e && e.name) || ''; if (n === 'TypeError') return { $tag: 0, _0: e }; if (n === 'InvalidStateError') return { $tag: 1, _0: e }; if (n === 'NotSupportedError') return { $tag: 2, _0: e }; if (n === 'QuotaExceededError') return { $tag: 3, _0: e }; return { $tag: 4, _0: e }; })() }))

///|
pub extern "js" fn MediaKeySession::update_with_array_buffer_view(
  self : MediaKeySession,
  response : ArrayBufferView,
) -> Promise[Unit] =
  #| (self, response) => self.update(response)

///|
pub extern "js" fn MediaKeySession::update_with_array_buffer(
  self : MediaKeySession,
  response : ArrayBuffer,
) -> Promise[Unit] =
  #| (self, response) => self.update(response)

///|
/// MediaKeyStatusMap interface
pub type MediaKeyStatusMap

///|
pub extern "js" fn MediaKeyStatusMap::to_js_value(
  self : MediaKeyStatusMap,
) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaKeyStatusMap (unchecked)
pub extern "js" fn MediaKeyStatusMap::from_js_value(
  v : JsValue,
) -> MediaKeyStatusMap =
  #| (v) => v

///|
/// Safely cast JsValue to MediaKeyStatusMap (checked with instanceof)
pub extern "js" fn MediaKeyStatusMap::from_js_value_opt(
  v : JsValue,
) -> MediaKeyStatusMap? =
  #| (v) => (v instanceof MediaKeyStatusMap) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaKeyStatusMap (checked with instanceof)
pub extern "js" fn JsValue::as_media_key_status_map(
  self : JsValue,
) -> MediaKeyStatusMap? =
  #| (self) => (self instanceof MediaKeyStatusMap) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaKeyStatusMap (unchecked)
pub extern "js" fn JsValue::to_media_key_status_map(
  self : JsValue,
) -> MediaKeyStatusMap =
  #| (self) => self

///|
pub extern "js" fn MediaKeyStatusMap::keys(self : MediaKeyStatusMap) -> JsValue =
  #| (self) => self.keys()

///|
pub extern "js" fn MediaKeyStatusMap::values(
  self : MediaKeyStatusMap,
) -> JsValue =
  #| (self) => self.values()

///|
pub extern "js" fn MediaKeyStatusMap::entries(
  self : MediaKeyStatusMap,
) -> JsValue =
  #| (self) => self.entries()

///|
pub extern "js" fn MediaKeyStatusMap::for_each(
  self : MediaKeyStatusMap,
  callback : JsValue,
) -> Unit =
  #| (self, callback) => { self.forEach(callback) }

///|
pub extern "js" fn MediaKeyStatusMap::get_size(self : MediaKeyStatusMap) -> Int =
  #| (self) => self.size

///|
pub extern "js" fn MediaKeyStatusMap::has(
  self : MediaKeyStatusMap,
  key_id : BufferSource,
) -> Bool =
  #| (self, key_id) => self.has(key_id)

///|
pub extern "js" fn MediaKeyStatusMap::get(
  self : MediaKeyStatusMap,
  key_id : BufferSource,
) -> MediaKeyStatusOrVoid =
  #| (self, key_id) => self.get(key_id)

///|
pub extern "js" fn MediaKeyStatusMap::has_with_array_buffer_view(
  self : MediaKeyStatusMap,
  key_id : ArrayBufferView,
) -> Bool =
  #| (self, key_id) => self.has(key_id)

///|
pub extern "js" fn MediaKeyStatusMap::has_with_array_buffer(
  self : MediaKeyStatusMap,
  key_id : ArrayBuffer,
) -> Bool =
  #| (self, key_id) => self.has(key_id)

///|
pub extern "js" fn MediaKeyStatusMap::get_with_array_buffer_view(
  self : MediaKeyStatusMap,
  key_id : ArrayBufferView,
) -> MediaKeyStatusOrVoid =
  #| (self, key_id) => self.get(key_id)

///|
pub extern "js" fn MediaKeyStatusMap::get_with_array_buffer(
  self : MediaKeyStatusMap,
  key_id : ArrayBuffer,
) -> MediaKeyStatusOrVoid =
  #| (self, key_id) => self.get(key_id)

///|
/// MediaKeyMessageEvent interface
pub type MediaKeyMessageEvent

///|
pub extern "js" fn MediaKeyMessageEvent::to_js_value(
  self : MediaKeyMessageEvent,
) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaKeyMessageEvent (unchecked)
pub extern "js" fn MediaKeyMessageEvent::from_js_value(
  v : JsValue,
) -> MediaKeyMessageEvent =
  #| (v) => v

///|
/// Safely cast JsValue to MediaKeyMessageEvent (checked with instanceof)
pub extern "js" fn MediaKeyMessageEvent::from_js_value_opt(
  v : JsValue,
) -> MediaKeyMessageEvent? =
  #| (v) => (v instanceof MediaKeyMessageEvent) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaKeyMessageEvent (checked with instanceof)
pub extern "js" fn JsValue::as_media_key_message_event(
  self : JsValue,
) -> MediaKeyMessageEvent? =
  #| (self) => (self instanceof MediaKeyMessageEvent) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaKeyMessageEvent (unchecked)
pub extern "js" fn JsValue::to_media_key_message_event(
  self : JsValue,
) -> MediaKeyMessageEvent =
  #| (self) => self

///|
pub extern "js" fn MediaKeyMessageEvent::to_event(
  self : MediaKeyMessageEvent,
) -> Event =
  #| (self) => self

///|
extern "js" fn MediaKeyMessageEvent::new_ffi(
  type_ : String,
  event_init_dict : JsValue,
) -> MediaKeyMessageEvent =
  #| (type_, event_init_dict) => new MediaKeyMessageEvent(type_, event_init_dict)

///|
pub fn MediaKeyMessageEvent::new(
  type_ : String,
  event_init_dict : MediaKeyMessageEventInit,
) -> MediaKeyMessageEvent {
  MediaKeyMessageEvent::new_ffi(type_, event_init_dict.to_js())
}

///|
pub extern "js" fn MediaKeyMessageEvent::get_message_type(
  self : MediaKeyMessageEvent,
) -> MediaKeyMessageType =
  #| (self) => ['license-request', 'license-renewal', 'license-release', 'individualization-request'].indexOf(self.messageType)

///|
pub extern "js" fn MediaKeyMessageEvent::get_message(
  self : MediaKeyMessageEvent,
) -> ArrayBuffer =
  #| (self) => self.message

///|
/// MediaEncryptedEvent interface
pub type MediaEncryptedEvent

///|
pub extern "js" fn MediaEncryptedEvent::to_js_value(
  self : MediaEncryptedEvent,
) -> JsValue =
  #| (self) => self

///|
/// Cast JsValue to MediaEncryptedEvent (unchecked)
pub extern "js" fn MediaEncryptedEvent::from_js_value(
  v : JsValue,
) -> MediaEncryptedEvent =
  #| (v) => v

///|
/// Safely cast JsValue to MediaEncryptedEvent (checked with instanceof)
pub extern "js" fn MediaEncryptedEvent::from_js_value_opt(
  v : JsValue,
) -> MediaEncryptedEvent? =
  #| (v) => (v instanceof MediaEncryptedEvent) ? { $tag: 1, _0: v } : { $tag: 0 }

///|
/// Safely cast JsValue to MediaEncryptedEvent (checked with instanceof)
pub extern "js" fn JsValue::as_media_encrypted_event(
  self : JsValue,
) -> MediaEncryptedEvent? =
  #| (self) => (self instanceof MediaEncryptedEvent) ? { $tag: 1, _0: self } : { $tag: 0 }

///|
/// Cast JsValue to MediaEncryptedEvent (unchecked)
pub extern "js" fn JsValue::to_media_encrypted_event(
  self : JsValue,
) -> MediaEncryptedEvent =
  #| (self) => self

///|
pub extern "js" fn MediaEncryptedEvent::to_event(
  self : MediaEncryptedEvent,
) -> Event =
  #| (self) => self

///|
pub extern "js" fn MediaEncryptedEvent::new(
  type_ : String,
) -> MediaEncryptedEvent =
  #| (type_) => new MediaEncryptedEvent(type_)

///|
extern "js" fn MediaEncryptedEvent::new_with_event_init_dict_ffi(
  type_ : String,
  event_init_dict : JsValue,
) -> MediaEncryptedEvent =
  #| (type_, event_init_dict) => new MediaEncryptedEvent(type_, event_init_dict)

///|
pub fn MediaEncryptedEvent::new_with_event_init_dict(
  type_ : String,
  event_init_dict : MediaEncryptedEventInit,
) -> MediaEncryptedEvent {
  MediaEncryptedEvent::new_with_event_init_dict_ffi(
    type_,
    event_init_dict.to_js(),
  )
}

///|
pub extern "js" fn MediaEncryptedEvent::get_init_data_type(
  self : MediaEncryptedEvent,
) -> String =
  #| (self) => self.initDataType

///|
pub extern "js" fn MediaEncryptedEvent::get_init_data(
  self : MediaEncryptedEvent,
) -> ArrayBuffer? =
  #| (self) => (() => { const v = self.initData; return v == null ? { $tag: 0 } : { $tag: 1, _0: v }; })()