scalar_api_ruby 0.2.0

data/lib/scalar_api_ruby/resources/authentication.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Authentication
+    class Authentication
+      # Exchange an API key for an access token.
+      #
+      # @overload exchange_personal_token(personal_token:, request_options: {})
+      #
+      # @param personal_token [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::AuthenticationExchangePersonalTokenResponse]
+      #
+      # @see Scalar::Models::AuthenticationExchangePersonalTokenParams
+      def exchange_personal_token(params)
+        parsed, options = Scalar::AuthenticationExchangePersonalTokenParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v1/auth/exchange",
+          body: parsed,
+          model: Scalar::Models::AuthenticationExchangePersonalTokenResponse,
+          options: options
+        )
+      end
+
+      # Get the authenticated user, including their available teams and theme.
+      #
+      # @overload list_current_user(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::User]
+      #
+      # @see Scalar::Models::AuthenticationListCurrentUserParams
+      def list_current_user(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/auth/me",
+          model: Scalar::User,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/login_portals.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Login Portals
+    class LoginPortals
+      # Create a login portal for the current team.
+      #
+      # @overload create(email:, page:, slug:, title:, request_options: {})
+      #
+      # @param email [Scalar::Models::LoginPortalEmail]
+      # @param page [Scalar::Models::LoginPortalPage]
+      # @param slug [String]
+      # @param title [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::UID]
+      #
+      # @see Scalar::Models::LoginPortalCreateParams
+      def create(params)
+        parsed, options = Scalar::LoginPortalCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v1/login-portals",
+          body: parsed,
+          model: Scalar::UID,
+          options: options
+        )
+      end
+
+      # Get a login portal by slug.
+      #
+      # @overload retrieve(slug, request_options: {})
+      #
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::LoginPortalRetrieveResponse]
+      #
+      # @see Scalar::Models::LoginPortalRetrieveParams
+      def retrieve(slug, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/login-portals/%1$s", slug],
+          model: Scalar::Models::LoginPortalRetrieveResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Update metadata for a login portal.
+      #
+      # @overload update(slug, title: nil, request_options: {})
+      #
+      # @param slug [String]
+      # @param title [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::LoginPortalUpdateParams
+      def update(slug, params = {})
+        parsed, options = Scalar::LoginPortalUpdateParams.dump_request(params)
+        @client.request(
+          method: :patch,
+          path: ["v1/login-portals/%1$s", slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # List all login portals for the current team.
+      #
+      # @overload list(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::LoginPortal>]
+      #
+      # @see Scalar::Models::LoginPortalListParams
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/login-portals",
+          model: Scalar::Internal::Type::ArrayOf[Scalar::LoginPortal],
+          options: params[:request_options]
+        )
+      end
+
+      # Delete a login portal.
+      #
+      # @overload delete(slug, request_options: {})
+      #
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::LoginPortalDeleteParams
+      def delete(slug, params = {})
+        @client.request(
+          method: :delete,
+          path: ["v1/login-portals/%1$s", slug],
+          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

data/lib/scalar_api_ruby/resources/mcp/servers/installations.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Mcp
+      class Servers
+        # MCP
+        class Installations
+          # Create an installation of an MCP server. `documentAuth` holds the credentials
+          # the server presents to the upstream API and is never returned.
+          #
+          # @overload create(id, document_auth:, name:, slug: nil, request_options: {})
+          #
+          # @param id [String]
+          # @param document_auth [Hash{Symbol=>Object}]
+          # @param name [String]
+          # @param slug [String]
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Scalar::Models::Mcp::McpInstallation]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationCreateParams
+          def create(id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationCreateParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: ["v1/mcp/servers/%1$s/installations", id],
+              body: parsed,
+              model: Scalar::Mcp::McpInstallation,
+              options: options
+            )
+          end
+
+          # Get a single installation of an MCP server.
+          #
+          # @overload retrieve(installation_id, id:, request_options: {})
+          #
+          # @param installation_id [String]
+          # @param id [String]
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Scalar::Models::Mcp::McpInstallation]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationRetrieveParams
+          def retrieve(installation_id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationRetrieveParams.dump_request(params)
+            id = parsed.delete(:id) { raise ArgumentError.new("missing required path argument #{_1}") }
+            @client.request(
+              method: :get,
+              path: ["v1/mcp/servers/%1$s/installations/%2$s", id, installation_id],
+              model: Scalar::Mcp::McpInstallation,
+              options: options
+            )
+          end
+
+          # Update an installation. Set `isPrivate` and add access groups to put it behind a
+          # login.
+          #
+          # @overload update(installation_id, id:, document_auth: nil, is_private: nil, login_portal_uid: nil, mcp_version: nil, name: nil, slug: nil, request_options: {})
+          #
+          # @param installation_id [String] Path param
+          #
+          # @param id [String] Path param
+          #
+          # @param document_auth [Hash{Symbol=>Object}] Body param
+          #
+          # @param is_private [Boolean] Body param
+          #
+          # @param login_portal_uid [String, nil] Body param
+          #
+          # @param mcp_version [String, nil] Body param
+          #
+          # @param name [String] Body param
+          #
+          # @param slug [String] Body param
+          #
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Scalar::Models::Mcp::McpInstallation]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationUpdateParams
+          def update(installation_id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationUpdateParams.dump_request(params)
+            id = parsed.delete(:id) { raise ArgumentError.new("missing required path argument #{_1}") }
+            @client.request(
+              method: :patch,
+              path: ["v1/mcp/servers/%1$s/installations/%2$s", id, installation_id],
+              body: parsed,
+              model: Scalar::Mcp::McpInstallation,
+              options: options
+            )
+          end
+
+          # List the installations of an MCP server. An installation is what an MCP client
+          # connects to.
+          #
+          # @overload list(id, request_options: {})
+          #
+          # @param id [String]
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Scalar::Models::Mcp::Servers::McpInstallationListItem>]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationListParams
+          def list(id, params = {})
+            @client.request(
+              method: :get,
+              path: ["v1/mcp/servers/%1$s/installations", id],
+              model: Scalar::Internal::Type::ArrayOf[Scalar::Mcp::Servers::McpInstallationListItem],
+              options: params[:request_options]
+            )
+          end
+
+          # Delete an installation of an MCP server.
+          #
+          # @overload delete(installation_id, id:, request_options: {})
+          #
+          # @param installation_id [String]
+          # @param id [String]
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Object]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationDeleteParams
+          def delete(installation_id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationDeleteParams.dump_request(params)
+            id = parsed.delete(:id) { raise ArgumentError.new("missing required path argument #{_1}") }
+            @client.request(
+              method: :delete,
+              path: ["v1/mcp/servers/%1$s/installations/%2$s", id, installation_id],
+              model: Scalar::Internal::Type::Unknown,
+              options: options
+            )
+          end
+
+          # Let an access group reach a private installation.
+          #
+          # @overload create_access_group(installation_id, id:, access_group_uid:, request_options: {})
+          #
+          # @param installation_id [String] Path param
+          #
+          # @param id [String] Path param
+          #
+          # @param access_group_uid [String] Body param
+          #
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Object]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationCreateAccessGroupParams
+          def create_access_group(installation_id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationCreateAccessGroupParams.dump_request(params)
+            id = parsed.delete(:id) { raise ArgumentError.new("missing required path argument #{_1}") }
+            @client.request(
+              method: :post,
+              path: ["v1/mcp/servers/%1$s/installations/%2$s/access-group", id, installation_id],
+              body: parsed,
+              model: Scalar::Internal::Type::Unknown,
+              options: options
+            )
+          end
+
+          # Stop an access group reaching a private installation.
+          #
+          # @overload delete_access_group(installation_id, id:, access_group_uid:, request_options: {})
+          #
+          # @param installation_id [String] Path param
+          #
+          # @param id [String] Path param
+          #
+          # @param access_group_uid [String] Body param
+          #
+          # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Object]
+          #
+          # @see Scalar::Models::Mcp::Servers::InstallationDeleteAccessGroupParams
+          def delete_access_group(installation_id, params)
+            parsed, options = Scalar::Mcp::Servers::InstallationDeleteAccessGroupParams.dump_request(params)
+            id = parsed.delete(:id) { raise ArgumentError.new("missing required path argument #{_1}") }
+            @client.request(
+              method: :delete,
+              path: ["v1/mcp/servers/%1$s/installations/%2$s/access-group", id, installation_id],
+              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
+end

data/lib/scalar_api_ruby/resources/mcp/servers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Mcp
+      # MCP
+      class Servers
+        # MCP
+        # @return [Scalar::Resources::Mcp::Servers::Installations]
+        attr_reader :installations
+
+        # Create an MCP server over one or more API document versions. The response
+        # carries the server and its first installation.
+        #
+        # @overload create(name:, project_uids: nil, slug: nil, version_uids: nil, request_options: {})
+        #
+        # @param name [String]
+        # @param project_uids [Array<String>]
+        # @param slug [String]
+        # @param version_uids [Array<String>]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Scalar::Models::Mcp::ServerCreateResponse]
+        #
+        # @see Scalar::Models::Mcp::ServerCreateParams
+        def create(params)
+          parsed, options = Scalar::Mcp::ServerCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "v1/mcp/servers",
+            body: parsed,
+            model: Scalar::Models::Mcp::ServerCreateResponse,
+            options: options
+          )
+        end
+
+        # Get a single MCP server by its id.
+        #
+        # @overload retrieve(id, request_options: {})
+        #
+        # @param id [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Scalar::Models::Mcp::McpServer]
+        #
+        # @see Scalar::Models::Mcp::ServerRetrieveParams
+        def retrieve(id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/mcp/servers/%1$s", id],
+            model: Scalar::Mcp::McpServer,
+            options: params[:request_options]
+          )
+        end
+
+        # Update MCP server metadata and which tools it exposes.
+        #
+        # @overload update(id, auto_add_operations: nil, docs_pages: nil, name: nil, operations: nil, slug: nil, request_options: {})
+        #
+        # @param id [String]
+        # @param auto_add_operations [Boolean]
+        # @param docs_pages [Array<String>]
+        # @param name [String]
+        # @param operations [Array<String>]
+        # @param slug [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Scalar::Models::Mcp::McpServer]
+        #
+        # @see Scalar::Models::Mcp::ServerUpdateParams
+        def update(id, params = {})
+          parsed, options = Scalar::Mcp::ServerUpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["v1/mcp/servers/%1$s", id],
+            body: parsed,
+            model: Scalar::Mcp::McpServer,
+            options: options
+          )
+        end
+
+        # List every MCP server on the team.
+        #
+        # @overload list(request_options: {})
+        #
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Array<Scalar::Models::Mcp::McpServer>]
+        #
+        # @see Scalar::Models::Mcp::ServerListParams
+        def list(params = {})
+          @client.request(
+            method: :get,
+            path: "v1/mcp/servers",
+            model: Scalar::Internal::Type::ArrayOf[Scalar::Mcp::McpServer],
+            options: params[:request_options]
+          )
+        end
+
+        # Delete an MCP server and every installation it serves.
+        #
+        # @overload delete(id, request_options: {})
+        #
+        # @param id [String]
+        # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see Scalar::Models::Mcp::ServerDeleteParams
+        def delete(id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v1/mcp/servers/%1$s", id],
+            model: Scalar::Internal::Type::Unknown,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Scalar::Client]
+        def initialize(client:)
+          @client = client
+          @installations = Scalar::Resources::Mcp::Servers::Installations.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/mcp.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    class Mcp
+      # MCP
+      # @return [Scalar::Resources::Mcp::Servers]
+      attr_reader :servers
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+        @servers = Scalar::Resources::Mcp::Servers.new(client: client)
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/namespaces.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Namespaces
+    class Namespaces
+      # Get all namespaces for the current team
+      #
+      # @overload list(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [String]
+      #
+      # @see Scalar::Models::NamespaceListParams
+      def list(params = {})
+        @client.request(method: :get, path: "v1/namespaces", model: String, options: params[:request_options])
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end