twilio-ruby 7.4.4 → 7.10.4

data/lib/twilio-ruby/rest/verify/v2/service/entity/challenge.rb

@@ -28,6 +28,7 @@ module Twilio
                     # @return [ChallengeList] ChallengeList
                     def initialize(version, service_sid: nil, identity: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { service_sid: service_sid, identity: identity }
                         @uri = "/Services/#{@solution[:service_sid]}/Entities/#{@solution[:identity]}/Challenges"
@@ -75,6 +76,54 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the ChallengeInstanceMetadata
+                    # @param [String] factor_sid The unique SID identifier of the Factor.
+                    # @param [Time] expiration_date The date-time when this Challenge expires, given in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format. The default value is five (5) minutes after Challenge creation. The max value is sixty (60) minutes after creation.
+                    # @param [String] details_message Shown to the user when the push notification arrives. Required when `factor_type` is `push`. Can be up to 256 characters in length
+                    # @param [Array[Hash]] details_fields A list of objects that describe the Fields included in the Challenge. Each object contains the label and value of the field, the label can be up to 36 characters in length and the value can be up to 128 characters in length. Used when `factor_type` is `push`. There can be up to 20 details fields.
+                    # @param [Object] hidden_details Details provided to give context about the Challenge. Not shown to the end user. It must be a stringified JSON with only strings values eg. `{\\\"ip\\\": \\\"172.168.1.234\\\"}`. Can be up to 1024 characters in length
+                    # @param [String] auth_payload Optional payload used to verify the Challenge upon creation. Only used with a Factor of type `totp` to carry the TOTP code that needs to be verified. For `TOTP` this value must be between 3 and 8 characters long.
+                    # @return [ChallengeInstance] Created ChallengeInstance
+                    def create_with_metadata(
+                      factor_sid: nil, 
+                      expiration_date: :unset, 
+                      details_message: :unset, 
+                      details_fields: :unset, 
+                      hidden_details: :unset, 
+                      auth_payload: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'FactorSid' => factor_sid,
+                            'ExpirationDate' => Twilio.serialize_iso8601_datetime(expiration_date),
+                            'Details.Message' => details_message,
+                            'Details.Fields' => Twilio.serialize_list(details_fields) { |e| Twilio.serialize_object(e) },
+                            'HiddenDetails' => Twilio.serialize_object(hidden_details),
+                            'AuthPayload' => auth_payload,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        challenge_instance = ChallengeInstance.new(
+                            @version,
+                            response.body,
+                            service_sid: @solution[:service_sid],
+                            identity: @solution[:identity],
+                        )
+                        ChallengeInstanceMetadata.new(
+                            @version,
+                            challenge_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
                     ##
                     # Lists ChallengeInstance records from the API as a list.
@@ -126,6 +175,34 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     end
 
+                    ##
+                    # Lists ChallengePageMetadata records from the API as a list.
+                      # @param [String] factor_sid The unique SID identifier of the Factor.
+                      # @param [ChallengeStatuses] status The Status of the Challenges to fetch. One of `pending`, `expired`, `approved` or `denied`.
+                      # @param [ListOrders] order The desired sort order of the Challenges list. One of `asc` or `desc` for ascending and descending respectively. Defaults to `asc`.
+                    # @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_with_metadata(factor_sid: :unset, status: :unset, order: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'FactorSid' => factor_sid,
+                            'Status' => status,
+                            'Order' => order,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        ChallengePageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
                     ##
                     # When passed a block, yields ChallengeInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -150,7 +227,7 @@ 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 ChallengeInstance
-                    def page(factor_sid: :unset, status: :unset, order: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(factor_sid: :unset, status: :unset, order: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
                             'FactorSid' => factor_sid,
                             'Status' => status,
@@ -200,6 +277,7 @@ module Twilio
                     # @return [ChallengeContext] ChallengeContext
                     def initialize(version, service_sid, identity, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { service_sid: service_sid, identity: identity, sid: sid,  }
@@ -229,6 +307,33 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the ChallengeInstanceMetadata
+                    # @return [ChallengeInstance] Fetched ChallengeInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        challenge_instance = ChallengeInstance.new(
+                            @version,
+                            response.body,
+                            service_sid: @solution[:service_sid],
+                            identity: @solution[:identity],
+                            sid: @solution[:sid],
+                        )
+                        ChallengeInstanceMetadata.new(
+                            @version,
+                            challenge_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the ChallengeInstance
                     # @param [String] auth_payload The optional payload needed to verify the Challenge. E.g., a TOTP would use the numeric code. For `TOTP` this value must be between 3 and 8 characters long. For `Push` this value can be up to 5456 characters in length
@@ -260,6 +365,43 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the ChallengeInstanceMetadata
+                    # @param [String] auth_payload The optional payload needed to verify the Challenge. E.g., a TOTP would use the numeric code. For `TOTP` this value must be between 3 and 8 characters long. For `Push` this value can be up to 5456 characters in length
+                    # @param [Object] metadata Custom metadata associated with the challenge. This is added by the Device/SDK directly to allow for the inclusion of device information. It must be a stringified JSON with only strings values eg. `{\\\"os\\\": \\\"Android\\\"}`. Can be up to 1024 characters in length.
+                    # @return [ChallengeInstance] Updated ChallengeInstance
+                    def update_with_metadata(
+                      auth_payload: :unset, 
+                      metadata: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'AuthPayload' => auth_payload,
+                            'Metadata' => Twilio.serialize_object(metadata),
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        challenge_instance = ChallengeInstance.new(
+                            @version,
+                            response.body,
+                            service_sid: @solution[:service_sid],
+                            identity: @solution[:identity],
+                            sid: @solution[:sid],
+                        )
+                        ChallengeInstanceMetadata.new(
+                            @version,
+                            challenge_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Access the notifications
                     # @return [NotificationList]
@@ -287,6 +429,53 @@ module Twilio
                     end
                 end
 
+                class ChallengeInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new ChallengeInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}ChallengeInstance] challenge_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 [ChallengeInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, challenge_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @challenge_instance = challenge_instance
+                    end
+
+                    def challenge
+                        @challenge_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.ChallengeInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class ChallengeListResponse < InstanceListResource
+                    # @param [Array<ChallengeInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @challenge_instance = payload.body[key].map do |data|
+                        ChallengeInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def challenge_instance
+                          @instance
+                      end
+                  end
+
                 class ChallengePage < Page
                     ##
                     # Initialize the ChallengePage
@@ -296,6 +485,7 @@ module Twilio
                     # @return [ChallengePage] ChallengePage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -315,6 +505,66 @@ module Twilio
                         '<Twilio.Verify.V2.ChallengePage>'
                     end
                 end
+
+                class ChallengePageMetadata < PageMetadata
+                    attr_reader :challenge_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @challenge_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @challenge_page << ChallengeListResponse.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
+                        @challenge_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Verify::V2PageMetadata>';
+                    end
+                end
+                class ChallengeListResponse < InstanceListResource
+
+                    # @param [Array<ChallengeInstance>] 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
+                      @challenge = data_list.map do |data|
+                        ChallengeInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def challenge
+                        @challenge
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class ChallengeInstance < InstanceResource
                     ##
                     # Initialize the ChallengeInstance
@@ -328,6 +578,7 @@ module Twilio
                     def initialize(version, payload , service_sid: nil, identity: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],

data/lib/twilio-ruby/rest/verify/v2/service/entity/factor.rb

@@ -28,6 +28,7 @@ module Twilio
                     # @return [FactorList] FactorList
                     def initialize(version, service_sid: nil, identity: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { service_sid: service_sid, identity: identity }
                         @uri = "/Services/#{@solution[:service_sid]}/Entities/#{@solution[:identity]}/Factors"
@@ -72,6 +73,28 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     end
 
+                    ##
+                    # Lists FactorPageMetadata records from the API as a list.
+                    # @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_with_metadata(limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        FactorPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
                     ##
                     # When passed a block, yields FactorInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -93,7 +116,7 @@ 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 FactorInstance
-                    def page(page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
                             'PageToken' => page_token,
                             'Page' => page_number,
@@ -140,6 +163,7 @@ module Twilio
                     # @return [FactorContext] FactorContext
                     def initialize(version, service_sid, identity, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { service_sid: service_sid, identity: identity, sid: sid,  }
@@ -156,9 +180,29 @@ module Twilio
                         
                         
                         
+
                         @version.delete('DELETE', @uri, headers: headers)
                     end
 
+                    ##
+                    # Delete the FactorInstanceMetadata
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                          response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                          factor_instance = FactorInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          FactorInstanceMetadata.new(@version, factor_instance, response.headers, response.status_code)
+                    end
+
                     ##
                     # Fetch the FactorInstance
                     # @return [FactorInstance] Fetched FactorInstance
@@ -180,6 +224,33 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the FactorInstanceMetadata
+                    # @return [FactorInstance] Fetched FactorInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        factor_instance = FactorInstance.new(
+                            @version,
+                            response.body,
+                            service_sid: @solution[:service_sid],
+                            identity: @solution[:identity],
+                            sid: @solution[:sid],
+                        )
+                        FactorInstanceMetadata.new(
+                            @version,
+                            factor_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the FactorInstance
                     # @param [String] auth_payload The optional payload needed to verify the Factor for the first time. E.g. for a TOTP, the numeric code.
@@ -232,6 +303,64 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the FactorInstanceMetadata
+                    # @param [String] auth_payload The optional payload needed to verify the Factor for the first time. E.g. for a TOTP, the numeric code.
+                    # @param [String] friendly_name The new friendly name of this Factor. It can be up to 64 characters.
+                    # @param [String] config_notification_token For APN, the device token. For FCM, the registration token. It is used to send the push notifications. Required when `factor_type` is `push`. If specified, this value must be between 32 and 255 characters long.
+                    # @param [String] config_sdk_version The Verify Push SDK version used to configure the factor
+                    # @param [String] config_time_step Defines how often, in seconds, are TOTP codes generated. i.e, a new TOTP code is generated every time_step seconds. Must be between 20 and 60 seconds, inclusive
+                    # @param [String] config_skew The number of time-steps, past and future, that are valid for validation of TOTP codes. Must be between 0 and 2, inclusive
+                    # @param [String] config_code_length Number of digits for generated TOTP codes. Must be between 3 and 8, inclusive
+                    # @param [TotpAlgorithms] config_alg 
+                    # @param [String] config_notification_platform The transport technology used to generate the Notification Token. Can be `apn`, `fcm` or `none`.  Required when `factor_type` is `push`.
+                    # @return [FactorInstance] Updated FactorInstance
+                    def update_with_metadata(
+                      auth_payload: :unset, 
+                      friendly_name: :unset, 
+                      config_notification_token: :unset, 
+                      config_sdk_version: :unset, 
+                      config_time_step: :unset, 
+                      config_skew: :unset, 
+                      config_code_length: :unset, 
+                      config_alg: :unset, 
+                      config_notification_platform: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'AuthPayload' => auth_payload,
+                            'FriendlyName' => friendly_name,
+                            'Config.NotificationToken' => config_notification_token,
+                            'Config.SdkVersion' => config_sdk_version,
+                            'Config.TimeStep' => config_time_step,
+                            'Config.Skew' => config_skew,
+                            'Config.CodeLength' => config_code_length,
+                            'Config.Alg' => config_alg,
+                            'Config.NotificationPlatform' => config_notification_platform,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        factor_instance = FactorInstance.new(
+                            @version,
+                            response.body,
+                            service_sid: @solution[:service_sid],
+                            identity: @solution[:identity],
+                            sid: @solution[:sid],
+                        )
+                        FactorInstanceMetadata.new(
+                            @version,
+                            factor_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
 
                     ##
                     # Provide a user friendly representation
@@ -248,6 +377,53 @@ module Twilio
                     end
                 end
 
+                class FactorInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new FactorInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}FactorInstance] factor_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 [FactorInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, factor_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @factor_instance = factor_instance
+                    end
+
+                    def factor
+                        @factor_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.FactorInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class FactorListResponse < InstanceListResource
+                    # @param [Array<FactorInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @factor_instance = payload.body[key].map do |data|
+                        FactorInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def factor_instance
+                          @instance
+                      end
+                  end
+
                 class FactorPage < Page
                     ##
                     # Initialize the FactorPage
@@ -257,6 +433,7 @@ module Twilio
                     # @return [FactorPage] FactorPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -276,6 +453,66 @@ module Twilio
                         '<Twilio.Verify.V2.FactorPage>'
                     end
                 end
+
+                class FactorPageMetadata < PageMetadata
+                    attr_reader :factor_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @factor_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @factor_page << FactorListResponse.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
+                        @factor_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Verify::V2PageMetadata>';
+                    end
+                end
+                class FactorListResponse < InstanceListResource
+
+                    # @param [Array<FactorInstance>] 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
+                      @factor = data_list.map do |data|
+                        FactorInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def factor
+                        @factor
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class FactorInstance < InstanceResource
                     ##
                     # Initialize the FactorInstance
@@ -289,6 +526,7 @@ module Twilio
                     def initialize(version, payload , service_sid: nil, identity: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],