moonbase-sdk 0.1.0.pre.alpha.2 → 0.1.0.pre.alpha.4

data/rbi/moonbase/models/form_retrieve_params.rbi

@@ -11,68 +11,17 @@ module Moonbase
           T.any(Moonbase::FormRetrieveParams, Moonbase::Internal::AnyHash)
         end
 
-      # Specifies which related objects to include in the response. Valid option is
-      # `collection.fields`.
       sig do
-        returns(
-          T.nilable(T::Array[Moonbase::FormRetrieveParams::Include::OrSymbol])
+        params(request_options: Moonbase::RequestOptions::OrHash).returns(
+          T.attached_class
         )
       end
-      attr_reader :include
-
-      sig do
-        params(
-          include: T::Array[Moonbase::FormRetrieveParams::Include::OrSymbol]
-        ).void
-      end
-      attr_writer :include
-
-      sig do
-        params(
-          include: T::Array[Moonbase::FormRetrieveParams::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 option is
-        # `collection.fields`.
-        include: nil,
-        request_options: {}
-      )
+      def self.new(request_options: {})
       end
 
-      sig do
-        override.returns(
-          {
-            include: T::Array[Moonbase::FormRetrieveParams::Include::OrSymbol],
-            request_options: Moonbase::RequestOptions
-          }
-        )
-      end
+      sig { override.returns({ request_options: Moonbase::RequestOptions }) }
       def to_hash
       end
-
-      module Include
-        extend Moonbase::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Moonbase::FormRetrieveParams::Include) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        COLLECTION_FIELDS =
-          T.let(
-            :"collection.fields",
-            Moonbase::FormRetrieveParams::Include::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[Moonbase::FormRetrieveParams::Include::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
-      end
     end
   end
 end

data/rbi/moonbase/models/formatted_text.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class FormattedText < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::FormattedText, Moonbase::Internal::AnyHash)
+        end
+
+      # The content formatted as Markdown text.
+      sig { returns(T.nilable(String)) }
+      attr_reader :markdown
+
+      sig { params(markdown: String).void }
+      attr_writer :markdown
+
+      # Structured content that can be rendered in multiple formats, currently
+      # supporting Markdown.
+      sig { params(markdown: String).returns(T.attached_class) }
+      def self.new(
+        # The content formatted as Markdown text.
+        markdown: nil
+      )
+      end
+
+      sig { override.returns({ markdown: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/funnel.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class Funnel < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::Funnel, Moonbase::Internal::AnyHash) }
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # An ordered list of `FunnelStep` objects that make up the funnel.
+      sig { returns(T::Array[Moonbase::FunnelStep]) }
+      attr_accessor :steps
+
+      # String representing the object’s type. Always `funnel` for this object.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # A Funnel represents a series of steps used to track progression.
+      sig do
+        params(
+          id: String,
+          steps: T::Array[Moonbase::FunnelStep::OrHash],
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # An ordered list of `FunnelStep` objects that make up the funnel.
+        steps:,
+        # String representing the object’s type. Always `funnel` for this object.
+        type: :funnel
+      )
+      end
+
+      sig do
+        override.returns(
+          { id: String, steps: T::Array[Moonbase::FunnelStep], type: Symbol }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/funnel_step.rbi

@@ -8,58 +8,86 @@ module Moonbase
           T.any(Moonbase::FunnelStep, Moonbase::Internal::AnyHash)
         end
 
-      sig { returns(Moonbase::FunnelStep::Step) }
-      attr_reader :step
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
 
-      sig { params(step: Moonbase::FunnelStep::Step::OrHash).void }
-      attr_writer :step
+      # The name of the step.
+      sig { returns(String) }
+      attr_accessor :name
 
+      # The status of the step in the funnel flow.
+      #
+      # - `active`: represents an in progress state within the funnel
+      # - `success`: completed successfully and exited the funnel
+      # - `failure`: exited the funnel without conversion
+      sig { returns(Moonbase::FunnelStep::StepType::OrSymbol) }
+      attr_accessor :step_type
+
+      # String representing the object’s type. Always `funnel_step` for this object.
       sig { returns(Symbol) }
       attr_accessor :type
 
-      # Funnel step value
+      # Represents a single step within a `Funnel`.
       sig do
-        params(step: Moonbase::FunnelStep::Step::OrHash, type: Symbol).returns(
-          T.attached_class
-        )
+        params(
+          id: String,
+          name: String,
+          step_type: Moonbase::FunnelStep::StepType::OrSymbol,
+          type: Symbol
+        ).returns(T.attached_class)
       end
-      def self.new(step:, type: :"value/funnel_step")
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The name of the step.
+        name:,
+        # The status of the step in the funnel flow.
+        #
+        # - `active`: represents an in progress state within the funnel
+        # - `success`: completed successfully and exited the funnel
+        # - `failure`: exited the funnel without conversion
+        step_type:,
+        # String representing the object’s type. Always `funnel_step` for this object.
+        type: :funnel_step
+      )
       end
 
       sig do
-        override.returns({ step: Moonbase::FunnelStep::Step, type: Symbol })
+        override.returns(
+          {
+            id: String,
+            name: String,
+            step_type: Moonbase::FunnelStep::StepType::OrSymbol,
+            type: Symbol
+          }
+        )
       end
       def to_hash
       end
 
-      class Step < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Moonbase::FunnelStep::Step, Moonbase::Internal::AnyHash)
-          end
-
-        sig { returns(String) }
-        attr_accessor :id
+      # The status of the step in the funnel flow.
+      #
+      # - `active`: represents an in progress state within the funnel
+      # - `success`: completed successfully and exited the funnel
+      # - `failure`: exited the funnel without conversion
+      module StepType
+        extend Moonbase::Internal::Type::Enum
 
-        sig { returns(Symbol) }
-        attr_accessor :type
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Moonbase::FunnelStep::StepType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        sig { returns(T.nilable(String)) }
-        attr_reader :name
-
-        sig { params(name: String).void }
-        attr_writer :name
+        ACTIVE = T.let(:active, Moonbase::FunnelStep::StepType::TaggedSymbol)
+        SUCCESS = T.let(:success, Moonbase::FunnelStep::StepType::TaggedSymbol)
+        FAILURE = T.let(:failure, Moonbase::FunnelStep::StepType::TaggedSymbol)
 
         sig do
-          params(id: String, name: String, type: Symbol).returns(
-            T.attached_class
+          override.returns(
+            T::Array[Moonbase::FunnelStep::StepType::TaggedSymbol]
           )
         end
-        def self.new(id:, name: nil, type: :funnel_step)
-        end
-
-        sig { override.returns({ id: String, type: Symbol, name: String }) }
-        def to_hash
+        def self.values
         end
       end
     end

data/rbi/moonbase/models/funnel_step_value.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class FunnelStepValue < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::FunnelStepValue, Moonbase::Internal::AnyHash)
+        end
+
+      # A specific funnel step, as configured on the Funnel
+      sig { returns(Moonbase::FunnelStep) }
+      attr_reader :data
+
+      sig { params(data: Moonbase::FunnelStep::OrHash).void }
+      attr_writer :data
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Funnel step value
+      sig do
+        params(data: Moonbase::FunnelStep::OrHash, type: Symbol).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # A specific funnel step, as configured on the Funnel
+        data:,
+        type: :"value/funnel_step"
+      )
+      end
+
+      sig { override.returns({ data: Moonbase::FunnelStep, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/funnel_step_value_param.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class FunnelStepValueParam < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::FunnelStepValueParam, Moonbase::Internal::AnyHash)
+        end
+
+      # A specific funnel step, as configured on the Funnel
+      sig { returns(T.any(Moonbase::FunnelStep, Moonbase::Pointer)) }
+      attr_accessor :data
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Funnel step value
+      sig do
+        params(
+          data: T.any(Moonbase::FunnelStep::OrHash, Moonbase::Pointer::OrHash),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A specific funnel step, as configured on the Funnel
+        data:,
+        type: :"value/funnel_step"
+      )
+      end
+
+      sig do
+        override.returns(
+          { data: T.any(Moonbase::FunnelStep, Moonbase::Pointer), type: Symbol }
+        )
+      end
+      def to_hash
+      end
+
+      # A specific funnel step, as configured on the Funnel
+      module Data
+        extend Moonbase::Internal::Type::Union
+
+        Variants =
+          T.type_alias { T.any(Moonbase::FunnelStep, Moonbase::Pointer) }
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::FunnelStepValueParam::Data::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/geo_field.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class GeoField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Moonbase::GeoField, Moonbase::Internal::AnyHash) }
+
+      # 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::GeoField::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., "Location").
+      sig { returns(String) }
+      attr_accessor :name
+
+      # 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., `location`).
+      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/geo` 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 geographic coordinates or location data.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::GeoField::Cardinality::OrSymbol,
+          created_at: Time,
+          name: String,
+          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., "Location").
+        name:,
+        # 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., `location`).
+        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/geo` for this field.
+        type: :"field/geo"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality: Moonbase::GeoField::Cardinality::TaggedSymbol,
+            created_at: Time,
+            name: String,
+            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::GeoField::Cardinality) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE = T.let(:one, Moonbase::GeoField::Cardinality::TaggedSymbol)
+        MANY = T.let(:many, Moonbase::GeoField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::GeoField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/geo_value.rbi

@@ -6,18 +6,25 @@ module Moonbase
       OrHash =
         T.type_alias { T.any(Moonbase::GeoValue, Moonbase::Internal::AnyHash) }
 
+      # A string that represents some geographic location. The exact format may vary
+      # based on context.
       sig { returns(String) }
-      attr_accessor :geo
+      attr_accessor :data
 
       sig { returns(Symbol) }
       attr_accessor :type
 
       # Geographic coordinate value
-      sig { params(geo: String, type: Symbol).returns(T.attached_class) }
-      def self.new(geo:, type: :"value/geo")
+      sig { params(data: String, type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # A string that represents some geographic location. The exact format may vary
+        # based on context.
+        data:,
+        type: :"value/geo"
+      )
       end
 
-      sig { override.returns({ geo: String, type: Symbol }) }
+      sig { override.returns({ data: String, type: Symbol }) }
       def to_hash
       end
     end

data/rbi/moonbase/models/inbox.rbi

@@ -10,11 +10,9 @@ module Moonbase
       sig { returns(String) }
       attr_accessor :id
 
-      sig { returns(Moonbase::Inbox::Links) }
-      attr_reader :links
-
-      sig { params(links: Moonbase::Inbox::Links::OrHash).void }
-      attr_writer :links
+      # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
 
       # The display name of the inbox.
       sig { returns(String) }
@@ -24,53 +22,45 @@ module Moonbase
       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 ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
 
       # The `Tagset` associated with this inbox, which defines the tags available for
       # its conversations.
+      #
+      # **Note:** Only present when requested using the `include` query parameter.
       sig { returns(T.nilable(Moonbase::Tagset)) }
       attr_reader :tagset
 
       sig { params(tagset: Moonbase::Tagset::OrHash).void }
       attr_writer :tagset
 
-      # 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 Inbox object represents a shared inbox for receiving and sending messages.
       sig do
         params(
           id: String,
-          links: Moonbase::Inbox::Links::OrHash,
-          name: String,
           created_at: Time,
-          tagset: Moonbase::Tagset::OrHash,
+          name: String,
           updated_at: Time,
+          tagset: Moonbase::Tagset::OrHash,
           type: Symbol
         ).returns(T.attached_class)
       end
       def self.new(
         # Unique identifier for the object.
         id:,
-        links:,
+        # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+        created_at:,
         # The display name of the inbox.
         name:,
-        # 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 ISO 8601 timestamp in UTC.
+        updated_at:,
         # The `Tagset` associated with this inbox, which defines the tags available for
         # its conversations.
+        #
+        # **Note:** Only present when requested using the `include` query parameter.
         tagset: nil,
-        # Time at which the object was last updated, as an RFC 3339 timestamp.
-        updated_at: nil,
         # String representing the object’s type. Always `inbox` for this object.
         type: :inbox
       )
@@ -80,48 +70,16 @@ module Moonbase
         override.returns(
           {
             id: String,
-            links: Moonbase::Inbox::Links,
+            created_at: Time,
             name: String,
             type: Symbol,
-            created_at: Time,
-            tagset: Moonbase::Tagset,
-            updated_at: Time
+            updated_at: Time,
+            tagset: Moonbase::Tagset
           }
         )
       end
       def to_hash
       end
-
-      class Links < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Moonbase::Inbox::Links, Moonbase::Internal::AnyHash)
-          end
-
-        # The canonical URL for this object.
-        sig { returns(String) }
-        attr_accessor :self_
-
-        # A link to the `Tagset` for this inbox.
-        sig { returns(T.nilable(String)) }
-        attr_reader :tagset
-
-        sig { params(tagset: String).void }
-        attr_writer :tagset
-
-        sig { params(self_: String, tagset: String).returns(T.attached_class) }
-        def self.new(
-          # The canonical URL for this object.
-          self_:,
-          # A link to the `Tagset` for this inbox.
-          tagset: nil
-        )
-        end
-
-        sig { override.returns({ self_: String, tagset: String }) }
-        def to_hash
-        end
-      end
     end
   end
 end