zavudev 0.0.2

data/rbi/zavudev/models/message_list_params.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class MessageListParams < Zavudev::Internal::Type::BaseModel
+      extend Zavudev::Internal::Type::RequestParameters::Converter
+      include Zavudev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::MessageListParams, Zavudev::Internal::AnyHash)
+        end
+
+      # Delivery channel. Use 'auto' for intelligent routing.
+      sig { returns(T.nilable(Zavudev::Channel::OrSymbol)) }
+      attr_reader :channel
+
+      sig { params(channel: Zavudev::Channel::OrSymbol).void }
+      attr_writer :channel
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig { returns(T.nilable(Zavudev::MessageStatus::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Zavudev::MessageStatus::OrSymbol).void }
+      attr_writer :status
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :to
+
+      sig { params(to: String).void }
+      attr_writer :to
+
+      sig do
+        params(
+          channel: Zavudev::Channel::OrSymbol,
+          cursor: String,
+          limit: Integer,
+          status: Zavudev::MessageStatus::OrSymbol,
+          to: String,
+          request_options: Zavudev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Delivery channel. Use 'auto' for intelligent routing.
+        channel: nil,
+        cursor: nil,
+        limit: nil,
+        status: nil,
+        to: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: Zavudev::Channel::OrSymbol,
+            cursor: String,
+            limit: Integer,
+            status: Zavudev::MessageStatus::OrSymbol,
+            to: String,
+            request_options: Zavudev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_react_params.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class MessageReactParams < Zavudev::Internal::Type::BaseModel
+      extend Zavudev::Internal::Type::RequestParameters::Converter
+      include Zavudev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::MessageReactParams, Zavudev::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :message_id
+
+      # Single emoji character to react with.
+      sig { returns(String) }
+      attr_accessor :emoji
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :zavu_sender
+
+      sig { params(zavu_sender: String).void }
+      attr_writer :zavu_sender
+
+      sig do
+        params(
+          message_id: String,
+          emoji: String,
+          zavu_sender: String,
+          request_options: Zavudev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        message_id:,
+        # Single emoji character to react with.
+        emoji:,
+        zavu_sender: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            message_id: String,
+            emoji: String,
+            zavu_sender: String,
+            request_options: Zavudev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_response.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class MessageResponse < Zavudev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::MessageResponse, Zavudev::Internal::AnyHash)
+        end
+
+      sig { returns(Zavudev::Message) }
+      attr_reader :message
+
+      sig { params(message: Zavudev::Message::OrHash).void }
+      attr_writer :message
+
+      sig do
+        params(message: Zavudev::Message::OrHash).returns(T.attached_class)
+      end
+      def self.new(message:)
+      end
+
+      sig { override.returns({ message: Zavudev::Message }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_retrieve_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class MessageRetrieveParams < Zavudev::Internal::Type::BaseModel
+      extend Zavudev::Internal::Type::RequestParameters::Converter
+      include Zavudev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::MessageRetrieveParams, Zavudev::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :message_id
+
+      sig do
+        params(
+          message_id: String,
+          request_options: Zavudev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(message_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { message_id: String, request_options: Zavudev::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_send_params.rbi

@@ -0,0 +1,181 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class MessageSendParams < Zavudev::Internal::Type::BaseModel
+      extend Zavudev::Internal::Type::RequestParameters::Converter
+      include Zavudev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::MessageSendParams, Zavudev::Internal::AnyHash)
+        end
+
+      # Recipient phone number in E.164 format or email address.
+      sig { returns(String) }
+      attr_accessor :to
+
+      # Delivery channel. Use 'auto' for intelligent routing. If omitted with non-text
+      # messageType, WhatsApp is used. For email recipients, defaults to 'email'.
+      sig { returns(T.nilable(Zavudev::Channel::OrSymbol)) }
+      attr_reader :channel
+
+      sig { params(channel: Zavudev::Channel::OrSymbol).void }
+      attr_writer :channel
+
+      # Additional content for non-text message types.
+      sig { returns(T.nilable(Zavudev::MessageContent)) }
+      attr_reader :content
+
+      sig { params(content: Zavudev::MessageContent::OrHash).void }
+      attr_writer :content
+
+      # Whether to enable automatic fallback to SMS if WhatsApp fails. Defaults to true.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :fallback_enabled
+
+      sig { params(fallback_enabled: T::Boolean).void }
+      attr_writer :fallback_enabled
+
+      # HTML body for email messages. If provided, email will be sent as multipart with
+      # both text and HTML.
+      sig { returns(T.nilable(String)) }
+      attr_reader :html_body
+
+      sig { params(html_body: String).void }
+      attr_writer :html_body
+
+      # Optional idempotency key to avoid duplicate sends.
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      # Type of message. Defaults to 'text'.
+      sig { returns(T.nilable(Zavudev::MessageType::OrSymbol)) }
+      attr_reader :message_type
+
+      sig { params(message_type: Zavudev::MessageType::OrSymbol).void }
+      attr_writer :message_type
+
+      # Arbitrary metadata to associate with the message.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      # Reply-To email address for email messages.
+      sig { returns(T.nilable(String)) }
+      attr_reader :reply_to
+
+      sig { params(reply_to: String).void }
+      attr_writer :reply_to
+
+      # Email subject line. Required when channel is 'email' or recipient is an email
+      # address.
+      sig { returns(T.nilable(String)) }
+      attr_reader :subject
+
+      sig { params(subject: String).void }
+      attr_writer :subject
+
+      # Text body for text messages or caption for media messages.
+      sig { returns(T.nilable(String)) }
+      attr_reader :text
+
+      sig { params(text: String).void }
+      attr_writer :text
+
+      # Language code for voice text-to-speech (e.g., 'en-US', 'es-ES', 'pt-BR'). If
+      # omitted, language is auto-detected from recipient's country code.
+      sig { returns(T.nilable(String)) }
+      attr_reader :voice_language
+
+      sig { params(voice_language: String).void }
+      attr_writer :voice_language
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :zavu_sender
+
+      sig { params(zavu_sender: String).void }
+      attr_writer :zavu_sender
+
+      sig do
+        params(
+          to: String,
+          channel: Zavudev::Channel::OrSymbol,
+          content: Zavudev::MessageContent::OrHash,
+          fallback_enabled: T::Boolean,
+          html_body: String,
+          idempotency_key: String,
+          message_type: Zavudev::MessageType::OrSymbol,
+          metadata: T::Hash[Symbol, String],
+          reply_to: String,
+          subject: String,
+          text: String,
+          voice_language: String,
+          zavu_sender: String,
+          request_options: Zavudev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Recipient phone number in E.164 format or email address.
+        to:,
+        # Delivery channel. Use 'auto' for intelligent routing. If omitted with non-text
+        # messageType, WhatsApp is used. For email recipients, defaults to 'email'.
+        channel: nil,
+        # Additional content for non-text message types.
+        content: nil,
+        # Whether to enable automatic fallback to SMS if WhatsApp fails. Defaults to true.
+        fallback_enabled: nil,
+        # HTML body for email messages. If provided, email will be sent as multipart with
+        # both text and HTML.
+        html_body: nil,
+        # Optional idempotency key to avoid duplicate sends.
+        idempotency_key: nil,
+        # Type of message. Defaults to 'text'.
+        message_type: nil,
+        # Arbitrary metadata to associate with the message.
+        metadata: nil,
+        # Reply-To email address for email messages.
+        reply_to: nil,
+        # Email subject line. Required when channel is 'email' or recipient is an email
+        # address.
+        subject: nil,
+        # Text body for text messages or caption for media messages.
+        text: nil,
+        # Language code for voice text-to-speech (e.g., 'en-US', 'es-ES', 'pt-BR'). If
+        # omitted, language is auto-detected from recipient's country code.
+        voice_language: nil,
+        zavu_sender: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            to: String,
+            channel: Zavudev::Channel::OrSymbol,
+            content: Zavudev::MessageContent,
+            fallback_enabled: T::Boolean,
+            html_body: String,
+            idempotency_key: String,
+            message_type: Zavudev::MessageType::OrSymbol,
+            metadata: T::Hash[Symbol, String],
+            reply_to: String,
+            subject: String,
+            text: String,
+            voice_language: String,
+            zavu_sender: String,
+            request_options: Zavudev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_status.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    module MessageStatus
+      extend Zavudev::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Zavudev::MessageStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      QUEUED = T.let(:queued, Zavudev::MessageStatus::TaggedSymbol)
+      SENDING = T.let(:sending, Zavudev::MessageStatus::TaggedSymbol)
+      SENT = T.let(:sent, Zavudev::MessageStatus::TaggedSymbol)
+      DELIVERED = T.let(:delivered, Zavudev::MessageStatus::TaggedSymbol)
+      FAILED = T.let(:failed, Zavudev::MessageStatus::TaggedSymbol)
+      RECEIVED = T.let(:received, Zavudev::MessageStatus::TaggedSymbol)
+      PENDING_URL_VERIFICATION =
+        T.let(:pending_url_verification, Zavudev::MessageStatus::TaggedSymbol)
+
+      sig { override.returns(T::Array[Zavudev::MessageStatus::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message_type.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    # Type of message. Non-text types are supported by WhatsApp and Telegram (varies
+    # by type).
+    module MessageType
+      extend Zavudev::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Zavudev::MessageType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      TEXT = T.let(:text, Zavudev::MessageType::TaggedSymbol)
+      IMAGE = T.let(:image, Zavudev::MessageType::TaggedSymbol)
+      VIDEO = T.let(:video, Zavudev::MessageType::TaggedSymbol)
+      AUDIO = T.let(:audio, Zavudev::MessageType::TaggedSymbol)
+      DOCUMENT = T.let(:document, Zavudev::MessageType::TaggedSymbol)
+      STICKER = T.let(:sticker, Zavudev::MessageType::TaggedSymbol)
+      LOCATION = T.let(:location, Zavudev::MessageType::TaggedSymbol)
+      CONTACT = T.let(:contact, Zavudev::MessageType::TaggedSymbol)
+      BUTTONS = T.let(:buttons, Zavudev::MessageType::TaggedSymbol)
+      LIST = T.let(:list, Zavudev::MessageType::TaggedSymbol)
+      REACTION = T.let(:reaction, Zavudev::MessageType::TaggedSymbol)
+      TEMPLATE = T.let(:template, Zavudev::MessageType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Zavudev::MessageType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/zavudev/models/owned_phone_number.rbi

@@ -0,0 +1,108 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class OwnedPhoneNumber < Zavudev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::OwnedPhoneNumber, Zavudev::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T::Array[String]) }
+      attr_accessor :capabilities
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(String) }
+      attr_accessor :phone_number
+
+      sig { returns(Zavudev::OwnedPhoneNumberPricing) }
+      attr_reader :pricing
+
+      sig { params(pricing: Zavudev::OwnedPhoneNumberPricing::OrHash).void }
+      attr_writer :pricing
+
+      sig { returns(Zavudev::PhoneNumberStatus::TaggedSymbol) }
+      attr_accessor :status
+
+      # Optional custom name for the phone number.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :next_renewal_date
+
+      sig { params(next_renewal_date: Time).void }
+      attr_writer :next_renewal_date
+
+      # Sender ID if the phone number is assigned to a sender.
+      sig { returns(T.nilable(String)) }
+      attr_reader :sender_id
+
+      sig { params(sender_id: String).void }
+      attr_writer :sender_id
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      sig do
+        params(
+          id: String,
+          capabilities: T::Array[String],
+          created_at: Time,
+          phone_number: String,
+          pricing: Zavudev::OwnedPhoneNumberPricing::OrHash,
+          status: Zavudev::PhoneNumberStatus::OrSymbol,
+          name: String,
+          next_renewal_date: Time,
+          sender_id: String,
+          updated_at: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        capabilities:,
+        created_at:,
+        phone_number:,
+        pricing:,
+        status:,
+        # Optional custom name for the phone number.
+        name: nil,
+        next_renewal_date: nil,
+        # Sender ID if the phone number is assigned to a sender.
+        sender_id: nil,
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            capabilities: T::Array[String],
+            created_at: Time,
+            phone_number: String,
+            pricing: Zavudev::OwnedPhoneNumberPricing,
+            status: Zavudev::PhoneNumberStatus::TaggedSymbol,
+            name: String,
+            next_renewal_date: Time,
+            sender_id: String,
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/owned_phone_number_pricing.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class OwnedPhoneNumberPricing < Zavudev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::OwnedPhoneNumberPricing, Zavudev::Internal::AnyHash)
+        end
+
+      # Whether this is a free number.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_free_number
+
+      sig { params(is_free_number: T::Boolean).void }
+      attr_writer :is_free_number
+
+      # Monthly cost in cents.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :monthly_cost
+
+      sig { params(monthly_cost: Float).void }
+      attr_writer :monthly_cost
+
+      # Monthly price in USD.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :monthly_price
+
+      sig { params(monthly_price: Float).void }
+      attr_writer :monthly_price
+
+      # One-time purchase cost in cents.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :upfront_cost
+
+      sig { params(upfront_cost: Float).void }
+      attr_writer :upfront_cost
+
+      sig do
+        params(
+          is_free_number: T::Boolean,
+          monthly_cost: Float,
+          monthly_price: Float,
+          upfront_cost: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Whether this is a free number.
+        is_free_number: nil,
+        # Monthly cost in cents.
+        monthly_cost: nil,
+        # Monthly price in USD.
+        monthly_price: nil,
+        # One-time purchase cost in cents.
+        upfront_cost: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            is_free_number: T::Boolean,
+            monthly_cost: Float,
+            monthly_price: Float,
+            upfront_cost: Float
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/phone_number_capabilities.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class PhoneNumberCapabilities < Zavudev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Zavudev::PhoneNumberCapabilities, Zavudev::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :mms
+
+      sig { params(mms: T::Boolean).void }
+      attr_writer :mms
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :sms
+
+      sig { params(sms: T::Boolean).void }
+      attr_writer :sms
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :voice
+
+      sig { params(voice: T::Boolean).void }
+      attr_writer :voice
+
+      sig do
+        params(mms: T::Boolean, sms: T::Boolean, voice: T::Boolean).returns(
+          T.attached_class
+        )
+      end
+      def self.new(mms: nil, sms: nil, voice: nil)
+      end
+
+      sig do
+        override.returns(
+          { mms: T::Boolean, sms: T::Boolean, voice: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end