merge_ruby_client 0.0.3 → 0.1.0

data/lib/merge_ruby_client/accounting/field_mapping/client.rb

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "../types/field_mapping_api_instance_response"
+require_relative "../types/field_mapping_instance_response"
+require_relative "../types/remote_field_api_response"
+require_relative "../types/external_target_field_api_response"
+require "async"
+
+module Merge
+  module Accounting
+    class FieldMappingClient
+      # @return [Merge::RequestClient]
+      attr_reader :request_client
+
+      # @param request_client [Merge::RequestClient]
+      # @return [Merge::Accounting::FieldMappingClient]
+      def initialize(request_client:)
+        @request_client = request_client
+      end
+
+      # Get all Field Mappings for this Linked Account. Field Mappings are mappings
+      #  between third-party Remote Fields and user defined Merge fields. [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/overview/).
+      #
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingApiInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_retrieve
+      def field_mappings_retrieve(request_options: nil)
+        response = @request_client.conn.get do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings"
+        end
+        Merge::Accounting::FieldMappingApiInstanceResponse.from_json(json_object: response.body)
+      end
+
+      # Create new Field Mappings that will be available after the next scheduled sync.
+      #  This will cause the next sync for this Linked Account to sync **ALL** data from
+      #  start.
+      #
+      # @param target_field_name [String] The name of the target field you want this remote field to map to.
+      # @param target_field_description [String] The description of the target field you want this remote field to map to.
+      # @param remote_field_traversal_path [Array<Object>] The field traversal path of the remote field listed when you hit the GET
+      #  /remote-fields endpoint.
+      # @param remote_method [String] The method of the remote endpoint where the remote field is coming from.
+      # @param remote_url_path [String] The path of the remote endpoint where the remote field is coming from.
+      # @param common_model_name [String] The name of the Common Model that the remote field corresponds to in a given
+      #  category.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_create(
+      #    target_field_name: "example_target_field_name",
+      #    target_field_description: "this is a example description of the target field",
+      #    remote_field_traversal_path: ,
+      #    remote_method: "GET",
+      #    remote_url_path: "/example-url-path",
+      #    common_model_name: "ExampleCommonModel"
+      #  )
+      def field_mappings_create(target_field_name:, target_field_description:, remote_field_traversal_path:,
+                                remote_method:, remote_url_path:, common_model_name:, request_options: nil)
+        response = @request_client.conn.post do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            target_field_name: target_field_name,
+            target_field_description: target_field_description,
+            remote_field_traversal_path: remote_field_traversal_path,
+            remote_method: remote_method,
+            remote_url_path: remote_url_path,
+            common_model_name: common_model_name
+          }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings"
+        end
+        Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+      end
+
+      # Deletes Field Mappings for a Linked Account. All data related to this Field
+      #  Mapping will be deleted and these changes will be reflected after the next
+      #  scheduled sync. This will cause the next sync for this Linked Account to sync
+      #  **ALL** data from start.
+      #
+      # @param field_mapping_id [String]
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_destroy(field_mapping_id: "field_mapping_id")
+      def field_mappings_destroy(field_mapping_id:, request_options: nil)
+        response = @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.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings/#{field_mapping_id}"
+        end
+        Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+      end
+
+      # Create or update existing Field Mappings for a Linked Account. Changes will be
+      #  reflected after the next scheduled sync. This will cause the next sync for this
+      #  Linked Account to sync **ALL** data from start.
+      #
+      # @param field_mapping_id [String]
+      # @param remote_field_traversal_path [Array<Object>] The field traversal path of the remote field listed when you hit the GET
+      #  /remote-fields endpoint.
+      # @param remote_method [String] The method of the remote endpoint where the remote field is coming from.
+      # @param remote_url_path [String] The path of the remote endpoint where the remote field is coming from.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_partial_update(field_mapping_id: "field_mapping_id")
+      def field_mappings_partial_update(field_mapping_id:, remote_field_traversal_path: nil, remote_method: nil,
+                                        remote_url_path: nil, 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.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            remote_field_traversal_path: remote_field_traversal_path,
+            remote_method: remote_method,
+            remote_url_path: remote_url_path
+          }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings/#{field_mapping_id}"
+        end
+        Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+      end
+
+      # Get all remote fields for a Linked Account. Remote fields are third-party fields
+      #  that are accessible after initial sync if remote_data is enabled. You can use
+      #  remote fields to override existing Merge fields or map a new Merge field. [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/overview/).
+      #
+      # @param common_models [String] A comma seperated list of Common Model names. If included, will only return
+      #  Remote Fields for those Common Models.
+      # @param include_example_values [String] If true, will include example values, where available, for remote fields in the
+      #  3rd party platform. These examples come from active data from your customers.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::RemoteFieldApiResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.remote_fields_retrieve
+      def remote_fields_retrieve(common_models: nil, include_example_values: nil, request_options: nil)
+        response = @request_client.conn.get do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.params = {
+            **(request_options&.additional_query_parameters || {}),
+            "common_models": common_models,
+            "include_example_values": include_example_values
+          }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/remote-fields"
+        end
+        Merge::Accounting::RemoteFieldApiResponse.from_json(json_object: response.body)
+      end
+
+      # Get all organization-wide Target Fields, this will not include any Linked
+      #  Account specific Target Fields. Organization-wide Target Fields are additional
+      #  fields appended to the Merge Common Model for all Linked Accounts in a category.
+      #  [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/target-fields/).
+      #
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::ExternalTargetFieldApiResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.target_fields_retrieve
+      def target_fields_retrieve(request_options: nil)
+        response = @request_client.conn.get do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/target-fields"
+        end
+        Merge::Accounting::ExternalTargetFieldApiResponse.from_json(json_object: response.body)
+      end
+    end
+
+    class AsyncFieldMappingClient
+      # @return [Merge::AsyncRequestClient]
+      attr_reader :request_client
+
+      # @param request_client [Merge::AsyncRequestClient]
+      # @return [Merge::Accounting::AsyncFieldMappingClient]
+      def initialize(request_client:)
+        @request_client = request_client
+      end
+
+      # Get all Field Mappings for this Linked Account. Field Mappings are mappings
+      #  between third-party Remote Fields and user defined Merge fields. [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/overview/).
+      #
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingApiInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_retrieve
+      def field_mappings_retrieve(request_options: nil)
+        Async do
+          response = @request_client.conn.get do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings"
+          end
+          Merge::Accounting::FieldMappingApiInstanceResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Create new Field Mappings that will be available after the next scheduled sync.
+      #  This will cause the next sync for this Linked Account to sync **ALL** data from
+      #  start.
+      #
+      # @param target_field_name [String] The name of the target field you want this remote field to map to.
+      # @param target_field_description [String] The description of the target field you want this remote field to map to.
+      # @param remote_field_traversal_path [Array<Object>] The field traversal path of the remote field listed when you hit the GET
+      #  /remote-fields endpoint.
+      # @param remote_method [String] The method of the remote endpoint where the remote field is coming from.
+      # @param remote_url_path [String] The path of the remote endpoint where the remote field is coming from.
+      # @param common_model_name [String] The name of the Common Model that the remote field corresponds to in a given
+      #  category.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_create(
+      #    target_field_name: "example_target_field_name",
+      #    target_field_description: "this is a example description of the target field",
+      #    remote_field_traversal_path: ,
+      #    remote_method: "GET",
+      #    remote_url_path: "/example-url-path",
+      #    common_model_name: "ExampleCommonModel"
+      #  )
+      def field_mappings_create(target_field_name:, target_field_description:, remote_field_traversal_path:,
+                                remote_method:, remote_url_path:, common_model_name:, request_options: nil)
+        Async do
+          response = @request_client.conn.post do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.body = {
+              **(request_options&.additional_body_parameters || {}),
+              target_field_name: target_field_name,
+              target_field_description: target_field_description,
+              remote_field_traversal_path: remote_field_traversal_path,
+              remote_method: remote_method,
+              remote_url_path: remote_url_path,
+              common_model_name: common_model_name
+            }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings"
+          end
+          Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Deletes Field Mappings for a Linked Account. All data related to this Field
+      #  Mapping will be deleted and these changes will be reflected after the next
+      #  scheduled sync. This will cause the next sync for this Linked Account to sync
+      #  **ALL** data from start.
+      #
+      # @param field_mapping_id [String]
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_destroy(field_mapping_id: "field_mapping_id")
+      def field_mappings_destroy(field_mapping_id:, request_options: nil)
+        Async do
+          response = @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.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings/#{field_mapping_id}"
+          end
+          Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Create or update existing Field Mappings for a Linked Account. Changes will be
+      #  reflected after the next scheduled sync. This will cause the next sync for this
+      #  Linked Account to sync **ALL** data from start.
+      #
+      # @param field_mapping_id [String]
+      # @param remote_field_traversal_path [Array<Object>] The field traversal path of the remote field listed when you hit the GET
+      #  /remote-fields endpoint.
+      # @param remote_method [String] The method of the remote endpoint where the remote field is coming from.
+      # @param remote_url_path [String] The path of the remote endpoint where the remote field is coming from.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::FieldMappingInstanceResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.field_mappings_partial_update(field_mapping_id: "field_mapping_id")
+      def field_mappings_partial_update(field_mapping_id:, remote_field_traversal_path: nil, remote_method: nil,
+                                        remote_url_path: nil, 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.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.body = {
+              **(request_options&.additional_body_parameters || {}),
+              remote_field_traversal_path: remote_field_traversal_path,
+              remote_method: remote_method,
+              remote_url_path: remote_url_path
+            }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/field-mappings/#{field_mapping_id}"
+          end
+          Merge::Accounting::FieldMappingInstanceResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Get all remote fields for a Linked Account. Remote fields are third-party fields
+      #  that are accessible after initial sync if remote_data is enabled. You can use
+      #  remote fields to override existing Merge fields or map a new Merge field. [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/overview/).
+      #
+      # @param common_models [String] A comma seperated list of Common Model names. If included, will only return
+      #  Remote Fields for those Common Models.
+      # @param include_example_values [String] If true, will include example values, where available, for remote fields in the
+      #  3rd party platform. These examples come from active data from your customers.
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::RemoteFieldApiResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.remote_fields_retrieve
+      def remote_fields_retrieve(common_models: nil, include_example_values: nil, request_options: nil)
+        Async do
+          response = @request_client.conn.get do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.params = {
+              **(request_options&.additional_query_parameters || {}),
+              "common_models": common_models,
+              "include_example_values": include_example_values
+            }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/remote-fields"
+          end
+          Merge::Accounting::RemoteFieldApiResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Get all organization-wide Target Fields, this will not include any Linked
+      #  Account specific Target Fields. Organization-wide Target Fields are additional
+      #  fields appended to the Merge Common Model for all Linked Accounts in a category.
+      #  [Learn
+      #  more](https://docs.merge.dev/supplemental-data/field-mappings/target-fields/).
+      #
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::ExternalTargetFieldApiResponse]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.target_fields_retrieve
+      def target_fields_retrieve(request_options: nil)
+        Async do
+          response = @request_client.conn.get do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/target-fields"
+          end
+          Merge::Accounting::ExternalTargetFieldApiResponse.from_json(json_object: response.body)
+        end
+      end
+    end
+  end
+end

data/lib/merge_ruby_client/accounting/force_resync/client.rb

@@ -2,65 +2,90 @@
 
 require_relative "../../../requests"
 require_relative "../types/sync_status"
+require "json"
 require "async"
 
 module Merge
   module Accounting
     class ForceResyncClient
+      # @return [Merge::RequestClient]
       attr_reader :request_client
 
-      # @param request_client [RequestClient]
-      # @return [Accounting::ForceResyncClient]
+      # @param request_client [Merge::RequestClient]
+      # @return [Merge::Accounting::ForceResyncClient]
       def initialize(request_client:)
-        # @type [RequestClient]
         @request_client = request_client
       end
 
-      # Force re-sync of all models. This is available for all organizations via the dashboard. Force re-sync is also available programmatically via API for monthly, quarterly, and highest sync frequency customers on the Core, Professional, or Enterprise plans. Doing so will consume a sync credit for the relevant linked account.
+      # Force re-sync of all models. This is available for all organizations via the
+      #  dashboard. Force re-sync is also available programmatically via API for monthly,
+      #  quarterly, and highest sync frequency customers on the Launch, Professional, or
+      #  Enterprise plans. Doing so will consume a sync credit for the relevant linked
+      #  account.
       #
-      # @param request_options [RequestOptions]
-      # @return [Array<Accounting::SyncStatus>]
+      # @param request_options [Merge::RequestOptions]
+      # @return [Array<Merge::Accounting::SyncStatus>]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.sync_status_resync_create
       def sync_status_resync_create(request_options: nil)
-        response = @request_client.conn.post("/api/accounting/v1/sync-status/resync") do |req|
+        response = @request_client.conn.post do |req|
           req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
           req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
           req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
           req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/sync-status/resync"
         end
-        return if response.body.nil?
-
-        response.body.map do |v|
+        parsed_json = JSON.parse(response.body)
+        parsed_json&.map do |v|
           v = v.to_json
-          Accounting::SyncStatus.from_json(json_object: v)
+          Merge::Accounting::SyncStatus.from_json(json_object: v)
         end
       end
     end
 
     class AsyncForceResyncClient
+      # @return [Merge::AsyncRequestClient]
       attr_reader :request_client
 
-      # @param request_client [AsyncRequestClient]
-      # @return [Accounting::AsyncForceResyncClient]
+      # @param request_client [Merge::AsyncRequestClient]
+      # @return [Merge::Accounting::AsyncForceResyncClient]
       def initialize(request_client:)
-        # @type [AsyncRequestClient]
         @request_client = request_client
       end
 
-      # Force re-sync of all models. This is available for all organizations via the dashboard. Force re-sync is also available programmatically via API for monthly, quarterly, and highest sync frequency customers on the Core, Professional, or Enterprise plans. Doing so will consume a sync credit for the relevant linked account.
+      # Force re-sync of all models. This is available for all organizations via the
+      #  dashboard. Force re-sync is also available programmatically via API for monthly,
+      #  quarterly, and highest sync frequency customers on the Launch, Professional, or
+      #  Enterprise plans. Doing so will consume a sync credit for the relevant linked
+      #  account.
       #
-      # @param request_options [RequestOptions]
-      # @return [Array<Accounting::SyncStatus>]
+      # @param request_options [Merge::RequestOptions]
+      # @return [Array<Merge::Accounting::SyncStatus>]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.sync_status_resync_create
       def sync_status_resync_create(request_options: nil)
         Async do
-          response = @request_client.conn.post("/api/accounting/v1/sync-status/resync") do |req|
+          response = @request_client.conn.post do |req|
             req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
             req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
             req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
             req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/sync-status/resync"
           end
-          response.body&.map do |v|
+          parsed_json = JSON.parse(response.body)
+          parsed_json&.map do |v|
             v = v.to_json
-            Accounting::SyncStatus.from_json(json_object: v)
+            Merge::Accounting::SyncStatus.from_json(json_object: v)
           end
         end
       end

data/lib/merge_ruby_client/accounting/generate_key/client.rb

@@ -7,57 +7,73 @@ require "async"
 module Merge
   module Accounting
     class GenerateKeyClient
+      # @return [Merge::RequestClient]
       attr_reader :request_client
 
-      # @param request_client [RequestClient]
-      # @return [Accounting::GenerateKeyClient]
+      # @param request_client [Merge::RequestClient]
+      # @return [Merge::Accounting::GenerateKeyClient]
       def initialize(request_client:)
-        # @type [RequestClient]
         @request_client = request_client
       end
 
       # Create a remote key.
       #
-      # @param name [String]
-      # @param request_options [RequestOptions]
-      # @return [Accounting::RemoteKey]
+      # @param name [String] The name of the remote key
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::RemoteKey]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.create(name: "Remote Deployment Key 1")
       def create(name:, request_options: nil)
-        response = @request_client.conn.post("/api/accounting/v1/generate-key") do |req|
+        response = @request_client.conn.post do |req|
           req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
           req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
           req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
           req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
           req.body = { **(request_options&.additional_body_parameters || {}), name: name }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/generate-key"
         end
-        Accounting::RemoteKey.from_json(json_object: response.body)
+        Merge::Accounting::RemoteKey.from_json(json_object: response.body)
       end
     end
 
     class AsyncGenerateKeyClient
+      # @return [Merge::AsyncRequestClient]
       attr_reader :request_client
 
-      # @param request_client [AsyncRequestClient]
-      # @return [Accounting::AsyncGenerateKeyClient]
+      # @param request_client [Merge::AsyncRequestClient]
+      # @return [Merge::Accounting::AsyncGenerateKeyClient]
       def initialize(request_client:)
-        # @type [AsyncRequestClient]
         @request_client = request_client
       end
 
       # Create a remote key.
       #
-      # @param name [String]
-      # @param request_options [RequestOptions]
-      # @return [Accounting::RemoteKey]
+      # @param name [String] The name of the remote key
+      # @param request_options [Merge::RequestOptions]
+      # @return [Merge::Accounting::RemoteKey]
+      # @example
+      #  api = Merge::Client.new(
+      #    environment: Environment::PRODUCTION,
+      #    base_url: "https://api.example.com",
+      #    api_key: "YOUR_AUTH_TOKEN"
+      #  )
+      #  api.accounting.create(name: "Remote Deployment Key 1")
       def create(name:, request_options: nil)
         Async do
-          response = @request_client.conn.post("/api/accounting/v1/generate-key") do |req|
+          response = @request_client.conn.post do |req|
             req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
             req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
             req.headers["X-Account-Token"] = request_options.account_token unless request_options&.account_token.nil?
             req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
             req.body = { **(request_options&.additional_body_parameters || {}), name: name }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/accounting/v1/generate-key"
           end
-          Accounting::RemoteKey.from_json(json_object: response.body)
+          Merge::Accounting::RemoteKey.from_json(json_object: response.body)
         end
       end
     end