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

data/rbi/moonbase/models/field_value_param.rbi

@@ -0,0 +1,237 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    # A field can be null, a single value, or an array of values
+    module FieldValueParam
+      extend Moonbase::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Moonbase::SingleLineTextValue,
+            Moonbase::MultiLineTextValue,
+            Moonbase::IntegerValue,
+            Moonbase::FloatValue,
+            Moonbase::MonetaryValue,
+            Moonbase::PercentageValue,
+            Moonbase::BooleanValue,
+            Moonbase::EmailValue,
+            Moonbase::URLValue,
+            Moonbase::DomainValue,
+            Moonbase::FieldValueParam::SocialXValueParam,
+            Moonbase::FieldValueParam::SocialLinkedInValueParam,
+            Moonbase::TelephoneNumber,
+            Moonbase::GeoValue,
+            Moonbase::DateValue,
+            Moonbase::DatetimeValue,
+            Moonbase::ChoiceValueParam,
+            Moonbase::FunnelStepValueParam,
+            Moonbase::RelationValueParam,
+            T::Array[Moonbase::ValueParam::Variants]
+          )
+        end
+
+      class SocialXValueParam < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::FieldValueParam::SocialXValueParam,
+              Moonbase::Internal::AnyHash
+            )
+          end
+
+        # Social media profile information including both the full URL and extracted
+        # username.
+        sig { returns(Moonbase::FieldValueParam::SocialXValueParam::Data) }
+        attr_reader :data
+
+        sig do
+          params(
+            data: Moonbase::FieldValueParam::SocialXValueParam::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The social media profile for the X (formerly Twitter) platform
+        sig do
+          params(
+            data: Moonbase::FieldValueParam::SocialXValueParam::Data::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Social media profile information including both the full URL and extracted
+          # username.
+          data:,
+          type: :"value/uri/social_x"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Moonbase::FieldValueParam::SocialXValueParam::Data,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Moonbase::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Moonbase::FieldValueParam::SocialXValueParam::Data,
+                Moonbase::Internal::AnyHash
+              )
+            end
+
+          # The full URL to the X profile, starting with 'https://x.com/'
+          sig { returns(T.nilable(String)) }
+          attr_reader :url
+
+          sig { params(url: String).void }
+          attr_writer :url
+
+          # The X username, up to 15 characters long, containing only lowercase letters
+          # (a-z), uppercase letters (A-Z), numbers (0-9), and underscores (\_). Does not
+          # include the '@' symbol prefix.
+          sig { returns(T.nilable(String)) }
+          attr_reader :username
+
+          sig { params(username: String).void }
+          attr_writer :username
+
+          # Social media profile information including both the full URL and extracted
+          # username.
+          sig do
+            params(url: String, username: String).returns(T.attached_class)
+          end
+          def self.new(
+            # The full URL to the X profile, starting with 'https://x.com/'
+            url: nil,
+            # The X username, up to 15 characters long, containing only lowercase letters
+            # (a-z), uppercase letters (A-Z), numbers (0-9), and underscores (\_). Does not
+            # include the '@' symbol prefix.
+            username: nil
+          )
+          end
+
+          sig { override.returns({ url: String, username: String }) }
+          def to_hash
+          end
+        end
+      end
+
+      class SocialLinkedInValueParam < Moonbase::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Moonbase::FieldValueParam::SocialLinkedInValueParam,
+              Moonbase::Internal::AnyHash
+            )
+          end
+
+        # The social media profile for the LinkedIn platform
+        sig do
+          returns(Moonbase::FieldValueParam::SocialLinkedInValueParam::Data)
+        end
+        attr_reader :data
+
+        sig do
+          params(
+            data:
+              Moonbase::FieldValueParam::SocialLinkedInValueParam::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The social media profile for the LinkedIn platform
+        sig do
+          params(
+            data:
+              Moonbase::FieldValueParam::SocialLinkedInValueParam::Data::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The social media profile for the LinkedIn platform
+          data:,
+          type: :"value/uri/social_linked_in"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Moonbase::FieldValueParam::SocialLinkedInValueParam::Data,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Moonbase::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Moonbase::FieldValueParam::SocialLinkedInValueParam::Data,
+                Moonbase::Internal::AnyHash
+              )
+            end
+
+          # The full URL to the LinkedIn profile.
+          sig { returns(T.nilable(String)) }
+          attr_reader :url
+
+          sig { params(url: String).void }
+          attr_writer :url
+
+          # The LinkedIn username, including the prefix 'company/' for company pages or
+          # 'in/' for personal profiles.
+          sig { returns(T.nilable(String)) }
+          attr_reader :username
+
+          sig { params(username: String).void }
+          attr_writer :username
+
+          # The social media profile for the LinkedIn platform
+          sig do
+            params(url: String, username: String).returns(T.attached_class)
+          end
+          def self.new(
+            # The full URL to the LinkedIn profile.
+            url: nil,
+            # The LinkedIn username, including the prefix 'company/' for company pages or
+            # 'in/' for personal profiles.
+            username: nil
+          )
+          end
+
+          sig { override.returns({ url: String, username: String }) }
+          def to_hash
+          end
+        end
+      end
+
+      sig { override.returns(T::Array[Moonbase::FieldValueParam::Variants]) }
+      def self.variants
+      end
+
+      ValueParamArray =
+        T.let(
+          Moonbase::Internal::Type::ArrayOf[union: Moonbase::ValueParam],
+          Moonbase::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/moonbase/models/float_field.rbi

@@ -0,0 +1,150 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class FloatField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::FloatField, 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::FloatField::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., "Rating").
+      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., `rating`).
+      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/number/unitless_float` 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 decimal numbers with floating-point precision.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::FloatField::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., "Rating").
+        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., `rating`).
+        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/number/unitless_float` for this field.
+        type: :"field/number/unitless_float"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality: Moonbase::FloatField::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::FloatField::Cardinality) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE = T.let(:one, Moonbase::FloatField::Cardinality::TaggedSymbol)
+        MANY = T.let(:many, Moonbase::FloatField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::FloatField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/float_value.rbi

@@ -9,17 +9,17 @@ module Moonbase
         end
 
       sig { returns(Float) }
-      attr_accessor :number
+      attr_accessor :data
 
       sig { returns(Symbol) }
       attr_accessor :type
 
       # Floating point number
-      sig { params(number: Float, type: Symbol).returns(T.attached_class) }
-      def self.new(number:, type: :"value/number/unitless_float")
+      sig { params(data: Float, type: Symbol).returns(T.attached_class) }
+      def self.new(data:, type: :"value/number/unitless_float")
       end
 
-      sig { override.returns({ number: Float, type: Symbol }) }
+      sig { override.returns({ data: Float, type: Symbol }) }
       def to_hash
       end
     end

data/rbi/moonbase/models/form.rbi

@@ -17,33 +17,25 @@ module Moonbase
       sig { params(collection: Moonbase::Collection::OrHash).void }
       attr_writer :collection
 
-      sig { returns(Moonbase::Form::Links) }
-      attr_reader :links
-
-      sig { params(links: Moonbase::Form::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 name of the form, used as the title on its public page.
       sig { returns(String) }
       attr_accessor :name
 
+      # `true` if the form is available at a public URL.
+      sig { returns(T::Boolean) }
+      attr_accessor :pages_enabled
+
       # String representing the object’s type. Always `form` 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
-
-      # `true` if the form is available at a public URL.
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :pages_enabled
-
-      sig { params(pages_enabled: T::Boolean).void }
-      attr_writer :pages_enabled
+      # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
 
       # The public URL for the form, if `pages_enabled` is `true`.
       sig { returns(T.nilable(String)) }
@@ -59,26 +51,18 @@ module Moonbase
       sig { params(redirect_url: String).void }
       attr_writer :redirect_url
 
-      # 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 Form provides a way to create `Items` in a `Collection`, often via a public
       # URL for external users. Each form submission creates a new item.
       sig do
         params(
           id: String,
           collection: Moonbase::Collection::OrHash,
-          links: Moonbase::Form::Links::OrHash,
-          name: String,
           created_at: Time,
+          name: String,
           pages_enabled: T::Boolean,
+          updated_at: Time,
           pages_url: String,
           redirect_url: String,
-          updated_at: Time,
           type: Symbol
         ).returns(T.attached_class)
       end
@@ -87,19 +71,18 @@ module Moonbase
         id:,
         # The `Collection` that submissions to this form are saved to.
         collection:,
-        links:,
+        # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+        created_at:,
         # The name of the form, used as the title on its public page.
         name:,
-        # Time at which the object was created, as an RFC 3339 timestamp.
-        created_at: nil,
         # `true` if the form is available at a public URL.
-        pages_enabled: nil,
+        pages_enabled:,
+        # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+        updated_at:,
         # The public URL for the form, if `pages_enabled` is `true`.
         pages_url: nil,
         # An optional URL to redirect users to after a successful submission.
         redirect_url: nil,
-        # Time at which the object was last updated, as an RFC 3339 timestamp.
-        updated_at: nil,
         # String representing the object’s type. Always `form` for this object.
         type: :form
       )
@@ -110,52 +93,18 @@ module Moonbase
           {
             id: String,
             collection: Moonbase::Collection,
-            links: Moonbase::Form::Links,
-            name: String,
-            type: Symbol,
             created_at: Time,
+            name: String,
             pages_enabled: T::Boolean,
+            type: Symbol,
+            updated_at: Time,
             pages_url: String,
-            redirect_url: String,
-            updated_at: Time
+            redirect_url: String
           }
         )
       end
       def to_hash
       end
-
-      class Links < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Moonbase::Form::Links, Moonbase::Internal::AnyHash)
-          end
-
-        # The canonical URL for this object.
-        sig { returns(String) }
-        attr_accessor :self_
-
-        # A link to the `Collection` where form submissions are saved.
-        sig { returns(T.nilable(String)) }
-        attr_reader :collection
-
-        sig { params(collection: String).void }
-        attr_writer :collection
-
-        sig do
-          params(self_: String, collection: String).returns(T.attached_class)
-        end
-        def self.new(
-          # The canonical URL for this object.
-          self_:,
-          # A link to the `Collection` where form submissions are saved.
-          collection: nil
-        )
-        end
-
-        sig { override.returns({ self_: String, collection: String }) }
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/moonbase/models/form_list_params.rbi

@@ -29,22 +29,6 @@ module Moonbase
       sig { params(before: String).void }
       attr_writer :before
 
-      # Specifies which related objects to include in the response. Valid option is
-      # `collection.fields`.
-      sig do
-        returns(
-          T.nilable(T::Array[Moonbase::FormListParams::Include::OrSymbol])
-        )
-      end
-      attr_reader :include
-
-      sig do
-        params(
-          include: T::Array[Moonbase::FormListParams::Include::OrSymbol]
-        ).void
-      end
-      attr_writer :include
-
       # 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)) }
@@ -57,7 +41,6 @@ module Moonbase
         params(
           after: String,
           before: String,
-          include: T::Array[Moonbase::FormListParams::Include::OrSymbol],
           limit: Integer,
           request_options: Moonbase::RequestOptions::OrHash
         ).returns(T.attached_class)
@@ -71,9 +54,6 @@ module Moonbase
         # by this cursor. Use the cursor value from the response's metadata to fetch the
         # previous page of results.
         before: nil,
-        # Specifies which related objects to include in the response. Valid option is
-        # `collection.fields`.
-        include: nil,
         # Maximum number of items to return per page. Must be between 1 and 100. Defaults
         # to 20 if not specified.
         limit: nil,
@@ -86,7 +66,6 @@ module Moonbase
           {
             after: String,
             before: String,
-            include: T::Array[Moonbase::FormListParams::Include::OrSymbol],
             limit: Integer,
             request_options: Moonbase::RequestOptions
           }
@@ -94,28 +73,6 @@ module Moonbase
       end
       def to_hash
       end
-
-      module Include
-        extend Moonbase::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Moonbase::FormListParams::Include) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        COLLECTION_FIELDS =
-          T.let(
-            :"collection.fields",
-            Moonbase::FormListParams::Include::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[Moonbase::FormListParams::Include::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
-      end
     end
   end
 end