twilio-ruby 5.10.5 → 5.10.6

data/lib/twilio-ruby/rest/api/v2010/account/conference/participant.rb

@@ -17,7 +17,7 @@ module Twilio
               # Initialize the ParticipantList
               # @param [Version] version Version that contains the resource
               # @param [String] account_sid The unique id of the
-              #   [Account](https://www.twilio.com/docs/api/rest/account) that created this
+              #   [Account](https://www.twilio.com/docs/iam/api/account) that created this
               #   conference
               # @param [String] conference_sid A 34 character string that identifies the
               #   conference this participant is in
@@ -33,35 +33,87 @@ module Twilio
               ##
               # Retrieve a single page of ParticipantInstance records from the API.
               # Request is executed immediately.
-              # @param [String] from number, client id
-              # @param [String] to number, client id, sip address
-              # @param [String] status_callback absolute url
-              # @param [String] status_callback_method GET, POST
-              # @param [String] status_callback_event initiated, ringing, answered, completed
-              # @param [String] timeout 5-600
-              # @param [Boolean] record true, false
-              # @param [Boolean] muted true, false
-              # @param [String] beep true, false, onEnter, onExit
-              # @param [Boolean] start_conference_on_enter true, false
-              # @param [Boolean] end_conference_on_exit true, false
-              # @param [String] wait_url absolute url
-              # @param [String] wait_method GET, POST
-              # @param [Boolean] early_media true, false
-              # @param [String] max_participants 2-10
-              # @param [String] conference_record true, false, record-from-start, do-not-record
-              # @param [String] conference_trim trim-silence or do-not-trim
-              # @param [String] conference_status_callback absolute url
-              # @param [String] conference_status_callback_method GET, POST
-              # @param [String] conference_status_callback_event start end join leave mute hold
-              #   speaker
-              # @param [String] recording_channels mono, dual
-              # @param [String] recording_status_callback absolute url
-              # @param [String] recording_status_callback_method GET, POST
-              # @param [String] sip_auth_username sip username
-              # @param [String] sip_auth_password sip password
-              # @param [String] region us1, ie1, de1, sg1, br1, au1, jp1
-              # @param [String] conference_recording_status_callback absolute url
-              # @param [String] conference_recording_status_callback_method GET, POST
+              # @param [String] from The `from` phone number that will dial the new conference
+              #   participant. Values may be a phone number or client id.
+              # @param [String] to The phone number, client id, or sip address you are inviting
+              #   to this conference.
+              # @param [String] status_callback The absolute URL where Twilio should send a
+              #   webhook with conference event information that you request with the
+              #   `StatusCallbackEvent` parameter.
+              # @param [String] status_callback_method The method Twilio should use when
+              #   requesting your `StatusCallback` URL. Options are `GET` and `POST`. Defaults to
+              #   `POST`.
+              # @param [String] status_callback_event Specifies which conference state changes
+              #   should generate a webhook to the `StatusCallback` URL. Options are `initiated`,
+              #   `ringing`, `answered`, and `completed`. To specify multiple values, separate
+              #   each with a space. Defaults to `completed`.
+              # @param [String] timeout The number of seconds (integer) that Twilio should allow
+              #   the phone to ring before assuming there is no answer. Defaults to 60 seconds.
+              #   Minimum allowed timeout is `5`, max is `600`. Twilio always adds a 5-second
+              #   timeout buffer to outgoing calls, so if you enter a timeout value of 10 seconds,
+              #   you will see an actual timeout closer to 15 seconds.
+              # @param [Boolean] record Records the agent and their conferences, including
+              #   downtime between conferences. Values may be `true` or `false`. Defaults to
+              #   `false`.
+              # @param [Boolean] muted Specify whether the agent can speak in the conference.
+              #   Values can be `true` or `false`. Defaults to `false`.
+              # @param [String] beep Play a notification beep to the conference when this
+              #   participant joins. Options are `true`, `false`, `onEnter`, or `onExit`. Defaults
+              #   to `true`.
+              # @param [Boolean] start_conference_on_enter If the conference has not already
+              #   begun, `true` will start the conference when this participant joins. Specifying
+              #   `false` will mute the participant and play background music until the conference
+              #   begins. Defaults to `true`.
+              # @param [Boolean] end_conference_on_exit If `true`, will end the conference when
+              #   this participant leaves. Defaults to `false`.
+              # @param [String] wait_url Specify an absolute URL that hosts music to play before
+              #   the  conference starts. Defualts to Twilio's standard [hold
+              #   music](https://www.twilio.com/labs/twimlets/holdmusic).
+              # @param [String] wait_method Specify which method, `GET` or `POST`, Twilio should
+              #   use to request the `WaitUrl` for this conference. Be sure to use `GET` if you
+              #   are directly requesting static audio files so that Twilio properly caches the
+              #   files. Defaults to `POST`.
+              # @param [Boolean] early_media Allow an agent to hear the state of the outbound
+              #   call, including ringing or disconnect messages. Can be `true` or `false`.
+              #   Defaults to `true`.
+              # @param [String] max_participants The maximum number of participants within this
+              #   agent conference. Values can be positive integers from `2`-`10`. Defaults to
+              #   `10`.
+              # @param [String] conference_record Records the conference that this participant
+              #   is joining. Options are `true`, `false`, `record-from-start`, and
+              #   `do-not-record`. Deafults to `false`
+              # @param [String] conference_trim Specify whether to trim leading and trailing
+              #   silence from your recorded conference audio files. Options are `trim-silence`
+              #   and `do-not-trim`. Defaults to `trim-silence`
+              # @param [String] conference_status_callback The absolute URL Twilio should
+              #   request with conference events specified in `ConferenceStatusCallbackEvent`.
+              #   This value is set by the first Participant to join the conference, and
+              #   subsequent callback URLs will be ignored.
+              # @param [String] conference_status_callback_method The HTTP method Twilio should
+              #   use when requesting the `ConferenceStatusCallback` URL. Either `GET` or `POST`.
+              #   Defaults to `POST`.
+              # @param [String] conference_status_callback_event Specifies which conference
+              #   state changes should generate a webhook to the URL specified in the
+              #   `ConferenceStatusCallback` attribute. Available values are `start`, `end`,
+              #   `join`, `leave`, `mute`, `hold`, and `speaker`. To specify multiple values,
+              #   separate them with a space. Defaults to `start` and `end`.
+              # @param [String] recording_channels Set the recording channels for the final
+              #   agent/conference recording. Either `mono` or `dual`. Defaults to `mono`.
+              # @param [String] recording_status_callback Specifies the `absolute URL` that
+              #   Twilio should request when the recording is available if the agent and
+              #   conference are recorded.
+              # @param [String] recording_status_callback_method The HTTP method Twilio should
+              #   use when requesting the `RecordingStatusCallback`. `GET` or `POST`. Defaults to
+              #   `POST`.
+              # @param [String] sip_auth_username SIP username used for authenticating.
+              # @param [String] sip_auth_password SIP password for authentication.
+              # @param [String] region Specifies the
+              #   [region](https://support.twilio.com/hc/en-us/articles/223132167-How-global-low-latency-routing-and-region-selection-work-for-conferences-and-Client-calls) where Twilio should mix the recorded audio. Options are `us1`, `ie1`, `de1`, `sg1`, `br1`, `au1`, `jp1`.
+              # @param [String] conference_recording_status_callback The `absolute URL` Twilio
+              #   should request when the conference recording is available.
+              # @param [String] conference_recording_status_callback_method The HTTP method
+              #   Twilio should use when requesting your recording status callback URL, either
+              #   `GET` or `POST`. Defaults to `POST`.
               # @param [String] recording_status_callback_event The
               #   recording_status_callback_event
               # @param [String] conference_recording_status_callback_event The
@@ -119,10 +171,10 @@ module Twilio
               # Lists ParticipantInstance records from the API as a list.
               # Unlike stream(), this operation is eager and will load `limit` records into
               # memory before returning.
-              # @param [Boolean] muted Only show participants that are muted or unmuted. Either
-              #   `true` or `false`.
-              # @param [Boolean] hold Only show participants that are held or unheld. Either
-              #   `true` or `false`.
+              # @param [Boolean] muted Only return participants that are muted or unmuted.
+              #   Either `true` or `false`.
+              # @param [Boolean] hold Only return participants that are on hold or not on hold.
+              #   Either `true` or `false`.
               # @param [Integer] limit Upper limit for the number of records to return. stream()
               #    guarantees to never return more than limit.  Default is no limit
               # @param [Integer] page_size Number of records to fetch per request, when
@@ -138,10 +190,10 @@ module Twilio
               # Streams ParticipantInstance records from the API as an Enumerable.
               # This operation lazily loads records as efficiently as possible until the limit
               # is reached.
-              # @param [Boolean] muted Only show participants that are muted or unmuted. Either
-              #   `true` or `false`.
-              # @param [Boolean] hold Only show participants that are held or unheld. Either
-              #   `true` or `false`.
+              # @param [Boolean] muted Only return participants that are muted or unmuted.
+              #   Either `true` or `false`.
+              # @param [Boolean] hold Only return participants that are on hold or not on hold.
+              #   Either `true` or `false`.
               # @param [Integer] limit Upper limit for the number of records to return. stream()
               #    guarantees to never return more than limit. Default is no limit.
               # @param [Integer] page_size Number of records to fetch per request, when
@@ -174,10 +226,10 @@ module Twilio
               ##
               # Retrieve a single page of ParticipantInstance records from the API.
               # Request is executed immediately.
-              # @param [Boolean] muted Only show participants that are muted or unmuted. Either
-              #   `true` or `false`.
-              # @param [Boolean] hold Only show participants that are held or unheld. Either
-              #   `true` or `false`.
+              # @param [Boolean] muted Only return participants that are muted or unmuted.
+              #   Either `true` or `false`.
+              # @param [Boolean] hold Only return participants that are on hold or not on hold.
+              #   Either `true` or `false`.
               # @param [String] page_token PageToken provided by the API
               # @param [Integer] page_number Page Number, this value is simply for client state
               # @param [Integer] page_size Number of records to return, defaults to 50
@@ -258,8 +310,8 @@ module Twilio
               # @param [Version] version Version that contains the resource
               # @param [String] account_sid The account_sid
               # @param [String] conference_sid The string that uniquely identifies the
-              #   conference this participant is in
-              # @param [String] call_sid The call_sid
+              #   conference this participant is in.
+              # @param [String] call_sid The Participant's unique Call SID.
               # @return [ParticipantContext] ParticipantContext
               def initialize(version, account_sid, conference_sid, call_sid)
                 super(version)
@@ -296,15 +348,17 @@ module Twilio
               #   `false` will un-mute. Anything other than `true` or `false` is interpreted as
               #   `false`.
               # @param [Boolean] hold Specifying `true` will hold the participant, while `false`
-              #   will un-hold.
+              #   will remove them from hold.
               # @param [String] hold_url The 'HoldUrl' attribute lets you specify a URL for
-              #   music that plays when a participant is held. The URL may be an MP3, a WAV or a
-              #   TwiML document that uses `<Play>`, `<Say>` or `<Redirect>`.
-              # @param [String] hold_method Specify GET or POST, defaults to GET
+              #   music that plays when a participant is on hold. The URL may be an MP3, a WAV or
+              #   a TwiML document that uses `<Play>`, `<Say>` or `<Redirect>`.
+              # @param [String] hold_method Specify the HTTP method Twilio should use to request
+              #   your `HoldUrl`, either `GET` or `POST`. Defaults to `GET`.
               # @param [String] announce_url The 'AnnounceUrl' attribute lets you specify a URL
               #   for announcing something to the participant. The URL may return an MP3, a WAV or
               #   a TwiML document with `<Play>` or `<Say>`.
-              # @param [String] announce_method Specify GET or POST, defaults to POST
+              # @param [String] announce_method Specify the HTTP method Twilio should use to
+              #   request your `AnnounceUrl`, either `GET` or `POST`. Defaults to `POST`.
               # @return [ParticipantInstance] Updated ParticipantInstance
               def update(muted: :unset, hold: :unset, hold_url: :unset, hold_method: :unset, announce_url: :unset, announce_method: :unset)
                 data = Twilio::Values.of({
@@ -352,11 +406,11 @@ module Twilio
               # @param [Version] version Version that contains the resource
               # @param [Hash] payload payload that contains response from Twilio
               # @param [String] account_sid The unique id of the
-              #   [Account](https://www.twilio.com/docs/api/rest/account) that created this
+              #   [Account](https://www.twilio.com/docs/iam/api/account) that created this
               #   conference
               # @param [String] conference_sid A 34 character string that identifies the
               #   conference this participant is in
-              # @param [String] call_sid The call_sid
+              # @param [String] call_sid The Participant's unique Call SID.
               # @return [ParticipantInstance] ParticipantInstance
               def initialize(version, payload, account_sid: nil, conference_sid: nil, call_sid: nil)
                 super(version)
@@ -480,15 +534,17 @@ module Twilio
               #   `false` will un-mute. Anything other than `true` or `false` is interpreted as
               #   `false`.
               # @param [Boolean] hold Specifying `true` will hold the participant, while `false`
-              #   will un-hold.
+              #   will remove them from hold.
               # @param [String] hold_url The 'HoldUrl' attribute lets you specify a URL for
-              #   music that plays when a participant is held. The URL may be an MP3, a WAV or a
-              #   TwiML document that uses `<Play>`, `<Say>` or `<Redirect>`.
-              # @param [String] hold_method Specify GET or POST, defaults to GET
+              #   music that plays when a participant is on hold. The URL may be an MP3, a WAV or
+              #   a TwiML document that uses `<Play>`, `<Say>` or `<Redirect>`.
+              # @param [String] hold_method Specify the HTTP method Twilio should use to request
+              #   your `HoldUrl`, either `GET` or `POST`. Defaults to `GET`.
               # @param [String] announce_url The 'AnnounceUrl' attribute lets you specify a URL
               #   for announcing something to the participant. The URL may return an MP3, a WAV or
               #   a TwiML document with `<Play>` or `<Say>`.
-              # @param [String] announce_method Specify GET or POST, defaults to POST
+              # @param [String] announce_method Specify the HTTP method Twilio should use to
+              #   request your `AnnounceUrl`, either `GET` or `POST`. Defaults to `POST`.
               # @return [ParticipantInstance] Updated ParticipantInstance
               def update(muted: :unset, hold: :unset, hold_url: :unset, hold_method: :unset, announce_url: :unset, announce_method: :unset)
                 context.update(

data/lib/twilio-ruby/rest/api/v2010/account/conference/recording.rb

@@ -0,0 +1,460 @@
+##
+# This code was generated by
+# \ / _    _  _|   _  _
+#  | (_)\/(_)(_|\/| |(/_  v1.0.0
+#       /       /
+# 
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class Api < Domain
+      class V2010 < Version
+        class AccountContext < InstanceContext
+          class ConferenceContext < InstanceContext
+            class RecordingList < ListResource
+              ##
+              # Initialize the RecordingList
+              # @param [Version] version Version that contains the resource
+              # @param [String] account_sid The unique ID of the
+              #   [Account](https://www.twilio.com/docs/api/rest/account) responsible for this
+              #   recording.
+              # @param [String] conference_sid The unique id for the conference associated with
+              #   the recording.
+              # @return [RecordingList] RecordingList
+              def initialize(version, account_sid: nil, conference_sid: nil)
+                super(version)
+
+                # Path Solution
+                @solution = {account_sid: account_sid, conference_sid: conference_sid}
+                @uri = "/Accounts/#{@solution[:account_sid]}/Conferences/#{@solution[:conference_sid]}/Recordings.json"
+              end
+
+              ##
+              # Lists RecordingInstance records from the API as a list.
+              # Unlike stream(), this operation is eager and will load `limit` records into
+              # memory before returning.
+              # @param [Time] date_created_before Filter by date created
+              # @param [Time] date_created Filter by date created
+              # @param [Time] date_created_after Filter by date created
+              # @param [Integer] limit Upper limit for the number of records to return. stream()
+              #    guarantees to never return more than limit.  Default is no limit
+              # @param [Integer] page_size Number of records to fetch per request, when
+              #    not set will use the default value of 50 records.  If no page_size is defined
+              #    but a limit is defined, stream() will attempt to read the limit with the most
+              #    efficient page size, i.e. min(limit, 1000)
+              # @return [Array] Array of up to limit results
+              def list(date_created_before: :unset, date_created: :unset, date_created_after: :unset, limit: nil, page_size: nil)
+                self.stream(
+                    date_created_before: date_created_before,
+                    date_created: date_created,
+                    date_created_after: date_created_after,
+                    limit: limit,
+                    page_size: page_size
+                ).entries
+              end
+
+              ##
+              # Streams RecordingInstance records from the API as an Enumerable.
+              # This operation lazily loads records as efficiently as possible until the limit
+              # is reached.
+              # @param [Time] date_created_before Filter by date created
+              # @param [Time] date_created Filter by date created
+              # @param [Time] date_created_after Filter by date created
+              # @param [Integer] limit Upper limit for the number of records to return. stream()
+              #    guarantees to never return more than limit. Default is no limit.
+              # @param [Integer] page_size Number of records to fetch per request, when
+              #    not set will use the default value of 50 records. If no page_size is defined
+              #    but a limit is defined, stream() will attempt to read the limit with the most
+              #    efficient page size, i.e. min(limit, 1000)
+              # @return [Enumerable] Enumerable that will yield up to limit results
+              def stream(date_created_before: :unset, date_created: :unset, date_created_after: :unset, limit: nil, page_size: nil)
+                limits = @version.read_limits(limit, page_size)
+
+                page = self.page(
+                    date_created_before: date_created_before,
+                    date_created: date_created,
+                    date_created_after: date_created_after,
+                    page_size: limits[:page_size],
+                )
+
+                @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+              end
+
+              ##
+              # When passed a block, yields RecordingInstance records from the API.
+              # This operation lazily loads records as efficiently as possible until the limit
+              # is reached.
+              def each
+                limits = @version.read_limits
+
+                page = self.page(page_size: limits[:page_size], )
+
+                @version.stream(page,
+                                limit: limits[:limit],
+                                page_limit: limits[:page_limit]).each {|x| yield x}
+              end
+
+              ##
+              # Retrieve a single page of RecordingInstance records from the API.
+              # Request is executed immediately.
+              # @param [Time] date_created_before Filter by date created
+              # @param [Time] date_created Filter by date created
+              # @param [Time] date_created_after Filter by date created
+              # @param [String] page_token PageToken provided by the API
+              # @param [Integer] page_number Page Number, this value is simply for client state
+              # @param [Integer] page_size Number of records to return, defaults to 50
+              # @return [Page] Page of RecordingInstance
+              def page(date_created_before: :unset, date_created: :unset, date_created_after: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+                params = Twilio::Values.of({
+                    'DateCreated<' => Twilio.serialize_iso8601_date(date_created_before),
+                    'DateCreated' => Twilio.serialize_iso8601_date(date_created),
+                    'DateCreated>' => Twilio.serialize_iso8601_date(date_created_after),
+                    'PageToken' => page_token,
+                    'Page' => page_number,
+                    'PageSize' => page_size,
+                })
+                response = @version.page(
+                    'GET',
+                    @uri,
+                    params
+                )
+                RecordingPage.new(@version, response, @solution)
+              end
+
+              ##
+              # Retrieve a single page of RecordingInstance records from the API.
+              # Request is executed immediately.
+              # @param [String] target_url API-generated URL for the requested results page
+              # @return [Page] Page of RecordingInstance
+              def get_page(target_url)
+                response = @version.domain.request(
+                    'GET',
+                    target_url
+                )
+                RecordingPage.new(@version, response, @solution)
+              end
+
+              ##
+              # Provide a user friendly representation
+              def to_s
+                '#<Twilio.Api.V2010.RecordingList>'
+              end
+            end
+
+            class RecordingPage < Page
+              ##
+              # Initialize the RecordingPage
+              # @param [Version] version Version that contains the resource
+              # @param [Response] response Response from the API
+              # @param [Hash] solution Path solution for the resource
+              # @return [RecordingPage] RecordingPage
+              def initialize(version, response, solution)
+                super(version, response)
+
+                # Path Solution
+                @solution = solution
+              end
+
+              ##
+              # Build an instance of RecordingInstance
+              # @param [Hash] payload Payload response from the API
+              # @return [RecordingInstance] RecordingInstance
+              def get_instance(payload)
+                RecordingInstance.new(
+                    @version,
+                    payload,
+                    account_sid: @solution[:account_sid],
+                    conference_sid: @solution[:conference_sid],
+                )
+              end
+
+              ##
+              # Provide a user friendly representation
+              def to_s
+                '<Twilio.Api.V2010.RecordingPage>'
+              end
+            end
+
+            class RecordingContext < InstanceContext
+              ##
+              # Initialize the RecordingContext
+              # @param [Version] version Version that contains the resource
+              # @param [String] account_sid The account_sid
+              # @param [String] conference_sid The conference Sid that uniquely identifies this
+              #   resource
+              # @param [String] sid The recording Sid that uniquely identifies this resource
+              # @return [RecordingContext] RecordingContext
+              def initialize(version, account_sid, conference_sid, sid)
+                super(version)
+
+                # Path Solution
+                @solution = {account_sid: account_sid, conference_sid: conference_sid, sid: sid, }
+                @uri = "/Accounts/#{@solution[:account_sid]}/Conferences/#{@solution[:conference_sid]}/Recordings/#{@solution[:sid]}.json"
+              end
+
+              ##
+              # Update the RecordingInstance
+              # @param [recording.Status] status The status to change the recording to. 
+              #   Possible values : stopped, paused, in-progress
+              # @return [RecordingInstance] Updated RecordingInstance
+              def update(status: nil)
+                data = Twilio::Values.of({'Status' => status, })
+
+                payload = @version.update(
+                    'POST',
+                    @uri,
+                    data: data,
+                )
+
+                RecordingInstance.new(
+                    @version,
+                    payload,
+                    account_sid: @solution[:account_sid],
+                    conference_sid: @solution[:conference_sid],
+                    sid: @solution[:sid],
+                )
+              end
+
+              ##
+              # Fetch a RecordingInstance
+              # @return [RecordingInstance] Fetched RecordingInstance
+              def fetch
+                params = Twilio::Values.of({})
+
+                payload = @version.fetch(
+                    'GET',
+                    @uri,
+                    params,
+                )
+
+                RecordingInstance.new(
+                    @version,
+                    payload,
+                    account_sid: @solution[:account_sid],
+                    conference_sid: @solution[:conference_sid],
+                    sid: @solution[:sid],
+                )
+              end
+
+              ##
+              # Deletes the RecordingInstance
+              # @return [Boolean] true if delete succeeds, true otherwise
+              def delete
+                @version.delete('delete', @uri)
+              end
+
+              ##
+              # Provide a user friendly representation
+              def to_s
+                context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
+                "#<Twilio.Api.V2010.RecordingContext #{context}>"
+              end
+            end
+
+            class RecordingInstance < InstanceResource
+              ##
+              # Initialize the RecordingInstance
+              # @param [Version] version Version that contains the resource
+              # @param [Hash] payload payload that contains response from Twilio
+              # @param [String] account_sid The unique ID of the
+              #   [Account](https://www.twilio.com/docs/api/rest/account) responsible for this
+              #   recording.
+              # @param [String] conference_sid The unique id for the conference associated with
+              #   the recording.
+              # @param [String] sid The recording Sid that uniquely identifies this resource
+              # @return [RecordingInstance] RecordingInstance
+              def initialize(version, payload, account_sid: nil, conference_sid: nil, sid: nil)
+                super(version)
+
+                # Marshaled Properties
+                @properties = {
+                    'account_sid' => payload['account_sid'],
+                    'api_version' => payload['api_version'],
+                    'call_sid' => payload['call_sid'],
+                    'conference_sid' => payload['conference_sid'],
+                    'date_created' => Twilio.deserialize_rfc2822(payload['date_created']),
+                    'date_updated' => Twilio.deserialize_rfc2822(payload['date_updated']),
+                    'start_time' => Twilio.deserialize_rfc2822(payload['start_time']),
+                    'duration' => payload['duration'],
+                    'sid' => payload['sid'],
+                    'price' => payload['price'].to_f,
+                    'price_unit' => payload['price_unit'],
+                    'status' => payload['status'],
+                    'channels' => payload['channels'].to_i,
+                    'source' => payload['source'],
+                    'error_code' => payload['error_code'] == nil ? payload['error_code'] : payload['error_code'].to_i,
+                    'encryption_details' => payload['encryption_details'],
+                    'uri' => payload['uri'],
+                }
+
+                # Context
+                @instance_context = nil
+                @params = {
+                    'account_sid' => account_sid,
+                    'conference_sid' => conference_sid,
+                    'sid' => sid || @properties['sid'],
+                }
+              end
+
+              ##
+              # Generate an instance context for the instance, the context is capable of
+              # performing various actions.  All instance actions are proxied to the context
+              # @return [RecordingContext] RecordingContext for this RecordingInstance
+              def context
+                unless @instance_context
+                  @instance_context = RecordingContext.new(
+                      @version,
+                      @params['account_sid'],
+                      @params['conference_sid'],
+                      @params['sid'],
+                  )
+                end
+                @instance_context
+              end
+
+              ##
+              # @return [String] The unique sid that identifies this account
+              def account_sid
+                @properties['account_sid']
+              end
+
+              ##
+              # @return [String] The version of the API in use during the recording.
+              def api_version
+                @properties['api_version']
+              end
+
+              ##
+              # @return [String] The unique id for the call leg that corresponds to the recording.
+              def call_sid
+                @properties['call_sid']
+              end
+
+              ##
+              # @return [String] The unique id for the conference associated with the recording.
+              def conference_sid
+                @properties['conference_sid']
+              end
+
+              ##
+              # @return [Time] The date this resource was created
+              def date_created
+                @properties['date_created']
+              end
+
+              ##
+              # @return [Time] The date this resource was last updated
+              def date_updated
+                @properties['date_updated']
+              end
+
+              ##
+              # @return [Time] The start time of the recording, given in RFC 2822 format.
+              def start_time
+                @properties['start_time']
+              end
+
+              ##
+              # @return [String] The length of the recording, in seconds.
+              def duration
+                @properties['duration']
+              end
+
+              ##
+              # @return [String] A string that uniquely identifies this recording
+              def sid
+                @properties['sid']
+              end
+
+              ##
+              # @return [String] The one-time cost of creating this recording.
+              def price
+                @properties['price']
+              end
+
+              ##
+              # @return [String] The currency used in the Price property.
+              def price_unit
+                @properties['price_unit']
+              end
+
+              ##
+              # @return [recording.Status] The status of the recording.
+              def status
+                @properties['status']
+              end
+
+              ##
+              # @return [String] The number of channels in the final recording file as an integer.
+              def channels
+                @properties['channels']
+              end
+
+              ##
+              # @return [recording.Source] The way in which this recording was created.
+              def source
+                @properties['source']
+              end
+
+              ##
+              # @return [String] More information about the recording failure, if Status is failed.
+              def error_code
+                @properties['error_code']
+              end
+
+              ##
+              # @return [Hash] Details for how to decrypt the recording.
+              def encryption_details
+                @properties['encryption_details']
+              end
+
+              ##
+              # @return [String] The URI for this resource
+              def uri
+                @properties['uri']
+              end
+
+              ##
+              # Update the RecordingInstance
+              # @param [recording.Status] status The status to change the recording to. 
+              #   Possible values : stopped, paused, in-progress
+              # @return [RecordingInstance] Updated RecordingInstance
+              def update(status: nil)
+                context.update(status: status, )
+              end
+
+              ##
+              # Fetch a RecordingInstance
+              # @return [RecordingInstance] Fetched RecordingInstance
+              def fetch
+                context.fetch
+              end
+
+              ##
+              # Deletes the RecordingInstance
+              # @return [Boolean] true if delete succeeds, true otherwise
+              def delete
+                context.delete
+              end
+
+              ##
+              # Provide a user friendly representation
+              def to_s
+                values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
+                "<Twilio.Api.V2010.RecordingInstance #{values}>"
+              end
+
+              ##
+              # Provide a detailed, user friendly representation
+              def inspect
+                values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
+                "<Twilio.Api.V2010.RecordingInstance #{values}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end