amritk-galaxy-staging 0.2.0

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

@@ -0,0 +1,41 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetRetrieveParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PlanetRetrieveParams,
+            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_update_params.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetUpdateParams < DemoApiScalarGalaxy::Models::Planet
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PlanetUpdateParams,
+            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_upload_image_params.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetUploadImageParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::PlanetUploadImageParams,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Integer) }
+      attr_accessor :planet_id
+
+      # The image file to upload
+      sig { returns(T.nilable(DemoApiScalarGalaxy::Internal::FileInput)) }
+      attr_reader :image
+
+      sig { params(image: DemoApiScalarGalaxy::Internal::FileInput).void }
+      attr_writer :image
+
+      sig do
+        params(
+          planet_id: Integer,
+          image: DemoApiScalarGalaxy::Internal::FileInput,
+          request_options: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        planet_id:,
+        # The image file to upload
+        image: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            planet_id: Integer,
+            image: DemoApiScalarGalaxy::Internal::FileInput,
+            request_options: DemoApiScalarGalaxy::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class PlanetUploadImageResponse < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::Models::PlanetUploadImageResponse,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      # Size of the uploaded image in bytes
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :file_size
+
+      sig { params(file_size: Integer).void }
+      attr_writer :file_size
+
+      # The URL where the uploaded image can be accessed
+      sig { returns(T.nilable(String)) }
+      attr_reader :image_url
+
+      sig { params(image_url: String).void }
+      attr_writer :image_url
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # The content type of the uploaded image
+      sig { returns(T.nilable(String)) }
+      attr_reader :mime_type
+
+      sig { params(mime_type: String).void }
+      attr_writer :mime_type
+
+      # Timestamp when the image was uploaded
+      sig { returns(T.nilable(Time)) }
+      attr_reader :uploaded_at
+
+      sig { params(uploaded_at: Time).void }
+      attr_writer :uploaded_at
+
+      sig do
+        params(
+          file_size: Integer,
+          image_url: String,
+          message: String,
+          mime_type: String,
+          uploaded_at: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Size of the uploaded image in bytes
+        file_size: nil,
+        # The URL where the uploaded image can be accessed
+        image_url: nil,
+        message: nil,
+        # The content type of the uploaded image
+        mime_type: nil,
+        # Timestamp when the image was uploaded
+        uploaded_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            file_size: Integer,
+            image_url: String,
+            message: String,
+            mime_type: String,
+            uploaded_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class Satellite < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::Satellite,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(DemoApiScalarGalaxy::Satellite::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :id
+
+      sig { params(id: Integer).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Diameter in kilometers
+      sig { returns(T.nilable(Float)) }
+      attr_reader :diameter
+
+      sig { params(diameter: Float).void }
+      attr_writer :diameter
+
+      sig { returns(T.nilable(DemoApiScalarGalaxy::Satellite::Orbit)) }
+      attr_reader :orbit
+
+      sig { params(orbit: DemoApiScalarGalaxy::Satellite::Orbit::OrHash).void }
+      attr_writer :orbit
+
+      # Every satellite in the Scalar Galaxy
+      sig do
+        params(
+          name: String,
+          type: DemoApiScalarGalaxy::Satellite::Type::OrSymbol,
+          id: Integer,
+          description: T.nilable(String),
+          diameter: Float,
+          orbit: DemoApiScalarGalaxy::Satellite::Orbit::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        name:,
+        type:,
+        id: nil,
+        description: nil,
+        # Diameter in kilometers
+        diameter: nil,
+        orbit: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            type: DemoApiScalarGalaxy::Satellite::Type::OrSymbol,
+            id: Integer,
+            description: T.nilable(String),
+            diameter: Float,
+            orbit: DemoApiScalarGalaxy::Satellite::Orbit
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend DemoApiScalarGalaxy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, DemoApiScalarGalaxy::Satellite::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SATELLITE =
+          T.let(:satellite, DemoApiScalarGalaxy::Satellite::Type::TaggedSymbol)
+        MOON = T.let(:moon, DemoApiScalarGalaxy::Satellite::Type::TaggedSymbol)
+        ASTEROID =
+          T.let(:asteroid, DemoApiScalarGalaxy::Satellite::Type::TaggedSymbol)
+        COMET =
+          T.let(:comet, DemoApiScalarGalaxy::Satellite::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[DemoApiScalarGalaxy::Satellite::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Orbit < DemoApiScalarGalaxy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DemoApiScalarGalaxy::Satellite::Orbit,
+              DemoApiScalarGalaxy::Internal::AnyHash
+            )
+          end
+
+        # Average distance from the planet in kilometers
+        sig { returns(T.nilable(Float)) }
+        attr_reader :distance
+
+        sig { params(distance: Float).void }
+        attr_writer :distance
+
+        # Orbital period in Earth days
+        sig { returns(T.nilable(Float)) }
+        attr_reader :orbital_period
+
+        sig { params(orbital_period: Float).void }
+        attr_writer :orbital_period
+
+        # The ID of the planet this satellite orbits
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :planet_id
+
+        sig { params(planet_id: Integer).void }
+        attr_writer :planet_id
+
+        sig do
+          params(
+            distance: Float,
+            orbital_period: Float,
+            planet_id: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Average distance from the planet in kilometers
+          distance: nil,
+          # Orbital period in Earth days
+          orbital_period: nil,
+          # The ID of the planet this satellite orbits
+          planet_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { distance: Float, orbital_period: Float, planet_id: Integer }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class Token < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::Token,
+            DemoApiScalarGalaxy::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      # A token to authenticate a user
+      sig { params(token: String).returns(T.attached_class) }
+      def self.new(token: nil)
+      end
+
+      sig { override.returns({ token: String }) }
+      def to_hash
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class User < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::User,
+            DemoApiScalarGalaxy::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/amritk-galaxy-staging/models/webhook_unwrap_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Models
+    class WebhookUnwrapParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DemoApiScalarGalaxy::WebhookUnwrapParams,
+            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.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  AuthenticationCreateTokenParams =
+    DemoApiScalarGalaxy::Models::AuthenticationCreateTokenParams
+
+  AuthenticationCreateUserParams =
+    DemoApiScalarGalaxy::Models::AuthenticationCreateUserParams
+
+  AuthenticationListMeParams =
+    DemoApiScalarGalaxy::Models::AuthenticationListMeParams
+
+  CelestialBody = DemoApiScalarGalaxy::Models::CelestialBody
+
+  CelestialBodyCreateParams =
+    DemoApiScalarGalaxy::Models::CelestialBodyCreateParams
+
+  NewPlanetWebhookEvent = DemoApiScalarGalaxy::Models::NewPlanetWebhookEvent
+
+  PaginatedResource = DemoApiScalarGalaxy::Models::PaginatedResource
+
+  Planet = DemoApiScalarGalaxy::Models::Planet
+
+  PlanetCreateParams = DemoApiScalarGalaxy::Models::PlanetCreateParams
+
+  PlanetDeleteParams = DemoApiScalarGalaxy::Models::PlanetDeleteParams
+
+  PlanetListParams = DemoApiScalarGalaxy::Models::PlanetListParams
+
+  PlanetRetrieveParams = DemoApiScalarGalaxy::Models::PlanetRetrieveParams
+
+  PlanetUpdateParams = DemoApiScalarGalaxy::Models::PlanetUpdateParams
+
+  PlanetUploadImageParams = DemoApiScalarGalaxy::Models::PlanetUploadImageParams
+
+  Satellite = DemoApiScalarGalaxy::Models::Satellite
+
+  Token = DemoApiScalarGalaxy::Models::Token
+
+  UnwrapWebhookEvent = DemoApiScalarGalaxy::Models::UnwrapWebhookEvent
+
+  User = DemoApiScalarGalaxy::Models::User
+
+  WebhookUnwrapParams = DemoApiScalarGalaxy::Models::WebhookUnwrapParams
+end

data/rbi/amritk-galaxy-staging/request_options.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  # 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 < DemoApiScalarGalaxy::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(
+          DemoApiScalarGalaxy::RequestOptions,
+          DemoApiScalarGalaxy::Internal::AnyHash
+        )
+      end
+
+    # @api private
+    sig { params(opts: DemoApiScalarGalaxy::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: DemoApiScalarGalaxy::Internal::AnyHash).returns(
+        T.attached_class
+      )
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/resources/authentication.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  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: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(DemoApiScalarGalaxy::Token)
+      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: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(DemoApiScalarGalaxy::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: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(DemoApiScalarGalaxy::User)
+      end
+      def list_me(request_options: {})
+      end
+
+      # @api private
+      sig do
+        params(client: DemoApiScalarGalaxy::Client).returns(T.attached_class)
+      end
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/amritk-galaxy-staging/resources/celestial_bodies.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module DemoApiScalarGalaxy
+  module Resources
+    # Celestial bodies are the planets and satellites in the Scalar Galaxy.
+    class CelestialBodies
+      # Create a celestial body
+      sig do
+        params(
+          celestial_body:
+            T.any(
+              DemoApiScalarGalaxy::Planet::OrHash,
+              DemoApiScalarGalaxy::Satellite::OrHash
+            ),
+          request_options: DemoApiScalarGalaxy::RequestOptions::OrHash
+        ).returns(DemoApiScalarGalaxy::CelestialBody::Variants)
+      end
+      def create(celestial_body:, request_options: {})
+      end
+
+      # @api private
+      sig do
+        params(client: DemoApiScalarGalaxy::Client).returns(T.attached_class)
+      end
+      def self.new(client:)
+      end
+    end
+  end
+end