revox 0.2.0 → 0.4.0

data/rbi/revox/models/campaign_statistics_response.rbi

@@ -0,0 +1,1069 @@
+# typed: strong
+
+module Revox
+  module Models
+    class CampaignStatisticsResponse < Revox::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Revox::Models::CampaignStatisticsResponse,
+            Revox::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Revox::Models::CampaignStatisticsResponse::Statistics) }
+      attr_reader :statistics
+
+      sig do
+        params(
+          statistics:
+            Revox::Models::CampaignStatisticsResponse::Statistics::OrHash
+        ).void
+      end
+      attr_writer :statistics
+
+      sig do
+        params(
+          statistics:
+            Revox::Models::CampaignStatisticsResponse::Statistics::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(statistics:)
+      end
+
+      sig do
+        override.returns(
+          { statistics: Revox::Models::CampaignStatisticsResponse::Statistics }
+        )
+      end
+      def to_hash
+      end
+
+      class Statistics < Revox::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Revox::Models::CampaignStatisticsResponse::Statistics,
+              Revox::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Revox::Models::CampaignStatisticsResponse::Statistics::Campaign
+          )
+        end
+        attr_reader :campaign
+
+        sig do
+          params(
+            campaign:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::OrHash
+          ).void
+        end
+        attr_writer :campaign
+
+        sig do
+          returns(
+            T.nilable(
+              Revox::Models::CampaignStatisticsResponse::Statistics::DataExtraction
+            )
+          )
+        end
+        attr_reader :data_extraction
+
+        sig do
+          params(
+            data_extraction:
+              T.nilable(
+                Revox::Models::CampaignStatisticsResponse::Statistics::DataExtraction::OrHash
+              )
+          ).void
+        end
+        attr_writer :data_extraction
+
+        sig do
+          returns(Revox::Models::CampaignStatisticsResponse::Statistics::Effort)
+        end
+        attr_reader :effort
+
+        sig do
+          params(
+            effort:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Effort::OrHash
+          ).void
+        end
+        attr_writer :effort
+
+        sig do
+          returns(Revox::Models::CampaignStatisticsResponse::Statistics::Funnel)
+        end
+        attr_reader :funnel
+
+        sig do
+          params(
+            funnel:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::OrHash
+          ).void
+        end
+        attr_writer :funnel
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :hot_lead_outcomes
+
+        sig do
+          returns(
+            Revox::Models::CampaignStatisticsResponse::Statistics::Inbound
+          )
+        end
+        attr_reader :inbound
+
+        sig do
+          params(
+            inbound:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Inbound::OrHash
+          ).void
+        end
+        attr_writer :inbound
+
+        sig do
+          returns(Revox::Models::CampaignStatisticsResponse::Statistics::JumpIn)
+        end
+        attr_reader :jump_in
+
+        sig do
+          params(
+            jump_in:
+              Revox::Models::CampaignStatisticsResponse::Statistics::JumpIn::OrHash
+          ).void
+        end
+        attr_writer :jump_in
+
+        sig do
+          returns(Revox::Models::CampaignStatisticsResponse::Statistics::Leads)
+        end
+        attr_reader :leads
+
+        sig do
+          params(
+            leads:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Leads::OrHash
+          ).void
+        end
+        attr_writer :leads
+
+        sig do
+          returns(
+            T::Array[
+              Revox::Models::CampaignStatisticsResponse::Statistics::OutcomeBreakdown
+            ]
+          )
+        end
+        attr_accessor :outcome_breakdown
+
+        sig do
+          params(
+            campaign:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::OrHash,
+            data_extraction:
+              T.nilable(
+                Revox::Models::CampaignStatisticsResponse::Statistics::DataExtraction::OrHash
+              ),
+            effort:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Effort::OrHash,
+            funnel:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::OrHash,
+            hot_lead_outcomes: T::Array[String],
+            inbound:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Inbound::OrHash,
+            jump_in:
+              Revox::Models::CampaignStatisticsResponse::Statistics::JumpIn::OrHash,
+            leads:
+              Revox::Models::CampaignStatisticsResponse::Statistics::Leads::OrHash,
+            outcome_breakdown:
+              T::Array[
+                Revox::Models::CampaignStatisticsResponse::Statistics::OutcomeBreakdown::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          campaign:,
+          data_extraction:,
+          effort:,
+          funnel:,
+          hot_lead_outcomes:,
+          inbound:,
+          jump_in:,
+          leads:,
+          outcome_breakdown:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              campaign:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign,
+              data_extraction:
+                T.nilable(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::DataExtraction
+                ),
+              effort:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Effort,
+              funnel:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel,
+              hot_lead_outcomes: T::Array[String],
+              inbound:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Inbound,
+              jump_in:
+                Revox::Models::CampaignStatisticsResponse::Statistics::JumpIn,
+              leads:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads,
+              outcome_breakdown:
+                T::Array[
+                  Revox::Models::CampaignStatisticsResponse::Statistics::OutcomeBreakdown
+                ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Campaign < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :agent_name
+
+          sig { returns(T.anything) }
+          attr_accessor :first_activity_at
+
+          sig { returns(T::Boolean) }
+          attr_accessor :has_activity
+
+          sig { returns(T::Boolean) }
+          attr_accessor :is_cancelled
+
+          sig { returns(T.anything) }
+          attr_accessor :last_activity_at
+
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :max_attempts_per_contact
+
+          sig { returns(String) }
+          attr_accessor :name
+
+          sig do
+            returns(
+              Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          sig { returns(String) }
+          attr_accessor :timezone
+
+          sig do
+            params(
+              id: String,
+              agent_name: T.nilable(String),
+              first_activity_at: T.anything,
+              has_activity: T::Boolean,
+              is_cancelled: T::Boolean,
+              last_activity_at: T.anything,
+              max_attempts_per_contact: T.nilable(Float),
+              name: String,
+              status:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::OrSymbol,
+              timezone: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            agent_name:,
+            first_activity_at:,
+            has_activity:,
+            is_cancelled:,
+            last_activity_at:,
+            max_attempts_per_contact:,
+            name:,
+            status:,
+            timezone:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                agent_name: T.nilable(String),
+                first_activity_at: T.anything,
+                has_activity: T::Boolean,
+                is_cancelled: T::Boolean,
+                last_activity_at: T.anything,
+                max_attempts_per_contact: T.nilable(Float),
+                name: String,
+                status:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol,
+                timezone: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Status
+            extend Revox::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            RUNNING =
+              T.let(
+                :running,
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol
+              )
+            PAUSED =
+              T.let(
+                :paused,
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol
+              )
+            COMPLETED =
+              T.let(
+                :completed,
+                Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Campaign::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class DataExtraction < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::DataExtraction,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T::Array[String]) }
+          attr_accessor :fields
+
+          sig { returns(String) }
+          attr_accessor :intro
+
+          sig do
+            params(fields: T::Array[String], intro: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(fields:, intro:)
+          end
+
+          sig { override.returns({ fields: T::Array[String], intro: String }) }
+          def to_hash
+          end
+        end
+
+        class Effort < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Effort,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :calls_total
+
+          sig { returns(Float) }
+          attr_accessor :inbound_calls
+
+          sig { returns(Float) }
+          attr_accessor :outbound_attempts
+
+          sig do
+            params(
+              calls_total: Float,
+              inbound_calls: Float,
+              outbound_attempts: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(calls_total:, inbound_calls:, outbound_attempts:)
+          end
+
+          sig do
+            override.returns(
+              {
+                calls_total: Float,
+                inbound_calls: Float,
+                outbound_attempts: Float
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Funnel < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Called
+            )
+          end
+          attr_reader :called
+
+          sig do
+            params(
+              called:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Called::OrHash
+            ).void
+          end
+          attr_writer :called
+
+          sig do
+            returns(
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::HotLeads
+            )
+          end
+          attr_reader :hot_leads
+
+          sig do
+            params(
+              hot_leads:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::HotLeads::OrHash
+            ).void
+          end
+          attr_writer :hot_leads
+
+          sig do
+            returns(
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Reached
+            )
+          end
+          attr_reader :reached
+
+          sig do
+            params(
+              reached:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Reached::OrHash
+            ).void
+          end
+          attr_writer :reached
+
+          sig do
+            returns(
+              Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::RealExchanges
+            )
+          end
+          attr_reader :real_exchanges
+
+          sig do
+            params(
+              real_exchanges:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::RealExchanges::OrHash
+            ).void
+          end
+          attr_writer :real_exchanges
+
+          sig do
+            params(
+              called:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Called::OrHash,
+              hot_leads:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::HotLeads::OrHash,
+              reached:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Reached::OrHash,
+              real_exchanges:
+                Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::RealExchanges::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(called:, hot_leads:, reached:, real_exchanges:)
+          end
+
+          sig do
+            override.returns(
+              {
+                called:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Called,
+                hot_leads:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::HotLeads,
+                reached:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Reached,
+                real_exchanges:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::RealExchanges
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Called < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Called,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Float) }
+            attr_accessor :count
+
+            sig { returns(Float) }
+            attr_accessor :imported_rows
+
+            sig do
+              params(count: Float, imported_rows: Float).returns(
+                T.attached_class
+              )
+            end
+            def self.new(count:, imported_rows:)
+            end
+
+            sig { override.returns({ count: Float, imported_rows: Float }) }
+            def to_hash
+            end
+          end
+
+          class HotLeads < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::HotLeads,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Float) }
+            attr_accessor :count
+
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :pct_of_reached
+
+            sig do
+              params(count: Float, pct_of_reached: T.nilable(Float)).returns(
+                T.attached_class
+              )
+            end
+            def self.new(count:, pct_of_reached:)
+            end
+
+            sig do
+              override.returns(
+                { count: Float, pct_of_reached: T.nilable(Float) }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          class Reached < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::Reached,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Float) }
+            attr_accessor :count
+
+            sig { returns(Float) }
+            attr_accessor :inbound
+
+            sig { returns(Float) }
+            attr_accessor :outbound
+
+            sig { returns(Float) }
+            attr_accessor :overlap
+
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :pct_of_called
+
+            sig do
+              params(
+                count: Float,
+                inbound: Float,
+                outbound: Float,
+                overlap: Float,
+                pct_of_called: T.nilable(Float)
+              ).returns(T.attached_class)
+            end
+            def self.new(count:, inbound:, outbound:, overlap:, pct_of_called:)
+            end
+
+            sig do
+              override.returns(
+                {
+                  count: Float,
+                  inbound: Float,
+                  outbound: Float,
+                  overlap: Float,
+                  pct_of_called: T.nilable(Float)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          class RealExchanges < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Funnel::RealExchanges,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Float) }
+            attr_accessor :count
+
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :pct_of_reached
+
+            sig do
+              params(count: Float, pct_of_reached: T.nilable(Float)).returns(
+                T.attached_class
+              )
+            end
+            def self.new(count:, pct_of_reached:)
+            end
+
+            sig do
+              override.returns(
+                { count: Float, pct_of_reached: T.nilable(Float) }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class Inbound < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Inbound,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :unique_callers
+
+          sig { params(unique_callers: Float).returns(T.attached_class) }
+          def self.new(unique_callers:)
+          end
+
+          sig { override.returns({ unique_callers: Float }) }
+          def to_hash
+          end
+        end
+
+        class JumpIn < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::JumpIn,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :joined_calls
+
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :median_conversation_seconds
+
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :median_time_to_join_seconds
+
+          sig do
+            params(
+              joined_calls: Float,
+              median_conversation_seconds: T.nilable(Float),
+              median_time_to_join_seconds: T.nilable(Float)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            joined_calls:,
+            median_conversation_seconds:,
+            median_time_to_join_seconds:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                joined_calls: Float,
+                median_conversation_seconds: T.nilable(Float),
+                median_time_to_join_seconds: T.nilable(Float)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Leads < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T::Array[
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested
+              ]
+            )
+          end
+          attr_accessor :callback_requested
+
+          sig do
+            returns(
+              T::Array[
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested
+              ]
+            )
+          end
+          attr_accessor :interested
+
+          sig do
+            params(
+              callback_requested:
+                T::Array[
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::OrHash
+                ],
+              interested:
+                T::Array[
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::OrHash
+                ]
+            ).returns(T.attached_class)
+          end
+          def self.new(callback_requested:, interested:)
+          end
+
+          sig do
+            override.returns(
+              {
+                callback_requested:
+                  T::Array[
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested
+                  ],
+                interested:
+                  T::Array[
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested
+                  ]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class CallbackRequested < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :attempt_id
+
+            sig { returns(String) }
+            attr_accessor :call_id
+
+            sig do
+              returns(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::TaggedSymbol
+              )
+            end
+            attr_accessor :direction
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :email
+
+            sig { returns(T.anything) }
+            attr_accessor :last_activity_at
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(String) }
+            attr_accessor :phone
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :summary
+
+            sig do
+              params(
+                attempt_id: T.nilable(String),
+                call_id: String,
+                direction:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::OrSymbol,
+                email: T.nilable(String),
+                last_activity_at: T.anything,
+                name: String,
+                phone: String,
+                summary: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              attempt_id:,
+              call_id:,
+              direction:,
+              email:,
+              last_activity_at:,
+              name:,
+              phone:,
+              summary:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  attempt_id: T.nilable(String),
+                  call_id: String,
+                  direction:
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::TaggedSymbol,
+                  email: T.nilable(String),
+                  last_activity_at: T.anything,
+                  name: String,
+                  phone: String,
+                  summary: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            module Direction
+              extend Revox::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              INBOUND =
+                T.let(
+                  :inbound,
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::TaggedSymbol
+                )
+              OUTBOUND =
+                T.let(
+                  :outbound,
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::CallbackRequested::Direction::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
+          class Interested < Revox::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested,
+                  Revox::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :attempt_id
+
+            sig { returns(String) }
+            attr_accessor :call_id
+
+            sig do
+              returns(
+                Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::TaggedSymbol
+              )
+            end
+            attr_accessor :direction
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :email
+
+            sig { returns(T.anything) }
+            attr_accessor :last_activity_at
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(String) }
+            attr_accessor :phone
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :summary
+
+            sig do
+              params(
+                attempt_id: T.nilable(String),
+                call_id: String,
+                direction:
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::OrSymbol,
+                email: T.nilable(String),
+                last_activity_at: T.anything,
+                name: String,
+                phone: String,
+                summary: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              attempt_id:,
+              call_id:,
+              direction:,
+              email:,
+              last_activity_at:,
+              name:,
+              phone:,
+              summary:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  attempt_id: T.nilable(String),
+                  call_id: String,
+                  direction:
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::TaggedSymbol,
+                  email: T.nilable(String),
+                  last_activity_at: T.anything,
+                  name: String,
+                  phone: String,
+                  summary: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            module Direction
+              extend Revox::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              INBOUND =
+                T.let(
+                  :inbound,
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::TaggedSymbol
+                )
+              OUTBOUND =
+                T.let(
+                  :outbound,
+                  Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Revox::Models::CampaignStatisticsResponse::Statistics::Leads::Interested::Direction::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+        end
+
+        class OutcomeBreakdown < Revox::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Revox::Models::CampaignStatisticsResponse::Statistics::OutcomeBreakdown,
+                Revox::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :count
+
+          sig { returns(String) }
+          attr_accessor :label
+
+          sig { returns(String) }
+          attr_accessor :outcome
+
+          sig do
+            params(count: Float, label: String, outcome: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(count:, label:, outcome:)
+          end
+
+          sig do
+            override.returns({ count: Float, label: String, outcome: String })
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end