scalar_api_ruby 0.2.0

data/lib/scalar_api_ruby/resources/sdks/repositories.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Sdks
+      # SDKs
+      class Repositories
+        # Link one language target to a GitHub repository, so builds sync there.
+        #
+        # @overload link(uid, base_branch:, language:, repository_id:, prerelease_type: nil, request_options: {})
+        #
+        # @param uid [String]
+        # @param base_branch [String]
+        # @param language [Symbol, Scalar::Models::Sdks::RepositoryLinkParams::Language]
+        # @param repository_id [Integer]
+        # @param prerelease_type [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Scalar::Models::Sdks::RepositoryLinkResponse]
+        #
+        # @see Scalar::Models::Sdks::RepositoryLinkParams
+        def link(uid, params)
+          parsed, options = Scalar::Sdks::RepositoryLinkParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["v1/sdks/%1$s/repositories", uid],
+            body: parsed,
+            model: Scalar::Models::Sdks::RepositoryLinkResponse,
+            options: options
+          )
+        end
+
+        # Unlink one language target from its repository.
+        #
+        # @overload unlink(language, uid:, request_options: {})
+        #
+        # @param language [Symbol, Scalar::Models::Sdks::RepositoryUnlinkParams::Language]
+        # @param uid [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Sdks::RepositoryUnlinkParams
+        def unlink(language, params)
+          parsed, options = Scalar::Sdks::RepositoryUnlinkParams.dump_request(params)
+          uid = parsed.delete(:uid) { raise ArgumentError.new("missing required path argument #{_1}") }
+          @client.request(
+            method: :delete,
+            path: ["v1/sdks/%1$s/repositories/%2$s", uid, language],
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # Toggle publish-on-merge and the release settings for a linked target.
+        #
+        # @overload update_publishing(language, uid:, publish_on_merge:, access: nil, auth_method: nil, tag: nil, request_options: {})
+        #
+        # @param language [Symbol, Scalar::Models::Sdks::RepositoryUpdatePublishingParams::Language] Path param
+        #
+        # @param uid [String] Path param
+        #
+        # @param publish_on_merge [Boolean] Body param
+        #
+        # @param access [Symbol, Scalar::Models::Sdks::RepositoryUpdatePublishingParams::Access] Body param
+        #
+        # @param auth_method [Symbol, Scalar::Models::Sdks::RepositoryUpdatePublishingParams::AuthMethod] Body param
+        #
+        # @param tag [String] Body param
+        #
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Sdks::RepositoryUpdatePublishingParams
+        def update_publishing(language, params)
+          parsed, options = Scalar::Sdks::RepositoryUpdatePublishingParams.dump_request(params)
+          uid = parsed.delete(:uid) { raise ArgumentError.new("missing required path argument #{_1}") }
+          @client.request(
+            method: :post,
+            path: ["v1/sdks/%1$s/repositories/%2$s/publishing", uid, language],
+            body: parsed,
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Scalar::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/sdks/versions.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Sdks
+      # SDKs
+      class Versions
+        # Create a new SDK version against a specific API version.
+        #
+        # @overload create(uid, api_version:, version:, request_options: {})
+        #
+        # @param uid [String]
+        # @param api_version [String]
+        # @param version [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Sdks::VersionCreateParams
+        def create(uid, params)
+          parsed, options = Scalar::Sdks::VersionCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["v1/sdks/%1$s/versions", uid],
+            body: parsed,
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # Permanently delete one version of an SDK.
+        #
+        # @overload delete(version, uid:, request_options: {})
+        #
+        # @param version [String]
+        # @param uid [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Sdks::VersionDeleteParams
+        def delete(version, params)
+          parsed, options = Scalar::Sdks::VersionDeleteParams.dump_request(params)
+          uid = parsed.delete(:uid) { raise ArgumentError.new("missing required path argument #{_1}") }
+          @client.request(
+            method: :delete,
+            path: ["v1/sdks/%1$s/versions/%2$s", uid, version],
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Scalar::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/sdks.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # SDKs
+    class Sdks
+      # SDKs
+      # @return [Scalar::Resources::Sdks::Versions]
+      attr_reader :versions
+
+      # SDKs
+      # @return [Scalar::Resources::Sdks::Repositories]
+      attr_reader :repositories
+
+      # Create an SDK from an API document, targeting one or more languages.
+      #
+      # @overload create(api_uid:, languages:, class_name: nil, config: nil, slug: nil, title: nil, request_options: {})
+      #
+      # @param api_uid [String]
+      # @param languages [Array<Symbol, Scalar::Models::SdkCreateParams::Language>]
+      # @param class_name [String]
+      # @param config [String]
+      # @param slug [String]
+      # @param title [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::UID]
+      #
+      # @see Scalar::Models::SdkCreateParams
+      def create(params)
+        parsed, options = Scalar::SdkCreateParams.dump_request(params)
+        @client.request(method: :post, path: "v1/sdks", body: parsed, model: Scalar::UID, options: options)
+      end
+
+      # Get a single SDK by its uid.
+      #
+      # @overload retrieve(uid, request_options: {})
+      #
+      # @param uid [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::Sdk]
+      #
+      # @see Scalar::Models::SdkRetrieveParams
+      def retrieve(uid, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/sdks/%1$s", uid],
+          model: Scalar::Sdk,
+          options: params[:request_options]
+        )
+      end
+
+      # Update SDK metadata, its linked API, or its config.
+      #
+      # @overload update(uid, api_uid: nil, api_version: nil, config: nil, is_private: nil, slug: nil, title: nil, request_options: {})
+      #
+      # @param uid [String]
+      # @param api_uid [String, nil]
+      # @param api_version [String, nil]
+      # @param config [String]
+      # @param is_private [Boolean]
+      # @param slug [String]
+      # @param title [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::SdkUpdateParams
+      def update(uid, params = {})
+        parsed, options = Scalar::SdkUpdateParams.dump_request(params)
+        @client.request(
+          method: :patch,
+          path: ["v1/sdks/%1$s", uid],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # List every SDK on the team.
+      #
+      # @overload list(limit: nil, request_options: {})
+      #
+      # @param limit [Integer]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::SdkListResponse]
+      #
+      # @see Scalar::Models::SdkListParams
+      def list(params = {})
+        parsed, options = Scalar::SdkListParams.dump_request(params)
+        query = Scalar::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "v1/sdks",
+          query: query,
+          model: Scalar::Models::SdkListResponse,
+          options: options
+        )
+      end
+
+      # Delete an SDK and every version it holds.
+      #
+      # @overload delete(uid, request_options: {})
+      #
+      # @param uid [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::SdkDeleteParams
+      def delete(uid, params = {})
+        @client.request(
+          method: :delete,
+          path: ["v1/sdks/%1$s", uid],
+          model: Scalar::Internal::Type::Unknown,
+          options: params[:request_options]
+        )
+      end
+
+      # Start a build. Omit `version` to build the current work — the open draft, else
+      # the latest version — and the resolved version comes back in the response.
+      #
+      # @overload build(uid, languages: nil, version: nil, request_options: {})
+      #
+      # @param uid [String]
+      # @param languages [Array<Symbol, Scalar::Models::SdkBuildParams::Language>]
+      # @param version [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::SdkBuildResponse]
+      #
+      # @see Scalar::Models::SdkBuildParams
+      def build(uid, params = {})
+        parsed, options = Scalar::SdkBuildParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/sdks/%1$s/build", uid],
+          body: parsed,
+          model: Scalar::Models::SdkBuildResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+        @versions = Scalar::Resources::Sdks::Versions.new(client: client)
+        @repositories = Scalar::Resources::Sdks::Repositories.new(client: client)
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/teams/invites.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Teams
+      # Teams
+      class Invites
+        # Withdraw an invite that has not been accepted.
+        #
+        # @overload cancel(uid, request_options: {})
+        #
+        # @param uid [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Teams::InviteCancelParams
+        def cancel(uid, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v1/teams/invites/%1$s", uid],
+            model: Scalar::Internal::Type::Unknown,
+            options: params[:request_options]
+          )
+        end
+
+        # Invite someone to the current team by email.
+        #
+        # @overload member(email:, role:, request_options: {})
+        #
+        # @param email [String]
+        # @param role [Symbol, Scalar::Models::Teams::Role]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Teams::InviteMemberParams
+        def member(params)
+          parsed, options = Scalar::Teams::InviteMemberParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "v1/teams/invites",
+            body: parsed,
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # Send the invite email again.
+        #
+        # @overload resend(uid, request_options: {})
+        #
+        # @param uid [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Teams::InviteResendParams
+        def resend(uid, params = {})
+          @client.request(
+            method: :patch,
+            path: ["v1/teams/invites/%1$s", uid],
+            model: Scalar::Internal::Type::Unknown,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Scalar::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/teams/members.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Teams
+      # Teams
+      class Members
+        # Change what a member of the current team is allowed to do.
+        #
+        # @overload update(uid, role:, request_options: {})
+        #
+        # @param uid [String]
+        # @param role [Symbol, Scalar::Models::Teams::Role]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Teams::MemberUpdateParams
+        def update(uid, params)
+          parsed, options = Scalar::Teams::MemberUpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["v1/teams/members/%1$s", uid],
+            body: parsed,
+            model: Scalar::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # List the members of the current team, along with the invites still outstanding.
+        #
+        # @overload list(request_options: {})
+        #
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Scalar::Models::Teams::MemberListResponse]
+        #
+        # @see Scalar::Models::Teams::MemberListParams
+        def list(params = {})
+          @client.request(
+            method: :get,
+            path: "v1/teams/members",
+            model: Scalar::Models::Teams::MemberListResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Remove someone from the current team.
+        #
+        # @overload delete(uid, request_options: {})
+        #
+        # @param uid [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Teams::MemberDeleteParams
+        def delete(uid, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v1/teams/members/%1$s", uid],
+            model: Scalar::Internal::Type::Unknown,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Scalar::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/teams.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Teams
+    class Teams
+      # Teams
+      # @return [Scalar::Resources::Teams::Members]
+      attr_reader :members
+
+      # Teams
+      # @return [Scalar::Resources::Teams::Invites]
+      attr_reader :invites
+
+      # List all available teams
+      #
+      # @overload list(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::Team>]
+      #
+      # @see Scalar::Models::TeamListParams
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/teams",
+          model: Scalar::Internal::Type::ArrayOf[Scalar::Team],
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+        @members = Scalar::Resources::Teams::Members.new(client: client)
+        @invites = Scalar::Resources::Teams::Invites.new(client: client)
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/themes.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Themes
+    class Themes
+      # Create a team theme.
+      #
+      # @overload create(document:, name:, slug:, description: nil, request_options: {})
+      #
+      # @param document [String]
+      # @param name [String]
+      # @param slug [String]
+      # @param description [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::UID]
+      #
+      # @see Scalar::Models::ThemeCreateParams
+      def create(params)
+        parsed, options = Scalar::ThemeCreateParams.dump_request(params)
+        @client.request(method: :post, path: "v1/themes", body: parsed, model: Scalar::UID, options: options)
+      end
+
+      # Get the theme document by slug.
+      #
+      # @overload retrieve(slug, request_options: {})
+      #
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [String]
+      #
+      # @see Scalar::Models::ThemeRetrieveParams
+      def retrieve(slug, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/themes/%1$s", slug],
+          headers: {
+            "accept" => "text/plain"
+          },
+          model: String,
+          options: params[:request_options]
+        )
+      end
+
+      # Update theme metadata.
+      #
+      # @overload update(slug, description: nil, name: nil, request_options: {})
+      #
+      # @param slug [String]
+      # @param description [String]
+      # @param name [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::ThemeUpdateParams
+      def update(slug, params = {})
+        parsed, options = Scalar::ThemeUpdateParams.dump_request(params)
+        @client.request(
+          method: :patch,
+          path: ["v1/themes/%1$s", slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # List all team themes.
+      #
+      # @overload list(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::Theme>]
+      #
+      # @see Scalar::Models::ThemeListParams
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/themes",
+          model: Scalar::Internal::Type::ArrayOf[Scalar::Theme],
+          options: params[:request_options]
+        )
+      end
+
+      # Delete a theme by slug.
+      #
+      # @overload delete(slug, request_options: {})
+      #
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::ThemeDeleteParams
+      def delete(slug, params = {})
+        @client.request(
+          method: :delete,
+          path: ["v1/themes/%1$s", slug],
+          model: Scalar::Internal::Type::Unknown,
+          options: params[:request_options]
+        )
+      end
+
+      # Replace the theme document.
+      #
+      # @overload replace_document(slug, document:, request_options: {})
+      #
+      # @param slug [String]
+      # @param document [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::ThemeReplaceDocumentParams
+      def replace_document(slug, params)
+        parsed, options = Scalar::ThemeReplaceDocumentParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: ["v1/themes/%1$s", slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Scalar
+  VERSION = "0.2.0" # x-release-please-version
+end