scalar_api_ruby 0.2.0

data/rbi/scalar_api_ruby/request_options.rbi

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

data/rbi/scalar_api_ruby/resources/access_groups/domains.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    class AccessGroups
+      # Access Groups
+      class Domains
+        # Allow an exact email domain in a group. Requires docs edit permission. A group
+        # supports up to 1000 domains.
+        sig do
+          params(
+            slug: String,
+            domain: String,
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(T.anything)
+        end
+        def create(slug, domain:, request_options: {})
+        end
+
+        # Remove an exact email domain from a group. Requires docs edit permission. Other
+        # allowed domains and emails are preserved.
+        sig do
+          params(
+            slug: String,
+            domain: String,
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(T.anything)
+        end
+        def delete(slug, domain:, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Scalar::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/access_groups.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    # Access Groups
+    class AccessGroups
+      # Access Groups
+      sig { returns(Scalar::Resources::AccessGroups::Domains) }
+      attr_reader :domains
+
+      # Create a group for the current team. Requires docs edit permission and the
+      # access groups billing feature. Domains are exact email domains, without
+      # wildcards or implicit subdomain matching.
+      sig do
+        params(
+          allowed_domains: String,
+          name: String,
+          slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(Scalar::Models::AccessGroupCreateResponse)
+      end
+      def create(
+        allowed_domains: nil,
+        name: nil,
+        slug: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a group and its email and domain allowlists by slug.
+      sig do
+        params(
+          slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(Scalar::Models::AccessGroupRetrieveResponse)
+      end
+      def retrieve(slug, request_options: {})
+      end
+
+      # Update group metadata. Requires docs edit permission. After changing the slug,
+      # use the new slug in subsequent requests.
+      sig do
+        params(
+          path_slug: String,
+          name: String,
+          body_slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(T.anything)
+      end
+      def update(path_slug, name: nil, body_slug: nil, request_options: {})
+      end
+
+      # Delete a group and remove its project assignments. Requires docs edit
+      # permission.
+      sig do
+        params(
+          slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(T.anything)
+      end
+      def delete(slug, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Scalar::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/authentication.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    # Authentication
+    class Authentication
+      # Exchange an API key for an access token.
+      sig do
+        params(
+          personal_token: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(Scalar::Models::AuthenticationExchangePersonalTokenResponse)
+      end
+      def exchange_personal_token(personal_token:, request_options: {})
+      end
+
+      # Get the authenticated user, including their available teams and theme.
+      sig do
+        params(request_options: Scalar::RequestOptions::OrHash).returns(
+          Scalar::User
+        )
+      end
+      def list_current_user(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Scalar::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/login_portals.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    # Login Portals
+    class LoginPortals
+      # Create a login portal for the current team.
+      sig do
+        params(
+          email: Scalar::LoginPortalEmail::OrHash,
+          page: Scalar::LoginPortalPage::OrHash,
+          slug: String,
+          title: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(Scalar::UID)
+      end
+      def create(email:, page:, slug:, title:, request_options: {})
+      end
+
+      # Get a login portal by slug.
+      sig do
+        params(
+          slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(Scalar::Models::LoginPortalRetrieveResponse)
+      end
+      def retrieve(slug, request_options: {})
+      end
+
+      # Update metadata for a login portal.
+      sig do
+        params(
+          slug: String,
+          title: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(T.anything)
+      end
+      def update(slug, title: nil, request_options: {})
+      end
+
+      # List all login portals for the current team.
+      sig do
+        params(request_options: Scalar::RequestOptions::OrHash).returns(
+          T::Array[Scalar::LoginPortal]
+        )
+      end
+      def list(request_options: {})
+      end
+
+      # Delete a login portal.
+      sig do
+        params(
+          slug: String,
+          request_options: Scalar::RequestOptions::OrHash
+        ).returns(T.anything)
+      end
+      def delete(slug, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Scalar::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/mcp/servers/installations.rbi

@@ -0,0 +1,140 @@
+# typed: strong
+
+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.
+          sig do
+            params(
+              id: String,
+              document_auth: T::Hash[Symbol, T.anything],
+              name: String,
+              slug: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(Scalar::Mcp::McpInstallation)
+          end
+          def create(id, document_auth:, name:, slug: nil, request_options: {})
+          end
+
+          # Get a single installation of an MCP server.
+          sig do
+            params(
+              installation_id: String,
+              id: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(Scalar::Mcp::McpInstallation)
+          end
+          def retrieve(installation_id, id:, request_options: {})
+          end
+
+          # Update an installation. Set `isPrivate` and add access groups to put it behind a
+          # login.
+          sig do
+            params(
+              installation_id: String,
+              id: String,
+              document_auth: T::Hash[Symbol, T.anything],
+              is_private: T::Boolean,
+              login_portal_uid: T.nilable(String),
+              mcp_version: T.nilable(String),
+              name: String,
+              slug: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(Scalar::Mcp::McpInstallation)
+          end
+          def update(
+            # Path param
+            installation_id,
+            # Path param
+            id:,
+            # Body param
+            document_auth: nil,
+            # Body param
+            is_private: nil,
+            # Body param
+            login_portal_uid: nil,
+            # Body param
+            mcp_version: nil,
+            # Body param
+            name: nil,
+            # Body param
+            slug: nil,
+            request_options: {}
+          )
+          end
+
+          # List the installations of an MCP server. An installation is what an MCP client
+          # connects to.
+          sig do
+            params(
+              id: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(T::Array[Scalar::Mcp::Servers::McpInstallationListItem])
+          end
+          def list(id, request_options: {})
+          end
+
+          # Delete an installation of an MCP server.
+          sig do
+            params(
+              installation_id: String,
+              id: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(T.anything)
+          end
+          def delete(installation_id, id:, request_options: {})
+          end
+
+          # Let an access group reach a private installation.
+          sig do
+            params(
+              installation_id: String,
+              id: String,
+              access_group_uid: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(T.anything)
+          end
+          def create_access_group(
+            # Path param
+            installation_id,
+            # Path param
+            id:,
+            # Body param
+            access_group_uid:,
+            request_options: {}
+          )
+          end
+
+          # Stop an access group reaching a private installation.
+          sig do
+            params(
+              installation_id: String,
+              id: String,
+              access_group_uid: String,
+              request_options: Scalar::RequestOptions::OrHash
+            ).returns(T.anything)
+          end
+          def delete_access_group(
+            # Path param
+            installation_id,
+            # Path param
+            id:,
+            # Body param
+            access_group_uid:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Scalar::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/mcp/servers.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    class Mcp
+      # MCP
+      class Servers
+        # MCP
+        sig { returns(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.
+        sig do
+          params(
+            name: String,
+            project_uids: T::Array[String],
+            slug: String,
+            version_uids: T::Array[String],
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(Scalar::Models::Mcp::ServerCreateResponse)
+        end
+        def create(
+          name:,
+          project_uids: nil,
+          slug: nil,
+          version_uids: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a single MCP server by its id.
+        sig do
+          params(
+            id: String,
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(Scalar::Mcp::McpServer)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        # Update MCP server metadata and which tools it exposes.
+        sig do
+          params(
+            id: String,
+            auto_add_operations: T::Boolean,
+            docs_pages: T::Array[String],
+            name: String,
+            operations: T::Array[String],
+            slug: String,
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(Scalar::Mcp::McpServer)
+        end
+        def update(
+          id,
+          auto_add_operations: nil,
+          docs_pages: nil,
+          name: nil,
+          operations: nil,
+          slug: nil,
+          request_options: {}
+        )
+        end
+
+        # List every MCP server on the team.
+        sig do
+          params(request_options: Scalar::RequestOptions::OrHash).returns(
+            T::Array[Scalar::Mcp::McpServer]
+          )
+        end
+        def list(request_options: {})
+        end
+
+        # Delete an MCP server and every installation it serves.
+        sig do
+          params(
+            id: String,
+            request_options: Scalar::RequestOptions::OrHash
+          ).returns(T.anything)
+        end
+        def delete(id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Scalar::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/mcp.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    class Mcp
+      # MCP
+      sig { returns(Scalar::Resources::Mcp::Servers) }
+      attr_reader :servers
+
+      # @api private
+      sig { params(client: Scalar::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/scalar_api_ruby/resources/namespaces.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Scalar
+  module Resources
+    # Namespaces
+    class Namespaces
+      # Get all namespaces for the current team
+      sig do
+        params(request_options: Scalar::RequestOptions::OrHash).returns(String)
+      end
+      def list(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Scalar::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end