twilio-ruby 7.4.4 → 7.10.4

data/lib/twilio-ruby/rest/messaging/v1/domain_config_messaging_service.rb

@@ -25,6 +25,7 @@ module Twilio
                     # @return [DomainConfigMessagingServiceList] DomainConfigMessagingServiceList
                     def initialize(version)
                         super(version)
+                        
                         # Path Solution
                         @solution = {  }
                         
@@ -48,6 +49,7 @@ module Twilio
                     # @return [DomainConfigMessagingServiceContext] DomainConfigMessagingServiceContext
                     def initialize(version, messaging_service_sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { messaging_service_sid: messaging_service_sid,  }
@@ -74,6 +76,31 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the DomainConfigMessagingServiceInstanceMetadata
+                    # @return [DomainConfigMessagingServiceInstance] Fetched DomainConfigMessagingServiceInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        domain_config_messaging_service_instance = DomainConfigMessagingServiceInstance.new(
+                            @version,
+                            response.body,
+                            messaging_service_sid: @solution[:messaging_service_sid],
+                        )
+                        DomainConfigMessagingServiceInstanceMetadata.new(
+                            @version,
+                            domain_config_messaging_service_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
 
                     ##
                     # Provide a user friendly representation
@@ -90,6 +117,53 @@ module Twilio
                     end
                 end
 
+                class DomainConfigMessagingServiceInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new DomainConfigMessagingServiceInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}DomainConfigMessagingServiceInstance] domain_config_messaging_service_instance The instance associated with the metadata.
+                    # @param [Hash] headers Header object with response headers.
+                    # @param [Integer] status_code The HTTP status code of the response.
+                    # @return [DomainConfigMessagingServiceInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, domain_config_messaging_service_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @domain_config_messaging_service_instance = domain_config_messaging_service_instance
+                    end
+
+                    def domain_config_messaging_service
+                        @domain_config_messaging_service_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.DomainConfigMessagingServiceInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class DomainConfigMessagingServiceListResponse < InstanceListResource
+                    # @param [Array<DomainConfigMessagingServiceInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @domain_config_messaging_service_instance = payload.body[key].map do |data|
+                        DomainConfigMessagingServiceInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def domain_config_messaging_service_instance
+                          @instance
+                      end
+                  end
+
                 class DomainConfigMessagingServicePage < Page
                     ##
                     # Initialize the DomainConfigMessagingServicePage
@@ -99,6 +173,7 @@ module Twilio
                     # @return [DomainConfigMessagingServicePage] DomainConfigMessagingServicePage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -118,6 +193,66 @@ module Twilio
                         '<Twilio.Messaging.V1.DomainConfigMessagingServicePage>'
                     end
                 end
+
+                class DomainConfigMessagingServicePageMetadata < PageMetadata
+                    attr_reader :domain_config_messaging_service_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @domain_config_messaging_service_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @domain_config_messaging_service_page << DomainConfigMessagingServiceListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += @payload.body[key].size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @domain_config_messaging_service_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Messaging::V1PageMetadata>';
+                    end
+                end
+                class DomainConfigMessagingServiceListResponse < InstanceListResource
+
+                    # @param [Array<DomainConfigMessagingServiceInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @domain_config_messaging_service = data_list.map do |data|
+                        DomainConfigMessagingServiceInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def domain_config_messaging_service
+                        @domain_config_messaging_service
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class DomainConfigMessagingServiceInstance < InstanceResource
                     ##
                     # Initialize the DomainConfigMessagingServiceInstance
@@ -131,6 +266,7 @@ module Twilio
                     def initialize(version, payload , messaging_service_sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'domain_sid' => payload['domain_sid'],

data/lib/twilio-ruby/rest/messaging/v1/domain_validate_dn.rb

@@ -0,0 +1,344 @@
+##
+#    This code was generated by
+#    ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+#     |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+#     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+#
+#    Twilio - Messaging
+#    This is the public Twilio REST API.
+#
+#    NOTE: This class is auto generated by OpenAPI Generator.
+#    https://openapi-generator.tech
+#    Do not edit the class manually.
+#
+
+
+module Twilio
+    module REST
+        class Messaging < MessagingBase
+            class V1 < Version
+                class DomainValidateDnList < ListResource
+                
+                    ##
+                    # Initialize the DomainValidateDnList
+                    # @param [Version] version Version that contains the resource
+                    # @return [DomainValidateDnList] DomainValidateDnList
+                    def initialize(version)
+                        super(version)
+                        
+                        # Path Solution
+                        @solution = {  }
+                        
+                        
+                    end
+                
+
+
+                    # Provide a user friendly representation
+                    def to_s
+                        '#<Twilio.Messaging.V1.DomainValidateDnList>'
+                    end
+                end
+
+
+                class DomainValidateDnContext < InstanceContext
+                    ##
+                    # Initialize the DomainValidateDnContext
+                    # @param [Version] version Version that contains the resource
+                    # @param [String] domain_sid Unique string used to identify the domain.
+                    # @return [DomainValidateDnContext] DomainValidateDnContext
+                    def initialize(version, domain_sid)
+                        super(version)
+                        
+
+                        # Path Solution
+                        @solution = { domain_sid: domain_sid,  }
+                        @uri = "/LinkShortening/Domains/#{@solution[:domain_sid]}/ValidateDns"
+
+                        
+                    end
+                    ##
+                    # Fetch the DomainValidateDnInstance
+                    # @return [DomainValidateDnInstance] Fetched DomainValidateDnInstance
+                    def fetch
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
+                        DomainValidateDnInstance.new(
+                            @version,
+                            payload,
+                            domain_sid: @solution[:domain_sid],
+                        )
+                    end
+
+                    ##
+                    # Fetch the DomainValidateDnInstanceMetadata
+                    # @return [DomainValidateDnInstance] Fetched DomainValidateDnInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        domain_validate_dn_instance = DomainValidateDnInstance.new(
+                            @version,
+                            response.body,
+                            domain_sid: @solution[:domain_sid],
+                        )
+                        DomainValidateDnInstanceMetadata.new(
+                            @version,
+                            domain_validate_dn_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Messaging.V1.DomainValidateDnContext #{context}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Messaging.V1.DomainValidateDnContext #{context}>"
+                    end
+                end
+
+                class DomainValidateDnInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new DomainValidateDnInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}DomainValidateDnInstance] domain_validate_dn_instance The instance associated with the metadata.
+                    # @param [Hash] headers Header object with response headers.
+                    # @param [Integer] status_code The HTTP status code of the response.
+                    # @return [DomainValidateDnInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, domain_validate_dn_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @domain_validate_dn_instance = domain_validate_dn_instance
+                    end
+
+                    def domain_validate_dn
+                        @domain_validate_dn_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.DomainValidateDnInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class DomainValidateDnListResponse < InstanceListResource
+                    # @param [Array<DomainValidateDnInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @domain_validate_dn_instance = payload.body[key].map do |data|
+                        DomainValidateDnInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def domain_validate_dn_instance
+                          @instance
+                      end
+                  end
+
+                class DomainValidateDnPage < Page
+                    ##
+                    # Initialize the DomainValidateDnPage
+                    # @param [Version] version Version that contains the resource
+                    # @param [Response] response Response from the API
+                    # @param [Hash] solution Path solution for the resource
+                    # @return [DomainValidateDnPage] DomainValidateDnPage
+                    def initialize(version, response, solution)
+                        super(version, response)
+                        
+
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    ##
+                    # Build an instance of DomainValidateDnInstance
+                    # @param [Hash] payload Payload response from the API
+                    # @return [DomainValidateDnInstance] DomainValidateDnInstance
+                    def get_instance(payload)
+                        DomainValidateDnInstance.new(@version, payload)
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        '<Twilio.Messaging.V1.DomainValidateDnPage>'
+                    end
+                end
+
+                class DomainValidateDnPageMetadata < PageMetadata
+                    attr_reader :domain_validate_dn_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @domain_validate_dn_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @domain_validate_dn_page << DomainValidateDnListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += @payload.body[key].size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @domain_validate_dn_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Messaging::V1PageMetadata>';
+                    end
+                end
+                class DomainValidateDnListResponse < InstanceListResource
+
+                    # @param [Array<DomainValidateDnInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @domain_validate_dn = data_list.map do |data|
+                        DomainValidateDnInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def domain_validate_dn
+                        @domain_validate_dn
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
+                class DomainValidateDnInstance < InstanceResource
+                    ##
+                    # Initialize the DomainValidateDnInstance
+                    # @param [Version] version Version that contains the resource
+                    # @param [Hash] payload payload that contains response from Twilio
+                    # @param [String] account_sid The SID of the
+                    #   {Account}[https://www.twilio.com/docs/iam/api/account] that created this DomainValidateDn
+                    #   resource.
+                    # @param [String] sid The SID of the Call resource to fetch.
+                    # @return [DomainValidateDnInstance] DomainValidateDnInstance
+                    def initialize(version, payload , domain_sid: nil)
+                        super(version)
+                        
+                        
+                        # Marshaled Properties
+                        @properties = { 
+                            'domain_sid' => payload['domain_sid'],
+                            'is_valid' => payload['is_valid'],
+                            'reason' => payload['reason'],
+                            'url' => payload['url'],
+                        }
+
+                        # Context
+                        @instance_context = nil
+                        @params = { 'domain_sid' => domain_sid  || @properties['domain_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 [DomainValidateDnContext] CallContext for this CallInstance
+                    def context
+                        unless @instance_context
+                            @instance_context = DomainValidateDnContext.new(@version , @params['domain_sid'])
+                        end
+                        @instance_context
+                    end
+                    
+                    ##
+                    # @return [String] The unique string that we created to identify the Domain resource.
+                    def domain_sid
+                        @properties['domain_sid']
+                    end
+                    
+                    ##
+                    # @return [Boolean] 
+                    def is_valid
+                        @properties['is_valid']
+                    end
+                    
+                    ##
+                    # @return [String] 
+                    def reason
+                        @properties['reason']
+                    end
+                    
+                    ##
+                    # @return [String] 
+                    def url
+                        @properties['url']
+                    end
+                    
+                    ##
+                    # Fetch the DomainValidateDnInstance
+                    # @return [DomainValidateDnInstance] Fetched DomainValidateDnInstance
+                    def fetch
+
+                        context.fetch
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Messaging.V1.DomainValidateDnInstance #{values}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Messaging.V1.DomainValidateDnInstance #{values}>"
+                    end
+                end
+
+            end
+        end
+    end
+end

data/lib/twilio-ruby/rest/messaging/v1/external_campaign.rb

@@ -25,6 +25,7 @@ module Twilio
                     # @return [ExternalCampaignList] ExternalCampaignList
                     def initialize(version)
                         super(version)
+                        
                         # Path Solution
                         @solution = {  }
                         @uri = "/Services/PreregisteredUsa2p"
@@ -61,6 +62,43 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the ExternalCampaignInstanceMetadata
+                    # @param [String] campaign_id ID of the preregistered campaign.
+                    # @param [String] messaging_service_sid The SID of the [Messaging Service](https://www.twilio.com/docs/messaging/api/service-resource) that the resource is associated with.
+                    # @param [Boolean] cnp_migration Customers should use this flag during the ERC registration process to indicate to Twilio that the campaign being registered is undergoing CNP migration. It is important for the user to first trigger the CNP migration process for said campaign in their CSP portal and have Twilio accept the sharing request, before making this api call.
+                    # @return [ExternalCampaignInstance] Created ExternalCampaignInstance
+                    def create_with_metadata(
+                      campaign_id: nil, 
+                      messaging_service_sid: nil, 
+                      cnp_migration: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'CampaignId' => campaign_id,
+                            'MessagingServiceSid' => messaging_service_sid,
+                            'CnpMigration' => cnp_migration,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        external_campaign_instance = ExternalCampaignInstance.new(
+                            @version,
+                            response.body,
+                        )
+                        ExternalCampaignInstanceMetadata.new(
+                            @version,
+                            external_campaign_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
 
 
@@ -79,6 +117,7 @@ module Twilio
                     # @return [ExternalCampaignPage] ExternalCampaignPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -98,6 +137,66 @@ module Twilio
                         '<Twilio.Messaging.V1.ExternalCampaignPage>'
                     end
                 end
+
+                class ExternalCampaignPageMetadata < PageMetadata
+                    attr_reader :external_campaign_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @external_campaign_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @external_campaign_page << ExternalCampaignListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += @payload.body[key].size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @external_campaign_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Messaging::V1PageMetadata>';
+                    end
+                end
+                class ExternalCampaignListResponse < InstanceListResource
+
+                    # @param [Array<ExternalCampaignInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @external_campaign = data_list.map do |data|
+                        ExternalCampaignInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def external_campaign
+                        @external_campaign
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class ExternalCampaignInstance < InstanceResource
                     ##
                     # Initialize the ExternalCampaignInstance
@@ -111,6 +210,7 @@ module Twilio
                     def initialize(version, payload )
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],