candidhealth 0.0.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a1adb84cd11b812275e563c4043c816e6824a121a01fa03cdf706736527246e
-  data.tar.gz: 7cbe92716d81098bc29656e6ab56652b0cd0afe766ebed733bd664bfba988c91
+  metadata.gz: 0ec163005788baacf8b5afa3738624bac96fe454c6bbd7d1c47c2feda3c7def1
+  data.tar.gz: dbe20fcc6609e0d6e7e33df97842c66748f4f9acc0cf57e99ddde424af3a4d69
 SHA512:
-  metadata.gz: a828749f074506bf1074adb98dec7c05ef8b995784caabfb42bbdc291378067938038bd22f2d3053f99afa279c5ede391d1d1b3a1a7b318a31d2d6005ca7f18b
-  data.tar.gz: 3e64f090085799ba849f83b72cad4866d9224eb38e9f3e2341c785f58a90025dc0a231ccb32cf15a50bae4f726b8c51b8324c5094b6b0759bec9d079e0011868
+  metadata.gz: a60be793fb9db59989d3649c7c31a1a8419dade0146ed4bff33ef42cb0e9e17ddcfaccc25fc0fde8317e749715e36fb00d5f4237cc04256d44e2819d34674405
+  data.tar.gz: d780ab9fb480c4f2a89069e97f353ac27b06374fba880586d3c42e7802773510a475d6e06f6a25dac41530f6168494a2aaebcda716fa0a37ac32ce43fd5b0751

data/lib/candidhealth/auth/client.rb

@@ -1,29 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "../../requests"
-require_relative "default/client"
+require_relative "v_2/client"
 
 module CandidApiClient
   module Auth
     class Client
-      # @return [CandidApiClient::Auth::Default::DefaultClient]
-      attr_reader :default
+      attr_reader :v_2
 
-      # @param request_client [CandidApiClient::RequestClient]
-      # @return [CandidApiClient::Auth::Client]
+      # @param request_client [RequestClient]
+      # @return [Auth::Client]
       def initialize(request_client:)
-        @default = CandidApiClient::Auth::Default::DefaultClient.new(request_client: request_client)
+        @v_2 = Auth::V2::V2Client.new(request_client: request_client)
       end
     end
 
     class AsyncClient
-      # @return [CandidApiClient::Auth::Default::AsyncDefaultClient]
-      attr_reader :default
+      attr_reader :v_2
 
-      # @param request_client [CandidApiClient::AsyncRequestClient]
-      # @return [CandidApiClient::Auth::AsyncClient]
+      # @param request_client [RequestClient]
+      # @return [Auth::AsyncClient]
       def initialize(request_client:)
-        @default = CandidApiClient::Auth::Default::AsyncDefaultClient.new(request_client: request_client)
+        @v_2 = Auth::V2::AsyncV2Client.new(request_client: request_client)
       end
     end
   end

data/lib/candidhealth/auth/v_2/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "types/auth_get_token_request"
+require_relative "types/auth_get_token_response"
+require "async"
+
+module CandidApiClient
+  module Auth
+    module V2
+      class V2Client
+        attr_reader :request_client
+
+        # @param request_client [RequestClient]
+        # @return [Auth::V2::V2Client]
+        def initialize(request_client:)
+          # @type [RequestClient]
+          @request_client = request_client
+        end
+
+        # Authenticating with the Candid Health API.
+        #
+        # Candid Health utilizes the [OAuth 2.0 bearer token authentication scheme](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication) in our auth flow. You obtain the bearer token for all
+        # subsequent API requests via the `/auth/token` endpoint defined below, which requires you to provide your `client_id` and `client_secret`. Your `client_id` and `client_secret` can be [generated](https://support.joincandidhealth.com/hc/en-us/articles/23065219476244--Generating-Candid-API-Keys) from the "Users & Credentials" tab by your org admin.
+        #
+        # The bearer token should be provided in the `Authorization` header for all subsequent API calls.
+        #
+        # **Warning:**
+        #
+        # The bearer token expires 5 hours after it has been created. After it has expired, the client will receive an "HTTP 401
+        # Unauthorized" error, at which point the client should generate a new token. It is important that tokens be reused between requests; if the client attempts to generate a token too often, it will be rate-limited and will receive an "HTTP 429 Too Many Requests" error.
+        #
+        # @param request [Hash] Request of type Auth::V2::AuthGetTokenRequest, as a Hash
+        #   * :client_id (String)
+        #   * :client_secret (String)
+        # @param request_options [RequestOptions]
+        # @return [Auth::V2::AuthGetTokenResponse]
+        def get_token(request:, request_options: nil)
+          response = @request_client.conn.post("/api/auth/v2/token") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          end
+          Auth::V2::AuthGetTokenResponse.from_json(json_object: response.body)
+        end
+      end
+
+      class AsyncV2Client
+        attr_reader :request_client
+
+        # @param request_client [AsyncRequestClient]
+        # @return [Auth::V2::AsyncV2Client]
+        def initialize(request_client:)
+          # @type [AsyncRequestClient]
+          @request_client = request_client
+        end
+
+        # Authenticating with the Candid Health API.
+        #
+        # Candid Health utilizes the [OAuth 2.0 bearer token authentication scheme](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication) in our auth flow. You obtain the bearer token for all
+        # subsequent API requests via the `/auth/token` endpoint defined below, which requires you to provide your `client_id` and `client_secret`. Your `client_id` and `client_secret` can be [generated](https://support.joincandidhealth.com/hc/en-us/articles/23065219476244--Generating-Candid-API-Keys) from the "Users & Credentials" tab by your org admin.
+        #
+        # The bearer token should be provided in the `Authorization` header for all subsequent API calls.
+        #
+        # **Warning:**
+        #
+        # The bearer token expires 5 hours after it has been created. After it has expired, the client will receive an "HTTP 401
+        # Unauthorized" error, at which point the client should generate a new token. It is important that tokens be reused between requests; if the client attempts to generate a token too often, it will be rate-limited and will receive an "HTTP 429 Too Many Requests" error.
+        #
+        # @param request [Hash] Request of type Auth::V2::AuthGetTokenRequest, as a Hash
+        #   * :client_id (String)
+        #   * :client_secret (String)
+        # @param request_options [RequestOptions]
+        # @return [Auth::V2::AuthGetTokenResponse]
+        def get_token(request:, request_options: nil)
+          Async do
+            response = @request_client.conn.post("/api/auth/v2/token") do |req|
+              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+              req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+              req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+            end
+            Auth::V2::AuthGetTokenResponse.from_json(json_object: response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/auth/v_2/types/auth_get_token_request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CandidApiClient
+  module Auth
+    module V2
+      class AuthGetTokenRequest
+        attr_reader :client_id, :client_secret, :additional_properties
+
+        # @param client_id [String] Your application's Client ID.
+        # @param client_secret [String] Your application's Client Secret.
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Auth::V2::AuthGetTokenRequest]
+        def initialize(client_id:, client_secret:, additional_properties: nil)
+          # @type [String] Your application's Client ID.
+          @client_id = client_id
+          # @type [String] Your application's Client Secret.
+          @client_secret = client_secret
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of AuthGetTokenRequest
+        #
+        # @param json_object [JSON]
+        # @return [Auth::V2::AuthGetTokenRequest]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          client_id = struct.client_id
+          client_secret = struct.client_secret
+          new(client_id: client_id, client_secret: client_secret, additional_properties: struct)
+        end
+
+        # Serialize an instance of AuthGetTokenRequest to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "client_id": @client_id, "client_secret": @client_secret }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.client_id.is_a?(String) != false || raise("Passed value for field obj.client_id is not the expected type, validation failed.")
+          obj.client_secret.is_a?(String) != false || raise("Passed value for field obj.client_secret is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/auth/v_2/types/auth_get_token_response.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CandidApiClient
+  module Auth
+    module V2
+      class AuthGetTokenResponse
+        attr_reader :access_token, :expires_in, :token_type, :additional_properties
+
+        # @param access_token [String]
+        # @param expires_in [Integer] Time in seconds.
+        # @param token_type [String]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Auth::V2::AuthGetTokenResponse]
+        def initialize(access_token:, expires_in:, token_type:, additional_properties: nil)
+          # @type [String]
+          @access_token = access_token
+          # @type [Integer] Time in seconds.
+          @expires_in = expires_in
+          # @type [String]
+          @token_type = token_type
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of AuthGetTokenResponse
+        #
+        # @param json_object [JSON]
+        # @return [Auth::V2::AuthGetTokenResponse]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          access_token = struct.access_token
+          expires_in = struct.expires_in
+          token_type = struct.token_type
+          new(access_token: access_token, expires_in: expires_in, token_type: token_type, additional_properties: struct)
+        end
+
+        # Serialize an instance of AuthGetTokenResponse to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "access_token": @access_token, "expires_in": @expires_in, "token_type": @token_type }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.access_token.is_a?(String) != false || raise("Passed value for field obj.access_token is not the expected type, validation failed.")
+          obj.expires_in.is_a?(Integer) != false || raise("Passed value for field obj.expires_in is not the expected type, validation failed.")
+          obj.token_type.is_a?(String) != false || raise("Passed value for field obj.token_type is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/auth/v_2/types/too_many_requests_error_type.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CandidApiClient
+  module Auth
+    module V2
+      class TooManyRequestsErrorType
+        attr_reader :message, :additional_properties
+
+        # @param message [String]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Auth::V2::TooManyRequestsErrorType]
+        def initialize(message:, additional_properties: nil)
+          # @type [String]
+          @message = message
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of TooManyRequestsErrorType
+        #
+        # @param json_object [JSON]
+        # @return [Auth::V2::TooManyRequestsErrorType]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          message = struct.message
+          new(message: message, additional_properties: struct)
+        end
+
+        # Serialize an instance of TooManyRequestsErrorType to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "message": @message }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/billing_notes/client.rb

@@ -6,24 +6,22 @@ require_relative "v_2/client"
 module CandidApiClient
   module BillingNotes
     class Client
-      # @return [CandidApiClient::BillingNotes::V2::V2Client]
       attr_reader :v_2
 
-      # @param request_client [CandidApiClient::RequestClient]
-      # @return [CandidApiClient::BillingNotes::Client]
+      # @param request_client [RequestClient]
+      # @return [BillingNotes::Client]
       def initialize(request_client:)
-        @v_2 = CandidApiClient::BillingNotes::V2::V2Client.new(request_client: request_client)
+        @v_2 = BillingNotes::V2::V2Client.new(request_client: request_client)
       end
     end
 
     class AsyncClient
-      # @return [CandidApiClient::BillingNotes::V2::AsyncV2Client]
       attr_reader :v_2
 
-      # @param request_client [CandidApiClient::AsyncRequestClient]
-      # @return [CandidApiClient::BillingNotes::AsyncClient]
+      # @param request_client [RequestClient]
+      # @return [BillingNotes::AsyncClient]
       def initialize(request_client:)
-        @v_2 = CandidApiClient::BillingNotes::V2::AsyncV2Client.new(request_client: request_client)
+        @v_2 = BillingNotes::V2::AsyncV2Client.new(request_client: request_client)
       end
     end
   end

data/lib/candidhealth/billing_notes/v_2/client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../../requests"
-require "ostruct"
+require_relative "../../commons/types/encounter_id"
 require_relative "types/billing_note"
 require "async"
 
@@ -9,177 +9,65 @@ module CandidApiClient
   module BillingNotes
     module V2
       class V2Client
-        # @return [CandidApiClient::RequestClient]
         attr_reader :request_client
 
-        # @param request_client [CandidApiClient::RequestClient]
-        # @return [CandidApiClient::BillingNotes::V2::V2Client]
+        # @param request_client [RequestClient]
+        # @return [BillingNotes::V2::V2Client]
         def initialize(request_client:)
+          # @type [RequestClient]
           @request_client = request_client
         end
 
         # @param text [String] Empty string not allowed.
         # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-        # @param _field_set [Object]
-        # @param encounter_id [String]
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [CandidApiClient::BillingNotes::V2::Types::BillingNote]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.create(encounter_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
-        def create(text:, encounter_id:, additional_properties: nil, _field_set: nil, request_options: nil)
-          response = @request_client.conn.post do |req|
+        # @param encounter_id [Commons::ENCOUNTER_ID]
+        # @param request_options [RequestOptions]
+        # @return [BillingNotes::V2::BillingNote]
+        def create(text:, encounter_id:, additional_properties: nil, request_options: nil)
+          response = @request_client.conn.post("/api/billing_notes/v2") do |req|
             req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
             req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-            req.headers = {
-          **(req.headers || {}),
-          **@request_client.get_headers,
-          **(request_options&.additional_headers || {})
-            }.compact
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
             req.body = {
               **(request_options&.additional_body_parameters || {}),
               text: text,
               additional_properties: additional_properties,
-              _field_set: _field_set,
               encounter_id: encounter_id
             }.compact
-            req.url "#{@request_client.get_url(environment: CandidApi,
-                                               request_options: request_options)}/api/billing_notes/v2"
-          end
-          CandidApiClient::BillingNotes::V2::Types::BillingNote.from_json(json_object: response.body)
-        end
-
-        # @param billing_note_id [String]
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [Void]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.delete(billing_note_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
-        def delete(billing_note_id:, request_options: nil)
-          @request_client.conn.delete do |req|
-            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
-            req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-            req.headers = {
-          **(req.headers || {}),
-          **@request_client.get_headers,
-          **(request_options&.additional_headers || {})
-            }.compact
-            req.url "#{@request_client.get_url(environment: CandidApi,
-                                               request_options: request_options)}/api/billing_notes/v2/#{billing_note_id}"
-          end
-        end
-
-        # @param billing_note_id [String]
-        # @param text [String] Empty string not allowed.
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [CandidApiClient::BillingNotes::V2::Types::BillingNote]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.update(billing_note_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", text: "text")
-        def update(billing_note_id:, text:, request_options: nil)
-          response = @request_client.conn.patch do |req|
-            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
-            req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-            req.headers = {
-          **(req.headers || {}),
-          **@request_client.get_headers,
-          **(request_options&.additional_headers || {})
-            }.compact
-            req.body = { **(request_options&.additional_body_parameters || {}), text: text }.compact
-            req.url "#{@request_client.get_url(environment: CandidApi,
-                                               request_options: request_options)}/api/billing_notes/v2/#{billing_note_id}"
           end
-          CandidApiClient::BillingNotes::V2::Types::BillingNote.from_json(json_object: response.body)
+          BillingNotes::V2::BillingNote.from_json(json_object: response.body)
         end
       end
 
       class AsyncV2Client
-        # @return [CandidApiClient::AsyncRequestClient]
         attr_reader :request_client
 
-        # @param request_client [CandidApiClient::AsyncRequestClient]
-        # @return [CandidApiClient::BillingNotes::V2::AsyncV2Client]
+        # @param request_client [AsyncRequestClient]
+        # @return [BillingNotes::V2::AsyncV2Client]
         def initialize(request_client:)
+          # @type [AsyncRequestClient]
           @request_client = request_client
         end
 
         # @param text [String] Empty string not allowed.
         # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-        # @param _field_set [Object]
-        # @param encounter_id [String]
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [CandidApiClient::BillingNotes::V2::Types::BillingNote]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.create(encounter_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
-        def create(text:, encounter_id:, additional_properties: nil, _field_set: nil, request_options: nil)
+        # @param encounter_id [Commons::ENCOUNTER_ID]
+        # @param request_options [RequestOptions]
+        # @return [BillingNotes::V2::BillingNote]
+        def create(text:, encounter_id:, additional_properties: nil, request_options: nil)
           Async do
-            response = @request_client.conn.post do |req|
+            response = @request_client.conn.post("/api/billing_notes/v2") do |req|
               req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
               req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-              req.headers = {
-            **(req.headers || {}),
-            **@request_client.get_headers,
-            **(request_options&.additional_headers || {})
-              }.compact
+              req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
               req.body = {
                 **(request_options&.additional_body_parameters || {}),
                 text: text,
                 additional_properties: additional_properties,
-                _field_set: _field_set,
                 encounter_id: encounter_id
               }.compact
-              req.url "#{@request_client.get_url(environment: CandidApi,
-                                                 request_options: request_options)}/api/billing_notes/v2"
-            end
-            CandidApiClient::BillingNotes::V2::Types::BillingNote.from_json(json_object: response.body)
-          end
-        end
-
-        # @param billing_note_id [String]
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [Void]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.delete(billing_note_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
-        def delete(billing_note_id:, request_options: nil)
-          Async do
-            @request_client.conn.delete do |req|
-              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
-              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-              req.headers = {
-            **(req.headers || {}),
-            **@request_client.get_headers,
-            **(request_options&.additional_headers || {})
-              }.compact
-              req.url "#{@request_client.get_url(environment: CandidApi,
-                                                 request_options: request_options)}/api/billing_notes/v2/#{billing_note_id}"
-            end
-          end
-        end
-
-        # @param billing_note_id [String]
-        # @param text [String] Empty string not allowed.
-        # @param request_options [CandidApiClient::RequestOptions]
-        # @return [CandidApiClient::BillingNotes::V2::Types::BillingNote]
-        # @example
-        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
-        #  api.billing_notes.v_2.update(billing_note_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", text: "text")
-        def update(billing_note_id:, text:, request_options: nil)
-          Async do
-            response = @request_client.conn.patch do |req|
-              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
-              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
-              req.headers = {
-            **(req.headers || {}),
-            **@request_client.get_headers,
-            **(request_options&.additional_headers || {})
-              }.compact
-              req.body = { **(request_options&.additional_body_parameters || {}), text: text }.compact
-              req.url "#{@request_client.get_url(environment: CandidApi,
-                                                 request_options: request_options)}/api/billing_notes/v2/#{billing_note_id}"
             end
-            CandidApiClient::BillingNotes::V2::Types::BillingNote.from_json(json_object: response.body)
+            BillingNotes::V2::BillingNote.from_json(json_object: response.body)
           end
         end
       end