moonbase-sdk 0.1.0.pre.alpha.1

data/rbi/moonbase/models/activity_list_params.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityListParams < Moonbase::Internal::Type::BaseModel
+      extend Moonbase::Internal::Type::RequestParameters::Converter
+      include Moonbase::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::ActivityListParams, Moonbase::Internal::AnyHash)
+        end
+
+      # When specified, returns results starting immediately after the item identified
+      # by this cursor. Use the cursor value from the previous response's metadata to
+      # fetch the next page of results.
+      sig { returns(T.nilable(String)) }
+      attr_reader :after
+
+      sig { params(after: String).void }
+      attr_writer :after
+
+      # When specified, returns results starting immediately before the item identified
+      # by this cursor. Use the cursor value from the response's metadata to fetch the
+      # previous page of results.
+      sig { returns(T.nilable(String)) }
+      attr_reader :before
+
+      sig { params(before: String).void }
+      attr_writer :before
+
+      # Maximum number of items to return per page. Must be between 1 and 100. Defaults
+      # to 20 if not specified.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          after: String,
+          before: String,
+          limit: Integer,
+          request_options: Moonbase::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # When specified, returns results starting immediately after the item identified
+        # by this cursor. Use the cursor value from the previous response's metadata to
+        # fetch the next page of results.
+        after: nil,
+        # When specified, returns results starting immediately before the item identified
+        # by this cursor. Use the cursor value from the response's metadata to fetch the
+        # previous page of results.
+        before: nil,
+        # Maximum number of items to return per page. Must be between 1 and 100. Defaults
+        # to 20 if not specified.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            before: String,
+            limit: Integer,
+            request_options: Moonbase::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_retrieve_params.rbi

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

data/rbi/moonbase/models/address.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Address < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::Address, Moonbase::Internal::AnyHash) }
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The email address.
+      sig { returns(String) }
+      attr_accessor :email
+
+      # String representing the object’s type. Always `address` for this object.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Time at which the object was created, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      # A hash of related links.
+      sig { returns(T.nilable(Moonbase::Address::Links)) }
+      attr_reader :links
+
+      sig { params(links: Moonbase::Address::Links::OrHash).void }
+      attr_writer :links
+
+      # The role of the address in the message. Can be `from`, `reply_to`, `to`, `cc`,
+      # or `bcc`.
+      sig { returns(T.nilable(Moonbase::Address::Role::TaggedSymbol)) }
+      attr_reader :role
+
+      sig { params(role: Moonbase::Address::Role::OrSymbol).void }
+      attr_writer :role
+
+      # Time at which the object was last updated, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      # The Address object represents a recipient or sender of a message. It contains an
+      # email address and can be linked to a person and an organization in your
+      # collections.
+      sig do
+        params(
+          id: String,
+          email: String,
+          created_at: Time,
+          links: Moonbase::Address::Links::OrHash,
+          role: Moonbase::Address::Role::OrSymbol,
+          updated_at: Time,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The email address.
+        email:,
+        # Time at which the object was created, as an RFC 3339 timestamp.
+        created_at: nil,
+        # A hash of related links.
+        links: nil,
+        # The role of the address in the message. Can be `from`, `reply_to`, `to`, `cc`,
+        # or `bcc`.
+        role: nil,
+        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        updated_at: nil,
+        # String representing the object’s type. Always `address` for this object.
+        type: :address
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            email: String,
+            type: Symbol,
+            created_at: Time,
+            links: Moonbase::Address::Links,
+            role: Moonbase::Address::Role::TaggedSymbol,
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Links < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Moonbase::Address::Links, Moonbase::Internal::AnyHash)
+          end
+
+        # A link to the associated `Organization` item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :organization
+
+        sig { params(organization: String).void }
+        attr_writer :organization
+
+        # A link to the associated `Person` item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :person
+
+        sig { params(person: String).void }
+        attr_writer :person
+
+        # A hash of related links.
+        sig do
+          params(organization: String, person: String).returns(T.attached_class)
+        end
+        def self.new(
+          # A link to the associated `Organization` item.
+          organization: nil,
+          # A link to the associated `Person` item.
+          person: nil
+        )
+        end
+
+        sig { override.returns({ organization: String, person: String }) }
+        def to_hash
+        end
+      end
+
+      # The role of the address in the message. Can be `from`, `reply_to`, `to`, `cc`,
+      # or `bcc`.
+      module Role
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Moonbase::Address::Role) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FROM = T.let(:from, Moonbase::Address::Role::TaggedSymbol)
+        REPLY_TO = T.let(:reply_to, Moonbase::Address::Role::TaggedSymbol)
+        TO = T.let(:to, Moonbase::Address::Role::TaggedSymbol)
+        CC = T.let(:cc, Moonbase::Address::Role::TaggedSymbol)
+        BCC = T.let(:bcc, Moonbase::Address::Role::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Moonbase::Address::Role::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/attendee.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Attendee < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::Attendee, Moonbase::Internal::AnyHash) }
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The email address of the attendee.
+      sig { returns(String) }
+      attr_accessor :email
+
+      # A hash of related links.
+      sig { returns(Moonbase::Attendee::Links) }
+      attr_reader :links
+
+      sig { params(links: Moonbase::Attendee::Links::OrHash).void }
+      attr_writer :links
+
+      # String representing the object’s type. Always `attendee` for this object.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Time at which the object was created, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      # Time at which the object was last updated, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      # The Attendee object represents a participant in a meeting. It includes their
+      # email address and links to associated `Person` and `Organization` items, if they
+      # exist in your collections.
+      sig do
+        params(
+          id: String,
+          email: String,
+          links: Moonbase::Attendee::Links::OrHash,
+          created_at: Time,
+          updated_at: Time,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The email address of the attendee.
+        email:,
+        # A hash of related links.
+        links:,
+        # Time at which the object was created, as an RFC 3339 timestamp.
+        created_at: nil,
+        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        updated_at: nil,
+        # String representing the object’s type. Always `attendee` for this object.
+        type: :attendee
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            email: String,
+            links: Moonbase::Attendee::Links,
+            type: Symbol,
+            created_at: Time,
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Links < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Moonbase::Attendee::Links, Moonbase::Internal::AnyHash)
+          end
+
+        # A link to the associated `Organization` item.
+        sig { returns(String) }
+        attr_accessor :organization
+
+        # A link to the associated `Person` item.
+        sig { returns(String) }
+        attr_accessor :person
+
+        # A hash of related links.
+        sig do
+          params(organization: String, person: String).returns(T.attached_class)
+        end
+        def self.new(
+          # A link to the associated `Organization` item.
+          organization:,
+          # A link to the associated `Person` item.
+          person:
+        )
+        end
+
+        sig { override.returns({ organization: String, person: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/boolean_value.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class BooleanValue < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::BooleanValue, Moonbase::Internal::AnyHash)
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :boolean
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # True or false value
+      sig do
+        params(boolean: T::Boolean, type: Symbol).returns(T.attached_class)
+      end
+      def self.new(boolean:, type: :"value/boolean")
+      end
+
+      sig { override.returns({ boolean: T::Boolean, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/call.rbi

@@ -0,0 +1,293 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Call < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::Call, Moonbase::Internal::AnyHash) }
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The direction of the call, either `incoming` or `outgoing`.
+      sig { returns(Moonbase::Call::Direction::TaggedSymbol) }
+      attr_accessor :direction
+
+      # The participants involved in the call.
+      sig { returns(T::Array[Moonbase::Call::Participant]) }
+      attr_accessor :participants
+
+      # The name of the phone provider that handled the call.
+      sig { returns(String) }
+      attr_accessor :provider
+
+      # The unique identifier for the call from the provider's system.
+      sig { returns(String) }
+      attr_accessor :provider_id
+
+      # The time the call started, as an RFC 3339 timestamp.
+      sig { returns(Time) }
+      attr_accessor :start_at
+
+      # The current status of the call.
+      sig { returns(Moonbase::Call::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # String representing the object’s type. Always `call` for this object.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # The time the call was answered, if available, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :answered_at
+
+      sig { params(answered_at: Time).void }
+      attr_writer :answered_at
+
+      # Time at which the object was created, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      # The time the call ended, if available, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :end_at
+
+      sig { params(end_at: Time).void }
+      attr_writer :end_at
+
+      # A hash of additional metadata from the provider.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :provider_metadata
+
+      sig { params(provider_metadata: T::Hash[Symbol, T.anything]).void }
+      attr_writer :provider_metadata
+
+      # Time at which the object was last updated, as an RFC 3339 timestamp.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      # The Call object represents a phone call that has been logged in the system. It
+      # contains details about the participants, timing, and outcome of the call.
+      sig do
+        params(
+          id: String,
+          direction: Moonbase::Call::Direction::OrSymbol,
+          participants: T::Array[Moonbase::Call::Participant::OrHash],
+          provider: String,
+          provider_id: String,
+          start_at: Time,
+          status: Moonbase::Call::Status::OrSymbol,
+          answered_at: Time,
+          created_at: Time,
+          end_at: Time,
+          provider_metadata: T::Hash[Symbol, T.anything],
+          updated_at: Time,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The direction of the call, either `incoming` or `outgoing`.
+        direction:,
+        # The participants involved in the call.
+        participants:,
+        # The name of the phone provider that handled the call.
+        provider:,
+        # The unique identifier for the call from the provider's system.
+        provider_id:,
+        # The time the call started, as an RFC 3339 timestamp.
+        start_at:,
+        # The current status of the call.
+        status:,
+        # The time the call was answered, if available, as an RFC 3339 timestamp.
+        answered_at: nil,
+        # Time at which the object was created, as an RFC 3339 timestamp.
+        created_at: nil,
+        # The time the call ended, if available, as an RFC 3339 timestamp.
+        end_at: nil,
+        # A hash of additional metadata from the provider.
+        provider_metadata: nil,
+        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        updated_at: nil,
+        # String representing the object’s type. Always `call` for this object.
+        type: :call
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            direction: Moonbase::Call::Direction::TaggedSymbol,
+            participants: T::Array[Moonbase::Call::Participant],
+            provider: String,
+            provider_id: String,
+            start_at: Time,
+            status: Moonbase::Call::Status::TaggedSymbol,
+            type: Symbol,
+            answered_at: Time,
+            created_at: Time,
+            end_at: Time,
+            provider_metadata: T::Hash[Symbol, T.anything],
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The direction of the call, either `incoming` or `outgoing`.
+      module Direction
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Moonbase::Call::Direction) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCOMING = T.let(:incoming, Moonbase::Call::Direction::TaggedSymbol)
+        OUTGOING = T.let(:outgoing, Moonbase::Call::Direction::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Moonbase::Call::Direction::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      class Participant < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Moonbase::Call::Participant, Moonbase::Internal::AnyHash)
+          end
+
+        # Unique identifier for the object.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The E.164 formatted phone number of the participant.
+        sig { returns(String) }
+        attr_accessor :phone
+
+        # The role of the participant in the call. Can be `caller`, `callee`, or `other`.
+        sig { returns(Moonbase::Call::Participant::Role::TaggedSymbol) }
+        attr_accessor :role
+
+        # String representing the object’s type. Always `participant` for this object.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Time at which the object was created, as an RFC 3339 timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :created_at
+
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
+
+        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :updated_at
+
+        sig { params(updated_at: Time).void }
+        attr_writer :updated_at
+
+        # Represents a participant in a call.
+        sig do
+          params(
+            id: String,
+            phone: String,
+            role: Moonbase::Call::Participant::Role::OrSymbol,
+            created_at: Time,
+            updated_at: Time,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique identifier for the object.
+          id:,
+          # The E.164 formatted phone number of the participant.
+          phone:,
+          # The role of the participant in the call. Can be `caller`, `callee`, or `other`.
+          role:,
+          # Time at which the object was created, as an RFC 3339 timestamp.
+          created_at: nil,
+          # Time at which the object was last updated, as an RFC 3339 timestamp.
+          updated_at: nil,
+          # String representing the object’s type. Always `participant` for this object.
+          type: :participant
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              phone: String,
+              role: Moonbase::Call::Participant::Role::TaggedSymbol,
+              type: Symbol,
+              created_at: Time,
+              updated_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The role of the participant in the call. Can be `caller`, `callee`, or `other`.
+        module Role
+          extend Moonbase::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Moonbase::Call::Participant::Role) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CALLER =
+            T.let(:caller, Moonbase::Call::Participant::Role::TaggedSymbol)
+          CALLEE =
+            T.let(:callee, Moonbase::Call::Participant::Role::TaggedSymbol)
+          OTHER = T.let(:other, Moonbase::Call::Participant::Role::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Moonbase::Call::Participant::Role::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      # The current status of the call.
+      module Status
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Moonbase::Call::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED = T.let(:queued, Moonbase::Call::Status::TaggedSymbol)
+        INITIATED = T.let(:initiated, Moonbase::Call::Status::TaggedSymbol)
+        RINGING = T.let(:ringing, Moonbase::Call::Status::TaggedSymbol)
+        IN_PROGRESS = T.let(:in_progress, Moonbase::Call::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, Moonbase::Call::Status::TaggedSymbol)
+        BUSY = T.let(:busy, Moonbase::Call::Status::TaggedSymbol)
+        FAILED = T.let(:failed, Moonbase::Call::Status::TaggedSymbol)
+        NO_ANSWER = T.let(:no_answer, Moonbase::Call::Status::TaggedSymbol)
+        CANCELED = T.let(:canceled, Moonbase::Call::Status::TaggedSymbol)
+        MISSED = T.let(:missed, Moonbase::Call::Status::TaggedSymbol)
+        ANSWERED = T.let(:answered, Moonbase::Call::Status::TaggedSymbol)
+        FORWARDED = T.let(:forwarded, Moonbase::Call::Status::TaggedSymbol)
+        ABANDONED = T.let(:abandoned, Moonbase::Call::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Moonbase::Call::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end