scalar_api_ruby 0.2.0

data/lib/scalar_api_ruby/resources/registry.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Registry
+    class Registry
+      # Create an API document.
+      #
+      # @overload create_api_document(namespace, document:, slug:, title:, version:, description: nil, is_private: nil, ruleset: nil, request_options: {})
+      #
+      # @param namespace [String]
+      # @param document [String]
+      # @param slug [String]
+      # @param title [String]
+      # @param version [String]
+      # @param description [String]
+      # @param is_private [Boolean]
+      # @param ruleset [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::RegistryCreateAPIDocumentResponse]
+      #
+      # @see Scalar::Models::RegistryCreateAPIDocumentParams
+      def create_api_document(namespace, params)
+        parsed, options = Scalar::RegistryCreateAPIDocumentParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/apis/%1$s", namespace],
+          body: parsed,
+          model: Scalar::Models::RegistryCreateAPIDocumentResponse,
+          options: options
+        )
+      end
+
+      # Add an access group to an API document.
+      #
+      # @overload create_api_document_access_group(slug, access_group_slug:, namespace:, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param access_group_slug [String] Body param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RegistryCreateAPIDocumentAccessGroupParams
+      def create_api_document_access_group(slug, params)
+        parsed, options = Scalar::RegistryCreateAPIDocumentAccessGroupParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :post,
+          path: ["v1/apis/%1$s/%2$s/access-group", namespace, slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Create a new API document version.
+      #
+      # @overload create_api_document_version(slug, namespace:, document:, version:, force: nil, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param document [String] Body param
+      #
+      # @param version [String] Body param
+      #
+      # @param force [Boolean] Body param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::ManagedDocVersion]
+      #
+      # @see Scalar::Models::RegistryCreateAPIDocumentVersionParams
+      def create_api_document_version(slug, params)
+        parsed, options = Scalar::RegistryCreateAPIDocumentVersionParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :post,
+          path: ["v1/apis/%1$s/%2$s/version", namespace, slug],
+          body: parsed,
+          model: Scalar::ManagedDocVersion,
+          options: options
+        )
+      end
+
+      # Delete an API document and all versions.
+      #
+      # @overload delete_api_document(slug, namespace:, request_options: {})
+      #
+      # @param slug [String]
+      # @param namespace [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RegistryDeleteAPIDocumentParams
+      def delete_api_document(slug, params)
+        parsed, options = Scalar::RegistryDeleteAPIDocumentParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :delete,
+          path: ["v1/apis/%1$s/%2$s", namespace, slug],
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Remove an access group from an API document.
+      #
+      # @overload delete_api_document_access_group(slug, access_group_slug:, namespace:, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param access_group_slug [String] Body param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RegistryDeleteAPIDocumentAccessGroupParams
+      def delete_api_document_access_group(slug, params)
+        parsed, options = Scalar::RegistryDeleteAPIDocumentAccessGroupParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :delete,
+          path: ["v1/apis/%1$s/%2$s/access-group", namespace, slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Delete a specific API document version.
+      #
+      # @overload delete_api_document_version(semver, namespace:, slug:, request_options: {})
+      #
+      # @param semver [String]
+      # @param namespace [String]
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RegistryDeleteAPIDocumentVersionParams
+      def delete_api_document_version(semver, params)
+        parsed, options = Scalar::RegistryDeleteAPIDocumentVersionParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        slug = parsed.delete(:slug) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :delete,
+          path: ["v1/apis/%1$s/%2$s/version/%3$s", namespace, slug, semver],
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # List all API documents across every namespace the caller can access.
+      #
+      # @overload list_all_api_documents(request_options: {})
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::APIDocument>]
+      #
+      # @see Scalar::Models::RegistryListAllAPIDocumentsParams
+      def list_all_api_documents(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/apis",
+          model: Scalar::Internal::Type::ArrayOf[Scalar::APIDocument],
+          options: params[:request_options]
+        )
+      end
+
+      # Get metadata (uid, content shas, version sha, tags) for a specific API document
+      # version.
+      #
+      # @overload list_api_document_version_metadata(semver, namespace:, slug:, request_options: {})
+      #
+      # @param semver [String]
+      # @param namespace [String]
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::ManagedDocVersion]
+      #
+      # @see Scalar::Models::RegistryListAPIDocumentVersionMetadataParams
+      def list_api_document_version_metadata(semver, params)
+        parsed, options = Scalar::RegistryListAPIDocumentVersionMetadataParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        slug = parsed.delete(:slug) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :get,
+          path: ["v1/apis/%1$s/%2$s/version/%3$s/metadata", namespace, slug, semver],
+          model: Scalar::ManagedDocVersion,
+          options: options
+        )
+      end
+
+      # List API documents in a namespace.
+      #
+      # @overload list_api_documents(namespace, request_options: {})
+      #
+      # @param namespace [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::APIDocument>]
+      #
+      # @see Scalar::Models::RegistryListAPIDocumentsParams
+      def list_api_documents(namespace, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/apis/%1$s", namespace],
+          model: Scalar::Internal::Type::ArrayOf[Scalar::APIDocument],
+          options: params[:request_options]
+        )
+      end
+
+      # Get a specific API document version.
+      #
+      # @overload retrieve_api_document_version(semver, namespace:, slug:, request_options: {})
+      #
+      # @param semver [String]
+      # @param namespace [String]
+      # @param slug [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [String]
+      #
+      # @see Scalar::Models::RegistryRetrieveAPIDocumentVersionParams
+      def retrieve_api_document_version(semver, params)
+        parsed, options = Scalar::RegistryRetrieveAPIDocumentVersionParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        slug = parsed.delete(:slug) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :get,
+          path: ["v1/apis/%1$s/%2$s/version/%3$s", namespace, slug, semver],
+          headers: {
+            "accept" => "text/plain"
+          },
+          model: String,
+          options: options
+        )
+      end
+
+      # Update metadata for an API document.
+      #
+      # @overload update_api_document(slug, namespace:, description: nil, is_private: nil, ruleset: nil, title: nil, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param description [String] Body param
+      #
+      # @param is_private [Boolean] Body param
+      #
+      # @param ruleset [String] Body param
+      #
+      # @param title [String] Body param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RegistryUpdateAPIDocumentParams
+      def update_api_document(slug, params)
+        parsed, options = Scalar::RegistryUpdateAPIDocumentParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :patch,
+          path: ["v1/apis/%1$s/%2$s", namespace, slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Update the registry file content for an API document version.
+      #
+      # @overload update_api_document_version(semver, namespace:, slug:, document:, request_options: {})
+      #
+      # @param semver [String] Path param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param slug [String] Path param
+      #
+      # @param document [String] Body param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::RegistryUpdateAPIDocumentVersionResponse]
+      #
+      # @see Scalar::Models::RegistryUpdateAPIDocumentVersionParams
+      def update_api_document_version(semver, params)
+        parsed, options = Scalar::RegistryUpdateAPIDocumentVersionParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        slug = parsed.delete(:slug) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :patch,
+          path: ["v1/apis/%1$s/%2$s/version/%3$s", namespace, slug, semver],
+          body: parsed,
+          model: Scalar::Models::RegistryUpdateAPIDocumentVersionResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Scalar::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/scalar_api_ruby/resources/rules.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Scalar
+  module Resources
+    # Rules
+    class Rules
+      # Create a rule in a namespace.
+      #
+      # @overload create_ruleset(namespace, document:, slug:, title:, description: nil, is_private: nil, request_options: {})
+      #
+      # @param namespace [String]
+      # @param document [String]
+      # @param slug [String]
+      # @param title [String]
+      # @param description [String]
+      # @param is_private [Boolean]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Scalar::Models::UID]
+      #
+      # @see Scalar::Models::RuleCreateRulesetParams
+      def create_ruleset(namespace, params)
+        parsed, options = Scalar::RuleCreateRulesetParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/rulesets/%1$s", namespace],
+          body: parsed,
+          model: Scalar::UID,
+          options: options
+        )
+      end
+
+      # Grant an access group to a rule.
+      #
+      # @overload create_ruleset_access_group(slug, access_group_slug:, namespace:, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param access_group_slug [String] Body param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RuleCreateRulesetAccessGroupParams
+      def create_ruleset_access_group(slug, params)
+        parsed, options = Scalar::RuleCreateRulesetAccessGroupParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :post,
+          path: ["v1/rulesets/%1$s/%2$s/access-group", namespace, slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Delete a rule by slug.
+      #
+      # @overload delete_ruleset(slug, namespace:, request_options: {})
+      #
+      # @param slug [String]
+      # @param namespace [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RuleDeleteRulesetParams
+      def delete_ruleset(slug, params)
+        parsed, options = Scalar::RuleDeleteRulesetParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :delete,
+          path: ["v1/rulesets/%1$s/%2$s", namespace, slug],
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # Remove an access group from a rule.
+      #
+      # @overload delete_ruleset_access_group(slug, access_group_slug:, namespace:, request_options: {})
+      #
+      # @param slug [String] Path param
+      #
+      # @param access_group_slug [String] Body param
+      #
+      # @param namespace [String] Path param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RuleDeleteRulesetAccessGroupParams
+      def delete_ruleset_access_group(slug, params)
+        parsed, options = Scalar::RuleDeleteRulesetAccessGroupParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :delete,
+          path: ["v1/rulesets/%1$s/%2$s/access-group", namespace, slug],
+          body: parsed,
+          model: Scalar::Internal::Type::Unknown,
+          options: options
+        )
+      end
+
+      # List all rulesets in a namespace.
+      #
+      # @overload list_rulesets(namespace, request_options: {})
+      #
+      # @param namespace [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Scalar::Models::Rule>]
+      #
+      # @see Scalar::Models::RuleListRulesetsParams
+      def list_rulesets(namespace, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/rulesets/%1$s", namespace],
+          model: Scalar::Internal::Type::ArrayOf[Scalar::Rule],
+          options: params[:request_options]
+        )
+      end
+
+      # Get a rule document by slug.
+      #
+      # @overload retrieve_ruleset_document(slug, namespace:, request_options: {})
+      #
+      # @param slug [String]
+      # @param namespace [String]
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [String]
+      #
+      # @see Scalar::Models::RuleRetrieveRulesetDocumentParams
+      def retrieve_ruleset_document(slug, params)
+        parsed, options = Scalar::RuleRetrieveRulesetDocumentParams.dump_request(params)
+        namespace =
+          parsed.delete(:namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :get,
+          path: ["v1/rulesets/%1$s/%2$s", namespace, slug],
+          headers: {
+            "accept" => "text/plain"
+          },
+          model: String,
+          options: options
+        )
+      end
+
+      # Update rule metadata by slug.
+      #
+      # @overload update_ruleset(path_slug, path_namespace:, description: nil, is_private: nil, body_namespace: nil, body_slug: nil, title: nil, request_options: {})
+      #
+      # @param path_slug [String] Path param
+      #
+      # @param path_namespace [String] Path param
+      #
+      # @param description [String] Body param
+      #
+      # @param is_private [Boolean] Body param
+      #
+      # @param body_namespace [String] Body param
+      #
+      # @param body_slug [String] Body param
+      #
+      # @param title [String] Body param
+      #
+      # @param request_options [Scalar::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Object]
+      #
+      # @see Scalar::Models::RuleUpdateRulesetParams
+      def update_ruleset(path_slug, params)
+        parsed, options = Scalar::RuleUpdateRulesetParams.dump_request(params)
+        path_namespace =
+          parsed.delete(:path_namespace) { raise ArgumentError.new("missing required path argument #{_1}") }
+        @client.request(
+          method: :patch,
+          path: ["v1/rulesets/%1$s/%2$s", path_namespace, path_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