moonbase-sdk 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.3

data/rbi/moonbase/models/call_upsert_params.rbi

@@ -0,0 +1,392 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class CallUpsertParams < Moonbase::Internal::Type::BaseModel
+      extend Moonbase::Internal::Type::RequestParameters::Converter
+      include Moonbase::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::CallUpsertParams, Moonbase::Internal::AnyHash)
+        end
+
+      # The direction of the call, either `incoming` or `outgoing`.
+      sig { returns(Moonbase::CallUpsertParams::Direction::OrSymbol) }
+      attr_accessor :direction
+
+      # An array of participants involved in the call.
+      sig { returns(T::Array[Moonbase::CallUpsertParams::Participant]) }
+      attr_accessor :participants
+
+      # The name of the phone provider that handled the call (e.g., `openphone`).
+      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 status of the call.
+      sig { returns(String) }
+      attr_accessor :provider_status
+
+      # The time the call started, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :start_at
+
+      # The time the call was answered, as an ISO 8601 timestamp in UTC.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :answered_at
+
+      sig { params(answered_at: Time).void }
+      attr_writer :answered_at
+
+      # The time the call ended, as an ISO 8601 timestamp in UTC.
+      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
+
+      # Any recordings associated with the call.
+      sig do
+        returns(T.nilable(T::Array[Moonbase::CallUpsertParams::Recording]))
+      end
+      attr_reader :recordings
+
+      sig do
+        params(
+          recordings: T::Array[Moonbase::CallUpsertParams::Recording::OrHash]
+        ).void
+      end
+      attr_writer :recordings
+
+      # A transcript of the call.
+      sig { returns(T.nilable(Moonbase::CallUpsertParams::Transcript)) }
+      attr_reader :transcript
+
+      sig do
+        params(transcript: Moonbase::CallUpsertParams::Transcript::OrHash).void
+      end
+      attr_writer :transcript
+
+      sig do
+        params(
+          direction: Moonbase::CallUpsertParams::Direction::OrSymbol,
+          participants:
+            T::Array[Moonbase::CallUpsertParams::Participant::OrHash],
+          provider: String,
+          provider_id: String,
+          provider_status: String,
+          start_at: Time,
+          answered_at: Time,
+          end_at: Time,
+          provider_metadata: T::Hash[Symbol, T.anything],
+          recordings: T::Array[Moonbase::CallUpsertParams::Recording::OrHash],
+          transcript: Moonbase::CallUpsertParams::Transcript::OrHash,
+          request_options: Moonbase::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The direction of the call, either `incoming` or `outgoing`.
+        direction:,
+        # An array of participants involved in the call.
+        participants:,
+        # The name of the phone provider that handled the call (e.g., `openphone`).
+        provider:,
+        # The unique identifier for the call from the provider's system.
+        provider_id:,
+        # The status of the call.
+        provider_status:,
+        # The time the call started, as an ISO 8601 timestamp in UTC.
+        start_at:,
+        # The time the call was answered, as an ISO 8601 timestamp in UTC.
+        answered_at: nil,
+        # The time the call ended, as an ISO 8601 timestamp in UTC.
+        end_at: nil,
+        # A hash of additional metadata from the provider.
+        provider_metadata: nil,
+        # Any recordings associated with the call.
+        recordings: nil,
+        # A transcript of the call.
+        transcript: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            direction: Moonbase::CallUpsertParams::Direction::OrSymbol,
+            participants: T::Array[Moonbase::CallUpsertParams::Participant],
+            provider: String,
+            provider_id: String,
+            provider_status: String,
+            start_at: Time,
+            answered_at: Time,
+            end_at: Time,
+            provider_metadata: T::Hash[Symbol, T.anything],
+            recordings: T::Array[Moonbase::CallUpsertParams::Recording],
+            transcript: Moonbase::CallUpsertParams::Transcript,
+            request_options: Moonbase::RequestOptions
+          }
+        )
+      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::CallUpsertParams::Direction) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCOMING =
+          T.let(:incoming, Moonbase::CallUpsertParams::Direction::TaggedSymbol)
+        OUTGOING =
+          T.let(:outgoing, Moonbase::CallUpsertParams::Direction::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::CallUpsertParams::Direction::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Participant < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::CallUpsertParams::Participant,
+              Moonbase::Internal::AnyHash
+            )
+          end
+
+        # 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::CallUpsertParams::Participant::Role::OrSymbol) }
+        attr_accessor :role
+
+        # Parameters for creating a `Participant` object.
+        sig do
+          params(
+            phone: String,
+            role: Moonbase::CallUpsertParams::Participant::Role::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              phone: String,
+              role: Moonbase::CallUpsertParams::Participant::Role::OrSymbol
+            }
+          )
+        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 do
+              T.all(Symbol, Moonbase::CallUpsertParams::Participant::Role)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CALLER =
+            T.let(
+              :caller,
+              Moonbase::CallUpsertParams::Participant::Role::TaggedSymbol
+            )
+          CALLEE =
+            T.let(
+              :callee,
+              Moonbase::CallUpsertParams::Participant::Role::TaggedSymbol
+            )
+          OTHER =
+            T.let(
+              :other,
+              Moonbase::CallUpsertParams::Participant::Role::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Moonbase::CallUpsertParams::Participant::Role::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class Recording < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::CallUpsertParams::Recording,
+              Moonbase::Internal::AnyHash
+            )
+          end
+
+        # The content type of the recording. Note that only `audio/mpeg` is supported at
+        # this time.
+        sig { returns(String) }
+        attr_accessor :content_type
+
+        # The unique identifier for the recording from the provider's system.
+        sig { returns(String) }
+        attr_accessor :provider_id
+
+        # The URL pointing to the recording.
+        sig { returns(String) }
+        attr_accessor :url
+
+        # Parameters for creating a `CallRecording` object.
+        sig do
+          params(
+            content_type: String,
+            provider_id: String,
+            url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The content type of the recording. Note that only `audio/mpeg` is supported at
+          # this time.
+          content_type:,
+          # The unique identifier for the recording from the provider's system.
+          provider_id:,
+          # The URL pointing to the recording.
+          url:
+        )
+        end
+
+        sig do
+          override.returns(
+            { content_type: String, provider_id: String, url: String }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Transcript < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::CallUpsertParams::Transcript,
+              Moonbase::Internal::AnyHash
+            )
+          end
+
+        # A list of cues that identify the text spoken in specific time slices of the
+        # call.
+        sig { returns(T::Array[Moonbase::CallUpsertParams::Transcript::Cue]) }
+        attr_accessor :cues
+
+        # A transcript of the call.
+        sig do
+          params(
+            cues: T::Array[Moonbase::CallUpsertParams::Transcript::Cue::OrHash]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A list of cues that identify the text spoken in specific time slices of the
+          # call.
+          cues:
+        )
+        end
+
+        sig do
+          override.returns(
+            { cues: T::Array[Moonbase::CallUpsertParams::Transcript::Cue] }
+          )
+        end
+        def to_hash
+        end
+
+        class Cue < Moonbase::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Moonbase::CallUpsertParams::Transcript::Cue,
+                Moonbase::Internal::AnyHash
+              )
+            end
+
+          # The start time of the slice, in fractional seconds from the start of the call.
+          sig { returns(Float) }
+          attr_accessor :from
+
+          # The E.164 formatted phone number of the speaker.
+          sig { returns(String) }
+          attr_accessor :speaker
+
+          # The text spoken during the slice.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The end time of the slice, in fractional seconds from the start of the call.
+          sig { returns(Float) }
+          attr_accessor :to
+
+          # Parameters for creating a `CallTranscriptCue` object to capture the text spoken
+          # in a specific time slice.
+          sig do
+            params(
+              from: Float,
+              speaker: String,
+              text: String,
+              to: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The start time of the slice, in fractional seconds from the start of the call.
+            from:,
+            # The E.164 formatted phone number of the speaker.
+            speaker:,
+            # The text spoken during the slice.
+            text:,
+            # The end time of the slice, in fractional seconds from the start of the call.
+            to:
+          )
+          end
+
+          sig do
+            override.returns(
+              { from: Float, speaker: String, text: String, to: Float }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/choice_field.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ChoiceField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::ChoiceField, Moonbase::Internal::AnyHash)
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Specifies whether the field can hold a single value (`one`) or multiple values
+      # (`many`).
+      sig { returns(Moonbase::ChoiceField::Cardinality::TaggedSymbol) }
+      attr_accessor :cardinality
+
+      # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # The human-readable name of the field (e.g., "Priority").
+      sig { returns(String) }
+      attr_accessor :name
+
+      # A list of `FieldOption` objects representing the available choices for this
+      # field.
+      sig { returns(T::Array[Moonbase::ChoiceFieldOption]) }
+      attr_accessor :options
+
+      # If `true`, the value of this field is system-managed and cannot be updated via
+      # the API.
+      sig { returns(T::Boolean) }
+      attr_accessor :readonly
+
+      # A unique, stable, machine-readable identifier for the field within its
+      # collection (e.g., `priority`).
+      sig { returns(String) }
+      attr_accessor :ref
+
+      # If `true`, this field must have a value.
+      sig { returns(T::Boolean) }
+      attr_accessor :required
+
+      # The data type of the field. Always `field/choice` for this field.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # If `true`, values for this field must be unique across all items in the
+      # collection.
+      sig { returns(T::Boolean) }
+      attr_accessor :unique
+
+      # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # An optional, longer-form description of the field's purpose.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # A field that stores one or more predefined options from a list of choices.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::ChoiceField::Cardinality::OrSymbol,
+          created_at: Time,
+          name: String,
+          options: T::Array[Moonbase::ChoiceFieldOption::OrHash],
+          readonly: T::Boolean,
+          ref: String,
+          required: T::Boolean,
+          unique: T::Boolean,
+          updated_at: Time,
+          description: String,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # Specifies whether the field can hold a single value (`one`) or multiple values
+        # (`many`).
+        cardinality:,
+        # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+        created_at:,
+        # The human-readable name of the field (e.g., "Priority").
+        name:,
+        # A list of `FieldOption` objects representing the available choices for this
+        # field.
+        options:,
+        # If `true`, the value of this field is system-managed and cannot be updated via
+        # the API.
+        readonly:,
+        # A unique, stable, machine-readable identifier for the field within its
+        # collection (e.g., `priority`).
+        ref:,
+        # If `true`, this field must have a value.
+        required:,
+        # If `true`, values for this field must be unique across all items in the
+        # collection.
+        unique:,
+        # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+        updated_at:,
+        # An optional, longer-form description of the field's purpose.
+        description: nil,
+        # The data type of the field. Always `field/choice` for this field.
+        type: :"field/choice"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality: Moonbase::ChoiceField::Cardinality::TaggedSymbol,
+            created_at: Time,
+            name: String,
+            options: T::Array[Moonbase::ChoiceFieldOption],
+            readonly: T::Boolean,
+            ref: String,
+            required: T::Boolean,
+            type: Symbol,
+            unique: T::Boolean,
+            updated_at: Time,
+            description: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Specifies whether the field can hold a single value (`one`) or multiple values
+      # (`many`).
+      module Cardinality
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Moonbase::ChoiceField::Cardinality) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE = T.let(:one, Moonbase::ChoiceField::Cardinality::TaggedSymbol)
+        MANY = T.let(:many, Moonbase::ChoiceField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::ChoiceField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/choice_field_option.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ChoiceFieldOption < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::ChoiceFieldOption, Moonbase::Internal::AnyHash)
+        end
+
+      # Unique identifier for the option.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The human-readable text displayed for this option.
+      sig { returns(String) }
+      attr_accessor :label
+
+      # String representing the object’s type. Always `choice_field_option` for this
+      # object.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Represents a single selectable option within a choice field.
+      sig do
+        params(id: String, label: String, type: Symbol).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Unique identifier for the option.
+        id:,
+        # The human-readable text displayed for this option.
+        label:,
+        # String representing the object’s type. Always `choice_field_option` for this
+        # object.
+        type: :choice_field_option
+      )
+      end
+
+      sig { override.returns({ id: String, label: String, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/choice_value.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ChoiceValue < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::ChoiceValue, Moonbase::Internal::AnyHash)
+        end
+
+      # An option that must match one of the predefined options for the field.
+      sig { returns(Moonbase::ChoiceFieldOption) }
+      attr_reader :data
+
+      sig { params(data: Moonbase::ChoiceFieldOption::OrHash).void }
+      attr_writer :data
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Selected choice option
+      sig do
+        params(data: Moonbase::ChoiceFieldOption::OrHash, type: Symbol).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # An option that must match one of the predefined options for the field.
+        data:,
+        type: :"value/choice"
+      )
+      end
+
+      sig do
+        override.returns({ data: Moonbase::ChoiceFieldOption, type: Symbol })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/choice_value_param.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ChoiceValueParam < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::ChoiceValueParam, Moonbase::Internal::AnyHash)
+        end
+
+      # An option that must match one of the predefined options for the field.
+      sig { returns(T.any(Moonbase::ChoiceFieldOption, Moonbase::Pointer)) }
+      attr_accessor :data
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Selected choice option
+      sig do
+        params(
+          data:
+            T.any(
+              Moonbase::ChoiceFieldOption::OrHash,
+              Moonbase::Pointer::OrHash
+            ),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An option that must match one of the predefined options for the field.
+        data:,
+        type: :"value/choice"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.any(Moonbase::ChoiceFieldOption, Moonbase::Pointer),
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # An option that must match one of the predefined options for the field.
+      module Data
+        extend Moonbase::Internal::Type::Union
+
+        Variants =
+          T.type_alias { T.any(Moonbase::ChoiceFieldOption, Moonbase::Pointer) }
+
+        sig do
+          override.returns(T::Array[Moonbase::ChoiceValueParam::Data::Variants])
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end