whatsapp_sdk 0.12.1 → 0.13.0

data/lib/whatsapp_sdk/resource/interactive_header.rb

@@ -1,26 +1,18 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class InteractiveHeader
-      extend T::Sig
-
       # Returns the interactive header type.
       #
       # @returns type [String] Valid options are text, image, document, video.
-      sig { returns(Type) }
       attr_accessor :type
 
-      class Type < T::Enum
-        extend T::Sig
-
-        enums do
-          Text = new("text")
-          Image = new("image")
-          Document = new("document")
-          Video = new("video")
-        end
+      module Type
+        TEXT = "text"
+        IMAGE = "image"
+        DOCUMENT = "document"
+        VIDEO = "video"
       end
 
       # Returns Text string if the interactive header type is text.
@@ -28,35 +20,25 @@ module WhatsappSdk
       # For the body interactive, the character limit is 1024 characters.
       #
       # @returns text [String]
-      sig { returns(T.nilable(String)) }
       attr_accessor :text
 
       # Returns image if the interactive header type is image.
       #
       # @returns image [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :image
 
       # Returns document if the interactive header type is document.
       #
       # @returns document [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :document
 
       # Returns video if the interactive header type is video.
       #
       # @returns video [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :video
 
-      sig do
-        params(
-          type: T.any(Type, String), text: T.nilable(String), image: T.nilable(Media),
-          document: T.nilable(Media), video: T.nilable(Media)
-        ).void
-      end
       def initialize(type:, text: nil, image: nil, document: nil, video: nil)
-        @type = T.let(deserialize_type(type), Type)
+        @type = type
         @text = text
         @image = image
         @document = document
@@ -64,54 +46,44 @@ module WhatsappSdk
         validate
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_json
-        json = { type: type.serialize }
-        json[type.serialize.to_sym] = case type.serialize
-                                      when "text"
-                                        text
-                                      when "image"
-                                        T.must(image).to_json
-                                      when "document"
-                                        T.must(document).to_json
-                                      when "video"
-                                        T.must(video).to_json
-                                      else
-                                        raise "Invalid type: #{type}"
-                                      end
+        json = { type: type }
+        json[type.to_sym] = case type
+                            when "text"
+                              text
+                            when "image"
+                              image.to_json
+                            when "document"
+                              document.to_json
+                            when "video"
+                              video.to_json
+                            else
+                              raise "Invalid type: #{type}"
+                            end
 
         json
       end
 
       private
 
-      sig { params(type: T.any(String, Type)).returns(Type) }
-      def deserialize_type(type)
-        return type if type.is_a?(Type)
-
-        Type.deserialize(type)
-      end
-
-      sig { void }
       def validate
         validate_attributes
       end
 
-      sig { void }
       def validate_attributes
         [
-          [Type::Text, text],
-          [Type::Image, image],
-          [Type::Document, document],
-          [Type::Video, video]
+          [Type::TEXT, text],
+          [Type::IMAGE, image],
+          [Type::DOCUMENT, document],
+          [Type::VIDEO, video]
         ].each do |type_b, value|
           next unless type == type_b
 
           next unless value.nil?
 
           raise Resource::Errors::MissingValue.new(
-            type.serialize,
-            "#{type.serialize} is required when the type is #{type_b}"
+            type,
+            "#{type} is required when the type is #{type_b}"
           )
         end
       end

data/lib/whatsapp_sdk/resource/location.rb

@@ -0,0 +1,44 @@
+# typed: false
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Location
+      # Returns the latitude of the location.
+      #
+      # @returns latitude [Float].
+      attr_accessor :latitude
+
+      # Returns the longitude of the location.
+      #
+      # @returns longitude [Float].
+      attr_accessor :longitude
+
+      # Returns the name of the location.
+      #
+      # @returns name [String].
+      attr_accessor :name
+
+      # Returns the address of the location.
+      #
+      # @returns address [String].
+      attr_accessor :address
+
+      def initialize(latitude:, longitude:, name:, address:)
+        @latitude = latitude
+        @longitude = longitude
+        @name = name
+        @address = address
+      end
+
+      def to_json
+        {
+          latitude: latitude,
+          longitude: longitude,
+          name: name,
+          address: address
+        }
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/media.rb

@@ -1,21 +1,11 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Media
-      extend T::Sig
-
       class InvalidMedia < StandardError
-        extend T::Sig
-
-        sig { returns(Symbol) }
-        attr_reader :field
-
-        sig { returns(String) }
-        attr_reader :message
+        attr_reader :field, :message
 
-        sig { params(field: Symbol, message: String).void }
         def initialize(field, message)
           @field = field
           @message = message
@@ -26,52 +16,37 @@ module WhatsappSdk
       # Returns media id.
       #
       # @returns id [String].
-      sig { returns(T.nilable(String)) }
       attr_accessor :id
 
-      class Type < T::Enum
-        extend T::Sig
-
-        enums do
-          Audio = new('audio')
-          Document = new('document')
-          Image = new('image')
-          Video = new('video')
-          Sticker = new('sticker')
-        end
+      module Type
+        AUDIO = 'audio'
+        DOCUMENT = 'document'
+        IMAGE = 'image'
+        VIDEO = 'video'
+        STICKER = 'sticker'
       end
 
       # @returns type [String]. Valid options ar audio, document, image, video and sticker.
-      sig { returns(Type) }
       attr_accessor :type
 
       # The protocol and URL of the media to be sent. Use only with HTTP/HTTPS URLs.
       # Do not use this field when the message type is set to text.
       #
       # @returns link [String].
-      sig { returns(T.nilable(String)) }
       attr_accessor :link
 
       # Describes the specified document or image media.
       #
       # @returns caption [String].
-      sig { returns(T.nilable(String)) }
       attr_accessor :caption
 
       # Describes the filename for the specific document. Use only with document media.
       #
       # @returns filename [String].
-      sig { returns(T.nilable(String)) }
       attr_accessor :filename
 
-      sig do
-        params(
-          type: T.any(Type, String), id: T.nilable(String), link: T.nilable(String),
-          caption: T.nilable(String), filename: T.nilable(String)
-        ).void
-      end
       def initialize(type:, id: nil, link: nil, caption: nil, filename: nil)
-        @type = T.let(deserialize_type(type), Type)
+        @type = type
         @id = id
         @link = link
         @caption = caption
@@ -79,7 +54,6 @@ module WhatsappSdk
         validate_media
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_json
         json = {}
         json[:id] = id unless id.nil?
@@ -91,14 +65,6 @@ module WhatsappSdk
 
       private
 
-      sig { params(type: T.any(String, Type)).returns(Type) }
-      def deserialize_type(type)
-        return type if type.is_a?(Type)
-
-        Type.deserialize(type)
-      end
-
-      sig { returns(T::Boolean) }
       def validate_media
         raise InvalidMedia.new(:filename, "filename can only be used with document") if filename && !supports_filename?
 
@@ -109,14 +75,12 @@ module WhatsappSdk
         true
       end
 
-      sig { returns(T::Boolean) }
       def supports_filename?
-        type == Type::Document
+        type == Type::DOCUMENT
       end
 
-      sig { returns(T::Boolean) }
       def supports_caption?
-        type == Type::Document || type == Type::Image
+        type == Type::DOCUMENT || type == Type::IMAGE
       end
     end
   end

data/lib/whatsapp_sdk/resource/media_types.rb

@@ -1,11 +1,8 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class MediaTypes
-      extend T::Sig
-
       # The media types supported by Whatsapp. The list contains all the types defined in the Whatsapp API
       # documentation: https://developers.facebook.com/docs/whatsapp/cloud-api/reference/media#supported-media-types
       #

data/lib/whatsapp_sdk/resource/message.rb

@@ -1,15 +1,10 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Message
-      extend T::Sig
-
-      sig { returns(String) }
       attr_reader :id
 
-      sig { params(id: String).void }
       def initialize(id:)
         @id = id
       end

data/lib/whatsapp_sdk/resource/name.rb

@@ -1,36 +1,10 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Name
-      extend T::Sig
+      attr_accessor :formatted_name, :first_name, :last_name, :middle_name, :suffix, :prefix
 
-      sig { returns(T.nilable(String)) }
-      attr_accessor :formatted_name
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :first_name
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :last_name
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :middle_name
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :suffix
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :prefix
-
-      sig do
-        params(
-          formatted_name: T.nilable(String), first_name: T.nilable(String),
-          last_name: T.nilable(String), middle_name: T.nilable(String),
-          suffix: T.nilable(String), prefix: T.nilable(String)
-        ).void
-      end
       def initialize(
         formatted_name: nil, first_name: nil,
         last_name: nil, middle_name: nil, suffix: nil, prefix: nil
@@ -43,7 +17,6 @@ module WhatsappSdk
         @prefix = prefix
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           formatted_name: @formatted_name,

data/lib/whatsapp_sdk/resource/org.rb

@@ -1,28 +1,16 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Org
-      extend T::Sig
+      attr_accessor :company, :department, :title
 
-      sig { returns(String) }
-      attr_accessor :company
-
-      sig { returns(String) }
-      attr_accessor :department
-
-      sig { returns(String) }
-      attr_accessor :title
-
-      sig { params(company: String, department: String, title: String).void }
       def initialize(company:, department:, title:)
         @company = company
         @department = department
         @title = title
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           company: @company,

data/lib/whatsapp_sdk/resource/parameter_object.rb

@@ -1,23 +1,14 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class ParameterObject
-      extend T::Sig
-
       class InvalidType < StandardError
-        extend T::Sig
-
-        sig { returns(String) }
         attr_accessor :message
 
-        sig { params(type: String).void }
         def initialize(type)
-          @message = T.let(
-            "invalid type #{type}. type should be text, currency, date_time, image, document or video",
-            String
-          )
+          @message = "invalid type #{type}. type should be text, currency, date_time, image, document or video"
+
           super
         end
       end
@@ -25,19 +16,29 @@ module WhatsappSdk
       # Returns the parameter type.
       #
       # @returns type [String] Valid options are text, currency, date_time, image, document, video.
-      sig { returns(Type) }
       attr_accessor :type
 
-      class Type < T::Enum
-        extend T::Sig
-
-        enums do
-          Text = new("text")
-          Currency = new("currency")
-          DateTime = new("date_time")
-          Image = new("image")
-          Document = new("document")
-          Video = new("video")
+      module Type
+        TEXT = "text"
+        CURRENCY = "currency"
+        DATE_TIME = "date_time"
+        IMAGE = "image"
+        DOCUMENT = "document"
+        VIDEO = "video"
+        LOCATION = "location"
+
+        TYPES = [
+          TEXT,
+          CURRENCY,
+          DATE_TIME,
+          IMAGE,
+          DOCUMENT,
+          VIDEO,
+          LOCATION
+        ].freeze
+
+        def self.valid?(type)
+          TYPES.include?(type)
         end
       end
 
@@ -46,117 +47,113 @@ module WhatsappSdk
       # For the body component, the character limit is 1024 characters.
       #
       # @returns text [String]
-      sig { returns(T.nilable(String)) }
       attr_accessor :text
 
       # Returns Currency if the parameter object type is currency.
       #
       # @returns currency [Currency]
-      sig { returns(T.nilable(Currency)) }
       attr_accessor :currency
 
       # Returns date_time if the parameter object type is date_time.
       #
       # @returns date_time [DateTime]
-      sig { returns(T.nilable(DateTime)) }
       attr_accessor :date_time
 
       # Returns image if the parameter object type is image.
       #
       # @returns image [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :image
 
       # Returns document if the parameter object type is document.
       #
       # @returns document [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :document
 
       # Returns video if the parameter object type is video.
       #
       # @returns video [Media]
-      sig { returns(T.nilable(Media)) }
       attr_accessor :video
 
-      sig do
-        params(
-          type: T.any(Type, String), text: T.nilable(String), currency: T.nilable(Currency),
-          date_time: T.nilable(DateTime), image: T.nilable(Media), document: T.nilable(Media), video: T.nilable(Media)
-        ).void
-      end
-      def initialize(type:, text: nil, currency: nil, date_time: nil, image: nil, document: nil, video: nil)
-        @type = T.let(deserialize_type(type), Type)
+      # Returns location if the parameter object type is location
+      #
+      # @returns location [Location]
+      attr_accessor :location
+
+      def initialize(
+        type:,
+        text: nil,
+        currency: nil,
+        date_time: nil,
+        image: nil,
+        document: nil,
+        video: nil,
+        location: nil
+      )
+        @type = type
         @text = text
         @currency = currency
         @date_time = date_time
         @image = image
         @document = document
         @video = video
+        @location = location
         validate
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_json
-        json = { type: type.serialize }
-        json[type.serialize.to_sym] = case type.serialize
-                                      when "text"
-                                        text
-                                      when "currency"
-                                        T.must(currency).to_json
-                                      when "date_time"
-                                        T.must(date_time).to_json
-                                      when "image"
-                                        T.must(image).to_json
-                                      when "document"
-                                        T.must(document).to_json
-                                      when "video"
-                                        T.must(video).to_json
-                                      else
-                                        raise "Invalid type: #{type}"
-                                      end
+        json = { type: type }
+        json[type.to_sym] = case type
+                            when "text"
+                              text
+                            when "currency"
+                              currency.to_json
+                            when "date_time"
+                              date_time.to_json
+                            when "image"
+                              image.to_json
+                            when "document"
+                              document.to_json
+                            when "video"
+                              video.to_json
+                            when "location"
+                              location.to_json
+                            else
+                              raise "Invalid type: #{type}"
+                            end
 
         json
       end
 
       private
 
-      sig { params(type: T.any(String, Type)).returns(Type) }
-      def deserialize_type(type)
-        return type if type.is_a?(Type)
-
-        Type.deserialize(type)
-      end
-
-      sig { void }
       def validate
         validate_attributes
         validate_type
       end
 
-      sig { void }
       def validate_type
         return if Type.valid?(type)
 
         raise InvalidType, type
       end
 
-      sig { void }
       def validate_attributes
         [
-          [Type::Text, text],
-          [Type::Currency, currency],
-          [Type::DateTime, date_time],
-          [Type::Image, image],
-          [Type::Document, document],
-          [Type::Video, video]
+          [Type::TEXT, text],
+          [Type::CURRENCY, currency],
+          [Type::DATE_TIME, date_time],
+          [Type::IMAGE, image],
+          [Type::DOCUMENT, document],
+          [Type::VIDEO, video],
+          [Type::LOCATION, location]
         ].each do |type_b, value|
           next unless type == type_b
+          next unless value.nil?
 
-          if value.nil?
-            raise Errors::MissingValue.new(type.serialize,
-                                           "#{type_b} is required when the type is #{type_b}")
-          end
+          raise Errors::MissingValue.new(
+            type,
+            "#{type_b} is required when the type is #{type_b}"
+          )
         end
       end
     end

data/lib/whatsapp_sdk/resource/phone_number.rb

@@ -1,28 +1,16 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class PhoneNumber
-      extend T::Sig
+      attr_accessor :phone, :wa_id, :type
 
-      sig { returns(String) }
-      attr_accessor :phone
-
-      sig { returns(String) }
-      attr_accessor :wa_id
-
-      sig { returns(AddressType) }
-      attr_accessor :type
-
-      sig { params(phone: String, type: AddressType, wa_id: String).void }
       def initialize(phone:, type:, wa_id:)
         @phone = phone
         @type = type
         @wa_id = wa_id
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           phone: @phone,