vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2025-10-16 12:05:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update definitions to more closely match current spec state

Browse Source
This commit is contained in:
Ken Smith 2013-05-31 10:09:31 -07:00
parent 6e09bce514
commit 7280954e72
2 changed files with 183 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
webrtc/MediaStream.d.ts vendored
View File

@ -1,42 +1,42 @@
// Type definitions take from http://dev.w3.org/2011/webrtc/editor/getusermedia.html
interface MediaStreamConstraints {
audio: bool;
video: bool;
audio: bool;
video: bool;
}
declare var MediaStreamConstraints: {
prototype: MediaStreamConstraints;
new (): MediaStreamConstraints;
prototype: MediaStreamConstraints;
new (): MediaStreamConstraints;
}
interface MediaTrackConstraints {
mandatory: MediaTrackConstraintSet;
optional: MediaTrackConstraint[];
mandatory: MediaTrackConstraintSet;
optional: MediaTrackConstraint[];
}
declare var MediaTrackConstraints: {
prototype: MediaTrackConstraints;
new (): MediaTrackConstraints;
prototype: MediaTrackConstraints;
new (): MediaTrackConstraints;
}
// ks - Not defined in the source doc.
interface MediaTrackConstraintSet {
}
declare var MediaTrackConstraintSet: {
prototype: MediaTrackConstraintSet;
new (): MediaTrackConstraintSet;
prototype: MediaTrackConstraintSet;
new (): MediaTrackConstraintSet;
}
// ks - Not defined in the source doc.
interface MediaTrackConstraint {
}
declare var MediaTrackConstraint: {
prototype: MediaTrackConstraint;
new (): MediaTrackConstraints;
prototype: MediaTrackConstraint;
new (): MediaTrackConstraints;
}
interface Navigator {
getUserMedia(constraints: MediaStreamConstraints, successCallback: (stream: LocalMediaStream) => void , errorCallback: (error: Error) => void );
webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: (stream: LocalMediaStream) => void , errorCallback: (error: Error) => void );
getUserMedia(constraints: MediaStreamConstraints, successCallback: (stream: any) => void , errorCallback: (error: Error) => void );
webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: (stream: any) => void , errorCallback: (error: Error) => void );
}
interface EventHandler { (event: Event): void; }
@ -44,93 +44,93 @@ interface EventHandler { (event: Event): void; }
interface NavigatorUserMediaSuccessCallback { (stream: LocalMediaStream): void; }
interface NavigatorUserMediaError {
PERMISSION_DENIED: number; // = 1;
code: number;
PERMISSION_DENIED: number; // = 1;
code: number;
}
declare var NavigatorUserMediaError: {
prototype: NavigatorUserMediaError;
new (): NavigatorUserMediaError;
PERMISSION_DENIED: number; // = 1;
prototype: NavigatorUserMediaError;
new (): NavigatorUserMediaError;
PERMISSION_DENIED: number; // = 1;
}
interface NavigatorUserMediaErrorCallback { (error: NavigatorUserMediaError): void; }
interface MediaStreamTrackList {
length: number;
item: MediaStreamTrack;
add(track: MediaStreamTrack): void;
remove(track: MediaStreamTrack): void;
onaddtrack: (event: Event) => void;
onremovetrack: (event: Event) => void;
length: number;
item: MediaStreamTrack;
add(track: MediaStreamTrack): void;
remove(track: MediaStreamTrack): void;
onaddtrack: (event: Event) => void;
onremovetrack: (event: Event) => void;
}
declare var MediaStreamTrackList: {
prototype: MediaStreamTrackList;
new (): MediaStreamTrackList;
prototype: MediaStreamTrackList;
new (): MediaStreamTrackList;
}
declare var webkitMediaStreamTrackList: {
prototype: MediaStreamTrackList;
new (): MediaStreamTrackList;
prototype: MediaStreamTrackList;
new (): MediaStreamTrackList;
}
interface MediaStream {
label: string;
audioTracks: MediaStreamTrackList;
videoTracks: MediaStreamTrackList;
ended: bool;
onended: (event: Event) => void;
label: string;
getAudioTracks(): MediaStreamTrackList;
getVideoTracks(): MediaStreamTrackList;
ended: bool;
onended: (event: Event) => void;
}
declare var MediaStream: {
prototype: MediaStream;
new (): MediaStream;
new (trackContainers: MediaStream[]): MediaStream;
new (trackContainers: MediaStreamTrackList[]): MediaStream;
new (trackContainers: MediaStreamTrack[]): MediaStream;
prototype: MediaStream;
new (): MediaStream;
new (trackContainers: MediaStream[]): MediaStream;
new (trackContainers: MediaStreamTrackList[]): MediaStream;
new (trackContainers: MediaStreamTrack[]): MediaStream;
}
declare var webkitMediaStream: {
prototype: MediaStream;
new (): MediaStream;
new (trackContainers: MediaStream[]): MediaStream;
new (trackContainers: MediaStreamTrackList[]): MediaStream;
new (trackContainers: MediaStreamTrack[]): MediaStream;
prototype: MediaStream;
new (): MediaStream;
new (trackContainers: MediaStream[]): MediaStream;
new (trackContainers: MediaStreamTrackList[]): MediaStream;
new (trackContainers: MediaStreamTrack[]): MediaStream;
}
interface LocalMediaStream extends MediaStream {
stop(): void;
stop(): void;
}
interface MediaStreamTrack {
kind: string;
label: string;
enabled: bool;
LIVE: number; // = 0;
MUTED: number; // = 1;
ENDED: number; // = 2;
readyState: number;
onmute: (event: Event) => void;
onunmute: (event: Event) => void;
onended: (event: Event) => void;
kind: string;
label: string;
enabled: bool;
LIVE: number; // = 0;
MUTED: number; // = 1;
ENDED: number; // = 2;
readyState: number;
onmute: (event: Event) => void;
onunmute: (event: Event) => void;
onended: (event: Event) => void;
}
var MediaStramTrack: {
prototype: MediaStreamTrack;
new (): MediaStreamTrack;
LIVE: number; // = 0;
MUTED: number; // = 1;
ENDED: number; // = 2;
prototype: MediaStreamTrack;
new (): MediaStreamTrack;
LIVE: number; // = 0;
MUTED: number; // = 1;
ENDED: number; // = 2;
}
interface URL {
createObjectURL(stream: MediaStream): string;
createObjectURL(stream: MediaStream): string;
}
var URL: {
prototype: MediaStreamTrack;
new (): URL;
createObjectURL(stream: MediaStream): string;
prototype: MediaStreamTrack;
new (): URL;
createObjectURL(stream: MediaStream): string;
}
interface WebkitURL extends URL {
}
var webkitURL: {
prototype: WebkitURL;
new (): URL;
createObjectURL(stream: MediaStream): string;
}
prototype: WebkitURL;
new (): URL;
createObjectURL(stream: MediaStream): string;
}

222
webrtc/RTCPeerConnection.d.ts vendored
View File

@ -3,63 +3,66 @@
// These are TypeScript definitions to support static typing in TypeScript when interacting with WebRtc.
// Definitions taken from http://dev.w3.org/2011/webrtc/editor/webrtc.html
// These are TypeScript definitions to support static typing in TypeScript when interacting with WebRtc.
// Definitions taken from http://dev.w3.org/2011/webrtc/editor/webrtc.html
interface RTCConfiguration {
iceServers: RTCIceServer[];
iceServers: RTCIceServer[];
}
var RTCConfiguration: {
prototype: RTCConfiguration;
new (): RTCConfiguration;
prototype: RTCConfiguration;
new (): RTCConfiguration;
}
interface RTCIceServer {
url: string;
credential?: string;
url: string;
credential?: string;
}
var RTCIceServer: {
prototype: RTCIceServer;
new (): RTCIceServer;
prototype: RTCIceServer;
new (): RTCIceServer;
}
interface webkitRTCPeerConnection extends RTCPeerConnection {
}
var webkitRTCPeerConnection: {
prototype: webkitRTCPeerConnection;
new (settings: RTCPeerConnectionConfig, constraints?:MediaConstraints): webkitRTCPeerConnection;
prototype: webkitRTCPeerConnection;
new (settings: RTCPeerConnectionConfig, constraints?:MediaConstraints): webkitRTCPeerConnection;
}
interface IceState {
}
var IceState: {
prototype: IceState;
new (): IceState;
prototype: IceState;
new (): IceState;
}
// ks 12/20/12 - There's more here that doesn't seem to be documented very well yet.
interface MediaConstraints {
mandatory: MediaOfferConstraints;
mandatory: MediaOfferConstraints;
}
interface MediaOfferConstraints {
OfferToReceiveAudio: bool;
OfferToReceiveVideo: bool;
OfferToReceiveAudio: bool;
OfferToReceiveVideo: bool;
}
interface RTCSessionDescription {
type?: RTCSdpType;
sdp?: string;
type?: RTCSdpType;
sdp?: string;
}
var RTCSessionDescription: {
prototype: RTCSessionDescription;
new (descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
prototype: RTCSessionDescription;
new (descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
}
interface RTCSessionDescriptionInit {
type: RTCSdpType;
sdp: string;
type: RTCSdpType;
sdp: string;
}
var RTCSessionDescriptionInit: {
prototype: RTCSessionDescriptionInit;
new (): RTCSessionDescriptionInit;
prototype: RTCSessionDescriptionInit;
new (): RTCSessionDescriptionInit;
}
interface SdpType {
@ -69,153 +72,158 @@ interface RTCPeerState {
}
interface RTCDataChannelInit {
reliable: bool;
reliable: bool;
}
enum RTCSdpType {
offer,
pranswer,
answer
offer,
pranswer,
answer
}
enum RTCDataChannelState {
connecting,
open,
closing,
closed
connecting,
open,
closing,
closed
}
interface RTCDataChannel extends EventTarget {
label: string;
reliable: bool;
readyState: RTCDataChannelState;
bufferedAmount: number;
onopen: (event: Event)=> void;
onerror: (event: Event)=> void;
onclose: (event: Event)=> void;
close(): void;
onmessage: (event: Event)=> void;
binaryType: string;
send(data: string);
send(data: ArrayBuffer);
send(data: Blob);
label: string;
reliable: bool;
readyState: RTCDataChannelState;
bufferedAmount: number;
onopen: (event: Event)=> void;
onerror: (event: Event)=> void;
onclose: (event: Event)=> void;
close(): void;
onmessage: (event: Event)=> void;
binaryType: string;
send(data: string);
send(data: ArrayBuffer);
send(data: Blob);
}
declare var RTCDataChannel: {
prototype: RTCDataChannel;
new (): RTCDataChannel;
prototype: RTCDataChannel;
new (): RTCDataChannel;
}
interface RTCDataChannelEvent extends Event {
constructor (eventInitDict: RTCDataChannelEventInit);
channel: RTCDataChannel;
constructor (eventInitDict: RTCDataChannelEventInit);
channel: RTCDataChannel;
}
var RTCDataChannelEvent: {
prototype: RTCDataChannelEvent;
new (eventInitDict: RTCDataChannelEventInit);
prototype: RTCDataChannelEvent;
new (eventInitDict: RTCDataChannelEventInit);
}
interface RTCIceCandidateEvent extends Event{
candidate: RTCIceCandidate;
candidate: RTCIceCandidate;
}
interface RTCMediaStreamEvent extends Event {
stream: MediaStream;
stream: MediaStream;
}
interface EventInit {
}
interface RTCDataChannelEventInit extends EventInit {
channel: RTCDataChannel;
channel: RTCDataChannel;
}
interface RTCVoidCallback {
(): void;
(): void;
}
interface RTCSessionDescriptionCallback {
(sdp: RTCSessionDescription): void;
(sdp: RTCSessionDescription): void;
}
interface RTCPeerConnectionErrorCallback {
(errorInformation: string): void;
(errorInformation: string): void;
}
// This should be an enum
interface RTCGatheringState {
string;
/** This should be an enum */
interface RTCIceGatheringState {
string;
}
// This should be an enum
interface RTCIceState {
string;
/** This should be an enum */
interface RTCIceConnectionState {
string;
}
/** This should be an enum */
interface RTCSignalingState{
string;
}
interface RTCPeerConnection {
createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback?: RTCPeerConnectionErrorCallback, constraints?: MediaConstraints): void;
createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback?: RTCPeerConnectionErrorCallback, constraints?: MediaConstraints): void;
setLocalDescription(description: RTCSessionDescription, successCallback?: RTCVoidCallback, failureCallback?: RTCPeerConnectionErrorCallback): void;
localDescription: RTCSessionDescription;
setRemoteDescription(description: RTCSessionDescription, successCallback?: RTCVoidCallback, failureCallback?: RTCPeerConnectionErrorCallback): void;
remoteDescription: RTCSessionDescription;
readyState: RTCPeerState;
updateIce(configuration?: RTCConfiguration, constraints?: MediaConstraints): void;
addIceCandidate(candidate: RTCIceCandidate): void;
iceGatheringState: RTCGatheringState;
iceState: RTCIceState;
localStreams: MediaStream[];
remoteStreams: MediaStream[];
createDataChannel(label?: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
ondatachannel: (event: Event)=> void;
addStream(stream: MediaStream, constraints?: MediaConstraints): void;
removeStream(stream: MediaStream): void;
close(): void;
onnegotiationneeded: (event: Event)=> void;
onconnecting: (event: Event)=> void;
onopen: (event: Event)=> void;
onaddstream: (event: RTCMediaStreamEvent)=> void;
onremovestream: (event: RTCMediaStreamEvent)=> void;
onstatechange: (event: Event)=> void;
onicechange: (event: Event)=> void;
onicecandidate: (event: RTCIceCandidateEvent)=> void;
onidentityresult: (event: Event)=> void;
createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback?: RTCPeerConnectionErrorCallback, constraints?: MediaConstraints): void;
createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback?: RTCPeerConnectionErrorCallback, constraints?: MediaConstraints): void;
setLocalDescription(description: RTCSessionDescription, successCallback?: RTCVoidCallback, failureCallback?: RTCPeerConnectionErrorCallback): void;
localDescription: RTCSessionDescription;
setRemoteDescription(description: RTCSessionDescription, successCallback?: RTCVoidCallback, failureCallback?: RTCPeerConnectionErrorCallback): void;
remoteDescription: RTCSessionDescription;
signalingState: RTCSignalingState;
updateIce(configuration?: RTCConfiguration, constraints?: MediaConstraints): void;
addIceCandidate(candidate: RTCIceCandidate): void;
iceGatheringState: RTCIceGatheringState;
iceConnectionState: RTCIceConnectionState;
getLocalStreams(): MediaStream[];
getRemoteStreams(): MediaStream[];
createDataChannel(label?: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
ondatachannel: (event: Event)=> void;
addStream(stream: MediaStream, constraints?: MediaConstraints): void;
removeStream(stream: MediaStream): void;
close(): void;
onnegotiationneeded: (event: Event)=> void;
onconnecting: (event: Event)=> void;
onopen: (event: Event)=> void;
onaddstream: (event: RTCMediaStreamEvent)=> void;
onremovestream: (event: RTCMediaStreamEvent)=> void;
onstatechange: (event: Event)=> void;
onicechange: (event: Event)=> void;
onicecandidate: (event: RTCIceCandidateEvent)=> void;
onidentityresult: (event: Event)=> void;
}
var RTCPeerConnection: {
prototype: RTCPeerConnection;
new (configuration: RTCConfiguration, constraints?: MediaConstraints): RTCPeerConnection;
prototype: RTCPeerConnection;
new (configuration: RTCConfiguration, constraints?: MediaConstraints): RTCPeerConnection;
}
interface RTCIceCandidate {
candidate?: string;
sdpMid?: string;
sdpMLineIndex?: number;
candidate?: string;
sdpMid?: string;
sdpMLineIndex?: number;
}
var RTCIceCandidate: {
prototype: RTCIceCandidate;
new (candidateInitDict?: RTCIceCandidate);
prototype: RTCIceCandidate;
new (candidateInitDict?: RTCIceCandidate);
}
interface RTCIceCandidateInit {
candidate: string;
sdpMid: string;
sdpMLineIndex: number;
candidate: string;
sdpMid: string;
sdpMLineIndex: number;
}
var RTCIceCandidateInit:{
prototype: RTCIceCandidateInit;
new (): RTCIceCandidateInit;
prototype: RTCIceCandidateInit;
new (): RTCIceCandidateInit;
}
interface PeerConnectionIceEvent {
peer: RTCPeerConnection;
candidate: RTCIceCandidate;
peer: RTCPeerConnection;
candidate: RTCIceCandidate;
}
var PeerConnectionIceEvent: {
prototype: PeerConnectionIceEvent;
new (): PeerConnectionIceEvent;
prototype: PeerConnectionIceEvent;
new (): PeerConnectionIceEvent;
}
interface RTCPeerConnectionConfig {
iceServers: RTCIceServer[];
iceServers: RTCIceServer[];
}
var RTCPeerConnectionConfig: {
prototype: RTCPeerConnectionConfig;
new (): RTCPeerConnectionConfig;
prototype: RTCPeerConnectionConfig;
new (): RTCPeerConnectionConfig;
}