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

data/rbi/moonbase/models/relation_field.rbi

@@ -0,0 +1,184 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class RelationField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::RelationField, 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::RelationField::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., "Account").
+      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., `account`).
+      sig { returns(String) }
+      attr_accessor :ref
+
+      # The type of relationship. Can be `one_way` for simple references or `two_way`
+      # for bidirectional relationships.
+      sig { returns(Moonbase::RelationField::RelationType::TaggedSymbol) }
+      attr_accessor :relation_type
+
+      # If `true`, this field must have a value.
+      sig { returns(T::Boolean) }
+      attr_accessor :required
+
+      # The data type of the field. Always `field/relation` 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 creates a link between items in different collections, enabling
+      # cross-collection relationships.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::RelationField::Cardinality::OrSymbol,
+          created_at: Time,
+          name: String,
+          readonly: T::Boolean,
+          ref: String,
+          relation_type: Moonbase::RelationField::RelationType::OrSymbol,
+          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., "Account").
+        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., `account`).
+        ref:,
+        # The type of relationship. Can be `one_way` for simple references or `two_way`
+        # for bidirectional relationships.
+        relation_type:,
+        # 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/relation` for this field.
+        type: :"field/relation"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality: Moonbase::RelationField::Cardinality::TaggedSymbol,
+            created_at: Time,
+            name: String,
+            readonly: T::Boolean,
+            ref: String,
+            relation_type: Moonbase::RelationField::RelationType::TaggedSymbol,
+            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::RelationField::Cardinality) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE = T.let(:one, Moonbase::RelationField::Cardinality::TaggedSymbol)
+        MANY = T.let(:many, Moonbase::RelationField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::RelationField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The type of relationship. Can be `one_way` for simple references or `two_way`
+      # for bidirectional relationships.
+      module RelationType
+        extend Moonbase::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Moonbase::RelationField::RelationType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE_WAY =
+          T.let(:one_way, Moonbase::RelationField::RelationType::TaggedSymbol)
+        TWO_WAY =
+          T.let(:two_way, Moonbase::RelationField::RelationType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::RelationField::RelationType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/relation_value.rbi

@@ -8,30 +8,30 @@ module Moonbase
           T.any(Moonbase::RelationValue, Moonbase::Internal::AnyHash)
         end
 
-      # An Item represents a single record or row within a Collection. It holds a set of
-      # `values` corresponding to the Collection's `fields`.
-      sig { returns(Moonbase::Item) }
-      attr_reader :item
+      # A reference to another Moonbase item.
+      sig { returns(Moonbase::ItemPointer) }
+      attr_reader :data
 
-      sig { params(item: Moonbase::Item).void }
-      attr_writer :item
+      sig { params(data: Moonbase::ItemPointer::OrHash).void }
+      attr_writer :data
 
       sig { returns(Symbol) }
       attr_accessor :type
 
       # Related item reference
       sig do
-        params(item: Moonbase::Item, type: Symbol).returns(T.attached_class)
+        params(data: Moonbase::ItemPointer::OrHash, type: Symbol).returns(
+          T.attached_class
+        )
       end
       def self.new(
-        # An Item represents a single record or row within a Collection. It holds a set of
-        # `values` corresponding to the Collection's `fields`.
-        item:,
+        # A reference to another Moonbase item.
+        data:,
         type: :"value/relation"
       )
       end
 
-      sig { override.returns({ item: Moonbase::Item, type: Symbol }) }
+      sig { override.returns({ data: Moonbase::ItemPointer, type: Symbol }) }
       def to_hash
       end
     end

data/rbi/moonbase/models/relation_value_param.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class RelationValueParam < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::RelationValueParam, Moonbase::Internal::AnyHash)
+        end
+
+      # A reference to another Moonbase item.
+      sig { returns(T.any(Moonbase::ItemPointer, Moonbase::Pointer)) }
+      attr_accessor :data
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Related item reference
+      sig do
+        params(
+          data: T.any(Moonbase::ItemPointer::OrHash, Moonbase::Pointer::OrHash),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A reference to another Moonbase item.
+        data:,
+        type: :"value/relation"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.any(Moonbase::ItemPointer, Moonbase::Pointer),
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # A reference to another Moonbase item.
+      module Data
+        extend Moonbase::Internal::Type::Union
+
+        Variants =
+          T.type_alias { T.any(Moonbase::ItemPointer, Moonbase::Pointer) }
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::RelationValueParam::Data::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/single_line_text_field.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class SingleLineTextField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::SingleLineTextField, 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::SingleLineTextField::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., "Company Name").
+      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., `company_name`).
+      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/text/single_line` 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 a single line of text without line breaks.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::SingleLineTextField::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., "Company Name").
+        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., `company_name`).
+        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/text/single_line` for this field.
+        type: :"field/text/single_line"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality:
+              Moonbase::SingleLineTextField::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 do
+            T.all(Symbol, Moonbase::SingleLineTextField::Cardinality)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE =
+          T.let(:one, Moonbase::SingleLineTextField::Cardinality::TaggedSymbol)
+        MANY =
+          T.let(:many, Moonbase::SingleLineTextField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::SingleLineTextField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/moonbase/models/single_line_text_value.rbi

@@ -8,18 +8,25 @@ module Moonbase
           T.any(Moonbase::SingleLineTextValue, Moonbase::Internal::AnyHash)
         end
 
+      # A single line of text, up to 1024 characters long. It should not contain line
+      # breaks.
       sig { returns(String) }
-      attr_accessor :text
+      attr_accessor :data
 
       sig { returns(Symbol) }
       attr_accessor :type
 
       # A single line of text
-      sig { params(text: String, type: Symbol).returns(T.attached_class) }
-      def self.new(text:, type: :"value/text/single_line")
+      sig { params(data: String, type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # A single line of text, up to 1024 characters long. It should not contain line
+        # breaks.
+        data:,
+        type: :"value/text/single_line"
+      )
       end
 
-      sig { override.returns({ text: String, type: Symbol }) }
+      sig { override.returns({ data: String, type: Symbol }) }
       def to_hash
       end
     end

data/rbi/moonbase/models/social_linked_in_field.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class SocialLinkedInField < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Moonbase::SocialLinkedInField, 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::SocialLinkedInField::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., "LinkedIn Profile").
+      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., `linkedin_profile`).
+      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/uri/social_linked_in` 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 LinkedIn profile information.
+      sig do
+        params(
+          id: String,
+          cardinality: Moonbase::SocialLinkedInField::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., "LinkedIn Profile").
+        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., `linkedin_profile`).
+        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/uri/social_linked_in` for this field.
+        type: :"field/uri/social_linked_in"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            cardinality:
+              Moonbase::SocialLinkedInField::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 do
+            T.all(Symbol, Moonbase::SocialLinkedInField::Cardinality)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ONE =
+          T.let(:one, Moonbase::SocialLinkedInField::Cardinality::TaggedSymbol)
+        MANY =
+          T.let(:many, Moonbase::SocialLinkedInField::Cardinality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Moonbase::SocialLinkedInField::Cardinality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end