moonbase-sdk 0.1.0.pre.alpha.1

data/rbi/moonbase/models/call_create_params.rbi

@@ -0,0 +1,263 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class CallCreateParams < Moonbase::Internal::Type::BaseModel
+      extend Moonbase::Internal::Type::RequestParameters::Converter
+      include Moonbase::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::CallCreateParams, Moonbase::Internal::AnyHash)
+        end
+
+      # The direction of the call, either `incoming` or `outgoing`.
+      sig { returns(Moonbase::CallCreateParams::Direction::OrSymbol) }
+      attr_accessor :direction
+
+      # An array of participants involved in the call.
+      sig { returns(T::Array[Moonbase::CallCreateParams::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 time the call started, as an RFC 3339 timestamp.
+      sig { returns(Time) }
+      attr_accessor :start_at
+
+      # The status of the call.
+      sig { returns(Moonbase::CallCreateParams::Status::OrSymbol) }
+      attr_accessor :status
+
+      # The time the call was answered, as an RFC 3339 timestamp.
+      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 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
+
+      sig do
+        params(
+          direction: Moonbase::CallCreateParams::Direction::OrSymbol,
+          participants:
+            T::Array[Moonbase::CallCreateParams::Participant::OrHash],
+          provider: String,
+          provider_id: String,
+          start_at: Time,
+          status: Moonbase::CallCreateParams::Status::OrSymbol,
+          answered_at: Time,
+          end_at: Time,
+          provider_metadata: T::Hash[Symbol, T.anything],
+          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 time the call started, as an RFC 3339 timestamp.
+        start_at:,
+        # The status of the call.
+        status:,
+        # The time the call was answered, as an RFC 3339 timestamp.
+        answered_at: nil,
+        # The time the call ended, as an RFC 3339 timestamp.
+        end_at: nil,
+        # A hash of additional metadata from the provider.
+        provider_metadata: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            direction: Moonbase::CallCreateParams::Direction::OrSymbol,
+            participants: T::Array[Moonbase::CallCreateParams::Participant],
+            provider: String,
+            provider_id: String,
+            start_at: Time,
+            status: Moonbase::CallCreateParams::Status::OrSymbol,
+            answered_at: Time,
+            end_at: Time,
+            provider_metadata: T::Hash[Symbol, T.anything],
+            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::CallCreateParams::Direction) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCOMING =
+          T.let(:incoming, Moonbase::CallCreateParams::Direction::TaggedSymbol)
+        OUTGOING =
+          T.let(:outgoing, Moonbase::CallCreateParams::Direction::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::CallCreateParams::Direction::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Participant < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::CallCreateParams::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::CallCreateParams::Participant::Role::OrSymbol) }
+        attr_accessor :role
+
+        # Parameters for creating a `Participant` object.
+        sig do
+          params(
+            phone: String,
+            role: Moonbase::CallCreateParams::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::CallCreateParams::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::CallCreateParams::Participant::Role)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CALLER =
+            T.let(
+              :caller,
+              Moonbase::CallCreateParams::Participant::Role::TaggedSymbol
+            )
+          CALLEE =
+            T.let(
+              :callee,
+              Moonbase::CallCreateParams::Participant::Role::TaggedSymbol
+            )
+          OTHER =
+            T.let(
+              :other,
+              Moonbase::CallCreateParams::Participant::Role::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Moonbase::CallCreateParams::Participant::Role::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      # The status of the call.
+      module Status
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Moonbase::CallCreateParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED =
+          T.let(:queued, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        INITIATED =
+          T.let(:initiated, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        RINGING =
+          T.let(:ringing, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        IN_PROGRESS =
+          T.let(:in_progress, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        COMPLETED =
+          T.let(:completed, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        BUSY = T.let(:busy, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        FAILED =
+          T.let(:failed, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        NO_ANSWER =
+          T.let(:no_answer, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        CANCELED =
+          T.let(:canceled, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        MISSED =
+          T.let(:missed, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        ANSWERED =
+          T.let(:answered, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        FORWARDED =
+          T.let(:forwarded, Moonbase::CallCreateParams::Status::TaggedSymbol)
+        ABANDONED =
+          T.let(:abandoned, Moonbase::CallCreateParams::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::CallCreateParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/choice.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Choice < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::Choice, Moonbase::Internal::AnyHash) }
+
+      sig { returns(Moonbase::Choice::Option) }
+      attr_reader :option
+
+      sig { params(option: Moonbase::Choice::Option::OrHash).void }
+      attr_writer :option
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Selected choice option
+      sig do
+        params(option: Moonbase::Choice::Option::OrHash, type: Symbol).returns(
+          T.attached_class
+        )
+      end
+      def self.new(option:, type: :"value/choice")
+      end
+
+      sig do
+        override.returns({ option: Moonbase::Choice::Option, type: Symbol })
+      end
+      def to_hash
+      end
+
+      class Option < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Moonbase::Choice::Option, Moonbase::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label
+
+        sig { params(label: String).void }
+        attr_writer :label
+
+        sig do
+          params(id: String, label: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(id:, label: nil, type: :field_option)
+        end
+
+        sig { override.returns({ id: String, type: Symbol, label: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/collection.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Collection < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::Collection, Moonbase::Internal::AnyHash)
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # A hash of related links.
+      sig { returns(Moonbase::Collection::Links) }
+      attr_reader :links
+
+      sig { params(links: Moonbase::Collection::Links::OrHash).void }
+      attr_writer :links
+
+      # The user-facing name of the collection (e.g., “Organizations”).
+      sig { returns(String) }
+      attr_accessor :name
+
+      # A unique, stable, machine-readable identifier for the collection. This reference
+      # is used in API requests and does not change even if the `name` is updated.
+      sig { returns(String) }
+      attr_accessor :ref
+
+      # String representing the object’s type. Always `collection` 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
+
+      # An optional, longer-form description of the collection's purpose.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # A list of `Field` objects that define the schema for items in this collection.
+      sig { returns(T.nilable(T::Array[Moonbase::Field])) }
+      attr_reader :fields
+
+      sig { params(fields: T::Array[Moonbase::Field::OrHash]).void }
+      attr_writer :fields
+
+      # 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
+
+      # A list of saved `View` objects for presenting the collection's data.
+      sig { returns(T.nilable(T::Array[Moonbase::View])) }
+      attr_reader :views
+
+      sig { params(views: T::Array[Moonbase::View]).void }
+      attr_writer :views
+
+      # A Collection is a container for structured data, similar to a database table or
+      # spreadsheet. It defines a schema using a set of `Fields` and holds the data as a
+      # list of `Items`.
+      sig do
+        params(
+          id: String,
+          links: Moonbase::Collection::Links::OrHash,
+          name: String,
+          ref: String,
+          created_at: Time,
+          description: String,
+          fields: T::Array[Moonbase::Field::OrHash],
+          updated_at: Time,
+          views: T::Array[Moonbase::View],
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # A hash of related links.
+        links:,
+        # The user-facing name of the collection (e.g., “Organizations”).
+        name:,
+        # A unique, stable, machine-readable identifier for the collection. This reference
+        # is used in API requests and does not change even if the `name` is updated.
+        ref:,
+        # Time at which the object was created, as an RFC 3339 timestamp.
+        created_at: nil,
+        # An optional, longer-form description of the collection's purpose.
+        description: nil,
+        # A list of `Field` objects that define the schema for items in this collection.
+        fields: nil,
+        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        updated_at: nil,
+        # A list of saved `View` objects for presenting the collection's data.
+        views: nil,
+        # String representing the object’s type. Always `collection` for this object.
+        type: :collection
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            links: Moonbase::Collection::Links,
+            name: String,
+            ref: String,
+            type: Symbol,
+            created_at: Time,
+            description: String,
+            fields: T::Array[Moonbase::Field],
+            updated_at: Time,
+            views: T::Array[Moonbase::View]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Links < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Moonbase::Collection::Links, Moonbase::Internal::AnyHash)
+          end
+
+        # The canonical URL for this object.
+        sig { returns(String) }
+        attr_accessor :self_
+
+        # A hash of related links.
+        sig { params(self_: String).returns(T.attached_class) }
+        def self.new(
+          # The canonical URL for this object.
+          self_:
+        )
+        end
+
+        sig { override.returns({ self_: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/collection_list_params.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class CollectionListParams < Moonbase::Internal::Type::BaseModel
+      extend Moonbase::Internal::Type::RequestParameters::Converter
+      include Moonbase::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::CollectionListParams, 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/collection_retrieve_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class CollectionRetrieveParams < Moonbase::Internal::Type::BaseModel
+      extend Moonbase::Internal::Type::RequestParameters::Converter
+      include Moonbase::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::CollectionRetrieveParams, Moonbase::Internal::AnyHash)
+        end
+
+      # Specifies which related objects to include in the response. Valid options are
+      # `fields` and `views`.
+      sig do
+        returns(
+          T.nilable(
+            T::Array[Moonbase::CollectionRetrieveParams::Include::OrSymbol]
+          )
+        )
+      end
+      attr_reader :include
+
+      sig do
+        params(
+          include:
+            T::Array[Moonbase::CollectionRetrieveParams::Include::OrSymbol]
+        ).void
+      end
+      attr_writer :include
+
+      sig do
+        params(
+          include:
+            T::Array[Moonbase::CollectionRetrieveParams::Include::OrSymbol],
+          request_options: Moonbase::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Specifies which related objects to include in the response. Valid options are
+        # `fields` and `views`.
+        include: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            include:
+              T::Array[Moonbase::CollectionRetrieveParams::Include::OrSymbol],
+            request_options: Moonbase::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Include
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Moonbase::CollectionRetrieveParams::Include)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FIELDS =
+          T.let(
+            :fields,
+            Moonbase::CollectionRetrieveParams::Include::TaggedSymbol
+          )
+        VIEWS =
+          T.let(
+            :views,
+            Moonbase::CollectionRetrieveParams::Include::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::CollectionRetrieveParams::Include::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/collections/field_retrieve_params.rbi

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