rcs 2.0.19 → 2.0.20.pre.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e091bff6486acfda5b53cfca3dc3932ac590ea259b0b2cae2189568d0fc840ba
-  data.tar.gz: 6744cf7efd79546cfbf30df36951fbf2f94a4f9ca8702b686f971c8688306142
+  metadata.gz: 707234356d07787fe0f7f144369c4992c305f20cf2b441614bacae5be1e359ca
+  data.tar.gz: 052f00f33d7b3a9c549450dc1df576187468e93067aae0eaff59f0fff7391085
 SHA512:
-  metadata.gz: 128b2005881929bdb87e4f76b4292a5ba1a233829ccacbdc17e68ede29a06e6ce070f777782d69c42ca9c8fc79bb406966809d20f48637b898c7319aa12d2b89
-  data.tar.gz: 4edcc26b246e1b503c1a48a3baaf01829b7b7d4148ce2d0d3375a095dca27b8964819a039fd56f33c97dfd3e2efbd516fe2272125c37d45b5bccfef1c00ff83c
+  metadata.gz: a4f1d05255213bf07f6a6edff5bf9b023617a3d2d52819a189b065dc63c3573e7a5cc7acc7a74c7e8c456f88a2a7676e4bcc7e4c78f25a797b64aaf74381122d
+  data.tar.gz: 2845f1d4104b24c44a7f8d335f3de9821548a8669795ce40c3781875a2e8486e66836b160b24629dadd0e4c75f2ca61cb1d8b3600a0851650bca5c9e05b57658

data/.fern/metadata.json

@@ -8,9 +8,8 @@
     "useProvidedDefaults": true,
     "rubocopVariableNumberStyle": "snake_case"
   },
-  "originGitCommit": "ea44c7af1bfea2caa2e7e18c7fcfba57c5b2cfdd",
-  "originGitCommitIsDirty": false,
-  "invokedBy": "ci",
-  "ciProvider": "github",
-  "sdkVersion": "2.0.19"
-}
+  "originGitCommit": "4107f10ce57b97cf22a650949d197352235c1567",
+  "originGitCommitIsDirty": true,
+  "invokedBy": "manual",
+  "sdkVersion": "2.0.20.pre.rc.1"
+}

data/lib/pinnacle/calls/client.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    class Client
+      # @param client [Pinnacle::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # List voice calls for your team. Results are sorted newest first.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [Integer, nil] :limit
+      # @option params [String, nil] :cursor
+      # @option params [Pinnacle::Types::CallState, nil] :state
+      # @option params [Pinnacle::Types::CallDirection, nil] :direction
+      # @option params [String, nil] :from
+      # @option params [String, nil] :to
+      # @option params [String, nil] :created_after
+      # @option params [String, nil] :created_before
+      #
+      # @return [Pinnacle::Types::ListCallsResponse]
+      def list(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["state"] = params[:state] if params.key?(:state)
+        query_params["direction"] = params[:direction] if params.key?(:direction)
+        query_params["from"] = params[:from] if params.key?(:from)
+        query_params["to"] = params[:to] if params.key?(:to)
+        query_params["created_after"] = params[:created_after] if params.key?(:created_after)
+        query_params["created_before"] = params[:created_before] if params.key?(:created_before)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "calls",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::ListCallsResponse.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Start an outbound voice call from a voice-enabled phone number owned by your team.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Calls::Types::CreateCallParams]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Pinnacle::Types::CreatedCall]
+      def create(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "calls",
+          body: Pinnacle::Calls::Types::CreateCallParams.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::CreatedCall.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve one voice call by its Pinnacle call ID.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @return [Pinnacle::Types::Call]
+      def get(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::Call.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # End a live call. Terminal calls are returned unchanged.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @return [Pinnacle::Types::Call]
+      def cancel(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::Call.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Replace a call's metadata. For live calls, future call events carry the updated metadata.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Calls::Types::UpdateCallParams]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @return [Pinnacle::Types::Call]
+      def update(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinnacle::Calls::Types::UpdateCallParams.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PATCH",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::Call.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List the event timeline for a call.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer, nil] :limit
+      # @option params [String, nil] :cursor
+      #
+      # @return [Pinnacle::Types::ListCallEventsResponse]
+      def list_events(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}/events",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::ListCallEventsResponse.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Mint a short-lived WebSocket token for a call. Use the returned `stream_url` to connect to Pinnacle's
+      # bidirectional voice stream.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Calls::Types::CreateStreamTokenParams]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @return [Pinnacle::Types::CallStreamToken]
+      def create_stream_token(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinnacle::Calls::Types::CreateStreamTokenParams.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}/stream-token",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::CallStreamToken.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return a short-lived signed URL for the call recording.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer, nil] :expires_in
+      #
+      # @return [Pinnacle::Types::RecordingDownload]
+      def download_recording(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["expires_in"] = params[:expires_in] if params.key?(:expires_in)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}/recording",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::RecordingDownload.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete the canonical recording and queued fragments for a terminal call.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @return [untyped]
+      def delete_recording(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "calls/#{URI.encode_uri_component(params[:id].to_s)}/recording",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/calls_download_recording_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class CallsDownloadRecordingRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :expires_in, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/calls_list_events_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class CallsListEventsRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :limit, -> { Integer }, optional: true, nullable: false
+
+        field :cursor, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/calls_list_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class CallsListRequest < Internal::Types::Model
+        field :limit, -> { Integer }, optional: true, nullable: false
+
+        field :cursor, -> { String }, optional: true, nullable: false
+
+        field :state, -> { Pinnacle::Types::CallState }, optional: true, nullable: false
+
+        field :direction, -> { Pinnacle::Types::CallDirection }, optional: true, nullable: false
+
+        field :from, -> { String }, optional: true, nullable: false
+
+        field :to, -> { String }, optional: true, nullable: false
+
+        field :created_after, -> { String }, optional: true, nullable: false
+
+        field :created_before, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/create_call_params.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class CreateCallParams < Internal::Types::Model
+        field :to, -> { String }, optional: false, nullable: false
+
+        field :from, -> { String }, optional: false, nullable: false
+
+        field :record, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+        field :metadata, -> { Internal::Types::Hash[String, String] }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/create_stream_token_params.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class CreateStreamTokenParams < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :commands_enabled, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+        field :stream_id, -> { String }, optional: true, nullable: false
+
+        field :record, -> { Internal::Types::Boolean }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/calls/types/update_call_params.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Calls
+    module Types
+      class UpdateCallParams < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :metadata, -> { Internal::Types::Hash[String, String] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/client.rb

@@ -10,7 +10,7 @@ module Pinnacle
       @raw_client = Pinnacle::Internal::Http::RawClient.new(
         base_url: base_url || Pinnacle::Environment::DEFAULT,
         headers: {
-          "User-Agent" => "rcs/2.0.19",
+          "User-Agent" => "rcs/2.0.20.pre.rc.1",
           "X-Fern-Language" => "Ruby",
           "PINNACLE-API-KEY" => api_key.to_s
         }
@@ -57,6 +57,11 @@ module Pinnacle
       @webhooks ||= Pinnacle::Webhooks::Client.new(client: @raw_client)
     end
 
+    # @return [Pinnacle::Calls::Client]
+    def calls
+      @calls ||= Pinnacle::Calls::Client.new(client: @raw_client)
+    end
+
     # @return [Pinnacle::Forms::Client]
     def forms
       @forms ||= Pinnacle::Forms::Client.new(client: @raw_client)
@@ -67,6 +72,11 @@ module Pinnacle
       @campaigns ||= Pinnacle::Campaigns::Client.new(client: @raw_client)
     end
 
+    # @return [Pinnacle::Network::Client]
+    def network
+      @network ||= Pinnacle::Network::Client.new(client: @raw_client)
+    end
+
     # @return [Pinnacle::Status::Client]
     def status
       @status ||= Pinnacle::Status::Client.new(client: @raw_client)

data/lib/pinnacle/forms/client.rb

@@ -174,7 +174,7 @@ module Pinnacle
       # for embedding the URL in your own outreach.
       #
       # On completion, a `FORM.SUBMISSION` webhook event is delivered to webhooks subscribed to the sender. See
-      # [Receiving Messages and User Events](/guides/messages/receiving).
+      # [Receiving Message, Call, and User Events](/guides/messages/receiving).
       #
       # @param request_options [Hash]
       # @param params [Pinnacle::Types::SendFormParams]

data/lib/pinnacle/network/client.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Network
+    class Client
+      # @param client [Pinnacle::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @return [Pinnacle::SimSwap::Client]
+      def sim_swap
+        @sim_swap ||= Pinnacle::Network::SimSwap::Client.new(client: @client)
+      end
+
+      # @return [Pinnacle::SubscriberMatch::Client]
+      def subscriber_match
+        @subscriber_match ||= Pinnacle::Network::SubscriberMatch::Client.new(client: @client)
+      end
+
+      # @return [Pinnacle::SilentAuth::Client]
+      def silent_auth
+        @silent_auth ||= Pinnacle::Network::SilentAuth::Client.new(client: @client)
+      end
+
+      # @return [Pinnacle::Requests::Client]
+      def requests
+        @requests ||= Pinnacle::Network::Requests::Client.new(client: @client)
+      end
+    end
+  end
+end

data/lib/pinnacle/network/requests/client.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Network
+    module Requests
+      class Client
+        # @param client [Pinnacle::Internal::Http::RawClient]
+        #
+        # @return [void]
+        def initialize(client:)
+          @client = client
+        end
+
+        # List Network API request records for your team, sorted newest first. Use filters to audit recent checks by
+        # type, status, or your own `clientRef`.
+        #
+        # <Note>
+        #   Limited availability. Contact [founders@pinnacle.sh](mailto:founders@pinnacle.sh) to request access.
+        # </Note>
+        #
+        # @param request_options [Hash]
+        # @param params [Pinnacle::Network::Requests::Types::ListNetworkRequestsParams]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        #
+        # @return [Pinnacle::Types::ListNetworkRequestsResponse]
+        def list(request_options: {}, **params)
+          params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+          request = Pinnacle::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "POST",
+            path: "network/requests/list",
+            body: Pinnacle::Network::Requests::Types::ListNetworkRequestsParams.new(params).to_h,
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Pinnacle::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            Pinnacle::Types::ListNetworkRequestsResponse.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Retrieve one Network API request by ID. The response includes lifecycle timestamps, request status, your
+        # `clientRef`, and result fields from the original check.
+        #
+        # <Note>
+        #   Limited availability. Contact [founders@pinnacle.sh](mailto:founders@pinnacle.sh) to request access.
+        # </Note>
+        #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [Pinnacle::Types::NetworkRequestId] :request_id
+        #
+        # @return [Pinnacle::Types::NetworkRequestSummary]
+        def get(request_options: {}, **params)
+          params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+          request = Pinnacle::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "GET",
+            path: "network/requests/#{URI.encode_uri_component(params[:request_id].to_s)}",
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Pinnacle::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            Pinnacle::Types::NetworkRequestSummary.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+      end
+    end
+  end
+end