apimatic-semgrep-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2444f05a2feb921ab081ddb53f4f73a9e0af77a4c06be31577d76c993af2471
+  data.tar.gz: e397e7b7847a0b907f5aed1af2b760b28b66f70f42148046930082b33618f4d8
+SHA512:
+  metadata.gz: 61583c9981eeca62d870e8a68dbef71fda5bec9c4dbf9b281345b34dfc873398f65689171248d3bfcb0c1481315aad07572b5d08ac964db167f2bcbbe5515eba
+  data.tar.gz: 8993bcf07822478d50fe25c32895e81eb173874e9845362bcc912b4d9e9b16399e954dfa5e419f8aea2c3a81392969b036c8c525fa0dd478b55f672a45a0218d

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2026 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,205 @@
+
+# Getting Started with Semgrep Web App
+
+## Introduction
+
+Welcome to Semgrep's portal for the Semgrep AppSec Platform web API.
+
+### Introduction
+
+Semgrep is a fast, open-source, static analysis tool for finding bugs and enforcing code standards at editor,
+commit, and CI time. [Get started.](https://semgrep.dev/docs/getting-started/)
+
+This API is documented in the **OpenAPI format**.
+
+### Authentication
+
+The API supports authentication with an API token with the "Web API" permission, without limited
+scopes of access.
+
+You can provision an API token [from the Settings page](https://semgrep.dev/orgs/-/settings/tokens).
+
+### Terms of Use
+
+Please note, the materials made available herein are subject to the
+[Semgrep Terms of Use](https://semgrep.dev/resources/website-terms/), and your
+access or use of any of the same is your acknowledgment and acceptance of the
+such terms.
+
+<br>
+
+
+___
+
+
+## Install the Package
+
+Install the gem from the command line:
+
+```bash
+gem install apimatic-semgrep-sdk -v 0.0.1
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'apimatic-semgrep-sdk', '0.0.1'
+```
+
+For additional gem details, see the [RubyGems page for the apimatic-semgrep-sdk gem](https://rubygems.org/gems/apimatic-semgrep-sdk/versions/0.0.1).
+
+## IRB Console Usage
+
+You can explore the SDK interactively using IRB in two ways
+
+### 1. Use IRB with Installed Gem
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and type the following command to start the irb console.
+
+```bash
+irb
+```
+
+Now you can load the SDK in the IRB
+
+```ruby
+require 'semgrep_web_app'
+include SemgrepWebApp
+```
+
+### 2. Use IRB within SDK
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and navigate to the root folder of SDK.
+
+```
+cd path/to/semgrep_web_app
+```
+
+Now you can start the preconfigured irb console by running the following command
+
+```bash
+ruby bin/console
+```
+
+**_Note:_** This automatically loads the SDK from lib/
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| environment | [`Environment`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/README.md#environments) | The API environment. <br> **Default: `Environment.PRODUCTION`** |
+| connection | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
+| adapter | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
+| timeout | `Float` | The value to use for connection timeout. <br> **Default: 30** |
+| max_retries | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| retry_interval | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| backoff_factor | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| retry_statuses | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| retry_methods | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+| http_callback | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
+| proxy_settings | [`ProxySettings`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/proxy-settings.md) | Optional proxy configuration to route HTTP requests through a proxy server. |
+| logging_configuration | [`LoggingConfiguration`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/logging-configuration.md) | The SDK logging configuration for API calls |
+| semgrep_admin_jwt_credentials | [`SemgrepAdminJwtCredentials`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token.md) | The credential object for OAuth 2 Bearer token |
+| semgrep_jwt_credentials | [`SemgrepJwtCredentials`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token-1.md) | The credential object for OAuth 2 Bearer token |
+| semgrep_web_token_credentials | [`SemgrepWebTokenCredentials`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token-2.md) | The credential object for OAuth 2 Bearer token |
+
+The API client can be initialized as follows:
+
+### Code-Based Client Initialization
+
+```ruby
+require 'semgrep_web_app'
+include SemgrepWebApp
+
+client = Client.new(
+  semgrep_admin_jwt_credentials: SemgrepAdminJwtCredentials.new(
+    access_token: 'AccessToken'
+  ),
+  semgrep_jwt_credentials: SemgrepJwtCredentials.new(
+    access_token: 'AccessToken'
+  ),
+  semgrep_web_token_credentials: SemgrepWebTokenCredentials.new(
+    access_token: 'AccessToken'
+  ),
+  environment: Environment::PRODUCTION,
+  logging_configuration: LoggingConfiguration.new(
+    log_level: Logger::INFO,
+    request_logging_config: RequestLoggingConfiguration.new(
+      log_body: true
+    ),
+    response_logging_config: ResponseLoggingConfiguration.new(
+      log_headers: true
+    )
+  )
+)
+```
+
+### Environment-Based Client Initialization
+
+```ruby
+require 'semgrep_web_app'
+include SemgrepWebApp
+
+# Create client from environment
+client = Client.from_env
+```
+
+See the [`Environment-Based Client Initialization`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/environment-based-client-initialization.md) section for details.
+
+## Environments
+
+The SDK can be configured to use a different environment for making API calls. Available environments are:
+
+### Fields
+
+| Name | Description |
+|  --- | --- |
+| PRODUCTION | **Default** |
+
+## Authorization
+
+This API uses the following authentication schemes.
+
+* [`SemgrepAdminJWT (OAuth 2 Bearer token)`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token.md)
+* [`SemgrepJWT (OAuth 2 Bearer token)`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token-1.md)
+* [`SemgrepWebToken (OAuth 2 Bearer token)`](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token-2.md)
+
+## List of APIs
+
+* [Deployments Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/deployments-service.md)
+* [Findings Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/findings-service.md)
+* [Misc Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/misc-service.md)
+* [Policies Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/policies-service.md)
+* [Projects Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/projects-service.md)
+* [Scans Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/scans-service.md)
+* [Secrets Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/secrets-service.md)
+* [Supply Chain Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/supply-chain-service.md)
+* [Ticketing Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/ticketing-service.md)
+* [Triage Service](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/controllers/triage-service.md)
+
+## SDK Infrastructure
+
+### Configuration
+
+* [ProxySettings](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/proxy-settings.md)
+* [Environment-Based Client Initialization](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/environment-based-client-initialization.md)
+* [AbstractLogger](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/abstract-logger.md)
+* [LoggingConfiguration](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/logging-configuration.md)
+* [RequestLoggingConfiguration](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/request-logging-configuration.md)
+* [ResponseLoggingConfiguration](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/response-logging-configuration.md)
+
+### HTTP
+
+* [HttpResponse](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/http-response.md)
+* [HttpRequest](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/http-request.md)
+
+### Utilities
+
+* [ApiResponse](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/api-response.md)
+* [ApiHelper](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/api-helper.md)
+* [DateTimeHelper](https://www.github.com/sdks-io/apimatic-semgrep-ruby-sdk/tree/0.0.1/doc/date-time-helper.md)
+

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# Load the lib folder into Ruby's load path
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+# Require the gem
+require 'semgrep_web_app'
+
+puts 'SemgrepWebApp SDK loaded!'
+puts 'You can now create a client with: client = SemgrepWebApp::Client.new'
+puts 'Or use from_env: client = SemgrepWebApp::Client.from_env'
+
+# Start an interactive IRB session
+require 'irb'
+IRB.start

data/lib/semgrep_web_app/api_helper.rb

@@ -0,0 +1,10 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # API utility class
+  class APIHelper < CoreLibrary::ApiHelper
+  end
+end

data/lib/semgrep_web_app/apis/base_api.rb

@@ -0,0 +1,67 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # BaseApi.
+  class BaseApi
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'Ruby-SDK/0.0.1 (OS: {os-info}, Engine: {engine}/{engine-version})'
+    end
+
+    def self.user_agent_parameters
+      {
+        '{engine}' => { 'value' => RUBY_ENGINE, 'encode' => false },
+        '{engine-version}' => { 'value' => RUBY_ENGINE_VERSION, 'encode' => false },
+        '{os-info}' => { 'value' => RUBY_PLATFORM, 'encode' => false }
+      }
+    end
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [String] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/semgrep_web_app/apis/deployments_service_api.rb

@@ -0,0 +1,29 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # DeploymentsServiceApi
+  class DeploymentsServiceApi < BaseApi
+    # Request the deployments your auth can access.
+    # Currently available auth scope does not extend over more than one
+    # deployment. This endpoint returns the single deployment your token can
+    # access. The endpoint additionally returns links to related resources
+    # available on this API.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def deployments_service_list_deployments
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/deployments',
+                                     Server::SEMGREP)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('SemgrepWebToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProtosOpenapiV1ListDeploymentsResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/semgrep_web_app/apis/findings_service_api.rb

@@ -0,0 +1,107 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # FindingsServiceApi
+  class FindingsServiceApi < BaseApi
+    # Request the list of code, supply chain, or AI-powered scan findings in an
+    # organization, paginated in pages of 100 entries and limited by the `since`
+    # timestamp. Findings are returned by `relevant_since` descending (see
+    # `since` in the Query Parameters list). Examples: List SAST findings with
+    # pagination, List SCA findings since timestamp, List AI-powered scan
+    # findings, List findings with filters.
+    # @param [String] deployment_slug Required parameter: TODO: type description
+    # here
+    # @param [IssueType2] issue_type Optional parameter: Example:sast
+    # @param [Float] since Optional parameter: TODO: type description here
+    # @param [Integer] page Optional parameter: Example:0
+    # @param [TrueClass | FalseClass] dedup Optional parameter: Example:false
+    # @param [Integer] page_size Optional parameter: Example:100
+    # @param [Array[String]] repos Optional parameter: TODO: type description
+    # here
+    # @param [Array[Integer]] repository_ids Optional parameter: TODO: type
+    # description here
+    # @param [Status9] status Optional parameter: Example:
+    # @param [TriageReasons2] triage_reasons Optional parameter: Example:
+    # @param [Severities2] severities Optional parameter: Example:
+    # @param [String] ref Optional parameter: TODO: type description here
+    # @param [Array[String]] policies Optional parameter: TODO: type description
+    # here
+    # @param [Array[String]] rules Optional parameter: TODO: type description
+    # here
+    # @param [Array[String]] categories Optional parameter: TODO: type
+    # description here
+    # @param [Confidence8] confidence Optional parameter: Example:
+    # @param [AutotriageVerdict2] autotriage_verdict Optional parameter:
+    # Example:
+    # @param [Array[String]] component_tags Optional parameter: TODO: type
+    # description here
+    # @param [Exposures2] exposures Optional parameter: Example:
+    # @param [Transitivities2] transitivities Optional parameter: Example:
+    # @param [TrueClass | FalseClass] is_malicious Optional parameter: TODO:
+    # type description here
+    # @param [ClickToFixPrState] click_to_fix_pr_state Optional parameter:
+    # Example:
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def findings_service_list_findings(deployment_slug,
+                                       issue_type: IssueType2::SAST,
+                                       since: nil,
+                                       page: 0,
+                                       dedup: false,
+                                       page_size: 100,
+                                       repos: nil,
+                                       repository_ids: nil,
+                                       status: nil,
+                                       triage_reasons: nil,
+                                       severities: nil,
+                                       ref: nil,
+                                       policies: nil,
+                                       rules: nil,
+                                       categories: nil,
+                                       confidence: nil,
+                                       autotriage_verdict: nil,
+                                       component_tags: nil,
+                                       exposures: nil,
+                                       transitivities: nil,
+                                       is_malicious: nil,
+                                       click_to_fix_pr_state: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/deployments/{deploymentSlug}/findings',
+                                     Server::SEMGREP)
+                   .template_param(new_parameter(deployment_slug, key: 'deploymentSlug')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(issue_type, key: 'issue_type'))
+                   .query_param(new_parameter(since, key: 'since'))
+                   .query_param(new_parameter(page, key: 'page'))
+                   .query_param(new_parameter(dedup, key: 'dedup'))
+                   .query_param(new_parameter(page_size, key: 'page_size'))
+                   .query_param(new_parameter(repos, key: 'repos'))
+                   .query_param(new_parameter(repository_ids, key: 'repository_ids'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .query_param(new_parameter(triage_reasons, key: 'triage_reasons'))
+                   .query_param(new_parameter(severities, key: 'severities'))
+                   .query_param(new_parameter(ref, key: 'ref'))
+                   .query_param(new_parameter(policies, key: 'policies'))
+                   .query_param(new_parameter(rules, key: 'rules'))
+                   .query_param(new_parameter(categories, key: 'categories'))
+                   .query_param(new_parameter(confidence, key: 'confidence'))
+                   .query_param(new_parameter(autotriage_verdict, key: 'autotriage_verdict'))
+                   .query_param(new_parameter(component_tags, key: 'component_tags'))
+                   .query_param(new_parameter(exposures, key: 'exposures'))
+                   .query_param(new_parameter(transitivities, key: 'transitivities'))
+                   .query_param(new_parameter(is_malicious, key: 'is_malicious'))
+                   .query_param(new_parameter(click_to_fix_pr_state, key: 'click_to_fix_pr_state'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('SemgrepWebToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ApiV1DeploymentsFindingsResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/semgrep_web_app/apis/misc_service_api.rb

@@ -0,0 +1,47 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # MiscServiceApi
+  class MiscServiceApi < BaseApi
+    # VPC support for Managed Scans is in private beta.
+    # Returns the Managed Scans VPC Bootstrap CloudFormation template in JSON
+    # format for setting up cross-account infrastructure.
+    # This template creates IAM roles and policies needed for Semgrep Managed
+    # Scanning (SMS) VPC infrastructure automation,
+    # including the semgrep-sms-vpc-automation role and EC2 Image Builder
+    # distribution roles for gVisor container runtime.
+    # See the original AWS cloudformation template format at
+    # https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-fo
+    # rmats.html
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def misc_service_get_bootstrap_sms_vpc
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/bootstrap-sms-vpc',
+                                     Server::SEMGREP)
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProtosOpenapiV1GetBootstrapSmsVpcResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Use to ping the server and assert liveness.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def misc_service_ping
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/ping',
+                                     Server::SEMGREP)
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:json_deserialize))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/semgrep_web_app/apis/policies_service_api.rb

@@ -0,0 +1,97 @@
+# semgrep_web_app
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SemgrepWebApp
+  # PoliciesServiceApi
+  class PoliciesServiceApi < BaseApi
+    # TODO: type endpoint description here
+    # @param [String] deployment_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def policies_service_list_policies(deployment_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/deployments/{deploymentId}/policies',
+                                     Server::SEMGREP)
+                   .template_param(new_parameter(deployment_id, key: 'deploymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('SemgrepWebToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProtosOpenapiV1ListPoliciesResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # TODO: type endpoint description here
+    # @param [String] deployment_id Required parameter: TODO: type description
+    # here
+    # @param [String] policy_id Required parameter: TODO: type description
+    # here
+    # @param [String] cursor Optional parameter: TODO: type description here
+    # @param [Integer] limit Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def policies_service_list_policy_rules(deployment_id,
+                                           policy_id,
+                                           cursor: nil,
+                                           limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/deployments/{deploymentId}/policies/{policyId}',
+                                     Server::SEMGREP)
+                   .template_param(new_parameter(deployment_id, key: 'deploymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(policy_id, key: 'policyId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('SemgrepWebToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProtosOpenapiV1ListPolicyRulesResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # TODO: type endpoint description here
+    # @param [String] deployment_id Required parameter: TODO: type description
+    # here
+    # @param [String] policy_id Required parameter: TODO: type description
+    # here
+    # @param [UpdatePolicyRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def policies_service_update_policy(deployment_id,
+                                       policy_id,
+                                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/api/v1/deployments/{deploymentId}/policies/{policyId}',
+                                     Server::SEMGREP)
+                   .template_param(new_parameter(deployment_id, key: 'deploymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(policy_id, key: 'policyId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('SemgrepWebToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProtosOpenapiV1UpdatePolicyResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end