amritk-galaxy-staging 0.2.0

data/lib/amritk-galaxy-staging/models/satellite.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Models
+    class Satellite < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      # @!attribute name
+      #
+      #   @return [String]
+      required :name, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, DemoApiScalarGalaxy::Models::Satellite::Type]
+      required :type, enum: -> { DemoApiScalarGalaxy::Satellite::Type }
+
+      # @!attribute description
+      #
+      #   @return [String, nil]
+      optional :description, String, nil?: true
+
+      # @!attribute diameter
+      #   Diameter in kilometers
+      #
+      #   @return [Float, nil]
+      optional :diameter, Float
+
+      # @!attribute orbit
+      #
+      #   @return [DemoApiScalarGalaxy::Models::Satellite::Orbit, nil]
+      optional :orbit, -> { DemoApiScalarGalaxy::Satellite::Orbit }
+
+      response_only do
+        # @!attribute id
+        #
+        #   @return [Integer, nil]
+        optional :id, Integer
+      end
+
+      # @!method initialize(name:, type:, id: nil, description: nil, diameter: nil, orbit: nil)
+      #   Every satellite in the Scalar Galaxy
+      #
+      #   @param name [String]
+      #
+      #   @param type [Symbol, DemoApiScalarGalaxy::Models::Satellite::Type]
+      #
+      #   @param id [Integer]
+      #
+      #   @param description [String, nil]
+      #
+      #   @param diameter [Float] Diameter in kilometers
+      #
+      #   @param orbit [DemoApiScalarGalaxy::Models::Satellite::Orbit]
+
+      # @see DemoApiScalarGalaxy::Models::Satellite#type
+      module Type
+        extend DemoApiScalarGalaxy::Internal::Type::Enum
+
+        SATELLITE = :satellite
+        MOON = :moon
+        ASTEROID = :asteroid
+        COMET = :comet
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # @see DemoApiScalarGalaxy::Models::Satellite#orbit
+      class Orbit < DemoApiScalarGalaxy::Internal::Type::BaseModel
+        # @!attribute distance
+        #   Average distance from the planet in kilometers
+        #
+        #   @return [Float, nil]
+        optional :distance, Float
+
+        # @!attribute orbital_period
+        #   Orbital period in Earth days
+        #
+        #   @return [Float, nil]
+        optional :orbital_period, Float, api_name: :orbitalPeriod
+
+        # @!attribute planet_id
+        #   The ID of the planet this satellite orbits
+        #
+        #   @return [Integer, nil]
+        optional :planet_id, Integer, api_name: :planetId
+
+        # @!method initialize(distance: nil, orbital_period: nil, planet_id: nil)
+        #   @param distance [Float] Average distance from the planet in kilometers
+        #
+        #   @param orbital_period [Float] Orbital period in Earth days
+        #
+        #   @param planet_id [Integer] The ID of the planet this satellite orbits
+      end
+    end
+  end
+end

data/lib/amritk-galaxy-staging/models/token.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Models
+    # @see DemoApiScalarGalaxy::Resources::Authentication#create_token
+    class Token < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      # @!attribute token
+      #
+      #   @return [String, nil]
+      optional :token, String
+
+      # @!method initialize(token: nil)
+      #   A token to authenticate a user
+      #
+      #   @param token [String]
+    end
+  end
+end

data/lib/amritk-galaxy-staging/models/unwrap_webhook_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Models
+    module UnwrapWebhookEvent
+      extend DemoApiScalarGalaxy::Internal::Type::Union
+
+      variant -> { DemoApiScalarGalaxy::NewPlanetWebhookEvent }
+
+      # @!method self.variants
+      #   @return [Array(DemoApiScalarGalaxy::Models::NewPlanetWebhookEvent)]
+    end
+  end
+end

data/lib/amritk-galaxy-staging/models/user.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Models
+    # @see DemoApiScalarGalaxy::Resources::Authentication#create_user
+    class User < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      # @!attribute name
+      #
+      #   @return [String, nil]
+      optional :name, String
+
+      response_only do
+        # @!attribute id
+        #
+        #   @return [Integer, nil]
+        optional :id, Integer
+      end
+
+      # @!method initialize(id: nil, name: nil)
+      #   A user
+      #
+      #   @param id [Integer]
+      #   @param name [String]
+    end
+  end
+end

data/lib/amritk-galaxy-staging/models/webhook_unwrap_params.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Models
+    # @see DemoApiScalarGalaxy::Resources::Webhooks#unwrap
+    class WebhookUnwrapParams < DemoApiScalarGalaxy::Internal::Type::BaseModel
+      extend DemoApiScalarGalaxy::Internal::Type::RequestParameters::Converter
+      include DemoApiScalarGalaxy::Internal::Type::RequestParameters
+
+      # @!method initialize(request_options: {})
+      #   @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/amritk-galaxy-staging/models.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  [
+    DemoApiScalarGalaxy::Internal::Type::BaseModel,
+    *DemoApiScalarGalaxy::Internal::Type::BaseModel.subclasses
+  ].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(cls, DemoApiScalarGalaxy::Internal::AnyHash) }
+    end
+  end
+
+  DemoApiScalarGalaxy::Internal::Util
+    .walk_namespaces(DemoApiScalarGalaxy::Models)
+    .each do |mod|
+      case mod
+      in DemoApiScalarGalaxy::Internal::Type::Enum | DemoApiScalarGalaxy::Internal::Type::Union
+        mod.constants.each do |name|
+          case mod.const_get(name)
+          in true | false
+            mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+            mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+          in Integer
+            mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+            mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+          in Float
+            mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+            mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+          in Symbol
+            mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+            mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+          else
+          end
+        end
+      else
+      end
+    end
+
+  DemoApiScalarGalaxy::Internal::Util
+    .walk_namespaces(DemoApiScalarGalaxy::Models)
+    .lazy
+    .grep(DemoApiScalarGalaxy::Internal::Type::Union)
+    .each do |mod|
+      const = :Variants
+      next if mod.sorbet_constant_defined?(const)
+
+      mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+    end
+
+  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/lib/amritk-galaxy-staging/request_options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+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
+    # @api private
+    #
+    # @param opts [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in DemoApiScalarGalaxy::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query,
+             DemoApiScalarGalaxy::Internal::Type::HashOf[DemoApiScalarGalaxy::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, DemoApiScalarGalaxy::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body,
+             DemoApiScalarGalaxy::Internal::Type::HashOf[DemoApiScalarGalaxy::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(DemoApiScalarGalaxy::RequestOptions, DemoApiScalarGalaxy::Internal::AnyHash) }
+    end
+  end
+end

data/lib/amritk-galaxy-staging/resources/authentication.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # @overload create_token(email:, password:, request_options: {})
+      #
+      # @param email [String]
+      # @param password [String]
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::Token]
+      #
+      # @see DemoApiScalarGalaxy::Models::AuthenticationCreateTokenParams
+      def create_token(params)
+        parsed, options = DemoApiScalarGalaxy::AuthenticationCreateTokenParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "auth/token",
+          body: parsed,
+          model: DemoApiScalarGalaxy::Token,
+          options: options
+        )
+      end
+
+      # Time to create a user account, eh?
+      #
+      # @overload create_user(email:, password:, name: nil, request_options: {})
+      #
+      # @param email [String]
+      # @param password [String]
+      # @param name [String]
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::User]
+      #
+      # @see DemoApiScalarGalaxy::Models::AuthenticationCreateUserParams
+      def create_user(params)
+        parsed, options = DemoApiScalarGalaxy::AuthenticationCreateUserParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "user/signup",
+          body: parsed,
+          model: DemoApiScalarGalaxy::User,
+          options: options
+        )
+      end
+
+      # Find yourself they say. That's what you can do here.
+      #
+      # @overload list_me(request_options: {})
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::User]
+      #
+      # @see DemoApiScalarGalaxy::Models::AuthenticationListMeParams
+      def list_me(params = {})
+        @client.request(
+          method: :get,
+          path: "me",
+          model: DemoApiScalarGalaxy::User,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [DemoApiScalarGalaxy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/amritk-galaxy-staging/resources/celestial_bodies.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  module Resources
+    # Celestial bodies are the planets and satellites in the Scalar Galaxy.
+    class CelestialBodies
+      # Create a celestial body
+      #
+      # @overload create(celestial_body:, request_options: {})
+      #
+      # @param celestial_body [DemoApiScalarGalaxy::Models::Planet, DemoApiScalarGalaxy::Models::Satellite]
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::Planet, DemoApiScalarGalaxy::Models::Satellite]
+      #
+      # @see DemoApiScalarGalaxy::Models::CelestialBodyCreateParams
+      def create(params)
+        parsed, options = DemoApiScalarGalaxy::CelestialBodyCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "celestial-bodies",
+          body: parsed[:celestial_body],
+          model: DemoApiScalarGalaxy::CelestialBody,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [DemoApiScalarGalaxy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/amritk-galaxy-staging/resources/planets.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module DemoApiScalarGalaxy
+  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?
+      #
+      # @overload create(id:, name:, type:, atmosphere: nil, creator: nil, description: nil, discovered_at: nil, failure_callback_url: nil, habitability_index: nil, image: nil, last_updated: nil, physical_properties: nil, satellites: nil, success_callback_url: nil, tags: nil, request_options: {})
+      #
+      # @param id [Integer]
+      #
+      # @param name [String]
+      #
+      # @param type [Symbol, DemoApiScalarGalaxy::Models::Planet::Type]
+      #
+      # @param atmosphere [Array<DemoApiScalarGalaxy::Models::Planet::Atmosphere>] Atmospheric composition
+      #
+      # @param creator [DemoApiScalarGalaxy::Models::User] A user
+      #
+      # @param description [String, nil]
+      #
+      # @param discovered_at [Time]
+      #
+      # @param failure_callback_url [String] URL which gets invoked upon a failed operation
+      #
+      # @param habitability_index [Float] A score from 0 to 1 indicating potential habitability
+      #
+      # @param image [String, nil]
+      #
+      # @param last_updated [Time]
+      #
+      # @param physical_properties [DemoApiScalarGalaxy::Models::Planet::PhysicalProperties]
+      #
+      # @param satellites [Array<DemoApiScalarGalaxy::Models::Satellite>]
+      #
+      # @param success_callback_url [String] URL which gets invoked upon a successful operation
+      #
+      # @param tags [Array<String>]
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::Planet]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetCreateParams
+      def create(params)
+        parsed, options = DemoApiScalarGalaxy::PlanetCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "planets",
+          body: parsed,
+          model: DemoApiScalarGalaxy::Planet,
+          options: 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.
+      #
+      # @overload retrieve(planet_id, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::Planet]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetRetrieveParams
+      def retrieve(planet_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["planets/%1$s", planet_id],
+          model: DemoApiScalarGalaxy::Planet,
+          options: params[:request_options]
+        )
+      end
+
+      # Sometimes you make mistakes, that's fine. No worries, you can update all
+      # planets.
+      #
+      # @overload update(planet_id, id:, name:, type:, atmosphere: nil, creator: nil, description: nil, discovered_at: nil, failure_callback_url: nil, habitability_index: nil, image: nil, last_updated: nil, physical_properties: nil, satellites: nil, success_callback_url: nil, tags: nil, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param id [Integer]
+      #
+      # @param name [String]
+      #
+      # @param type [Symbol, DemoApiScalarGalaxy::Models::Planet::Type]
+      #
+      # @param atmosphere [Array<DemoApiScalarGalaxy::Models::Planet::Atmosphere>] Atmospheric composition
+      #
+      # @param creator [DemoApiScalarGalaxy::Models::User] A user
+      #
+      # @param description [String, nil]
+      #
+      # @param discovered_at [Time]
+      #
+      # @param failure_callback_url [String] URL which gets invoked upon a failed operation
+      #
+      # @param habitability_index [Float] A score from 0 to 1 indicating potential habitability
+      #
+      # @param image [String, nil]
+      #
+      # @param last_updated [Time]
+      #
+      # @param physical_properties [DemoApiScalarGalaxy::Models::Planet::PhysicalProperties]
+      #
+      # @param satellites [Array<DemoApiScalarGalaxy::Models::Satellite>]
+      #
+      # @param success_callback_url [String] URL which gets invoked upon a successful operation
+      #
+      # @param tags [Array<String>]
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::Planet]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetUpdateParams
+      def update(planet_id, params)
+        parsed, options = DemoApiScalarGalaxy::PlanetUpdateParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: ["planets/%1$s", planet_id],
+          body: parsed,
+          model: DemoApiScalarGalaxy::Planet,
+          options: 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.
+      #
+      # @overload list(limit: nil, offset: nil, request_options: {})
+      #
+      # @param limit [Integer] The number of items to return
+      #
+      # @param offset [Integer] The number of items to skip before starting to collect the result set
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::PlanetListResponse]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetListParams
+      def list(params = {})
+        parsed, options = DemoApiScalarGalaxy::PlanetListParams.dump_request(params)
+        query = DemoApiScalarGalaxy::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "planets",
+          query: query,
+          model: DemoApiScalarGalaxy::Models::PlanetListResponse,
+          options: 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.
+      #
+      # @overload delete(planet_id, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetDeleteParams
+      def delete(planet_id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["planets/%1$s", planet_id],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # Got a crazy good photo of a planet? Share it with the world!
+      #
+      # @overload upload_image(planet_id, image: nil, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param image [Pathname, StringIO, IO, String, DemoApiScalarGalaxy::FilePart] The image file to upload
+      #
+      # @param request_options [DemoApiScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [DemoApiScalarGalaxy::Models::PlanetUploadImageResponse]
+      #
+      # @see DemoApiScalarGalaxy::Models::PlanetUploadImageParams
+      def upload_image(planet_id, params = {})
+        parsed, options = DemoApiScalarGalaxy::PlanetUploadImageParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["planets/%1$s/image", planet_id],
+          headers: {
+            "content-type" => "multipart/form-data"
+          },
+          body: parsed,
+          model: DemoApiScalarGalaxy::Models::PlanetUploadImageResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [DemoApiScalarGalaxy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end