rcs 2.0.21 → 2.0.22.pre.rc.1

data/lib/pinnacle/client.rb

@@ -10,21 +10,31 @@ module Pinnacle
       @raw_client = Pinnacle::Internal::Http::RawClient.new(
         base_url: base_url || Pinnacle::Environment::DEFAULT,
         headers: {
-          "User-Agent" => "rcs/2.0.21",
+          "User-Agent" => "rcs/2.0.22.pre.rc.1",
           "X-Fern-Language" => "Ruby",
           "PINNACLE-API-KEY" => api_key.to_s
         }
       )
     end
 
+    # @return [Pinnacle::Audiences::Client]
+    def audiences
+      @audiences ||= Pinnacle::Audiences::Client.new(client: @raw_client)
+    end
+
     # @return [Pinnacle::Brands::Client]
     def brands
       @brands ||= Pinnacle::Brands::Client.new(client: @raw_client)
     end
 
-    # @return [Pinnacle::Audiences::Client]
-    def audiences
-      @audiences ||= Pinnacle::Audiences::Client.new(client: @raw_client)
+    # @return [Pinnacle::Calls::Client]
+    def calls
+      @calls ||= Pinnacle::Calls::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinnacle::Conferences::Client]
+    def conferences
+      @conferences ||= Pinnacle::Conferences::Client.new(client: @raw_client)
     end
 
     # @return [Pinnacle::Contacts::Client]
@@ -37,6 +47,16 @@ module Pinnacle
       @conversations ||= Pinnacle::Conversations::Client.new(client: @raw_client)
     end
 
+    # @return [Pinnacle::Faxes::Client]
+    def faxes
+      @faxes ||= Pinnacle::Faxes::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinnacle::Forms::Client]
+    def forms
+      @forms ||= Pinnacle::Forms::Client.new(client: @raw_client)
+    end
+
     # @return [Pinnacle::Messages::Client]
     def messages
       @messages ||= Pinnacle::Messages::Client.new(client: @raw_client)
@@ -57,21 +77,16 @@ module Pinnacle
       @webhooks ||= Pinnacle::Webhooks::Client.new(client: @raw_client)
     end
 
-    # @return [Pinnacle::Faxes::Client]
-    def faxes
-      @faxes ||= Pinnacle::Faxes::Client.new(client: @raw_client)
-    end
-
-    # @return [Pinnacle::Forms::Client]
-    def forms
-      @forms ||= Pinnacle::Forms::Client.new(client: @raw_client)
-    end
-
     # @return [Pinnacle::Campaigns::Client]
     def campaigns
       @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/conferences/client.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    class Client
+      # @param client [Pinnacle::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Your team's conferences, newest first, each with its participants.
+      #
+      # @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 [Pinnacle::Types::ConferenceStatus, nil] :status
+      #
+      # @return [Pinnacle::Types::ListConferencesResponse]
+      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["status"] = params[:status] if params.key?(:status)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "conferences",
+          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::ListConferencesResponse.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a conference: a room that calls can be added to. Each participant is an ordinary call.
+      #
+      # You can add participants in the same request. Existing calls are added first, so the conference is live before
+      # dialed participants answer. With no participants the conference is `waiting` until the first one joins.
+      #
+      # Send an `Idempotency-Key` to make dialed participants safe to retry: each one is dialed at most once.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Conferences::Types::CreateConferenceParams]
+      # @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, nil] :idempotency_key
+      #
+      # @return [Pinnacle::Types::Conference]
+      def create(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinnacle::Conferences::Types::CreateConferenceParams.new(params).to_h
+        non_body_param_names = %w[Idempotency-Key]
+        body = request_data.except(*non_body_param_names)
+
+        headers = {}
+        headers["Idempotency-Key"] = params[:idempotency_key] if params[:idempotency_key]
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "conferences",
+          headers: headers,
+          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::Conference.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @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::Conference]
+      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: "conferences/#{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::Conference.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # End the conference and hang up every participant, including anyone still being dialed.
+      #
+      # @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::Conference]
+      def end_(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: "conferences/#{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::Conference.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Change the label, metadata, or hold audio. Only the fields you send change.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Conferences::Types::UpdateConferenceParams]
+      # @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::Conference]
+      def update(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinnacle::Conferences::Types::UpdateConferenceParams.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: "conferences/#{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::Conference.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @return [Pinnacle::Participants::Client]
+      def participants
+        @participants ||= Pinnacle::Conferences::Participants::Client.new(client: @client)
+      end
+    end
+  end
+end

data/lib/pinnacle/conferences/participants/client.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Participants
+      class Client
+        # @param client [Pinnacle::Internal::Http::RawClient]
+        #
+        # @return [void]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Everyone who has been in the conference, including people who left or never connected.
+        #
+        # @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::ListParticipantsResponse]
+        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: "GET",
+            path: "conferences/#{URI.encode_uri_component(params[:id].to_s)}/participants",
+            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::ListParticipantsResponse.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Add someone: dial a new number (`to` + `from`) or pull in a call you already have (`call_id`).
+        #
+        # A dialed participant is returned with status `dialing` and joins when they answer; you'll get
+        # `participant.joined` (or `participant.failed` if they don't answer). With `announce`, they hear it alone
+        # before joining.
+        #
+        # @param request_options [Hash]
+        # @param params [Pinnacle::Types::AddConferenceParticipantParams]
+        # @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 [String, nil] :idempotency_key
+        #
+        # @return [Pinnacle::Types::ConferenceParticipant]
+        def add(request_options: {}, **params)
+          params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+          path_param_names = %i[id]
+          body_params = params.except(*path_param_names)
+
+          headers = {}
+          headers["Idempotency-Key"] = params[:idempotency_key] if params[:idempotency_key]
+
+          request = Pinnacle::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "POST",
+            path: "conferences/#{URI.encode_uri_component(params[:id].to_s)}/participants",
+            headers: headers,
+            body: Pinnacle::Types::AddConferenceParticipantParams.new(body_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::ConferenceParticipant.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # @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 [String] :participant
+        #
+        # @return [Pinnacle::Types::ConferenceParticipant]
+        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: "conferences/#{URI.encode_uri_component(params[:id].to_s)}/participants/#{URI.encode_uri_component(params[:participant].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::ConferenceParticipant.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Hang up this participant's call. Everyone else stays in the conference.
+        #
+        # @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 [String] :participant
+        #
+        # @return [Pinnacle::Types::ConferenceParticipant]
+        def remove(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: "conferences/#{URI.encode_uri_component(params[:id].to_s)}/participants/#{URI.encode_uri_component(params[:participant].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::ConferenceParticipant.load(response.body)
+          else
+            error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Mute, hold, or whisper. Only the fields you send change, and only real changes are applied.
+        #
+        # - `muted: true`: nobody hears them; they still hear everyone.
+        # - `on_hold: true`: they hear hold audio; nobody hears them.
+        # - `whisper_to: ["specialist"]`: only the specialist hears them. `null` goes back to everyone.
+        #
+        # @param request_options [Hash]
+        # @param params [Pinnacle::Conferences::Participants::Types::UpdateConferenceParticipantParams]
+        # @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 [String] :participant
+        #
+        # @return [Pinnacle::Types::ConferenceParticipant]
+        def update(request_options: {}, **params)
+          params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+          request_data = Pinnacle::Conferences::Participants::Types::UpdateConferenceParticipantParams.new(params).to_h
+          non_body_param_names = %w[id participant]
+          body = request_data.except(*non_body_param_names)
+
+          request = Pinnacle::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "PATCH",
+            path: "conferences/#{URI.encode_uri_component(params[:id].to_s)}/participants/#{URI.encode_uri_component(params[:participant].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::ConferenceParticipant.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

data/lib/pinnacle/conferences/participants/types/participants_add_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Participants
+      module Types
+        class ParticipantsAddRequest < Internal::Types::Model
+          field :id, -> { String }, optional: false, nullable: false
+
+          field :idempotency_key, -> { String }, optional: true, nullable: false, api_name: "Idempotency-Key"
+
+          field :body, -> { Pinnacle::Types::AddConferenceParticipantParams }, optional: false, nullable: false
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/conferences/participants/types/update_conference_participant_params.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Participants
+      module Types
+        class UpdateConferenceParticipantParams < Internal::Types::Model
+          field :id, -> { String }, optional: false, nullable: false
+
+          field :participant, -> { String }, optional: false, nullable: false
+
+          field :label, -> { String }, optional: true, nullable: false
+
+          field :muted, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+          field :on_hold, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+          field :whisper_to, -> { Internal::Types::Array[String] }, optional: true, nullable: false
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/conferences/types/conferences_list_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Types
+      class ConferencesListRequest < Internal::Types::Model
+        field :limit, -> { Integer }, optional: true, nullable: false
+
+        field :status, -> { Pinnacle::Types::ConferenceStatus }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/conferences/types/create_conference_params.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Types
+      class CreateConferenceParams < Internal::Types::Model
+        field :idempotency_key, -> { String }, optional: true, nullable: false, api_name: "Idempotency-Key"
+
+        field :label, -> { String }, optional: true, nullable: false
+
+        field :max_participants, -> { Integer }, optional: true, nullable: false
+
+        field :hold_audio_url, -> { String }, optional: true, nullable: false
+
+        field :speaking_events, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+        field :metadata, -> { Internal::Types::Hash[String, String] }, optional: true, nullable: false
+
+        field :participants, -> { Internal::Types::Array[Pinnacle::Types::AddConferenceParticipantParams] }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/conferences/types/update_conference_params.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Conferences
+    module Types
+      class UpdateConferenceParams < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :label, -> { String }, optional: true, nullable: false
+
+        field :hold_audio_url, -> { String }, optional: true, nullable: false
+
+        field :speaking_events, -> { 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/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