galaxy-ruby 0.2.0

data/rbi/galaxy-ruby/models/planet_list_all_data_response.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Models
+    class PlanetListAllDataResponse < ScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ScalarGalaxy::Models::PlanetListAllDataResponse,
+            ScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(T::Array[T.anything])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[T.anything]).void }
+      attr_writer :data
+
+      sig do
+        returns(
+          T.nilable(ScalarGalaxy::Models::PlanetListAllDataResponse::Meta)
+        )
+      end
+      attr_reader :meta
+
+      sig do
+        params(
+          meta: ScalarGalaxy::Models::PlanetListAllDataResponse::Meta::OrHash
+        ).void
+      end
+      attr_writer :meta
+
+      sig do
+        params(
+          data: T::Array[T.anything],
+          meta: ScalarGalaxy::Models::PlanetListAllDataResponse::Meta::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, meta: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[T.anything],
+            meta: ScalarGalaxy::Models::PlanetListAllDataResponse::Meta
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Meta < ScalarGalaxy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ScalarGalaxy::Models::PlanetListAllDataResponse::Meta,
+              ScalarGalaxy::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/galaxy-ruby/models/planet_retrieve_params.rbi

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

data/rbi/galaxy-ruby/models/planet_update_params.rbi

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

data/rbi/galaxy-ruby/models/unwrap_webhook_event.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Models
+    module UnwrapWebhookEvent
+      extend ScalarGalaxy::Internal::Type::Union
+
+      Variants = T.type_alias { T.any(ScalarGalaxy::NewPlanetWebhookEvent) }
+
+      sig do
+        override.returns(T::Array[ScalarGalaxy::UnwrapWebhookEvent::Variants])
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/models/user.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Models
+    class User < ScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(ScalarGalaxy::User, ScalarGalaxy::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :id
+
+      sig { params(id: Integer).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # A user
+      sig { params(id: Integer, name: String).returns(T.attached_class) }
+      def self.new(id: nil, name: nil)
+      end
+
+      sig { override.returns({ id: Integer, name: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/models/webhook_unwrap_params.rbi

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

data/rbi/galaxy-ruby/models.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module ScalarGalaxy
+  AuthenticationCreateTokenParams =
+    ScalarGalaxy::Models::AuthenticationCreateTokenParams
+
+  AuthenticationCreateUserParams =
+    ScalarGalaxy::Models::AuthenticationCreateUserParams
+
+  AuthenticationListMeParams = ScalarGalaxy::Models::AuthenticationListMeParams
+
+  CelestialBody = ScalarGalaxy::Models::CelestialBody
+
+  CelestialBodyCreateParams = ScalarGalaxy::Models::CelestialBodyCreateParams
+
+  Credentials = ScalarGalaxy::Models::Credentials
+
+  NewPlanetWebhookEvent = ScalarGalaxy::Models::NewPlanetWebhookEvent
+
+  Planet = ScalarGalaxy::Models::Planet
+
+  PlanetCreateParams = ScalarGalaxy::Models::PlanetCreateParams
+
+  PlanetDeleteParams = ScalarGalaxy::Models::PlanetDeleteParams
+
+  PlanetDelteImageParams = ScalarGalaxy::Models::PlanetDelteImageParams
+
+  PlanetListAllDataParams = ScalarGalaxy::Models::PlanetListAllDataParams
+
+  PlanetRetrieveParams = ScalarGalaxy::Models::PlanetRetrieveParams
+
+  PlanetUpdateParams = ScalarGalaxy::Models::PlanetUpdateParams
+
+  UnwrapWebhookEvent = ScalarGalaxy::Models::UnwrapWebhookEvent
+
+  User = ScalarGalaxy::Models::User
+
+  WebhookUnwrapParams = ScalarGalaxy::Models::WebhookUnwrapParams
+end

data/rbi/galaxy-ruby/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module ScalarGalaxy
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < ScalarGalaxy::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(ScalarGalaxy::RequestOptions, ScalarGalaxy::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: ScalarGalaxy::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: ScalarGalaxy::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/galaxy-ruby/resources/authentication.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Resources
+    # Some endpoints are public, but some require authentication. We provide all the
+    # required endpoints to create an account and authorize yourself.
+    class Authentication
+      # Yeah, this is the boring security stuff. Just get your super secret token and
+      # move on.
+      sig do
+        params(
+          email: String,
+          password: String,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Models::AuthenticationCreateTokenResponse)
+      end
+      def create_token(email:, password:, request_options: {})
+      end
+
+      # Time to create a user account, eh?
+      sig do
+        params(
+          email: String,
+          password: String,
+          name: String,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::User)
+      end
+      def create_user(email:, password:, name: nil, request_options: {})
+      end
+
+      # Find yourself they say. That's what you can do here.
+      sig do
+        params(request_options: ScalarGalaxy::RequestOptions::OrHash).returns(
+          ScalarGalaxy::User
+        )
+      end
+      def list_me(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ScalarGalaxy::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/resources/celestial_bodies.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Resources
+    # Celestial bodies are the planets and satellites in the Scalar Galaxy.
+    class CelestialBodies
+      # Stars, moons, comets, the occasional rogue asteroid — if it glows or drifts
+      # through the void, you can add it here.
+      sig do
+        params(
+          celestial_body:
+            T.any(
+              ScalarGalaxy::Planet::OrHash,
+              ScalarGalaxy::CelestialBody::Satellite::OrHash
+            ),
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::CelestialBody::Variants)
+      end
+      def create(celestial_body:, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ScalarGalaxy::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/resources/planets.rbi

@@ -0,0 +1,176 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Resources
+    # Everything about planets
+    class Planets
+      # Time to play god and create a new planet. What do you think? Ah, don't think too
+      # much. What could go wrong anyway?
+      sig do
+        params(
+          id: Integer,
+          name: String,
+          atmosphere: T::Array[ScalarGalaxy::Planet::Atmosphere::OrHash],
+          creator: ScalarGalaxy::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: ScalarGalaxy::Planet::PhysicalProperties::OrHash,
+          satellites: T::Array[T.anything],
+          success_callback_url: String,
+          tags: T::Array[String],
+          type: ScalarGalaxy::Planet::Type::OrSymbol,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Planet)
+      end
+      def create(
+        id:,
+        name:,
+        # 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,
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # You'll better learn a little bit more about the planets. It might come in handy
+      # once space travel is available for everyone.
+      sig do
+        params(
+          planet_id: Integer,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Planet)
+      end
+      def retrieve(
+        # The ID of the planet to get
+        planet_id,
+        request_options: {}
+      )
+      end
+
+      # Sometimes you make mistakes, that's fine. No worries, you can update all
+      # planets.
+      sig do
+        params(
+          planet_id: Integer,
+          id: Integer,
+          name: String,
+          atmosphere: T::Array[ScalarGalaxy::Planet::Atmosphere::OrHash],
+          creator: ScalarGalaxy::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: ScalarGalaxy::Planet::PhysicalProperties::OrHash,
+          satellites: T::Array[T.anything],
+          success_callback_url: String,
+          tags: T::Array[String],
+          type: ScalarGalaxy::Planet::Type::OrSymbol,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Planet)
+      end
+      def update(
+        # The ID of the planet to get
+        planet_id,
+        id:,
+        name:,
+        # 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,
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint was used to delete planets. Unfortunately, that caused a lot of
+      # trouble for planets with life. So, this endpoint is now deprecated and should
+      # not be used anymore.
+      sig do
+        params(
+          planet_id: Integer,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).void
+      end
+      def delete(
+        # The ID of the planet to get
+        planet_id,
+        request_options: {}
+      )
+      end
+
+      # Got a crazy good photo of a planet? Share it with the world!
+      sig do
+        params(
+          planet_id: Integer,
+          image: ScalarGalaxy::Internal::FileInput,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Models::PlanetDelteImageResponse)
+      end
+      def delte_image(
+        # The ID of the planet to get
+        planet_id,
+        # The image file to upload
+        image: nil,
+        request_options: {}
+      )
+      end
+
+      # It's easy to say you know them all, but do you really? Retrieve all the planets
+      # and check whether you missed one.
+      sig do
+        params(
+          limit: Integer,
+          offset: Integer,
+          request_options: ScalarGalaxy::RequestOptions::OrHash
+        ).returns(ScalarGalaxy::Models::PlanetListAllDataResponse)
+      end
+      def list_all_data(
+        # 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
+
+      # @api private
+      sig { params(client: ScalarGalaxy::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/resources/webhooks.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Resources
+    class Webhooks
+      sig do
+        params(
+          payload: String,
+          headers: T::Hash[String, String],
+          key: T.nilable(String)
+        ).returns(ScalarGalaxy::NewPlanetWebhookEvent)
+      end
+      def unwrap(
+        # The raw webhook payload as a string
+        payload,
+        # The raw HTTP headers that came with the payload
+        headers:,
+        # The webhook signing key
+        key: @client.webhook_secret
+      )
+      end
+
+      # @api private
+      sig { params(client: ScalarGalaxy::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/galaxy-ruby/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module ScalarGalaxy
+  VERSION = T.let(T.unsafe(nil), String)
+end