servo/tests/wpt/web-platform-tests/interfaces/webrtc-pc.idl

// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the WebRTC spec.
// See https://w3c.github.io/webrtc-pc/

dictionary RTCConfiguration {
             sequence<RTCIceServer>   iceServers;
             RTCIceTransportPolicy    iceTransportPolicy = "all";
             RTCBundlePolicy          bundlePolicy = "balanced";
             RTCRtcpMuxPolicy         rtcpMuxPolicy = "require";
             DOMString                peerIdentity;
             sequence<RTCCertificate> certificates;
             [EnforceRange]
             octet                    iceCandidatePoolSize = 0;
};

enum RTCIceCredentialType {
    "password",
    "oauth"
};

dictionary RTCOAuthCredential {
    required DOMString        macKey;
    required DOMString        accessToken;
};

dictionary RTCIceServer {
    required (DOMString or sequence<DOMString>) urls;
             DOMString                          username;
             (DOMString or RTCOAuthCredential)     credential;
             RTCIceCredentialType               credentialType = "password";
};

enum RTCIceTransportPolicy {
    "relay",
    "all"
};

enum RTCBundlePolicy {
    "balanced",
    "max-compat",
    "max-bundle"
};

enum RTCRtcpMuxPolicy {
    // At risk due to lack of implementers' interest.
    "negotiate",
    "require"
};

dictionary RTCOfferAnswerOptions {
             boolean voiceActivityDetection = true;
};

dictionary RTCOfferOptions : RTCOfferAnswerOptions {
             boolean iceRestart = false;
};

          dictionary RTCAnswerOptions : RTCOfferAnswerOptions {
};

enum RTCSignalingState {
    "stable",
    "have-local-offer",
    "have-remote-offer",
    "have-local-pranswer",
    "have-remote-pranswer",
    "closed"
};

enum RTCIceGatheringState {
    "new",
    "gathering",
    "complete"
};

enum RTCPeerConnectionState {
    "new",
    "connecting",
    "connected",
    "disconnected",
    "failed",
    "closed"
};

enum RTCIceConnectionState {
    "new",
    "checking",
    "connected",
    "completed",
    "disconnected",
    "failed",
    "closed"
};

          [ Constructor (optional RTCConfiguration configuration), Exposed=Window]
interface RTCPeerConnection : EventTarget  {
    Promise<RTCSessionDescriptionInit> createOffer (optional RTCOfferOptions options);
    Promise<RTCSessionDescriptionInit> createAnswer (optional RTCAnswerOptions options);
    Promise<void>                      setLocalDescription (RTCSessionDescriptionInit description);
    readonly        attribute RTCSessionDescription?    localDescription;
    readonly        attribute RTCSessionDescription?    currentLocalDescription;
    readonly        attribute RTCSessionDescription?    pendingLocalDescription;
    Promise<void>                      setRemoteDescription (RTCSessionDescriptionInit description);
    readonly        attribute RTCSessionDescription?    remoteDescription;
    readonly        attribute RTCSessionDescription?    currentRemoteDescription;
    readonly        attribute RTCSessionDescription?    pendingRemoteDescription;
    Promise<void>                      addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate);
    readonly        attribute RTCSignalingState         signalingState;
    readonly        attribute RTCIceGatheringState      iceGatheringState;
    readonly        attribute RTCIceConnectionState     iceConnectionState;
    readonly        attribute RTCPeerConnectionState    connectionState;
    readonly        attribute boolean?                  canTrickleIceCandidates;
    static sequence<RTCIceServer>      getDefaultIceServers ();
    RTCConfiguration                   getConfiguration ();
    void                               setConfiguration (RTCConfiguration configuration);
    void                               close ();
                    attribute EventHandler              onnegotiationneeded;
                    attribute EventHandler              onicecandidate;
                    attribute EventHandler              onicecandidateerror;
                    attribute EventHandler              onsignalingstatechange;
                    attribute EventHandler              oniceconnectionstatechange;
                    attribute EventHandler              onicegatheringstatechange;
                    attribute EventHandler              onconnectionstatechange;
};

partial interface RTCPeerConnection {
    Promise<void> createOffer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback, optional RTCOfferOptions options);
    Promise<void> setLocalDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
    Promise<void> createAnswer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback);
    Promise<void> setRemoteDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
    Promise<void> addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
};

                callback RTCPeerConnectionErrorCallback = void (DOMException error);

                callback RTCSessionDescriptionCallback = void (RTCSessionDescriptionInit description);

partial dictionary RTCOfferOptions {
            boolean offerToReceiveAudio;
            boolean offerToReceiveVideo;
          };

enum RTCSdpType {
    "offer",
    "pranswer",
    "answer",
    "rollback"
};

          [ Constructor (RTCSessionDescriptionInit descriptionInitDict), Exposed=Window]
interface RTCSessionDescription {
    readonly        attribute RTCSdpType type;
    readonly        attribute DOMString  sdp;
    [Default] object toJSON();
};

dictionary RTCSessionDescriptionInit {
    required RTCSdpType type;
             DOMString  sdp = "";
};

          [ Constructor (optional RTCIceCandidateInit candidateInitDict), Exposed=Window]
interface RTCIceCandidate {
    readonly        attribute DOMString               candidate;
    readonly        attribute DOMString?              sdpMid;
    readonly        attribute unsigned short?         sdpMLineIndex;
    readonly        attribute DOMString?              foundation;
    readonly        attribute RTCIceComponent?        component;
    readonly        attribute unsigned long?          priority;
    readonly        attribute DOMString?              ip;
    readonly        attribute RTCIceProtocol?         protocol;
    readonly        attribute unsigned short?         port;
    readonly        attribute RTCIceCandidateType?    type;
    readonly        attribute RTCIceTcpCandidateType? tcpType;
    readonly        attribute DOMString?              relatedAddress;
    readonly        attribute unsigned short?         relatedPort;
    readonly        attribute DOMString?              usernameFragment;
    RTCIceCandidateInit toJSON();
};

dictionary RTCIceCandidateInit {
             DOMString       candidate = "";
             DOMString?      sdpMid = null;
             unsigned short? sdpMLineIndex = null;
             DOMString       usernameFragment;
};

enum RTCIceProtocol {
    "udp",
    "tcp"
};

enum RTCIceTcpCandidateType {
    "active",
    "passive",
    "so"
};

enum RTCIceCandidateType {
    "host",
    "srflx",
    "prflx",
    "relay"
};

          [ Constructor (DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceEvent : Event {
    readonly        attribute RTCIceCandidate? candidate;
    readonly        attribute DOMString?       url;
};

          dictionary RTCPeerConnectionIceEventInit : EventInit {
             RTCIceCandidate? candidate;
             DOMString?       url;
};

          [ Constructor (DOMString type, RTCPeerConnectionIceErrorEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceErrorEvent : Event {
    readonly        attribute DOMString      hostCandidate;
    readonly        attribute DOMString      url;
    readonly        attribute unsigned short errorCode;
    readonly        attribute USVString      errorText;
};

          dictionary RTCPeerConnectionIceErrorEventInit : EventInit {
             DOMString      hostCandidate;
             DOMString      url;
             required unsigned short errorCode;
             USVString      statusText;
};

enum RTCPriorityType {
    "very-low",
    "low",
    "medium",
    "high"
};

partial interface RTCPeerConnection {
    static Promise<RTCCertificate> generateCertificate (AlgorithmIdentifier keygenAlgorithm);
};

dictionary RTCCertificateExpiration {
    [EnforceRange]
    DOMTimeStamp expires;
};

[Exposed=Window] interface RTCCertificate {
    readonly        attribute DOMTimeStamp expires;
    static sequence<AlgorithmIdentifier> getSupportedAlgorithms();
    sequence<RTCDtlsFingerprint> getFingerprints ();
};

partial interface RTCPeerConnection {
    sequence<RTCRtpSender>      getSenders ();
    sequence<RTCRtpReceiver>    getReceivers ();
    sequence<RTCRtpTransceiver> getTransceivers ();
    RTCRtpSender                addTrack (MediaStreamTrack track, MediaStream... streams);
    void                        removeTrack (RTCRtpSender sender);
    RTCRtpTransceiver           addTransceiver ((MediaStreamTrack or DOMString) trackOrKind, optional RTCRtpTransceiverInit init);
                    attribute EventHandler ontrack;
};

dictionary RTCRtpTransceiverInit {
             RTCRtpTransceiverDirection         direction = "sendrecv";
             sequence<MediaStream>              streams = [];
             sequence<RTCRtpEncodingParameters> sendEncodings = [];
};

enum RTCRtpTransceiverDirection {
    "sendrecv",
    "sendonly",
    "recvonly",
    "inactive"
};

[Exposed=Window] interface RTCRtpSender {
    readonly        attribute MediaStreamTrack? track;
    readonly        attribute RTCDtlsTransport?  transport;
    readonly        attribute RTCDtlsTransport? rtcpTransport;
    static RTCRtpCapabilities getCapabilities (DOMString kind);
    Promise<void>             setParameters (optional RTCRtpParameters parameters);
    RTCRtpParameters          getParameters ();
    Promise<void>             replaceTrack (MediaStreamTrack? withTrack);
    Promise<RTCStatsReport>   getStats();
};

dictionary RTCRtpParameters {
             DOMString                                 transactionId;
             sequence<RTCRtpEncodingParameters>        encodings;
             sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
             RTCRtcpParameters                         rtcp;
             sequence<RTCRtpCodecParameters>           codecs;
             RTCDegradationPreference                  degradationPreference;
};

dictionary RTCRtpEncodingParameters {
             octet               codecPayloadType;
             RTCDtxStatus        dtx;
             boolean             active = true;
             RTCPriorityType     priority = "low";
             unsigned long       ptime;
             unsigned long       maxBitrate;
             double              maxFramerate;
             DOMString           rid;
             double              scaleResolutionDownBy;
};

enum RTCDtxStatus {
         "disabled",
         "enabled"
         };

enum RTCDegradationPreference {
    "maintain-framerate",
    "maintain-resolution",
    "balanced"
};

dictionary RTCRtcpParameters {
             DOMString cname;
             boolean   reducedSize;
};

dictionary RTCRtpHeaderExtensionParameters {
             DOMString      uri;
             unsigned short id;
             boolean        encrypted;
};

dictionary RTCRtpCodecParameters {
             octet          payloadType;
             DOMString      mimeType;
             unsigned long  clockRate;
             unsigned short channels;
             DOMString      sdpFmtpLine;
};

dictionary RTCRtpCapabilities {
             sequence<RTCRtpCodecCapability>           codecs;
             sequence<RTCRtpHeaderExtensionCapability> headerExtensions;
};

dictionary RTCRtpCodecCapability {
             DOMString mimeType;
             unsigned long  clockRate;
             unsigned short channels;
             DOMString      sdpFmtpLine;
};

dictionary RTCRtpHeaderExtensionCapability {
             DOMString uri;
};

[Exposed=Window] interface RTCRtpReceiver {
    readonly        attribute MediaStreamTrack  track;
    readonly        attribute RTCDtlsTransport? transport;
    readonly        attribute RTCDtlsTransport? rtcpTransport;
    static RTCRtpCapabilities          getCapabilities (DOMString kind);
    RTCRtpParameters                   getParameters ();
    sequence<RTCRtpContributingSource>    getContributingSources ();
    sequence<RTCRtpSynchronizationSource> getSynchronizationSources ();
    Promise<RTCStatsReport>   getStats();
};

dictionary RTCRtpContributingSource {
    required DOMHighResTimeStamp timestamp;
    required unsigned long       source;
             double              audioLevel;
};

dictionary RTCRtpSynchronizationSource : RTCRtpContributingSource {
    boolean voiceActivityFlag;
};

[Exposed=Window] interface RTCRtpTransceiver {
    readonly        attribute DOMString?                  mid;
    [SameObject]
    readonly        attribute RTCRtpSender                sender;
    [SameObject]
    readonly        attribute RTCRtpReceiver              receiver;
    readonly        attribute boolean                     stopped;
                    attribute RTCRtpTransceiverDirection  direction;
    readonly        attribute RTCRtpTransceiverDirection? currentDirection;
    void stop ();
    void setCodecPreferences (sequence<RTCRtpCodecCapability> codecs);
};

[Exposed=Window] interface RTCDtlsTransport : EventTarget {
    readonly        attribute RTCIceTransport       transport;
    readonly        attribute RTCDtlsTransportState state;
    sequence<ArrayBuffer> getRemoteCertificates ();
                    attribute EventHandler          onstatechange;
                    attribute EventHandler          onerror;
};

enum RTCDtlsTransportState {
    "new",
    "connecting",
    "connected",
    "closed",
    "failed"
};

dictionary RTCDtlsFingerprint {
             DOMString algorithm;
             DOMString value;
};

[Exposed=Window] interface RTCIceTransport : EventTarget {
    readonly        attribute RTCIceRole           role;
    readonly        attribute RTCIceComponent      component;
    readonly        attribute RTCIceTransportState state;
    readonly        attribute RTCIceGathererState gatheringState;
    sequence<RTCIceCandidate> getLocalCandidates ();
    sequence<RTCIceCandidate> getRemoteCandidates ();
    RTCIceCandidatePair?      getSelectedCandidatePair ();
    RTCIceParameters?         getLocalParameters ();
    RTCIceParameters?         getRemoteParameters ();
                    attribute EventHandler         onstatechange;
                    attribute EventHandler         ongatheringstatechange;
                    attribute EventHandler         onselectedcandidatepairchange;
};

dictionary RTCIceParameters {
             DOMString usernameFragment;
             DOMString password;
};

dictionary RTCIceCandidatePair {
             RTCIceCandidate local;
             RTCIceCandidate remote;
};

enum RTCIceGathererState {
    "new",
    "gathering",
    "complete"
};

enum RTCIceTransportState {
    "new",
    "checking",
    "connected",
    "completed",
    "disconnected",
    "failed",
    "closed"
};

enum RTCIceRole {
    "controlling",
    "controlled"
};

enum RTCIceComponent {
    "rtp",
    "rtcp"
};

        [ Constructor (DOMString type, RTCTrackEventInit eventInitDict), Exposed=Window]
interface RTCTrackEvent : Event {
    readonly        attribute RTCRtpReceiver           receiver;
    readonly        attribute MediaStreamTrack         track;
    [SameObject]
    readonly        attribute FrozenArray<MediaStream> streams;
    readonly        attribute RTCRtpTransceiver        transceiver;
};

dictionary RTCTrackEventInit : EventInit {
    required RTCRtpReceiver        receiver;
    required MediaStreamTrack      track;
             sequence<MediaStream> streams = [];
    required RTCRtpTransceiver     transceiver;
};

partial interface RTCPeerConnection {
    readonly        attribute RTCSctpTransport? sctp;
    RTCDataChannel createDataChannel (USVString label, optional RTCDataChannelInit dataChannelDict);
                    attribute EventHandler      ondatachannel;
};

[Exposed=Window] interface RTCSctpTransport {
    readonly        attribute RTCDtlsTransport transport;
    readonly        attribute RTCSctpTransportState state;
    readonly        attribute unrestricted double maxMessageSize;
                    attribute EventHandler     onstatechange;
};

enum RTCSctpTransportState {
    "new",
    "connecting",
    "connected",
    "closed"
};

[Exposed=Window] interface RTCDataChannel : EventTarget {
    readonly        attribute USVString           label;
    readonly        attribute boolean             ordered;
    readonly        attribute unsigned short?     maxPacketLifeTime;
    readonly        attribute unsigned short?     maxRetransmits;
    readonly        attribute USVString           protocol;
    readonly        attribute boolean             negotiated;
    readonly        attribute unsigned short?     id;
    readonly        attribute RTCPriorityType     priority;
    readonly        attribute RTCDataChannelState readyState;
    readonly        attribute unsigned long       bufferedAmount;
                    attribute unsigned long       bufferedAmountLowThreshold;
                    attribute EventHandler        onopen;
                    attribute EventHandler        onbufferedamountlow;
                    attribute EventHandler        onerror;
                    attribute EventHandler        onclose;
    void close ();
                    attribute EventHandler        onmessage;
                    attribute DOMString           binaryType;
    void send (USVString data);
    void send (Blob data);
    void send (ArrayBuffer data);
    void send (ArrayBufferView data);
};

dictionary RTCDataChannelInit {
             boolean         ordered = true;
             unsigned short  maxPacketLifeTime;
             unsigned short  maxRetransmits;
             USVString       protocol = "";
             boolean         negotiated = false;
             [EnforceRange]
             unsigned short  id;
             RTCPriorityType priority = "low";
};

enum RTCDataChannelState {
    "connecting",
    "open",
    "closing",
    "closed"
};

        [ Constructor (DOMString type, RTCDataChannelEventInit eventInitDict), Exposed=Window]
interface RTCDataChannelEvent : Event {
    readonly        attribute RTCDataChannel channel;
};

dictionary RTCDataChannelEventInit : EventInit {
             required RTCDataChannel channel;
};

partial interface RTCRtpSender {
    readonly        attribute RTCDTMFSender? dtmf;
};

[Exposed=Window] interface RTCDTMFSender : EventTarget {
    void insertDTMF (DOMString tones, optional unsigned long duration = 100, optional unsigned long interToneGap = 70);
                    attribute EventHandler ontonechange;
    readonly        attribute boolean      canInsertDTMF;
    readonly        attribute DOMString    toneBuffer;
};

        [ Constructor (DOMString type, RTCDTMFToneChangeEventInit eventInitDict), Exposed=Window]
interface RTCDTMFToneChangeEvent : Event {
    readonly        attribute DOMString tone;
};

dictionary RTCDTMFToneChangeEventInit : EventInit {
             required DOMString tone;
};

partial interface RTCPeerConnection {
    Promise<RTCStatsReport> getStats (optional MediaStreamTrack? selector = null);
    attribute EventHandler onstatsended;
          };

[Exposed=Window] interface RTCStatsReport {
    readonly maplike<DOMString, object>;
};

dictionary RTCStats {
             required DOMHighResTimeStamp timestamp;
             required RTCStatsType        type;
             required DOMString           id;
};

[ Constructor (DOMString type, RTCStatsEventInit
          eventInitDict), Exposed=Window]
          interface RTCStatsEvent : Event {
            readonly attribute RTCStatsReport report;
          };

[Global, Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderGlobalScope : WorkerGlobalScope {
    readonly        attribute RTCIdentityProviderRegistrar rtcIdentityProvider;
};

[Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderRegistrar {
    void register (RTCIdentityProvider idp);
};

dictionary RTCIdentityProvider {
    required GenerateAssertionCallback generateAssertion;
    required ValidateAssertionCallback validateAssertion;
};

          callback GenerateAssertionCallback = Promise<RTCIdentityAssertionResult>
          (DOMString contents, DOMString origin, RTCIdentityProviderOptions options);

          callback ValidateAssertionCallback = Promise<RTCIdentityValidationResult>
          (DOMString assertion, DOMString origin);

dictionary RTCIdentityAssertionResult {
    required RTCIdentityProviderDetails idp;
    required DOMString                  assertion;
};

dictionary RTCIdentityProviderDetails {
    required DOMString domain;
             DOMString protocol = "default";
};

dictionary RTCIdentityValidationResult {
    required DOMString identity;
    required DOMString contents;
};

partial interface RTCPeerConnection {
    void               setIdentityProvider (DOMString provider, optional RTCIdentityProviderOptions options);
    Promise<DOMString> getIdentityAssertion ();
    readonly        attribute Promise<RTCIdentityAssertion> peerIdentity;
    readonly        attribute DOMString?                    idpLoginUrl;
    readonly        attribute DOMString?                    idpErrorInfo;
};

dictionary RTCIdentityProviderOptions {
    DOMString protocol = "default";
    DOMString usernameHint;
    DOMString peerIdentity;
};

[Constructor(DOMString idp, DOMString name), Exposed=Window]
interface RTCIdentityAssertion {
    attribute DOMString idp;
    attribute DOMString name;
};

partial dictionary MediaStreamConstraints {
             DOMString peerIdentity;
};

partial interface MediaStreamTrack {
    readonly        attribute boolean      isolated;
                    attribute EventHandler onisolationchange;
};

enum RTCErrorDetailType {
              "data-channel-failure",
              "dtls-failure",
              "fingerprint-failure",
              "idp-bad-script-failure",
              "idp-execution-failure",
              "idp-load-failure",
              "idp-need-login",
              "idp-timeout",
              "idp-tls-failure",
              "idp-token-expired",
              "idp-token-invalid",
              "sctp-failure",
              "sdp-syntax-error",
              "hardware-encoder-not-available",
              "hardware-encoder-error"
          };

[Exposed=Window,
 Constructor (DOMString type, RTCErrorEventInit eventInitDict)]
interface RTCErrorEvent : Event {
    readonly        attribute RTCError? error;
};

dictionary RTCErrorEventInit : EventInit {
             RTCError? error = null;
};