openlayer 0.14.1 → 0.16.0

data/rbi/openlayer/resources/governance/rule_results.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+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.
+        sig do
+          params(
+            rule_result_id: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleResultRetrieveResponse)
+        end
+        def retrieve(
+          # The rule result id.
+          rule_result_id,
+          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.
+        sig do
+          params(
+            rule_result_id: String,
+            assignee_id: T.nilable(String),
+            blocked_by:
+              T::Array[
+                Openlayer::Governance::RuleResultUpdateParams::BlockedBy::OrHash
+              ],
+            blocking:
+              T::Array[
+                Openlayer::Governance::RuleResultUpdateParams::Blocking::OrHash
+              ],
+            deactivated: T::Boolean,
+            deactivated_reason: T.nilable(String),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleResultUpdateResponse)
+        end
+        def update(
+          # The rule result id.
+          rule_result_id,
+          # The user responsible for this result.
+          assignee_id: nil,
+          # Rule results that must pass before this one can be satisfied.
+          blocked_by: nil,
+          # Rule results that this one blocks.
+          blocking: nil,
+          # Whether this result is excluded from compliance calculations.
+          deactivated: nil,
+          # Why the result was excluded.
+          deactivated_reason: nil,
+          request_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.
+        sig do
+          params(
+            workspace_id: String,
+            enabled_framework_only: T::Boolean,
+            framework_id: String,
+            include_unframed: T::Boolean,
+            page: Integer,
+            per_page: Integer,
+            project_id: String,
+            rule_id: String,
+            scope: Openlayer::Governance::RuleResultListParams::Scope::OrSymbol,
+            search_query: String,
+            status:
+              Openlayer::Governance::RuleResultListParams::Status::OrSymbol,
+            type: Openlayer::Governance::RuleResultListParams::Type::OrSymbol,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleResultListResponse)
+        end
+        def list(
+          # The workspace id.
+          workspace_id,
+          # Only include items belonging to at least one enabled framework.
+          enabled_framework_only: nil,
+          # Only include items belonging to this framework.
+          framework_id: nil,
+          # Whether to include rules that are not part of any framework.
+          include_unframed: nil,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          # Only include items that apply to this project.
+          project_id: nil,
+          # Only include results of this rule.
+          rule_id: nil,
+          # Only include rules with this scope.
+          scope: nil,
+          # Filter by a free-text search over names and descriptions.
+          search_query: nil,
+          # Only include items whose rule result has this compliance status.
+          status: nil,
+          # Only include rules of this type.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # 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.
+        sig do
+          params(
+            rule_result_id: String,
+            description: T.nilable(String),
+            name: T.nilable(String),
+            storage_uri: T.nilable(String),
+            text: T.nilable(String),
+            url: T.nilable(String),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(
+            Openlayer::Models::Governance::RuleResultCreateEvidenceResponse
+          )
+        end
+        def create_evidence(
+          # The rule result id.
+          rule_result_id,
+          # A description of what the evidence shows.
+          description: nil,
+          # The evidence name.
+          name: nil,
+          # Where the uploaded file is stored. Set when the rule's `evidenceType` is
+          # `document`.
+          storage_uri: nil,
+          # The evidence text. Set when the rule's `evidenceType` is `text`.
+          text: nil,
+          # A link to the evidence. Set when the rule's `evidenceType` is `url`.
+          url: nil,
+          request_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.
+        sig do
+          params(
+            rule_result_id: String,
+            page: Integer,
+            per_page: Integer,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(
+            Openlayer::Models::Governance::RuleResultListEvidenceResponse
+          )
+        end
+        def list_evidence(
+          # The rule result id.
+          rule_result_id,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/governance/rule_stats.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+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.
+        sig do
+          params(
+            workspace_id: String,
+            framework_id: String,
+            project_id: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleStatRetrieveResponse)
+        end
+        def retrieve(
+          # The workspace id.
+          workspace_id,
+          # Only include items belonging to this framework.
+          framework_id: nil,
+          # Only include items that apply to this project.
+          project_id: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/governance/rule_tags.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+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).
+        sig do
+          params(
+            workspace_id: String,
+            page: Integer,
+            per_page: Integer,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleTagListResponse)
+        end
+        def list(
+          # The workspace id.
+          workspace_id,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/governance/rules.rbi

@@ -0,0 +1,233 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Governance
+      class Rules
+        # 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.
+        sig do
+          params(
+            workspace_id: String,
+            name: String,
+            scope: Openlayer::Governance::RuleCreateParams::Scope::OrSymbol,
+            type: Openlayer::Governance::RuleCreateParams::Type::OrSymbol,
+            assignee_id: T.nilable(String),
+            automation_params: T.nilable(T::Hash[Symbol, T.anything]),
+            automation_type: T.nilable(String),
+            deactivated: T::Boolean,
+            description: T.nilable(String),
+            evidence_type:
+              T.nilable(
+                Openlayer::Governance::RuleCreateParams::EvidenceType::OrSymbol
+              ),
+            renewal_cadence_days: T.nilable(Integer),
+            tag_ids: T.nilable(T::Array[String]),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleCreateResponse)
+        end
+        def create(
+          # The workspace id.
+          workspace_id,
+          # The rule name.
+          name:,
+          # Whether the rule is evaluated once for the whole workspace, or once per project
+          # the rule's frameworks apply to.
+          scope:,
+          # `platform` rules are evaluated automatically from the state of your Openlayer
+          # workspace. `evidence` rules are satisfied by attaching evidence.
+          type:,
+          # The user responsible for satisfying the rule.
+          assignee_id: nil,
+          # Configuration for the platform check, when the automation takes parameters.
+          automation_params: nil,
+          # Which workspace signal a platform rule checks, for example
+          # `monitoring_mode_enabled`, `test_setup`, or `project_owner_set`. `null` for
+          # evidence rules.
+          automation_type: nil,
+          # Whether the rule is excluded from compliance calculations.
+          deactivated: nil,
+          # What the rule requires.
+          description: nil,
+          # The kind of evidence that satisfies the rule. `null` for platform rules.
+          evidence_type: nil,
+          # How often evidence must be renewed, in days. Once evidence is older than this,
+          # the rule result becomes `due_soon` and then `failing`.
+          renewal_cadence_days: nil,
+          # The ids of the rule tags to associate with the rule. Replaces the rule's tags.
+          # Read them back from `tags`, and list the tags available in the workspace with
+          # `GET /workspaces/{workspaceId}/rule-tags`.
+          tag_ids: nil,
+          request_options: {}
+        )
+        end
+
+        # Retrieve a governance rule by its id, including the frameworks it belongs to and
+        # its tags.
+        sig do
+          params(
+            rule_id: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleRetrieveResponse)
+        end
+        def retrieve(
+          # The rule id.
+          rule_id,
+          request_options: {}
+        )
+        end
+
+        # 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.
+        sig do
+          params(
+            rule_id: String,
+            assignee_id: T.nilable(String),
+            deactivated: T::Boolean,
+            description: T.nilable(String),
+            name: String,
+            renewal_cadence_days: T.nilable(Integer),
+            tag_ids: T.nilable(T::Array[String]),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleUpdateResponse)
+        end
+        def update(
+          # The rule id.
+          rule_id,
+          # The user responsible for satisfying the rule.
+          assignee_id: nil,
+          # Whether the rule is excluded from compliance calculations.
+          deactivated: nil,
+          # What the rule requires.
+          description: nil,
+          # The rule name.
+          name: nil,
+          # How often evidence must be renewed, in days. Once evidence is older than this,
+          # the rule result becomes `due_soon` and then `failing`.
+          renewal_cadence_days: nil,
+          # The ids of the rule tags to associate with the rule. Replaces the rule's tags.
+          # Read them back from `tags`, and list the tags available in the workspace with
+          # `GET /workspaces/{workspaceId}/rule-tags`.
+          tag_ids: nil,
+          request_options: {}
+        )
+        end
+
+        # 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.
+        sig do
+          params(
+            workspace_id: String,
+            asc: T::Boolean,
+            assignee_id: String,
+            deactivated: T::Boolean,
+            enabled_framework_only: T::Boolean,
+            framework_id: String,
+            group: Openlayer::Governance::RuleListParams::Group::OrSymbol,
+            include_results: T::Boolean,
+            include_unframed: T::Boolean,
+            page: Integer,
+            per_page: Integer,
+            project_id: String,
+            scope: Openlayer::Governance::RuleListParams::Scope::OrSymbol,
+            search_query: String,
+            sort_by: Openlayer::Governance::RuleListParams::SortBy::OrSymbol,
+            status: Openlayer::Governance::RuleListParams::Status::OrSymbol,
+            tags: T::Array[String],
+            type: Openlayer::Governance::RuleListParams::Type::OrSymbol,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Governance::RuleListResponse)
+        end
+        def list(
+          # The workspace id.
+          workspace_id,
+          # Whether to sort in ascending order.
+          asc: nil,
+          # Only include rules assigned to this user.
+          assignee_id: nil,
+          # Only include rules that are deactivated (or active).
+          deactivated: nil,
+          # Only include items belonging to at least one enabled framework.
+          enabled_framework_only: nil,
+          # Only include items belonging to this framework.
+          framework_id: nil,
+          # Only include rules in one bucket of the compliance workflow. `open` covers rules
+          # that still need attention, `done` covers rules that are fully satisfied, and
+          # `excluded` covers rules that have been deactivated.
+          group: nil,
+          # Whether to include each rule's results inline, in a `results` array.
+          include_results: nil,
+          # Whether to include rules that are not part of any framework.
+          include_unframed: nil,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          # Only include items that apply to this project.
+          project_id: nil,
+          # Only include rules with this scope.
+          scope: nil,
+          # Filter by a free-text search over names and descriptions.
+          search_query: nil,
+          # The field to sort on.
+          sort_by: nil,
+          # Only include items whose rule result has this compliance status.
+          status: nil,
+          # Only include rules carrying all of these rule tags. Pass tag ids, which you can
+          # look up with [List rule tags](/api-reference/rest/governance/list-rule-tags).
+          tags: nil,
+          # Only include rules of this type.
+          type: nil,
+          request_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.
+        sig do
+          params(
+            rule_id: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).void
+        end
+        def delete(
+          # The rule id.
+          rule_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/governance.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Governance
+      sig { returns(Openlayer::Resources::Governance::Frameworks) }
+      attr_reader :frameworks
+
+      sig { returns(Openlayer::Resources::Governance::Rules) }
+      attr_reader :rules
+
+      sig { returns(Openlayer::Resources::Governance::RuleResults) }
+      attr_reader :rule_results
+
+      sig { returns(Openlayer::Resources::Governance::RuleStats) }
+      attr_reader :rule_stats
+
+      sig { returns(Openlayer::Resources::Governance::RuleTags) }
+      attr_reader :rule_tags
+
+      # @api private
+      sig { params(client: Openlayer::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/projects.rbi

@@ -17,7 +17,11 @@ module Openlayer
         params(
           name: String,
           task_type: Openlayer::ProjectCreateParams::TaskType::OrSymbol,
+          data_retention_days: T.nilable(Integer),
           description: T.nilable(String),
+          model_developer: T.nilable(String),
+          model_types: T.nilable(T::Array[String]),
+          purpose: T.nilable(String),
           request_options: Openlayer::RequestOptions::OrHash
         ).returns(Openlayer::Models::ProjectCreateResponse)
       end
@@ -26,8 +30,50 @@ module Openlayer
         name:,
         # The task type of the project.
         task_type:,
+        # Number of days to retain monitoring data for this project. Null means data is
+        # retained indefinitely.
+        data_retention_days: nil,
         # The project description.
         description: nil,
+        # Who developed the model used in this project.
+        model_developer: nil,
+        # The kinds of model used in this project.
+        model_types: nil,
+        # What the system in this project is intended to do.
+        purpose: nil,
+        request_options: {}
+      )
+      end
+
+      # Update a project's metadata.
+      sig do
+        params(
+          project_id: String,
+          data_retention_days: T.nilable(Integer),
+          description: T.nilable(String),
+          model_developer: T.nilable(String),
+          model_types: T.nilable(T::Array[String]),
+          name: String,
+          purpose: T.nilable(String),
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(Openlayer::Models::ProjectUpdateResponse)
+      end
+      def update(
+        # The project id.
+        project_id,
+        # Number of days to retain monitoring data for this project. Null means data is
+        # retained indefinitely.
+        data_retention_days: nil,
+        # The project description.
+        description: nil,
+        # Who developed the model used in this project.
+        model_developer: nil,
+        # The kinds of model used in this project.
+        model_types: nil,
+        # The project name.
+        name: nil,
+        # What the system in this project is intended to do.
+        purpose: nil,
         request_options: {}
       )
       end

data/rbi/openlayer/resources/storage/presigned_url.rbi

@@ -18,6 +18,29 @@ 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".
+        sig do
+          params(
+            storage_uri: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Storage::PresignedURLRetrieveResponse)
+        end
+        def retrieve(
+          # The object's storage uri.
+          storage_uri:,
+          request_options: {}
+        )
+        end
+
         # @api private
         sig { params(client: Openlayer::Client).returns(T.attached_class) }
         def self.new(client:)

data/sig/openlayer/client.rbs

@@ -22,6 +22,10 @@ module Openlayer
 
     attr_reader tests: Openlayer::Resources::Tests
 
+    attr_reader background_tasks: Openlayer::Resources::BackgroundTasks
+
+    attr_reader governance: Openlayer::Resources::Governance
+
     private def auth_headers: -> ::Hash[String, String]
 
     def initialize: (

data/sig/openlayer/models/background_task_retrieve_params.rbs

@@ -0,0 +1,23 @@
+module Openlayer
+  module Models
+    type background_task_retrieve_params =
+      { task_id: String } & Openlayer::Internal::Type::request_parameters
+
+    class BackgroundTaskRetrieveParams < Openlayer::Internal::Type::BaseModel
+      extend Openlayer::Internal::Type::RequestParameters::Converter
+      include Openlayer::Internal::Type::RequestParameters
+
+      attr_accessor task_id: String
+
+      def initialize: (
+        task_id: String,
+        ?request_options: Openlayer::request_opts
+      ) -> void
+
+      def to_hash: -> {
+        task_id: String,
+        request_options: Openlayer::RequestOptions
+      }
+    end
+  end
+end