zavudev 0.20.0 → 0.21.0

data/rbi/zavudev/models/functions/trigger_list_response.rbi

@@ -0,0 +1,152 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    module Functions
+      class TriggerListResponse < Zavudev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Zavudev::Models::Functions::TriggerListResponse,
+              Zavudev::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T::Array[Zavudev::Models::Functions::TriggerListResponse::Trigger]
+          )
+        end
+        attr_accessor :triggers
+
+        sig do
+          params(
+            triggers:
+              T::Array[
+                Zavudev::Models::Functions::TriggerListResponse::Trigger::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(triggers:)
+        end
+
+        sig do
+          override.returns(
+            {
+              triggers:
+                T::Array[
+                  Zavudev::Models::Functions::TriggerListResponse::Trigger
+                ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Trigger < Zavudev::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Zavudev::Models::Functions::TriggerListResponse::Trigger,
+                Zavudev::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(T::Boolean) }
+          attr_accessor :active
+
+          sig { returns(Time) }
+          attr_accessor :created_at
+
+          # Event type that fires the function. See GET /v1/functions/event-types for the
+          # supported list. The special type `cron` fires on a schedule instead of a
+          # messaging event and carries a `cron` expression.
+          sig { returns(String) }
+          attr_accessor :event_type
+
+          sig { returns(String) }
+          attr_accessor :function_id
+
+          sig { returns(Time) }
+          attr_accessor :updated_at
+
+          # 5-field cron expression (minute hour day-of-month month day-of-week), evaluated
+          # in UTC. Present only on `cron` triggers.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :cron
+
+          # Last time the schedule fired. Null until the first fire.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :last_run_at
+
+          # Next scheduled fire time. Present only on `cron` triggers.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :next_run_at
+
+          # Restrict the trigger to a single sender. Null means all senders in the project.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :sender_id
+
+          # A subscription that runs a Zavu Function when a messaging event fires.
+          sig do
+            params(
+              id: String,
+              active: T::Boolean,
+              created_at: Time,
+              event_type: String,
+              function_id: String,
+              updated_at: Time,
+              cron: T.nilable(String),
+              last_run_at: T.nilable(Time),
+              next_run_at: T.nilable(Time),
+              sender_id: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            active:,
+            created_at:,
+            # Event type that fires the function. See GET /v1/functions/event-types for the
+            # supported list. The special type `cron` fires on a schedule instead of a
+            # messaging event and carries a `cron` expression.
+            event_type:,
+            function_id:,
+            updated_at:,
+            # 5-field cron expression (minute hour day-of-month month day-of-week), evaluated
+            # in UTC. Present only on `cron` triggers.
+            cron: nil,
+            # Last time the schedule fired. Null until the first fire.
+            last_run_at: nil,
+            # Next scheduled fire time. Present only on `cron` triggers.
+            next_run_at: nil,
+            # Restrict the trigger to a single sender. Null means all senders in the project.
+            sender_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                active: T::Boolean,
+                created_at: Time,
+                event_type: String,
+                function_id: String,
+                updated_at: Time,
+                cron: T.nilable(String),
+                last_run_at: T.nilable(Time),
+                next_run_at: T.nilable(Time),
+                sender_id: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/zavudev/models/functions/trigger_update_params.rbi

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

data/rbi/zavudev/models/functions/trigger_update_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    module Functions
+      class TriggerUpdateResponse < Zavudev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Zavudev::Models::Functions::TriggerUpdateResponse,
+              Zavudev::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Boolean) }
+        attr_accessor :active
+
+        sig { returns(T::Boolean) }
+        attr_accessor :ok
+
+        sig do
+          params(active: T::Boolean, ok: T::Boolean).returns(T.attached_class)
+        end
+        def self.new(active:, ok:)
+        end
+
+        sig { override.returns({ active: T::Boolean, ok: T::Boolean }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/zavudev/models/introspect_validate_email_params.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class IntrospectValidateEmailParams < Zavudev::Internal::Type::BaseModel
+      extend Zavudev::Internal::Type::RequestParameters::Converter
+      include Zavudev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Zavudev::IntrospectValidateEmailParams,
+            Zavudev::Internal::AnyHash
+          )
+        end
+
+      # Single email address to validate.
+      sig { returns(T.nilable(String)) }
+      attr_reader :email
+
+      sig { params(email: String).void }
+      attr_writer :email
+
+      # Batch of email addresses to validate (max 100).
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :emails
+
+      sig { params(emails: T::Array[String]).void }
+      attr_writer :emails
+
+      sig do
+        params(
+          email: String,
+          emails: T::Array[String],
+          request_options: Zavudev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Single email address to validate.
+        email: nil,
+        # Batch of email addresses to validate (max 100).
+        emails: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            email: String,
+            emails: T::Array[String],
+            request_options: Zavudev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/zavudev/models/introspect_validate_email_response.rbi

@@ -0,0 +1,328 @@
+# typed: strong
+
+module Zavudev
+  module Models
+    class IntrospectValidateEmailResponse < Zavudev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Zavudev::Models::IntrospectValidateEmailResponse,
+            Zavudev::Internal::AnyHash
+          )
+        end
+
+      # One result per submitted address, in the same order.
+      sig do
+        returns(
+          T::Array[Zavudev::Models::IntrospectValidateEmailResponse::Result]
+        )
+      end
+      attr_accessor :results
+
+      sig { returns(Zavudev::Models::IntrospectValidateEmailResponse::Summary) }
+      attr_reader :summary
+
+      sig do
+        params(
+          summary:
+            Zavudev::Models::IntrospectValidateEmailResponse::Summary::OrHash
+        ).void
+      end
+      attr_writer :summary
+
+      sig do
+        params(
+          results:
+            T::Array[
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::OrHash
+            ],
+          summary:
+            Zavudev::Models::IntrospectValidateEmailResponse::Summary::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # One result per submitted address, in the same order.
+        results:,
+        summary:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            results:
+              T::Array[
+                Zavudev::Models::IntrospectValidateEmailResponse::Result
+              ],
+            summary: Zavudev::Models::IntrospectValidateEmailResponse::Summary
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Result < Zavudev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Zavudev::Models::IntrospectValidateEmailResponse::Result,
+              Zavudev::Internal::AnyHash
+            )
+          end
+
+        # Domain part of the address. Null when the syntax is invalid.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :domain
+
+        # The address exactly as submitted.
+        sig { returns(String) }
+        attr_accessor :email
+
+        # Lowercased, trimmed form of the address. Null when the syntax is invalid.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :normalized
+
+        # Signals behind the verdict. Empty for a clean `deliverable` address.
+        sig do
+          returns(
+            T::Array[
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            ]
+          )
+        end
+        attr_accessor :reasons
+
+        # Validation verdict.
+        #
+        # - `deliverable`: nothing suggests the address will bounce.
+        # - `risky`: sendable, but a signal predicts elevated bounce/complaint odds (role
+        #   address, disposable domain, MX-less domain, prior soft bounce).
+        # - `undeliverable`: will bounce or is blocked (invalid syntax, dead domain, or
+        #   the address is on your suppression list after a hard bounce/complaint).
+        sig do
+          returns(
+            Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+          )
+        end
+        attr_accessor :verdict
+
+        sig do
+          params(
+            domain: T.nilable(String),
+            email: String,
+            normalized: T.nilable(String),
+            reasons:
+              T::Array[
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::OrSymbol
+              ],
+            verdict:
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Domain part of the address. Null when the syntax is invalid.
+          domain:,
+          # The address exactly as submitted.
+          email:,
+          # Lowercased, trimmed form of the address. Null when the syntax is invalid.
+          normalized:,
+          # Signals behind the verdict. Empty for a clean `deliverable` address.
+          reasons:,
+          # Validation verdict.
+          #
+          # - `deliverable`: nothing suggests the address will bounce.
+          # - `risky`: sendable, but a signal predicts elevated bounce/complaint odds (role
+          #   address, disposable domain, MX-less domain, prior soft bounce).
+          # - `undeliverable`: will bounce or is blocked (invalid syntax, dead domain, or
+          #   the address is on your suppression list after a hard bounce/complaint).
+          verdict:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              domain: T.nilable(String),
+              email: String,
+              normalized: T.nilable(String),
+              reasons:
+                T::Array[
+                  Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+                ],
+              verdict:
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Reason
+          extend Zavudev::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          INVALID_SYNTAX =
+            T.let(
+              :invalid_syntax,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          DOMAIN_NOT_FOUND =
+            T.let(
+              :domain_not_found,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          DOMAIN_NO_MX =
+            T.let(
+              :domain_no_mx,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          DISPOSABLE_DOMAIN =
+            T.let(
+              :disposable_domain,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          ROLE_ADDRESS =
+            T.let(
+              :role_address,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          SUPPRESSED_HARD_BOUNCE =
+            T.let(
+              :suppressed_hard_bounce,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          SUPPRESSED_SOFT_BOUNCE =
+            T.let(
+              :suppressed_soft_bounce,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          SUPPRESSED_COMPLAINT =
+            T.let(
+              :suppressed_complaint,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          SUPPRESSED_MANUAL =
+            T.let(
+              :suppressed_manual,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+          SUPPRESSED_UNSUBSCRIBE =
+            T.let(
+              :suppressed_unsubscribe,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Reason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # Validation verdict.
+        #
+        # - `deliverable`: nothing suggests the address will bounce.
+        # - `risky`: sendable, but a signal predicts elevated bounce/complaint odds (role
+        #   address, disposable domain, MX-less domain, prior soft bounce).
+        # - `undeliverable`: will bounce or is blocked (invalid syntax, dead domain, or
+        #   the address is on your suppression list after a hard bounce/complaint).
+        module Verdict
+          extend Zavudev::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DELIVERABLE =
+            T.let(
+              :deliverable,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+            )
+          RISKY =
+            T.let(
+              :risky,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+            )
+          UNDELIVERABLE =
+            T.let(
+              :undeliverable,
+              Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Zavudev::Models::IntrospectValidateEmailResponse::Result::Verdict::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class Summary < Zavudev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Zavudev::Models::IntrospectValidateEmailResponse::Summary,
+              Zavudev::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Integer) }
+        attr_accessor :deliverable
+
+        sig { returns(Integer) }
+        attr_accessor :risky
+
+        sig { returns(Integer) }
+        attr_accessor :total
+
+        sig { returns(Integer) }
+        attr_accessor :undeliverable
+
+        sig do
+          params(
+            deliverable: Integer,
+            risky: Integer,
+            total: Integer,
+            undeliverable: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(deliverable:, risky:, total:, undeliverable:)
+        end
+
+        sig do
+          override.returns(
+            {
+              deliverable: Integer,
+              risky: Integer,
+              total: Integer,
+              undeliverable: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/zavudev/models/message.rbi

@@ -16,6 +16,11 @@ module Zavudev
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # Who sent the message. Needed to render a thread: `status` cannot tell the two
+      # apart, because an inbound message is also stored as `delivered`.
+      sig { returns(Zavudev::Message::Direction::TaggedSymbol) }
+      attr_accessor :direction
+
       # Type of message. Non-text types are supported by WhatsApp and Telegram (varies
       # by type).
       #
@@ -120,6 +125,7 @@ module Zavudev
           id: String,
           channel: Zavudev::Channel::OrSymbol,
           created_at: Time,
+          direction: Zavudev::Message::Direction::OrSymbol,
           message_type: Zavudev::MessageType::OrSymbol,
           status: Zavudev::MessageStatus::OrSymbol,
           to: String,
@@ -143,6 +149,9 @@ module Zavudev
         # Delivery channel. Use 'auto' for intelligent routing.
         channel:,
         created_at:,
+        # Who sent the message. Needed to render a thread: `status` cannot tell the two
+        # apart, because an inbound message is also stored as `delivered`.
+        direction:,
         # Type of message. Non-text types are supported by WhatsApp and Telegram (varies
         # by type).
         #
@@ -195,6 +204,7 @@ module Zavudev
             id: String,
             channel: Zavudev::Channel::TaggedSymbol,
             created_at: Time,
+            direction: Zavudev::Message::Direction::TaggedSymbol,
             message_type: Zavudev::MessageType::TaggedSymbol,
             status: Zavudev::MessageStatus::TaggedSymbol,
             to: String,
@@ -216,6 +226,25 @@ module Zavudev
       end
       def to_hash
       end
+
+      # Who sent the message. Needed to render a thread: `status` cannot tell the two
+      # apart, because an inbound message is also stored as `delivered`.
+      module Direction
+        extend Zavudev::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Zavudev::Message::Direction) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INBOUND = T.let(:inbound, Zavudev::Message::Direction::TaggedSymbol)
+        OUTBOUND = T.let(:outbound, Zavudev::Message::Direction::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Zavudev::Message::Direction::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
     end
   end
 end