openlayer 0.15.0 → 0.16.0

data/lib/openlayer/resources/governance/rule_results.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Governance
+      class RuleResults
+        # Retrieve a rule result by its id.
+        #
+        # Alongside the status, the response carries the evaluation and renewal dates that
+        # explain it: `dateLastEvaluated` and `dateOfNextEvaluation` for platform rules,
+        # `dateOfLatestEvidence` and `dateOfRenewal` for evidence rules.
+        #
+        # @overload retrieve(rule_result_id, request_options: {})
+        #
+        # @param rule_result_id [String] The rule result id.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleResultRetrieveResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleResultRetrieveParams
+        def retrieve(rule_result_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["rule-results/%1$s", rule_result_id],
+            model: Openlayer::Models::Governance::RuleResultRetrieveResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Update a rule result. Only the fields you send are changed.
+        #
+        # Use this to assign an owner, or to exclude a single result from compliance
+        # without deactivating the rule everywhere. `deactivatedReason` is required when
+        # setting `deactivated` to `true`.
+        #
+        # A result's `status` is computed by Openlayer and cannot be set directly.
+        #
+        # @overload update(rule_result_id, assignee_id: nil, blocked_by: nil, blocking: nil, deactivated: nil, deactivated_reason: nil, request_options: {})
+        #
+        # @param rule_result_id [String] The rule result id.
+        #
+        # @param assignee_id [String, nil] The user responsible for this result.
+        #
+        # @param blocked_by [Array<Openlayer::Models::Governance::RuleResultUpdateParams::BlockedBy>] Rule results that must pass before this one can be satisfied.
+        #
+        # @param blocking [Array<Openlayer::Models::Governance::RuleResultUpdateParams::Blocking>] Rule results that this one blocks.
+        #
+        # @param deactivated [Boolean] Whether this result is excluded from compliance calculations.
+        #
+        # @param deactivated_reason [String, nil] Why the result was excluded.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleResultUpdateResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleResultUpdateParams
+        def update(rule_result_id, params = {})
+          parsed, options = Openlayer::Governance::RuleResultUpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["rule-results/%1$s", rule_result_id],
+            body: parsed,
+            model: Openlayer::Models::Governance::RuleResultUpdateResponse,
+            options: options
+          )
+        end
+
+        # List rule results across a workspace.
+        #
+        # A rule result is the compliance status of one rule for one entity: a project for
+        # project-scoped rules, or the workspace itself for workspace-scoped rules. This
+        # is the endpoint to poll or export when you want your current compliance state,
+        # filtered to a framework, a project, or a status.
+        #
+        # @overload list(workspace_id, enabled_framework_only: nil, framework_id: nil, include_unframed: nil, page: nil, per_page: nil, project_id: nil, rule_id: nil, scope: nil, search_query: nil, status: nil, type: nil, request_options: {})
+        #
+        # @param workspace_id [String] The workspace id.
+        #
+        # @param enabled_framework_only [Boolean] Only include items belonging to at least one enabled framework.
+        #
+        # @param framework_id [String] Only include items belonging to this framework.
+        #
+        # @param include_unframed [Boolean] Whether to include rules that are not part of any framework.
+        #
+        # @param page [Integer] The page to return in a paginated query.
+        #
+        # @param per_page [Integer] Maximum number of items to return per page.
+        #
+        # @param project_id [String] Only include items that apply to this project.
+        #
+        # @param rule_id [String] Only include results of this rule.
+        #
+        # @param scope [Symbol, Openlayer::Models::Governance::RuleResultListParams::Scope] Only include rules with this scope.
+        #
+        # @param search_query [String] Filter by a free-text search over names and descriptions.
+        #
+        # @param status [Symbol, Openlayer::Models::Governance::RuleResultListParams::Status] Only include items whose rule result has this compliance status.
+        #
+        # @param type [Symbol, Openlayer::Models::Governance::RuleResultListParams::Type] Only include rules of this type.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleResultListResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleResultListParams
+        def list(workspace_id, params = {})
+          parsed, options = Openlayer::Governance::RuleResultListParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: ["workspaces/%1$s/rule-results", workspace_id],
+            query: query.transform_keys(
+              enabled_framework_only: "enabledFrameworkOnly",
+              framework_id: "frameworkId",
+              include_unframed: "includeUnframed",
+              per_page: "perPage",
+              project_id: "projectId",
+              rule_id: "ruleId",
+              search_query: "searchQuery"
+            ),
+            model: Openlayer::Models::Governance::RuleResultListResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Openlayer::Models::Governance::RuleResultCreateEvidenceParams} for more
+        # details.
+        #
+        # Attach evidence to a rule result, satisfying an evidence rule.
+        #
+        # Send the field that matches the rule's `evidenceType`: `storageUri` for an
+        # uploaded document, `text` for a written statement, or `url` for a link.
+        #
+        # For a document, upload the file first with `POST /storage/presigned-url` and
+        # send the resulting storage URI as `storageUri`.
+        #
+        # Attaching evidence re-evaluates the rule result. If the rule sets
+        # `renewalCadenceDays`, the renewal window restarts from this evidence.
+        #
+        # @overload create_evidence(rule_result_id, description: nil, name: nil, storage_uri: nil, text: nil, url: nil, request_options: {})
+        #
+        # @param rule_result_id [String] The rule result id.
+        #
+        # @param description [String, nil] A description of what the evidence shows.
+        #
+        # @param name [String, nil] The evidence name.
+        #
+        # @param storage_uri [String, nil] Where the uploaded file is stored. Set when the rule's `evidenceType` is `docume
+        #
+        # @param text [String, nil] The evidence text. Set when the rule's `evidenceType` is `text`.
+        #
+        # @param url [String, nil] A link to the evidence. Set when the rule's `evidenceType` is `url`.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleResultCreateEvidenceResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleResultCreateEvidenceParams
+        def create_evidence(rule_result_id, params = {})
+          parsed, options = Openlayer::Governance::RuleResultCreateEvidenceParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["rule-results/%1$s/evidence", rule_result_id],
+            body: parsed,
+            model: Openlayer::Models::Governance::RuleResultCreateEvidenceResponse,
+            options: options
+          )
+        end
+
+        # List the evidence attached to a rule result.
+        #
+        # Which field carries the evidence depends on the rule's `evidenceType`:
+        # `storageUri` for uploaded documents, `text` for written statements, and `url`
+        # for links.
+        #
+        # @overload list_evidence(rule_result_id, page: nil, per_page: nil, request_options: {})
+        #
+        # @param rule_result_id [String] The rule result id.
+        #
+        # @param page [Integer] The page to return in a paginated query.
+        #
+        # @param per_page [Integer] Maximum number of items to return per page.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleResultListEvidenceResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleResultListEvidenceParams
+        def list_evidence(rule_result_id, params = {})
+          parsed, options = Openlayer::Governance::RuleResultListEvidenceParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: ["rule-results/%1$s/evidence", rule_result_id],
+            query: query.transform_keys(per_page: "perPage"),
+            model: Openlayer::Models::Governance::RuleResultListEvidenceResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Openlayer::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/openlayer/resources/governance/rule_stats.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Governance
+      class RuleStats
+        # Get a compliance roll-up for a workspace: how many rules exist, and how many of
+        # their results are passing, failing, pending, or due for renewal.
+        #
+        # Counts respect the filters you pass, so `frameworkId` gives you a single
+        # framework's overall compliance and `projectId` gives you a single project's.
+        #
+        # @overload retrieve(workspace_id, framework_id: nil, project_id: nil, request_options: {})
+        #
+        # @param workspace_id [String] The workspace id.
+        #
+        # @param framework_id [String] Only include items belonging to this framework.
+        #
+        # @param project_id [String] Only include items that apply to this project.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleStatRetrieveResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleStatRetrieveParams
+        def retrieve(workspace_id, params = {})
+          parsed, options = Openlayer::Governance::RuleStatRetrieveParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: ["workspaces/%1$s/rule-stats", workspace_id],
+            query: query.transform_keys(framework_id: "frameworkId", project_id: "projectId"),
+            model: Openlayer::Models::Governance::RuleStatRetrieveResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Openlayer::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/openlayer/resources/governance/rule_tags.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Governance
+      class RuleTags
+        # List the rule tags in a workspace.
+        #
+        # Tags group rules across frameworks, for example by team or by control family.
+        # Use the ids returned here with the `tags` filter on
+        # [List rules](/api-reference/rest/governance/list-rules).
+        #
+        # @overload list(workspace_id, page: nil, per_page: nil, request_options: {})
+        #
+        # @param workspace_id [String] The workspace id.
+        #
+        # @param page [Integer] The page to return in a paginated query.
+        #
+        # @param per_page [Integer] Maximum number of items to return per page.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleTagListResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleTagListParams
+        def list(workspace_id, params = {})
+          parsed, options = Openlayer::Governance::RuleTagListParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: ["workspaces/%1$s/rule-tags", workspace_id],
+            query: query.transform_keys(per_page: "perPage"),
+            model: Openlayer::Models::Governance::RuleTagListResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Openlayer::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/openlayer/resources/governance/rules.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Governance
+      class Rules
+        # Some parameter documentations has been truncated, see
+        # {Openlayer::Models::Governance::RuleCreateParams} for more details.
+        #
+        # Create a governance rule in a workspace.
+        #
+        # A rule is one requirement. Its `type` decides how it is satisfied, and the two
+        # types accept different fields:
+        #
+        # - `platform` rules are evaluated automatically from the state of your workspace.
+        #   Set `automationType` to the signal to check. Their `scope` must be `project`,
+        #   and `evidenceType` and `renewalCadenceDays` must be omitted or `null`.
+        # - `evidence` rules are satisfied by attaching evidence. Set `evidenceType` to
+        #   the kind of evidence that satisfies them. `automationType` and
+        #   `automationParams` must be omitted or `null`.
+        #
+        # A new rule belongs to no framework. Map it to one from the Openlayer app.
+        #
+        # @overload create(workspace_id, name:, scope:, type:, assignee_id: nil, automation_params: nil, automation_type: nil, deactivated: nil, description: nil, evidence_type: nil, renewal_cadence_days: nil, tag_ids: nil, request_options: {})
+        #
+        # @param workspace_id [String] The workspace id.
+        #
+        # @param name [String] The rule name.
+        #
+        # @param scope [Symbol, Openlayer::Models::Governance::RuleCreateParams::Scope] Whether the rule is evaluated once for the whole workspace, or once per project
+        #
+        # @param type [Symbol, Openlayer::Models::Governance::RuleCreateParams::Type] `platform` rules are evaluated automatically from the state of your Openlayer wo
+        #
+        # @param assignee_id [String, nil] The user responsible for satisfying the rule.
+        #
+        # @param automation_params [Hash{Symbol=>Object}, nil] Configuration for the platform check, when the automation takes parameters.
+        #
+        # @param automation_type [String, nil] Which workspace signal a platform rule checks, for example `monitoring_mode_enab
+        #
+        # @param deactivated [Boolean] Whether the rule is excluded from compliance calculations.
+        #
+        # @param description [String, nil] What the rule requires.
+        #
+        # @param evidence_type [Symbol, Openlayer::Models::Governance::RuleCreateParams::EvidenceType, nil] The kind of evidence that satisfies the rule. `null` for platform rules.
+        #
+        # @param renewal_cadence_days [Integer, nil] How often evidence must be renewed, in days. Once evidence is older than this, t
+        #
+        # @param tag_ids [Array<String>, nil] The ids of the rule tags to associate with the rule. Replaces the rule's tags. R
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleCreateResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleCreateParams
+        def create(workspace_id, params)
+          parsed, options = Openlayer::Governance::RuleCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["workspaces/%1$s/rules", workspace_id],
+            body: parsed,
+            model: Openlayer::Models::Governance::RuleCreateResponse,
+            options: options
+          )
+        end
+
+        # Retrieve a governance rule by its id, including the frameworks it belongs to and
+        # its tags.
+        #
+        # @overload retrieve(rule_id, request_options: {})
+        #
+        # @param rule_id [String] The rule id.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleRetrieveResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleRetrieveParams
+        def retrieve(rule_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["rules/%1$s", rule_id],
+            model: Openlayer::Models::Governance::RuleRetrieveResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Openlayer::Models::Governance::RuleUpdateParams} for more details.
+        #
+        # Update a governance rule. Only the fields you send are changed.
+        #
+        # Rules that ship with Openlayer report `immutable: true` and cannot be edited.
+        #
+        # A rule's `scope`, `type`, `evidenceType`, and automation are fixed once it
+        # exists -- create a new rule instead of converting one.
+        #
+        # @overload update(rule_id, assignee_id: nil, deactivated: nil, description: nil, name: nil, renewal_cadence_days: nil, tag_ids: nil, request_options: {})
+        #
+        # @param rule_id [String] The rule id.
+        #
+        # @param assignee_id [String, nil] The user responsible for satisfying the rule.
+        #
+        # @param deactivated [Boolean] Whether the rule is excluded from compliance calculations.
+        #
+        # @param description [String, nil] What the rule requires.
+        #
+        # @param name [String] The rule name.
+        #
+        # @param renewal_cadence_days [Integer, nil] How often evidence must be renewed, in days. Once evidence is older than this, t
+        #
+        # @param tag_ids [Array<String>, nil] The ids of the rule tags to associate with the rule. Replaces the rule's tags. R
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleUpdateResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleUpdateParams
+        def update(rule_id, params = {})
+          parsed, options = Openlayer::Governance::RuleUpdateParams.dump_request(params)
+          @client.request(
+            method: :put,
+            path: ["rules/%1$s", rule_id],
+            body: parsed,
+            model: Openlayer::Models::Governance::RuleUpdateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Openlayer::Models::Governance::RuleListParams} for more details.
+        #
+        # List the governance rules in a workspace.
+        #
+        # A rule is a single requirement Openlayer tracks. `platform` rules are evaluated
+        # automatically from the state of your workspace; `evidence` rules are satisfied
+        # by attaching evidence. A rule can belong to several frameworks at once, and
+        # rules that belong to none are returned too unless you pass
+        # `includeUnframed=false`.
+        #
+        # Pass `includeResults=true` to get each rule's compliance results inline instead
+        # of fetching them separately.
+        #
+        # @overload list(workspace_id, asc: nil, assignee_id: nil, deactivated: nil, enabled_framework_only: nil, framework_id: nil, group: nil, include_results: nil, include_unframed: nil, page: nil, per_page: nil, project_id: nil, scope: nil, search_query: nil, sort_by: nil, status: nil, tags: nil, type: nil, request_options: {})
+        #
+        # @param workspace_id [String] The workspace id.
+        #
+        # @param asc [Boolean] Whether to sort in ascending order.
+        #
+        # @param assignee_id [String] Only include rules assigned to this user.
+        #
+        # @param deactivated [Boolean] Only include rules that are deactivated (or active).
+        #
+        # @param enabled_framework_only [Boolean] Only include items belonging to at least one enabled framework.
+        #
+        # @param framework_id [String] Only include items belonging to this framework.
+        #
+        # @param group [Symbol, Openlayer::Models::Governance::RuleListParams::Group] Only include rules in one bucket of the compliance workflow. `open` covers rules
+        #
+        # @param include_results [Boolean] Whether to include each rule's results inline, in a `results` array.
+        #
+        # @param include_unframed [Boolean] Whether to include rules that are not part of any framework.
+        #
+        # @param page [Integer] The page to return in a paginated query.
+        #
+        # @param per_page [Integer] Maximum number of items to return per page.
+        #
+        # @param project_id [String] Only include items that apply to this project.
+        #
+        # @param scope [Symbol, Openlayer::Models::Governance::RuleListParams::Scope] Only include rules with this scope.
+        #
+        # @param search_query [String] Filter by a free-text search over names and descriptions.
+        #
+        # @param sort_by [Symbol, Openlayer::Models::Governance::RuleListParams::SortBy] The field to sort on.
+        #
+        # @param status [Symbol, Openlayer::Models::Governance::RuleListParams::Status] Only include items whose rule result has this compliance status.
+        #
+        # @param tags [Array<String>] Only include rules carrying all of these rule tags. Pass tag ids, which you can
+        #
+        # @param type [Symbol, Openlayer::Models::Governance::RuleListParams::Type] Only include rules of this type.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Governance::RuleListResponse]
+        #
+        # @see Openlayer::Models::Governance::RuleListParams
+        def list(workspace_id, params = {})
+          parsed, options = Openlayer::Governance::RuleListParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: ["workspaces/%1$s/rules", workspace_id],
+            query: query.transform_keys(
+              assignee_id: "assigneeId",
+              enabled_framework_only: "enabledFrameworkOnly",
+              framework_id: "frameworkId",
+              include_results: "includeResults",
+              include_unframed: "includeUnframed",
+              per_page: "perPage",
+              project_id: "projectId",
+              search_query: "searchQuery",
+              sort_by: "sortBy"
+            ),
+            model: Openlayer::Models::Governance::RuleListResponse,
+            options: options
+          )
+        end
+
+        # Delete a governance rule and its rule results.
+        #
+        # Only rules you created can be deleted. Rules that ship with Openlayer report
+        # `immutable: true` and cannot be deleted -- exclude one from compliance by
+        # setting `deactivated` with `PUT /rules/{ruleId}` instead.
+        #
+        # @overload delete(rule_id, request_options: {})
+        #
+        # @param rule_id [String] The rule id.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see Openlayer::Models::Governance::RuleDeleteParams
+        def delete(rule_id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["rules/%1$s", rule_id],
+            model: NilClass,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Openlayer::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/openlayer/resources/governance.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Governance
+      # @return [Openlayer::Resources::Governance::Frameworks]
+      attr_reader :frameworks
+
+      # @return [Openlayer::Resources::Governance::Rules]
+      attr_reader :rules
+
+      # @return [Openlayer::Resources::Governance::RuleResults]
+      attr_reader :rule_results
+
+      # @return [Openlayer::Resources::Governance::RuleStats]
+      attr_reader :rule_stats
+
+      # @return [Openlayer::Resources::Governance::RuleTags]
+      attr_reader :rule_tags
+
+      # @api private
+      #
+      # @param client [Openlayer::Client]
+      def initialize(client:)
+        @client = client
+        @frameworks = Openlayer::Resources::Governance::Frameworks.new(client: client)
+        @rules = Openlayer::Resources::Governance::Rules.new(client: client)
+        @rule_results = Openlayer::Resources::Governance::RuleResults.new(client: client)
+        @rule_stats = Openlayer::Resources::Governance::RuleStats.new(client: client)
+        @rule_tags = Openlayer::Resources::Governance::RuleTags.new(client: client)
+      end
+    end
+  end
+end

data/lib/openlayer/resources/storage/presigned_url.rb

@@ -27,6 +27,38 @@ module Openlayer
           )
         end
 
+        # Exchange a `storageUri` for a short-lived presigned url you can download the
+        # object from.
+        #
+        # Use it to collect anything the platform stored on your behalf -- for example the
+        # archive a framework export leaves behind, whose `storageUri` comes back in the
+        # background task's `outputs`.
+        #
+        # The workspace is taken from the API key, so there is nothing else to send. The
+        # url is only issued for objects your workspace owns, and `404` covers both "no
+        # such object" and "not yours".
+        #
+        # @overload retrieve(storage_uri:, request_options: {})
+        #
+        # @param storage_uri [String] The object's storage uri.
+        #
+        # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Openlayer::Models::Storage::PresignedURLRetrieveResponse]
+        #
+        # @see Openlayer::Models::Storage::PresignedURLRetrieveParams
+        def retrieve(params)
+          parsed, options = Openlayer::Storage::PresignedURLRetrieveParams.dump_request(params)
+          query = Openlayer::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: "storage/presigned-url",
+            query: query.transform_keys(storage_uri: "storageUri"),
+            model: Openlayer::Models::Storage::PresignedURLRetrieveResponse,
+            options: options
+          )
+        end
+
         # @api private
         #
         # @param client [Openlayer::Client]

data/lib/openlayer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Openlayer
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end