amritk-galaxy-staging 0.2.0

data/rbi/amritk-galaxy-staging/models/celestial_body_create_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class CelestialBodyCreateParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::CelestialBodyCreateParams,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(
+          T.any(DemoApiScalarGalaxy::Planet, DemoApiScalarGalaxy::Satellite)
+        )
+      end
+      attr_accessor :celestial_body
+
+      sig do
+        params(
+          celestial_body:
+            T.any(
+              DemoApiScalarGalaxy::Planet::OrHash,
+              DemoApiScalarGalaxy::Satellite::OrHash
+            ),
+          request_options: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(celestial_body:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            celestial_body:
+              T.any(
+                DemoApiScalarGalaxy::Planet,
+                DemoApiScalarGalaxy::Satellite
+              ),
+            request_options: DemoApiScalarGalaxy::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/new_planet_webhook_event.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class NewPlanetWebhookEvent < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::NewPlanetWebhookEvent,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+
+      sig { override.returns({}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/paginated_resource.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PaginatedResource < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PaginatedResource,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(DemoApiScalarGalaxy::PaginatedResource::Meta)) }
+      attr_reader :meta
+
+      sig do
+        params(meta: DemoApiScalarGalaxy::PaginatedResource::Meta::OrHash).void
+      end
+      attr_writer :meta
+
+      # A paginated resource
+      sig do
+        params(
+          meta: DemoApiScalarGalaxy::PaginatedResource::Meta::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(meta: nil)
+      end
+
+      sig do
+        override.returns({ meta: DemoApiScalarGalaxy::PaginatedResource::Meta })
+      end
+      def to_hash
+      end
+
+      class Meta < DemoApiScalarGalaxy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DemoApiScalarGalaxy::PaginatedResource::Meta,
+              DemoApiScalarGalaxy::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :next_
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :offset
+
+        sig { params(offset: Integer).void }
+        attr_writer :offset
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :total
+
+        sig { params(total: Integer).void }
+        attr_writer :total
+
+        sig do
+          params(
+            limit: Integer,
+            next_: T.nilable(String),
+            offset: Integer,
+            total: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(limit: nil, next_: nil, offset: nil, total: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              limit: Integer,
+              next_: T.nilable(String),
+              offset: Integer,
+              total: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/planet.rbi

@@ -0,0 +1,373 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class Planet < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::Planet,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Integer) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(DemoApiScalarGalaxy::Planet::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Atmospheric composition
+      sig do
+        returns(T.nilable(T::Array[DemoApiScalarGalaxy::Planet::Atmosphere]))
+      end
+      attr_reader :atmosphere
+
+      sig do
+        params(
+          atmosphere: T::Array[DemoApiScalarGalaxy::Planet::Atmosphere::OrHash]
+        ).void
+      end
+      attr_writer :atmosphere
+
+      # A user
+      sig { returns(T.nilable(DemoApiScalarGalaxy::User)) }
+      attr_reader :creator
+
+      sig { params(creator: DemoApiScalarGalaxy::User::OrHash).void }
+      attr_writer :creator
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :discovered_at
+
+      sig { params(discovered_at: Time).void }
+      attr_writer :discovered_at
+
+      # URL which gets invoked upon a failed operation
+      sig { returns(T.nilable(String)) }
+      attr_reader :failure_callback_url
+
+      sig { params(failure_callback_url: String).void }
+      attr_writer :failure_callback_url
+
+      # A score from 0 to 1 indicating potential habitability
+      sig { returns(T.nilable(Float)) }
+      attr_reader :habitability_index
+
+      sig { params(habitability_index: Float).void }
+      attr_writer :habitability_index
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :image
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :last_updated
+
+      sig { params(last_updated: Time).void }
+      attr_writer :last_updated
+
+      sig do
+        returns(T.nilable(DemoApiScalarGalaxy::Planet::PhysicalProperties))
+      end
+      attr_reader :physical_properties
+
+      sig do
+        params(
+          physical_properties:
+            DemoApiScalarGalaxy::Planet::PhysicalProperties::OrHash
+        ).void
+      end
+      attr_writer :physical_properties
+
+      sig { returns(T.nilable(T::Array[DemoApiScalarGalaxy::Satellite])) }
+      attr_reader :satellites
+
+      sig do
+        params(
+          satellites: T::Array[DemoApiScalarGalaxy::Satellite::OrHash]
+        ).void
+      end
+      attr_writer :satellites
+
+      # URL which gets invoked upon a successful operation
+      sig { returns(T.nilable(String)) }
+      attr_reader :success_callback_url
+
+      sig { params(success_callback_url: String).void }
+      attr_writer :success_callback_url
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :tags
+
+      sig { params(tags: T::Array[String]).void }
+      attr_writer :tags
+
+      # A planet in the Scalar Galaxy
+      sig do
+        params(
+          id: Integer,
+          name: String,
+          type: DemoApiScalarGalaxy::Planet::Type::OrSymbol,
+          atmosphere: T::Array[DemoApiScalarGalaxy::Planet::Atmosphere::OrHash],
+          creator: DemoApiScalarGalaxy::User::OrHash,
+          description: T.nilable(String),
+          discovered_at: Time,
+          failure_callback_url: String,
+          habitability_index: Float,
+          image: T.nilable(String),
+          last_updated: Time,
+          physical_properties:
+            DemoApiScalarGalaxy::Planet::PhysicalProperties::OrHash,
+          satellites: T::Array[DemoApiScalarGalaxy::Satellite::OrHash],
+          success_callback_url: String,
+          tags: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        name:,
+        type:,
+        # Atmospheric composition
+        atmosphere: nil,
+        # A user
+        creator: nil,
+        description: nil,
+        discovered_at: nil,
+        # URL which gets invoked upon a failed operation
+        failure_callback_url: nil,
+        # A score from 0 to 1 indicating potential habitability
+        habitability_index: nil,
+        image: nil,
+        last_updated: nil,
+        physical_properties: nil,
+        satellites: nil,
+        # URL which gets invoked upon a successful operation
+        success_callback_url: nil,
+        tags: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: Integer,
+            name: String,
+            type: DemoApiScalarGalaxy::Planet::Type::OrSymbol,
+            atmosphere: T::Array[DemoApiScalarGalaxy::Planet::Atmosphere],
+            creator: DemoApiScalarGalaxy::User,
+            description: T.nilable(String),
+            discovered_at: Time,
+            failure_callback_url: String,
+            habitability_index: Float,
+            image: T.nilable(String),
+            last_updated: Time,
+            physical_properties:
+              DemoApiScalarGalaxy::Planet::PhysicalProperties,
+            satellites: T::Array[DemoApiScalarGalaxy::Satellite],
+            success_callback_url: String,
+            tags: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend DemoApiScalarGalaxy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, DemoApiScalarGalaxy::Planet::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PLANET = T.let(:planet, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+        TERRESTRIAL =
+          T.let(:terrestrial, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+        GAS_GIANT =
+          T.let(:gas_giant, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+        ICE_GIANT =
+          T.let(:ice_giant, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+        DWARF = T.let(:dwarf, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+        SUPER_EARTH =
+          T.let(:super_earth, DemoApiScalarGalaxy::Planet::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[DemoApiScalarGalaxy::Planet::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Atmosphere < DemoApiScalarGalaxy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DemoApiScalarGalaxy::Planet::Atmosphere,
+              DemoApiScalarGalaxy::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :compound
+
+        sig { params(compound: String).void }
+        attr_writer :compound
+
+        sig { returns(T.nilable(Float)) }
+        attr_reader :percentage
+
+        sig { params(percentage: Float).void }
+        attr_writer :percentage
+
+        sig do
+          params(compound: String, percentage: Float).returns(T.attached_class)
+        end
+        def self.new(compound: nil, percentage: nil)
+        end
+
+        sig { override.returns({ compound: String, percentage: Float }) }
+        def to_hash
+        end
+      end
+
+      class PhysicalProperties < DemoApiScalarGalaxy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DemoApiScalarGalaxy::Planet::PhysicalProperties,
+              DemoApiScalarGalaxy::Internal::AnyHash
+            )
+          end
+
+        # Surface gravity in Earth g
+        sig { returns(T.nilable(Float)) }
+        attr_reader :gravity
+
+        sig { params(gravity: Float).void }
+        attr_writer :gravity
+
+        # Mass in Earth masses (must be greater than 0)
+        sig { returns(T.nilable(Float)) }
+        attr_reader :mass
+
+        sig { params(mass: Float).void }
+        attr_writer :mass
+
+        # Radius in Earth radii (must be greater than 0)
+        sig { returns(T.nilable(Float)) }
+        attr_reader :radius
+
+        sig { params(radius: Float).void }
+        attr_writer :radius
+
+        sig do
+          returns(
+            T.nilable(
+              DemoApiScalarGalaxy::Planet::PhysicalProperties::Temperature
+            )
+          )
+        end
+        attr_reader :temperature
+
+        sig do
+          params(
+            temperature:
+              DemoApiScalarGalaxy::Planet::PhysicalProperties::Temperature::OrHash
+          ).void
+        end
+        attr_writer :temperature
+
+        sig do
+          params(
+            gravity: Float,
+            mass: Float,
+            radius: Float,
+            temperature:
+              DemoApiScalarGalaxy::Planet::PhysicalProperties::Temperature::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Surface gravity in Earth g
+          gravity: nil,
+          # Mass in Earth masses (must be greater than 0)
+          mass: nil,
+          # Radius in Earth radii (must be greater than 0)
+          radius: nil,
+          temperature: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              gravity: Float,
+              mass: Float,
+              radius: Float,
+              temperature:
+                DemoApiScalarGalaxy::Planet::PhysicalProperties::Temperature
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Temperature < DemoApiScalarGalaxy::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                DemoApiScalarGalaxy::Planet::PhysicalProperties::Temperature,
+                DemoApiScalarGalaxy::Internal::AnyHash
+              )
+            end
+
+          # Average temperature in Kelvin
+          sig { returns(T.nilable(Float)) }
+          attr_reader :average
+
+          sig { params(average: Float).void }
+          attr_writer :average
+
+          # Maximum temperature in Kelvin
+          sig { returns(T.nilable(Float)) }
+          attr_reader :max
+
+          sig { params(max: Float).void }
+          attr_writer :max
+
+          # Minimum temperature in Kelvin
+          sig { returns(T.nilable(Float)) }
+          attr_reader :min
+
+          sig { params(min: Float).void }
+          attr_writer :min
+
+          sig do
+            params(average: Float, max: Float, min: Float).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # Average temperature in Kelvin
+            average: nil,
+            # Maximum temperature in Kelvin
+            max: nil,
+            # Minimum temperature in Kelvin
+            min: nil
+          )
+          end
+
+          sig { override.returns({ average: Float, max: Float, min: Float }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/planet_create_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetCreateParams < DemoApiScalarGalaxy::Models::Planet
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PlanetCreateParams,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(
+          request_options: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { request_options: DemoApiScalarGalaxy::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/planet_delete_params.rbi

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

data/rbi/amritk-galaxy-staging/models/planet_list_params.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetListParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PlanetListParams,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      # The number of items to return
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # The number of items to skip before starting to collect the result set
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :offset
+
+      sig { params(offset: Integer).void }
+      attr_writer :offset
+
+      sig do
+        params(
+          limit: Integer,
+          offset: Integer,
+          request_options: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The number of items to return
+        limit: nil,
+        # The number of items to skip before starting to collect the result set
+        offset: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            offset: Integer,
+            request_options: DemoApiScalarGalaxy::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/models/planet_list_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetListResponse < DemoApiScalarGalaxy::Models::PaginatedResource
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::Models::PlanetListResponse,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(T::Array[DemoApiScalarGalaxy::Planet])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[DemoApiScalarGalaxy::Planet::OrHash]).void }
+      attr_writer :data
+
+      sig do
+        params(data: T::Array[DemoApiScalarGalaxy::Planet::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(data: nil)
+      end
+
+      sig { override.returns({ data: T::Array[DemoApiScalarGalaxy::Planet] }) }
+      def to_hash
+      end
+    end
+  end
+end