webex

Create a new Webex instance

Create a new Webex instance configured for your OAuth client

const webex = Webex.init({
  config: {
    credentials: {
      authorizationString: `<AUTHORIZATION URL FROM DEVELOPER PORTAL>`
    }
  }
});

Create a new Webex instance configured for a Bot

const webex = Webex.init({
  config: {
    credentials: `<BOT TOKEN FROM DEVELOPER PORTAL>`
  }
});

Alias of AuthorizationBrowser#isAuthorizing

Indicates if an Authorization Code exchange is inflight

Kicks off an oauth flow

Kicks off the Authorization Code grant flow. Typically called via AuthorizationBrowser#initiateLogin

Kicks off the Implicit Code grant flow. Typically called via AuthorizationBrowser#initiateLogin

Requests a Webex Teams access token for a user already authenticated into your product.

Note: You'll need to supply a jwtRefreshCallback of the form Promise<jwt> = jwtRefreshCallback(webex) for automatic token refresh to work.

Called by WebexCore#logout(). Redirects to the logout page

Alias of AuthorizationNode#isAuthorizing

Indicates if an Authorization Code exchange is inflight

Exchanges an authorization code for an access token

Requests a Webex Teams access token for a user already authenticated into your product.

Note: You'll need to supply a jwtRefreshCallback of the form Promise<jwt> = jwtRefreshCallback(webex) for automatic token refresh to work.

Indicates whether or not the WebSocket is connected

Type: Boolean

Specifies the facingMode to be used by Phone#dial and Call#answer when no constraint is specified. Does not apply if

• a MediaStream is passed to Phone#dial or Call#answer
• constraints are passed to Phone#dial or Call#answer The only valid values are user and environment. For any other values, you must provide your own constrains or MediaStream

indicates whether or not the client is registered with the Webex Teams cloud

Type: Boolean

Indicates if the current browser appears to support webrtc calling. Note: at this time, there's no way to determine if the current browser supports h264 without asking for camera permissions

Registers the client with the Webex Teams cloud and starts listening for WebSocket events.

Subsequent calls refresh the device registration.

Disconnects from WebSocket and unregisters from the Webex Teams cloud.

Subsequent calls will be a noop.

Create a MediaStream to be used for video preview.

Note: You must explicitly pass the resultant stream to Call#answer() or Phone#dial()

Place a call to the specified dialString. A dial string may be an email address or sip uri. If you set config.phone.enableExperimentalGroupCallingSupport to true, the dialString may also be a room id.

Call Created Event

Emitted when a call begins outside of the sdk

Incoming Call Event

Emitted when a call begins and when Phone#register is invoked and there are active calls.

Type: Object

Indicates if the other party in the call has turned off their microphone. undefined for multiparty calls

Indicates if the other party in the call has turned off their camera. undefined for multiparty calls

Returns the local MediaStream for the call. May initially be null between the time @{Phone#dial is invoked and the media stream is acquired if Phone#dial is invoked without a localMediaStream option.

This property can also be set mid-call in which case the streams sent to the remote party are replaced by this stream. On success, the Call's localMediaStream:change event fires, notifying any listeners that we are now sending media from a new source.

The other participant in a two-party call. undefined for multiparty calls

The initiating participant in a two-party call.

active - At least one person (not necessarily this user) is participating in the call
inactive - No one is participating in the call
initializing - reserved for future use
terminating - reserved for future use
Only defined if PhoneConfig.enableExperimentalGroupCallingSupport has been enabled

Type: string

initiated - Offer was sent to remote party but they have not yet accepted
ringing - Remote party has acknowledged the call
connected - At least one party is still on the call
disconnected - All parties have dropped
replaced - In (hopefully) rare cases, the underlying data backing a Call instance may change in such a way that further interaction with that Call is handled by a different instance. In such cases, the first Call's status, will transition to replaced, which is almost the same state as disconnected. Generally speaking, such a transition should not happen for a Call instance that is actively sending/receiving media.

Type: string

The host of the call Only defined if PhoneConfig.enableExperimentalGroupCallingSupport has been enabled

The room id of the call Only defined if PhoneConfig.enableExperimentalGroupCallingSupport has been enabled

Access to the remote party’s MediaStream.

Type: MediaStream

Access to the local party’s screen share MediaStream.

Type: MediaStream

Use to acknowledge (without answering) an incoming call. Will cause the initiator's Call instance to emit the ringing event.

Answers an incoming call.

Call and answer require nearly identical logic, so this method unifies them.

Alias of Call#reject

Returns a Readable that emits Call#media.pc's RTCStatsReport every second.

Returns a StatsStream piped through a StatsFilter

Disconnects the active call. Applies to both incoming and outgoing calls. This method may be invoked in any call state and the SDK should take care to tear down the call and free up all resources regardless of the state.

Rejects an incoming call. Only applies to incoming calls. Invoking this method on an outgoing call is a no-op.

Send DTMF tones to the current call

Sends feedback about the call to the Webex Teams cloud

Start receiving audio

Start receiving video

Starts sending audio to the Webex Teams Cloud

Starts sending video to the Webex Teams Cloud

Stop receiving audio

Stop receiving video

Stops sending audio to the Webex Teams Cloud. (stops broadcast immediately, even if renegotiation has not completed)

Stops sending video to the Webex Teams Cloud. (stops broadcast immediately, even if renegotiation has not completed)

Replaces the current mediaStrem with one with identical constraints, except for an opposite facing mode. If the current facing mode cannot be determined, the facing mode will be set to user. If the call is audio only, this function will throw.

Toggles receiving audio from the Webex Teams Cloud

Toggles receiving video from the Webex Teams Cloud

Toggles sending audio to the Webex Teams Cloud

Toggles sending video to the Webex Teams Cloud

This replaces the Call.ringing event, but note that it's subtly different. Call.ringing is emitted when the remote party calls Call#acknowledge() whereas Call.membership:notified emits shortly after (but as a direct result of) locally calling Phone#dial()

only emitted if enableExperimentalGroupCallingSupport is enabled

only emitted if enableExperimentalGroupCallingSupport is enabled

only emitted if enableExperimentalGroupCallingSupport is enabled

only emitted if enableExperimentalGroupCallingSupport is enabled

Emitted when a CallMembership is removed from Call#memberships.

Emitted when a new CallMembership is added to Call#memberships. Note that CallMembership#state still needs to be read to determine if the instance represents someone actively participating the call.

Indicates if the member started the call

Indicates the member's relationship with the call. One of

• notified - the party has been invited to the call but has not yet accepted
• connected - the party is participating in the call
• declined - the party chose not to accept the call
• disconnected - the party is no longer participating in the call
• waiting - reserved for future use

Indicates if the member has muted their microphone

Indicates if the member has disable their camera

initializes the reachability instance for Meetings

gets the reachability instance for Meetings

initializes and starts gathering reachability for Meetings

gets the personal meeting room instance, for saved PMR values for this user

Create a meeting.

get a specifc meeting given it's type matched to the value, i.e., locus url

Get all meetings.

syncs all the meeting from server

Get all scheduled meetings.

Get the Stats Analyzer singleton

Get the Stats Calculator singleton

Get the devices from the Media module

The PersonalMeetingRoom object to interact with server

Get the logger instance for plugin-meetings

The property name for what collection will be stored, i.e., this.meetingInfos, this.meetings, etc.

The actual object for the collection

Meetings Ready Event Emitted when the meetings instance on webex is ready

Meeting Removed Event Emitted when a meeting was removed from the cache of meetings

Meeting Added Event Emitted when a meeting was added to the cache of meetings

Media Ready Event Emitted when a stream is ready to be rendered

Register to listen for incoming membership events This is an alternate approach to registering for membership webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

webex.memberships.listen()
  .then(() => {
    console.log('listening to membership events');
    webex.memberships.on('created', (event) => {
      console.log(`Got a membership:created event:\n${event}`);
    }
    webex.memberships.on('updated', (event) => {
       console.log(`Got a membership:updated event:\n${event}`);
    }
    webex.memberships.on('seen', (event) => {
      // This represents a "read receipt" and will include a
      // lastSeenId for the message this member has just "read",
      // There is currently no equivelent webhook for this event.
      console.log(`Got a membership:seen event:\n${event}`);
    }
    webex.memberships.on('deleted', (event) =>  => {
      console.log(`Got a membership:created event:\n${event}`);
    }
  })
  .catch((e) => console.error(`Unable to register for membership events: ${e}`));
// App logic goes here...
// Later when it is time to clean up
webex.memberships.stopListening();
webex.memberships.off('created');
webex.memberships.off('updated');
webex.memberships.off('seen');
webex.memberships.off('deleted');

Adds a person to a room. The person can be added by ID (personId) or by Email Address (personEmail). The person can be optionally added to the room as a moderator.

webex.rooms.create({title: 'Create Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.roomId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert('isMonitor' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

Returns a single membership.

var membership;
webex.rooms.create({title: 'Get Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

Returns a list of memberships. In most cases the results will only contain rooms that the authentiated user is a member of. You can filter the results by room to list people in a room or by person to find rooms that a specific person is a member of.

var room;
webex.rooms.create({title: 'List Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    for (var i = 0; i < memberships.length; i+= 1) {
      assert.equal(memberships.items[i].roomId, room.id);
    }
    return 'success';
  });
  // => success

Returns a list of memberships with details about the lastSeenId for each user, allowing a client to indicate "read status" in a space GUI

This differs from the memberships.list() function in the following ways: -- it accepts only a room or object with a valid roomId -- no other options, eg: max, are considered -- results are not paginated -- memberships in the return do not include the "created", "isRoomHidden", fields -- memberships in the return do include the new "lastSeenId", and "lastSeenDate" fields these will not exist if the member has never "seen" the space

In general this function should be used only when the client needs to access read status info.

This function may be deprecated when this info is provided in the membership objects returned in the list function.

Deletes a single membership.

var membership, room;
webex.rooms.create({title: 'Remove Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    return webex.memberships.remove(membership);
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 1);
    return 'success';
  });
  // => success

Used to update a single membership's properties

var membership, room;
webex.rooms.create({title: 'Memberships Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    membership = memberships.items[0];
    var assert = require('assert');
    assert.equal(membership.isModerator, false);
    membership.isModerator = true;
    return webex.memberships.update(membership);
  })
  .then(function() {
    return webex.memberships.get(membership.id);
  })
  .then(function(membership) {
    var assert = require('assert');
    assert.equal(membership.isModerator, true);
    return 'success';
  });
  // => success

Updates the lastSeenId attribute of a membership. Call this method to send a "read receipt" for a given message. This will update the lastSeenId for the user's membership in space where the message is.

Register to listen for incoming messages events This is an alternate approach to registering for messages webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. The messages.listen() event objects can also include additional fields not available in the webhook's JSON payload: text, markdown, and files. These fields are available when their details are included in the web socket's activity object. Retrieving other fields, such as the html field, will require a manual request to get the corresponding message object. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

webex.messages.listen()
  .then(() => {
    console.log('listening to message events');
    webex.messages.on('created', (event) => console.log(`Got a message:created event:\n${event}`);
    webex.messages.on('deleted', (event) => console.log(`Got a message:deleted event:\n${event}`);
  })
  .catch((e) => console.error(`Unable to register for message events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.messages.stopListening();
webex.messages.off('created');
webex.messages.off('deleted');

Post a new message and/or media content into a room.

webex.rooms.create({title: 'Create Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(message) {
    var assert = require('assert');
    assert(message.id);
    assert(message.personId);
    assert(message.personEmail);
    assert(message.roomId);
    assert(message.created);
    return 'success';
  });
  // => success

Returns a single message.

var message;
webex.rooms.create({title: 'Get Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message = m;
    return webex.messages.get(message.id);
  })
  .then(function(message2) {
    var assert = require('assert');
    assert.deepEqual(message2, message);
    return 'success';
  });
  // => success

Returns a list of messages. In most cases the results will only contain messages posted in rooms that the authentiated user is a member of.

var message1, message2, room;
webex.rooms.create({title: 'List Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function(m) {
    message2 = m;
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.length, 2);
    assert.equal(messages.items[0].id, message2.id);
    assert.equal(messages.items[1].id, message1.id);
    return 'success';
  });
  // => success

Deletes a single message. Deleting a message will notify all members of the room that the authenticated user deleted the message. Generally, users can only delete their own messages except for the case of Moderated Rooms and Org Administrators.

var message1, room;
webex.rooms.create({title: 'Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.messages.remove(message1);
  })
  .then(function() {
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.items.length, 1);
    assert(messages.items[0].id !== message1.id);
    return 'success';
  });
  // => success

Returns a single person by ID

webex.rooms.create({title: 'Get Person Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    return webex.people.get(membership.personId);
  })
  .then(function(alice) {
    var assert = require('assert');
    assert(alice.id);
    assert(Array.isArray(alice.emails));
    assert.equal(alice.emails.filter(function(email) {
      return email === 'alice@example.com';
    }).length, 1);
    assert(alice.displayName);
    assert(alice.created);
    return 'success';
  });
  // => success

Returns a list of people

var room;
webex.rooms.create({title: 'List People Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.people.list({email: 'alice@example.com'});
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 1);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Example usage of array method

var room;
var aliceId;
var bobId;
webex.rooms.create({title: 'List People Array Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    aliceId = membership.personId;
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    bobId = membership.personId;
  })
  .then(function() {
    return webex.people.list([aliceId, bobId]);
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 2);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Register to listen for incoming rooms events This is an alternate approach to registering for rooms webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

webex.rooms.listen()
  .then(() => {
    console.log('listening to room events');
    webex.rooms.on('created', (event) => console.log(`Got a room:created event:\n${event}`);
    webex.rooms.on('updated', (event) => console.log(`Got a room:updated event:\n${event}`);
  })
  .catch((e) => console.error(`Unable to register for room events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.rooms.stopListening();
webex.rooms.off('created');
webex.rooms.off('updated');

Creates a new room. The authenticated user is automatically added as a member of the room. See the Memberships API to learn how to add more people to the room.

webex.rooms.create({title: 'Create Room Example'})
  .then(function(room) {
    var assert = require('assert')
    assert(typeof room.created === 'string');
    assert(typeof room.id === 'string');
    assert(room.title === 'Create Room Example');
    console.log(room.title);
    return 'success';
  });
  // => success

Returns a single room.

var room;
webex.rooms.create({title: 'Get Room Example'})
  .then(function(r) {
    room = r
    return webex.rooms.get(room.id)
  })
  .then(function(r) {
    var assert = require('assert');
    assert.deepEqual(r, room);
    return 'success';
  });
  // => success

Returns a list of rooms. In most cases the results will only contain rooms that the authentiated user is a member of.

var createdRooms;
Promise.all([
  webex.rooms.create({title: 'List Rooms Example 1'}),
  webex.rooms.create({title: 'List Rooms Example 2'}),
  webex.rooms.create({title: 'List Rooms Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.rooms.list({max: 3})
      .then(function(rooms) {
        var assert = require('assert');
        assert(rooms.length === 3);
        for (var i = 0; i < rooms.items.length; i+= 1) {
          assert(createdRooms.filter(function(room) {
            return room.id === rooms.items[i].id;
          }).length === 1);
        }
        return 'success';
      });
  });
  // => success

Returns a list of rooms with details about the data of the last actvity in the room, and the date of the users last presences in the room. The list is sorted with this with most recent activity first

For rooms where lastActivityDate > lastSeenDate the space can be considerd to be "unread"

This differs from the rooms.list() function in the following ways: -- when called with no parameters it returns an array of all spaces, up to 1000, that the user is a member of -- pagination is not supported. ALL rooms are returned which can result in a large payload -- For users with hundreds of spaces, this API can take some time to to return, for this reason it supports an optional maxRecent parameter. If set this will return only the specified number of spaces with activity in the last two weeks. Reccomended value is 30. Max supported is 100. -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available for each room in the list -- "title" is usually returned, but not guaranteed

In general this function should be used only when the client needs to access read status info, for example on startup. After startup, clients should track message and membership:seen events to maintain read status client side.

Since this API can take some time to return up to 1000 spaces, it is recommended that custom clients call this first with the maxRecent parameter set to 30, so that they can display some of the more recents spaces. Calling this API a second time with no parameters will return all the spaces.

Not all spaces may be returned, for example when users in more than 1000 spaces, or when a new spaces is added after this function is called, but before it returns. Custom clients should be prepared to gracefully andle cases where an event occurs in a space not returned by this call, by querying rooms.getWithReadStatus() with the id of the room in question

This function may be deprecated when this info is provided in the membership objects returned in the list function.

Returns a single room object with details about the data of the last actvity in the room, and the date of the users last presence in the room.

For rooms where lastActivityDate > lastSeenDate the room can be considerd to be "unread"

This differs from the rooms.get() function in the following ways: -- it takes a single roomId parameter to fetch -- no other options are considered -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available in the return object -- "title" is usually returned, but not guaranteed

In general clients should use the listWithReadStatus() method on startup to get the initial roomStatus and then update their client side copy by responding to message, membership and room events.

This function allows a custom client to be "nimble" if it is responding to an event with a roomId that was not in the original fetch. The anticipated behavior is that getWithReadStats is called "just in time", with the resulting room object being added to the list of cached room objects on the client side.

This function may be deprecated when this info is provided in the room object returned in the get function.

Deletes a single room.

var room;
webex.rooms.create({title: 'Remove Room Example'})
 .then(function(r) {
   room = r;
   return webex.rooms.remove(room.id);
 })
 .then(function() {
   return webex.rooms.get(room.id);
 })
 .then(function() {
   var assert = require('assert');
   assert(false, 'the previous get should have failed');
 })
 .catch(function(reason) {
   var assert = require('assert');
   assert.equal(reason.statusCode, 404);
   return 'success'
 });
 // => success

Used to update a single room's properties.

var room;
webex.rooms.update({title: 'Update Room Example'})
  .then(function(r) {
    room = r;
    room.title = 'Update Room Example (Updated Title)';
    return webex.rooms.update(room);
  })
  .then(function() {
    return webex.rooms.get(room.id);
  })
  .then(function(room) {
   var assert = require('assert');
    assert.equal(room.title, 'Update Room Example (Updated Title)');
    return 'success';
  });
  // => success

Create a new team.

webex.teams.create({name: 'Create Team Example'})
  .then(function(team) {
    var assert = require('assert');
    assert(team.id);
    assert(team.name);
    assert(team.created);
    return 'success';
  });
  // => success

Returns a single team

var team;
webex.teams.create({name: 'Get Team Example'})
  .then(function(r) {
    team = r;
    return webex.teams.get(team.id);
  })
  .then(function(team2) {
    var assert = require('assert');
    assert.equal(team2.id, team.id);
    return 'success';
  });
  // => success

List teams.

var createdRooms;
Promise.all([
  webex.teams.create({name: 'List Teams Example 1'}),
  webex.teams.create({name: 'List Teams Example 2'}),
  webex.teams.create({name: 'List Teams Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.teams.list({max: 3});
  })
  .then(function(teams) {
    var assert = require('assert');
    assert(teams.length === 3);
    for (var i = 0; i < teams.items.length; i+= 1) {
      assert(createdRooms.filter(function(room) {
        return room.id === teams.items[i].id;
      }).length === 1);
    }
    return 'success';
  });
  // => success

Update a team.

var teams;
webex.teams.create({name: 'Update Team Example'})
  .then(function(r) {
    teams = r;
    teams.name = 'Teams Example (Updated Title)';
    return webex.teams.update(teams);
  })
  .then(function() {
    return webex.teams.get(teams.id);
  })
  .then(function(teams) {
    var assert = require('assert');
    assert.equal(teams.name, 'Teams Example (Updated Title)');
    return 'success';
  });
  // => success

Add someone to a team by Person ID or email address; optionally making them a moderator.

webex.teams.create({name: 'Create Team Membership Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.teamId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

Get details for a membership by ID.

var membership;
webex.teams.create({name: 'Get Team Memberships Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
      personEmail: 'alice@example.com',
      teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

Lists all team memberships. By default, lists memberships for teams to which the authenticated user belongs.

var team;
webex.teams.create({name: 'List Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    for (var i = 0; i < teamMemberships.length; i+= 1) {
      assert.equal(teamMemberships.items[i].teamId, team.id);
    }
    return 'success';
  });
  // => success

Deletes a membership by ID.

var membership, team;
webex.teams.create({name: 'Remove Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    return webex.teamMemberships.remove(membership);
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 1);
    return 'success';
  });
  // => success

Updates properties for a membership.

Posts a webhook.

webex.rooms.create({title: 'Create Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert(webhook.id);
    assert(webhook.resource);
    assert(webhook.event);
    assert(webhook.filter);
    assert(webhook.targetUrl);
    assert(webhook.name);
    return 'success';
  });
  // => success

Shows details for a webhook.

var webhook;
webex.rooms.create({title: 'Get Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.get(webhook.id);
  })
  .then(function(webhook2) {
    var assert = require('assert');
    assert.deepEqual(webhook2, webhook);
    return 'success';
  });
  // => success

Lists all webhooks.

var room, webhook;
webex.rooms.create({title: 'List Webhooks Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 1);
    return 'success';
  });
  // => success

Delete a webhook.

var room, webhook;
webex.rooms.create({title: 'Remove Webhook Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.remove(webhook);
  })
  .then(function() {
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 0);
    return 'success';
  });
  // => success

Update a webhook.

var webhook;
webex.rooms.create({title: 'Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    webhook.targetUrl = 'https://example.com/webhook/newtarget';
    return webex.webhooks.update(webhook);
  })
  .then(function() {
    return webex.webhooks.get(webhook);
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert.equal(webhook.targetUrl, 'https://example.com/webhook/newtarget');
    return 'success';
  });
  // => success

setup Metrics with meeting Collection

poste Meeting event metrics

Docs for Call analyzer metrics https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml

Fetches meeting info from the server

• Error: if the options are not valid and complete

• Error: if the options are not valid and complete

Invite a guest to the call that isn't normally part of this call

Admit the guest(s) to the call once they are waiting

Remove the member from the meeting, boot them

Mute another member from the meeting

Transfer the moderator role to another eligible member

Reference to the Members object

Reference to the stats builder object

write the stats builder object and assign to meeting property

if you have started a stats instance, here's how you can stop it

Convenience function to tell whether a meeting is muted

Convenience function to tell if the end user last changed the audio state

Convenience function to tell whether video is muted

Convenience function to tell whether the end user changed the video state

Sets the remote stream on the class instance and emits and event to developers

Removes the remote stream on the class instance and triggers an event to developers

Removes the remote stream on the class instance and triggers an event to developers

Sets the sceen stream on the class instance and triggers and event to developers

Sets the local media stream on the class and emits an event to the developer

Sets the local media stream on the class and emits an event to the developer

Removes the local stream from the class and emits an event to the developer

Removes the local share from the class and emits an event to the developer

Sets the peer connections on the class sets up reconnection logic

Close the peer connections and remove them from the class. Triggers an event when each is closed.

Unsets the peer connections on the class warning DO NOT CALL WITHOUT CLOSING PEER CONNECTIONS FIRST

Mute the audio for a meeting

Unmute meeting audio

Mute the video for a meeting

Unmute meeting video

Shorthand function to join AND set up media

joinWithMedia({
 joinOptions: {resourceId: 'resourceId' },
 mediaSettings: {
  sendAudio: true,
  sendVideo: true,
  sendShare: false,
  receiveVideo:true,
  receiveAudio: true,
  receiveShare: true
}
audioVideoOptions: {
  audio: 'audioDeviceId',
  video: 'videoDeviceId'
}})

Initiates the reconnection of the media in the meeting

Moves the call to the specified resourceId

Moves the call from the specified resourceId, back to computer

Get local media streams based on options passed

Specify joining via audio (option: pstn), video, screenshare

A confluence of updateAudio, updateVideo, and updateShare this function re-establishes all of the media streams with new options

Update the main audio streams with new parameters

Update the main video streams with new parameters

Update the share streams, can be used to start sharing

Acknowledge the meeting, outgoing or incoming

Decline this meeting

Leave the current meeting

Stops the screen share

Intiate a recording of this meeting

End the recording of this meeting

Pauses the recording of this meeting

Resumes the recording of this meeting

Locks the current meeting if possible

Unlocks the current meeting if possible

created later

created later