twilio-ruby 5.0.0.rc21 → 5.0.0.rc22

data/lib/twilio-ruby/rest/wireless/v1/sim.rb

@@ -37,7 +37,7 @@ module Twilio
           #  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(status: nil, iccid: nil, rate_plan: nil, e_id: nil, sim_registration_code: nil, limit: nil, page_size: nil)
+          def list(status: :unset, iccid: :unset, rate_plan: :unset, e_id: :unset, sim_registration_code: :unset, limit: nil, page_size: nil)
             self.stream(
                 status: status,
                 iccid: iccid,
@@ -65,7 +65,7 @@ module Twilio
           #                       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(status: nil, iccid: nil, rate_plan: nil, e_id: nil, sim_registration_code: nil, limit: nil, page_size: nil)
+          def stream(status: :unset, iccid: :unset, rate_plan: :unset, e_id: :unset, sim_registration_code: :unset, limit: nil, page_size: nil)
             limits = @version.read_limits(limit, page_size)
 
             page = self.page(
@@ -119,8 +119,8 @@ module Twilio
           # @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 SimInstance
-          def page(status: nil, iccid: nil, rate_plan: nil, e_id: nil, sim_registration_code: nil, page_token: nil, page_number: nil, page_size: nil)
-            params = {
+          def page(status: :unset, iccid: :unset, rate_plan: :unset, e_id: :unset, sim_registration_code: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+            params = Twilio::Values.of({
                 'Status' => status,
                 'Iccid' => iccid,
                 'RatePlan' => rate_plan,
@@ -129,13 +129,26 @@ module Twilio
                 'PageToken' => page_token,
                 'Page' => page_number,
                 'PageSize' => page_size,
-            }
+            })
             response = @version.page(
                 'GET',
                 @uri,
                 params
             )
-            return SimPage.new(@version, response, @solution)
+            SimPage.new(@version, response, @solution)
+          end
+
+          ##
+          # Retrieve a single page of SimInstance records from the API.
+          # Request is executed immediately.
+          # @param [String] target_url API-generated URL for the requested results page
+          # @return [Page] Page of SimInstance
+          def get_page(target_url)
+            response = @version.domain.request(
+                'GET',
+                target_url
+            )
+            SimPage.new(@version, response, @solution)
           end
 
           ##
@@ -164,7 +177,7 @@ module Twilio
           # @param [Hash] payload Payload response from the API
           # @return [SimInstance] SimInstance
           def get_instance(payload)
-            return SimInstance.new(
+            SimInstance.new(
                 @version,
                 payload,
             )
@@ -200,7 +213,7 @@ module Twilio
           # Fetch a SimInstance
           # @return [SimInstance] Fetched SimInstance
           def fetch
-            params = {}
+            params = Twilio::Values.of({})
 
             payload = @version.fetch(
                 'GET',
@@ -208,7 +221,7 @@ module Twilio
                 params,
             )
 
-            return SimInstance.new(
+            SimInstance.new(
                 @version,
                 payload,
                 sid: @solution[:sid],
@@ -234,8 +247,8 @@ module Twilio
           # @param [String] voice_method The voice_method
           # @param [String] voice_url The voice_url
           # @return [SimInstance] Updated SimInstance
-          def update(unique_name: nil, callback_method: nil, callback_url: nil, friendly_name: nil, rate_plan: nil, status: nil, commands_callback_method: nil, commands_callback_url: nil, sms_fallback_method: nil, sms_fallback_url: nil, sms_method: nil, sms_url: nil, voice_fallback_method: nil, voice_fallback_url: nil, voice_method: nil, voice_url: nil)
-            data = {
+          def update(unique_name: :unset, callback_method: :unset, callback_url: :unset, friendly_name: :unset, rate_plan: :unset, status: :unset, commands_callback_method: :unset, commands_callback_url: :unset, sms_fallback_method: :unset, sms_fallback_url: :unset, sms_method: :unset, sms_url: :unset, voice_fallback_method: :unset, voice_fallback_url: :unset, voice_method: :unset, voice_url: :unset)
+            data = Twilio::Values.of({
                 'UniqueName' => unique_name,
                 'CallbackMethod' => callback_method,
                 'CallbackUrl' => callback_url,
@@ -252,7 +265,7 @@ module Twilio
                 'VoiceFallbackUrl' => voice_fallback_url,
                 'VoiceMethod' => voice_method,
                 'VoiceUrl' => voice_url,
-            }
+            })
 
             payload = @version.update(
                 'POST',
@@ -260,7 +273,7 @@ module Twilio
                 data: data,
             )
 
-            return SimInstance.new(
+            SimInstance.new(
                 @version,
                 payload,
                 sid: @solution[:sid],
@@ -461,7 +474,7 @@ module Twilio
           # @param [String] voice_method The voice_method
           # @param [String] voice_url The voice_url
           # @return [SimInstance] Updated SimInstance
-          def update(unique_name: nil, callback_method: nil, callback_url: nil, friendly_name: nil, rate_plan: nil, status: nil, commands_callback_method: nil, commands_callback_url: nil, sms_fallback_method: nil, sms_fallback_url: nil, sms_method: nil, sms_url: nil, voice_fallback_method: nil, voice_fallback_url: nil, voice_method: nil, voice_url: nil)
+          def update(unique_name: :unset, callback_method: :unset, callback_url: :unset, friendly_name: :unset, rate_plan: :unset, status: :unset, commands_callback_method: :unset, commands_callback_url: :unset, sms_fallback_method: :unset, sms_fallback_url: :unset, sms_method: :unset, sms_url: :unset, voice_fallback_method: :unset, voice_fallback_url: :unset, voice_method: :unset, voice_url: :unset)
             context.update(
                 unique_name: unique_name,
                 callback_method: callback_method,

data/lib/twilio-ruby/rest/wireless/v1/sim/usage_record.rb

@@ -39,7 +39,7 @@ module Twilio
             #  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(end_: nil, start: nil, granularity: nil, limit: nil, page_size: nil)
+            def list(end_: :unset, start: :unset, granularity: :unset, limit: nil, page_size: nil)
               self.stream(
                   end_: end_,
                   start: start,
@@ -63,7 +63,7 @@ module Twilio
             #                       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(end_: nil, start: nil, granularity: nil, limit: nil, page_size: nil)
+            def stream(end_: :unset, start: :unset, granularity: :unset, limit: nil, page_size: nil)
               limits = @version.read_limits(limit, page_size)
 
               page = self.page(
@@ -111,21 +111,34 @@ module Twilio
             # @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 UsageRecordInstance
-            def page(end_: nil, start: nil, granularity: nil, page_token: nil, page_number: nil, page_size: nil)
-              params = {
+            def page(end_: :unset, start: :unset, granularity: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+              params = Twilio::Values.of({
                   'End' => Twilio.serialize_iso8601(end_),
                   'Start' => Twilio.serialize_iso8601(start),
                   'Granularity' => granularity,
                   'PageToken' => page_token,
                   'Page' => page_number,
                   'PageSize' => page_size,
-              }
+              })
               response = @version.page(
                   'GET',
                   @uri,
                   params
               )
-              return UsageRecordPage.new(@version, response, @solution)
+              UsageRecordPage.new(@version, response, @solution)
+            end
+
+            ##
+            # Retrieve a single page of UsageRecordInstance records from the API.
+            # Request is executed immediately.
+            # @param [String] target_url API-generated URL for the requested results page
+            # @return [Page] Page of UsageRecordInstance
+            def get_page(target_url)
+              response = @version.domain.request(
+                  'GET',
+                  target_url
+              )
+              UsageRecordPage.new(@version, response, @solution)
             end
 
             ##
@@ -155,7 +168,7 @@ module Twilio
             # @param [Hash] payload Payload response from the API
             # @return [UsageRecordInstance] UsageRecordInstance
             def get_instance(payload)
-              return UsageRecordInstance.new(
+              UsageRecordInstance.new(
                   @version,
                   payload,
                   sim_sid: @solution[:sim_sid],

data/lib/twilio-ruby/twiml/messaging_response.rb

@@ -0,0 +1,147 @@
+module Twilio
+  module TwiML
+
+    # Messaging TwiML Response
+    class MessagingResponse < TwiML
+      # Create a new <Response>
+      def initialize()
+        super()
+        self.name = 'Response'
+      end
+
+      # Create a <Message> element
+      #
+      # == Parameters:
+      # body:: body of the message
+      # to:: number to send to
+      # from_:: number to send from
+      # method:: action HTTP method
+      # action:: action URL
+      # status_callback:: callback URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Message> child element
+      def message(
+        body,
+        to: nil,
+        from: nil,
+        method: nil,
+        action: nil,
+        status_callback: nil,
+        **keyword_args)
+
+        self.append(Message.new(
+          body: body,
+          to: to,
+          from: from,
+          method: method,
+          action: action,
+          status_callback: status_callback,
+          **keyword_args
+        ))
+      end
+
+      # Create an <Redirect> element
+      #
+      # == Parameters:
+      # url:: URL to redirect to
+      # method:: HTTP method
+      # keyword_args:: attributes
+      #
+      # == Returns:
+      # A <Response> element with an <Redirect> child element
+      def redirect(url, method: nil, **keyword_args)
+        self.append(Redirect.new(url, method: method, **keyword_args))
+      end
+    end
+
+    # <Message> element
+    class Message < TwiML
+      # Create a <Message> element
+      #
+      # == Parameters:
+      # body:: message body
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Message> element
+      def initialize(body: nil, **keyword_args)
+        super(**keyword_args)
+        if !(body.nil?)
+          @value = body
+        end
+      end
+
+      # Create a <Body> element
+      #
+      # == Parameters:
+      # body:: body of message
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Message> element with a <Body> child element
+      def body(body)
+        self.append(Body.new(body))
+      end
+
+      # Create a <Media> element
+      #
+      # == Parameters:
+      # body:: body of message
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Message> element with a <Media> child element
+      def media(url)
+        self.append(Media.new(url))
+      end
+    end
+
+    # <Body> element
+    class Body < TwiML
+      # Create a <Body> element
+      #
+      # == Parameters:
+      # body:: message body
+      #
+      # == Returns:
+      # A <Body> element
+      def initialize(body)
+        super()
+        @value = body
+      end
+    end
+
+    # <Media> element
+    class Media < TwiML
+      # Create a <Media> element
+      #
+      # == Parameters:
+      # url:: media URL location
+      #
+      # == Returns:
+      # A <Media> element
+      def initialize(url)
+        super()
+        @value = url
+      end
+    end
+
+    # <Redirect> element
+    class Redirect < TwiML
+      # Create a <Redirect> element
+      #
+      # == Parameters:
+      # url:: redirect URL location
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Redirect> element
+      def initialize(url, **keyword_args)
+        super(**keyword_args)
+        @value = url
+      end
+    end
+  end
+end

data/lib/twilio-ruby/twiml/twiml.rb

@@ -0,0 +1,77 @@
+require 'libxml'
+
+module Twilio
+  module TwiML
+    class TwiMLError < StandardError
+    end
+
+    class TwiML
+      # Generate getter/setter methods
+      attr_accessor :name
+      attr_accessor :indent
+
+      def initialize(indent: false, **keyword_args)
+        @name = self.class.name.split('::').last
+        @indent = indent
+        @value = nil
+        @verbs = []
+        @attrs = {}
+
+        keyword_args.each do |key, val|
+          if !(val.nil?)
+            @attrs[TwiML.to_lower_camel_case(key)] = val
+          end
+        end
+      end
+
+      def self.to_lower_camel_case(symbol)
+        # Symbols don't have the .split method, so convert to string first
+        result = symbol.to_s.split('_').map(&:capitalize).join
+        result[0].downcase + result[1..result.length]
+      end
+
+      def to_s()
+        self.to_xml_str
+      end
+
+      def to_xml_str(xml_declaration = true)
+        xml = self.xml.to_s(:indent => self.indent)
+
+        return ('<?xml version="1.0" encoding="UTF-8"?>' + xml) if xml_declaration
+        xml
+      end
+
+      def xml()
+        # create XML element
+        elem = LibXML::XML::Node.new(@name, @value)
+
+        # set element attributes
+        keys = @attrs.keys.sort
+        keys.each do |key|
+          value = @attrs[key]
+
+          if (value.is_a?(TrueClass) || value.is_a?(FalseClass))
+            elem[key] = value.to_s.downcase
+          else
+            elem[key] = value.to_s
+          end
+        end
+
+        @verbs.each do |verb|
+          elem << verb.xml
+        end
+
+        elem
+      end
+
+      def append(verb)
+        if !(verb.is_a?(TwiML))
+          raise TwiMLError.new "Only appending of TwiML is allowed"
+        end
+
+        @verbs << verb
+        self
+      end
+    end
+  end
+end

data/lib/twilio-ruby/twiml/voice_response.rb

@@ -0,0 +1,925 @@
+module Twilio
+  module TwiML
+
+    # Voice TwiML Response
+    class VoiceResponse < TwiML
+      # Create a new <Response>
+      def initialize()
+        super()
+        self.name = 'Response'
+      end
+
+      # Create a <Dial> element
+      #
+      # == Parameters:
+      # number:: phone number to dial
+      # action:: action URL
+      # method:: action HTTP method
+      # timeout:: time to wait for answer
+      # hangup_on_star:: hangup call on * press
+      # time_limit:: max time length
+      # caller_id:: caller ID to display
+      # record:: record the call
+      # trim:: trim the recording
+      # recording_status_callback:: status callback URL
+      # recording_status_callback_method:: status callback URL method
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Dial> child element
+      def dial(
+        number,
+        action: nil,
+        method: nil,
+        timeout: nil,
+        hangup_on_star: nil,
+        time_limit: nil,
+        caller_id: nil,
+        record: nil,
+        trim: nil,
+        recording_status_callback: nil,
+        recording_status_callback_method: nil,
+        **keyword_args)
+
+        self.append(Dial.new(
+          number: number,
+          action: action,
+          method: method,
+          timeout: timeout,
+          hangup_on_star: hangup_on_star,
+          time_limit: time_limit,
+          caller_id: caller_id,
+          record: record,
+          trim: trim,
+          recording_status_callback: recording_status_callback,
+          recording_status_callback_method: recording_status_callback_method,
+          **keyword_args
+        ))
+      end
+
+      # Create an <Echo> element
+      #
+      # == Parameters:
+      # keyword_args:: attributes
+      #
+      # == Returns:
+      # A <Response> element with an <Echo> child element
+      def echo(**keyword_args)
+        self.append(Echo.new(**keyword_args))
+      end
+
+      # Create an <Enqueue> element
+      #
+      # == Parameters:
+      # name:: friendly name
+      # action:: action URL
+      # method:: action URL method
+      # wait_url:: wait URL
+      # wait_url_method:: wait URL method
+      # workflow_sid:: TaskRouter workflow SID
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with an <Enqueue> child element
+      def enqueue(
+        name,
+        action: nil,
+        method: nil,
+        wait_url: nil,
+        wait_url_method: nil,
+        workflow_sid: nil,
+        **keyword_args)
+
+        self.append(Enqueue.new(
+          name,
+          action: action,
+          method: method,
+          wait_url: wait_url,
+          wait_url_method: wait_url_method,
+          workflow_sid: workflow_sid,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Gather> element
+      #
+      # == Parameters:
+      # action:: action URL
+      # method:: action URL method
+      # timeout:: time to wait while gathering input
+      # finish_on_key:: finish on key press
+      # num_digits:: digits to collect
+      # partial_result_callback:: callback url
+      # partial_result_callback_method:: callback method
+      # language:: locale string
+      # hints:: speech recognition hints
+      # barge_in:: stop playing media upon speech
+      # acknowledge_sound_url:: url to hit when sound starts
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Gather> child element
+      def gather(
+        action: nil,
+        method: nil,
+        timeout: nil,
+        finish_on_key: nil,
+        num_digits: nil,
+        partial_result_callback: nil,
+        partial_result_callback_method: nil,
+        language: nil,
+        hints: nil,
+        barge_in: nil,
+        acknowledge_sound_url: nil,
+        **keyword_args)
+
+        self.append(Gather.new(
+          action: action,
+          method: method,
+          timeout: timeout,
+          finish_on_key: finish_on_key,
+          num_digits: num_digits,
+          partial_result_callback: partial_result_callback,
+          partial_result_callback_method: partial_result_callback_method,
+          language: language,
+          hints: hints,
+          barge_in: barge_in,
+          acknowledge_sound_url: acknowledge_sound_url,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Hangup> element
+      #
+      # == Returns:
+      # A <Response> element with a <Hangup> child element
+      def hangup()
+        self.append(Hangup.new)
+      end
+
+      # Create a <Leave> element
+      #
+      # == Returns:
+      # A <Response> element with a <Leave> child element
+      def leave()
+        self.append(Leave.new)
+      end
+
+      # Create a <Pause> element
+      #
+      # == Parameters:
+      # length:: time in seconds to pause
+      #
+      # == Returns:
+      # A <Response> element with a <Pause> child element
+      def pause(length: nil)
+        self.append(Pause.new(length: length))
+      end
+
+      # Create a <Play> element
+      #
+      # == Parameters:
+      # url:: url to play
+      # loop:: times to loop
+      # digits:: play DTMF tones during a call
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Play> child element
+      def play(url, loop: nil, digits: nil, **keyword_args)
+        self.append(Play.new(
+          url,
+          loop: loop,
+          digits: digits,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Record> element
+      #
+      # == Parameters:
+      # action:: action URL
+      # method:: action URL method
+      # timeout:: timeout for recording
+      # finish_on_key:: finish recording on key
+      # max_length:: max length to record
+      # play_beep:: play beep
+      # trim:: trim the recording
+      # recording_status_callback:: status callback for the recordings
+      # recording_status_callback_method:: status callback method
+      # transcribe:: transcribe the recording
+      # transcribe_callback:: transcribe callback URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Record> child element
+      def record(
+        action: nil,
+        method: nil,
+        timeout: nil,
+        finish_on_key: nil,
+        max_length: nil,
+        play_beep: nil,
+        trim: nil,
+        recording_status_callback: nil,
+        recording_status_callback_method: nil,
+        transcribe: nil,
+        transcribe_callback: nil,
+        **keyword_args)
+
+        self.append(Record.new(
+          action: action,
+          method: method,
+          timeout: timeout,
+          finish_on_key: finish_on_key,
+          max_length: max_length,
+          play_beep: play_beep,
+          trim: trim,
+          recording_status_callback: recording_status_callback,
+          recording_status_callback_method: recording_status_callback_method,
+          transcribe: transcribe,
+          transcribe_callback: transcribe_callback,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Redirect> element
+      #
+      # == Parameters:
+      # url:: redirect URL
+      # method:: redirect method
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Redirect> child element
+      def redirect(url, method: nil, **keyword_args)
+        self.append(Redirect.new(url, method: method, **keyword_args))
+      end
+
+      # Create a <Reject> element
+      #
+      # == Parameters:
+      # reason:: rejection reason
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Reject> child element
+      def reject(reason: nil, **keyword_args)
+        self.append(Reject.new(reason: reason, **keyword_args))
+      end
+
+      # Create a <Say> element
+      #
+      # == Parameters:
+      # body:: message body
+      # loop:: times to loop
+      # language:: language of message
+      # voice:: voice to use
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Say> child element
+      def say(body, loop: nil, language: nil, voice: nil, **keyword_args)
+        self.append(Say.new(
+          body,
+          loop: loop,
+          language: language,
+          voice: voice,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Sms> element
+      #
+      # == Parameters:
+      # body:: body of message
+      # to:: to phone number
+      # from_:: from phone number
+      # method:: action URL method
+      # action:: action URL
+      # status_callback:: status callback URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Response> element with a <Sms> child element
+      def sms(
+        body,
+        to: nil,
+        from: nil,
+        method: nil,
+        action: nil,
+        status_callback: nil,
+        **keyword_args)
+
+        self.append(Sms.new(
+          body,
+          to: to,
+          from: from,
+          method: method,
+          action: action,
+          status_callback: status_callback,
+          **keyword_args
+        ))
+      end
+    end
+
+    # <Dial> element
+    class Dial < TwiML
+      # Create a <Dial> element
+      #
+      # == Parameters:
+      # number:: phone number to dial
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element
+      def initialize(number: nil, **keyword_args)
+        super(**keyword_args)
+        if !(number.nil?)
+          @value = number
+        end
+      end
+
+      # Create a <Client> element
+      #
+      # == Parameters:
+      # name:: name of client
+      # method:: action URL method
+      # url:: action URL
+      # status_callback_event:: events to call status callback
+      # status_callback_method:: status callback URL method
+      # status_callback:: status callback URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Client> child element
+      def client(
+        name,
+        method: nil,
+        url: nil,
+        status_callback_event: nil,
+        status_callback_method: nil,
+        status_callback: nil,
+        **keyword_args)
+
+        self.append(Client.new(
+          name,
+          method: method,
+          url: url,
+          status_callback_event: status_callback_event,
+          status_callback_method: status_callback_method,
+          status_callback: status_callback,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Conference> element
+      #
+      # == Parameters:
+      # name:: name of conference
+      # muted:: join the conference muted
+      # start_conference_on_enter:: start the conference on enter
+      # end_conference_on_exit:: end the conference on exit
+      # max_participants:: max number of people in conference
+      # beep:: play beep when joining
+      # record:: record the conference
+      # trim:: trim the recording
+      # wait_method:: wait URL method
+      # wait_url:: wait URL to play
+      # event_callback_url:: event callback URL
+      # status_callback_event:: events to call status callback
+      # status_callback:: status callback URL
+      # status_callback_method:: status callback URL method
+      # recording_status_callback:: recording status callback URL
+      # recording_status_callback_method:: recording status callback URL method
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Conference> child element
+      def conference(
+        name,
+        muted: nil,
+        start_conference_on_enter: nil,
+        end_conference_on_exit: nil,
+        max_participants: nil,
+        beep: nil,
+        record: nil,
+        trim: nil,
+        wait_url: nil,
+        wait_method: nil,
+        event_callback_url: nil,
+        status_callback: nil,
+        status_callback_event: nil,
+        status_callback_method: nil,
+        recording_status_callback: nil,
+        recording_status_callback_method: nil,
+        **keyword_args)
+
+        self.append(Conference.new(
+          name,
+          muted: muted,
+          start_conference_on_enter: start_conference_on_enter,
+          end_conference_on_exit: end_conference_on_exit,
+          max_participants: max_participants,
+          beep: beep,
+          record: record,
+          trim: trim,
+          wait_url: wait_url,
+          wait_method: wait_method,
+          event_callback_url: event_callback_url,
+          status_callback: status_callback,
+          status_callback_event: status_callback_event,
+          status_callback_method: status_callback_method,
+          recording_status_callback: recording_status_callback,
+          recording_status_callback_method: recording_status_callback_method,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Number> element
+      #
+      # == Parameters:
+      # number:: phone number to dial
+      # send_digits:: play DTMF tones when the call is answered
+      # url:: TwiML URL
+      # method:: TwiML URL method
+      # status_callback_event:: events to call status callback
+      # status_callback:: status callback URL
+      # status_callback_method:: status callback URL method
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Number> child element
+      def number(
+        number,
+        send_digits: nil,
+        url: nil,
+        method: nil,
+        status_callback: nil,
+        status_callback_event: nil,
+        status_callback_method: nil,
+        **keyword_args)
+
+        self.append(Number.new(
+          number,
+          send_digits: send_digits,
+          url: url,
+          method: method,
+          status_callback: status_callback,
+          status_callback_event: status_callback_event,
+          status_callback_method: status_callback_method,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Queue> element
+      #
+      # == Parameters:
+      # queue_name:: queue name
+      # url:: action URL
+      # method:: action URL method
+      # reservation_sid:: TaskRouter reservation SID
+      # post_work_activity_sid:: TaskRouter activity SID
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Queue> child element
+      def queue(
+        queue_name,
+        url: nil,
+        method: nil,
+        reservation_sid: nil,
+        post_work_activity_sid: nil,
+        **keyword_args)
+
+        self.append(Queue.new(
+          queue_name,
+          url: url,
+          method: method,
+          reservation_sid: reservation_sid,
+          post_work_activity_sid: post_work_activity_sid,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Sim> element
+      #
+      # == Parameters:
+      # sid:: sim sid
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Sim> child element
+      def sim(sid, **keyword_args)
+        self.append(Sim.new(sid,**keyword_args))
+      end
+
+      # Create a <Sip> element
+      #
+      # == Parameters:
+      # uri:: sip url
+      # username:: sip username
+      # password:: sip password
+      # url:: action URL
+      # method:: action URL method
+      # status_callback_event:: events to call status callback
+      # status_callback:: status callback URL
+      # status_callback_method:: status callback URL method
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Dial> element with a <Sip> child element
+      def sip(
+        uri,
+        username: nil,
+        password: nil,
+        url: nil,
+        method: nil,
+        status_callback: nil,
+        status_callback_event: nil,
+        status_callback_method: nil,
+        **keyword_args)
+
+        self.append(Sip.new(
+          uri,
+          username: username,
+          password: password,
+          url: url,
+          method: method,
+          status_callback: status_callback,
+          status_callback_event: status_callback_event,
+          status_callback_method: status_callback_method,
+          **keyword_args
+        ))
+      end
+    end
+
+    # <Client> element
+    class Client < TwiML
+      # Create a <Client> element
+      #
+      # == Parameters:
+      # name:: name of client
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Client> element
+      def initialize(name, **keyword_args)
+        super(**keyword_args)
+        @value = name
+      end
+    end
+
+    # <Conference> element
+    class Conference < TwiML
+      # Create a <Conference> element
+      #
+      # == Parameters:
+      # name:: name of conference
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Conference> element
+      def initialize(name, **keyword_args)
+        super(**keyword_args)
+        @value = name
+      end
+    end
+
+    # <Number> element
+    class Number < TwiML
+      # Create a <Number> element
+      #
+      # == Parameters:
+      # number:: phone number
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Number> element
+      def initialize(number, **keyword_args)
+        super(**keyword_args)
+        @value = number
+      end
+    end
+
+    # <Queue> element
+    class Queue < TwiML
+      # Create a <Queue> element
+      #
+      # == Parameters:
+      # queue_name:: name of queues
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Queue> element
+      def initialize(queue_name, **keyword_args)
+        super(**keyword_args)
+        @value = queue_name
+      end
+    end
+
+    # <Sim> element
+    class Sim < TwiML
+      # Create a <Sim> element
+      #
+      # == Parameters:
+      # sid:: sim sid
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Sim> element
+      def initialize(sid, **keyword_args)
+        super(**keyword_args)
+        @value = sid
+      end
+    end
+    # <Sip> element
+    class Sip < TwiML
+      # Create a <Sip> element
+      #
+      # == Parameters:
+      # uri:: sip uri
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Sip> element
+      def initialize(uri, **keyword_args)
+        super(**keyword_args)
+        @value = uri
+      end
+    end
+
+    # <Echo> element
+    class Echo < TwiML
+      # Create a <Echo> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Echo> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Enqueue> element
+    class Enqueue < TwiML
+      # Create a <Enqueue> element
+      #
+      # == Parameters:
+      # name:: queue name
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Enqueue> element
+      def initialize(name, **keyword_args)
+        super(**keyword_args)
+        @value = name
+      end
+
+      # Create a <Task> element
+      #
+      # == Parameters:
+      # attributes:: attributes for a task
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # An <Enqueue> element with a <Task> child element
+      def task(attributes, **keyword_args)
+        self.append(Task.new(attributes, **keyword_args))
+      end
+    end
+
+    # <Task> element
+    class Task < TwiML
+      # Create a <Task> element
+      #
+      # == Parameters:
+      # attributes:: attributes for a task
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Task> element
+      def initialize(attributes, **keyword_args)
+        super(**keyword_args)
+        if attributes.is_a?(String)
+          @value = attributes
+        else
+          @value = JSON.generate(attributes)
+        end
+      end
+    end
+
+    # <Gather> element
+    class Gather < TwiML
+      # Create a <Gather> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Gather> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+
+      # Create a <Say> element
+      #
+      # == Parameters:
+      # name:: name of client
+      # body:: message body
+      # loop:: times to loop
+      # language:: message language
+      # voice:: voice to use
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Gather> element with a <Say> child element
+      def say(
+        body,
+        loop: nil,
+        language: nil,
+        voice: nil,
+        **keyword_args)
+
+        self.append(Say.new(
+          body,
+          loop: loop,
+          language: language,
+          voice: voice,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Play> element
+      #
+      # == Parameters:
+      # url:: media URL
+      # loop:: times to loop
+      # digits:: digits to simulate
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Gather> element with a <Play> child element
+      def play(
+        url,
+        loop: nil,
+        digits: nil,
+        **keyword_args)
+
+        self.append(Play.new(
+          url,
+          loop: loop,
+          digits: digits,
+          **keyword_args
+        ))
+      end
+
+      # Create a <Pause> element
+      #
+      # == Parameters:
+      # length:: time to pause
+      #
+      # == Returns:
+      # A <Gather> element with a <Pause> child element
+      def pause(length: nil)
+        self.append(Pause.new(length: length))
+      end
+    end
+
+    # <Pause> element
+    class Pause < TwiML
+      # Create a <Pause> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Pause> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Play> element
+    class Play < TwiML
+      # Create a <Play> element
+      #
+      # == Parameters:
+      # url:: media URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Play> element
+      def initialize(url, **keyword_args)
+        super(**keyword_args)
+        @value = url
+      end
+    end
+
+    # <Say> element
+    class Say < TwiML
+      # Create a <Say> element
+      #
+      # == Parameters:
+      # body:: message body
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Say> element
+      def initialize(body, **keyword_args)
+        super(**keyword_args)
+        @value = body
+      end
+    end
+
+    # <Hangup> element
+    class Hangup < TwiML
+      # Create a <hangup_on_star> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <hangup_on_star> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Leave> element
+    class Leave < TwiML
+      # Create a <Leave> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Leave> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Record> element
+    class Record < TwiML
+      # Create a <Record> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Record> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Redirect> element
+    class Redirect < TwiML
+      # Create a <Redirect> element
+      #
+      # == Parameters:
+      # url:: TwiML URL
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Redirect> element
+      def initialize(url, **keyword_args)
+        super(**keyword_args)
+        @value = url
+      end
+    end
+
+    # <Reject> element
+    class Reject < TwiML
+      # Create a <Reject> element
+      #
+      # == Parameters:
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Reject> element
+      def initialize(**keyword_args)
+        super(**keyword_args)
+      end
+    end
+
+    # <Sms> element
+    class Sms < TwiML
+      # Create a <Sms> element
+      #
+      # == Parameters:
+      # body:: message body
+      # keyword_args:: additional attributes
+      #
+      # == Returns:
+      # A <Sms> element
+      def initialize(body, **keyword_args)
+        super(**keyword_args)
+        @value = body
+      end
+    end
+  end
+end