schematichq 1.4.3 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52c3520cf93bf33b5709b843536791c05f1f79cde2521fed583179802ea01a13
-  data.tar.gz: b321618dcbe10659189f72554ee428638e022fc8afb044a11cc87fc59c441624
+  metadata.gz: 85d9efb3046014492cb89dee9ca47427babf900a5738b4d2ebef375b014668c6
+  data.tar.gz: a3d972bc92e02315a9dba121231a4715e28704f1442f8f271177a0f1ce2f5779
 SHA512:
-  metadata.gz: c3c953562cb84790a3bd211f88eac886330a71e20c2d83d815a5216883a6eade2981e34df357c923dd9bae64571203600528855b747df3798e7e1d11ef9051b8
-  data.tar.gz: 2c3cead033c8c600ef24f886541fa8102b6cff15299aef884225f58e292793eedb356305ebc5c80fc0cdd4f5288ddd1cd33b29dca4284a999a1e904a25129bb9
+  metadata.gz: df77700f492d8ed2fc5dc9ba25722864ab60d995761a3c142966560ca66cfb230e117a5f51f17b713cde545a487d419731a70c77761dc0d0a2d06dc099c6037d
+  data.tar.gz: e99075d5f93882c41af77da371fac5d3b28b225979f5acf78b3438f9a42d4b6694543e62c1892c1a05b93b8aec0d39b4bdbdcf12e63754f6add9533292bc066b

data/.fern/metadata.json

@@ -13,6 +13,6 @@
       "webrick": ">= 1.0"
     }
   },
-  "originGitCommit": "a3057c10aa6a1daa708dc714c89ce943f67a722a",
-  "sdkVersion": "1.4.3"
+  "originGitCommit": "786b643cc0bf17aff1114597108246b5cf8af395",
+  "sdkVersion": "1.4.5"
 }

data/.fern/replay.lock

@@ -6,5 +6,504 @@ generations:
     timestamp: 2026-05-19T19:48:36.665Z
     cli_version: unknown
     generator_versions: {}
-current_generation: 298b1d0ee88b6637d99742bff32b353cfbd5b32e
-patches: []
+  - commit_sha: 0dd219c7b903329d9db2fb5b9fb570f2fd6e1a39
+    tree_hash: 7a0aadd77d8091d4846b0968fc36d335be98a66d
+    timestamp: 2026-06-08T18:13:52.357Z
+    cli_version: unknown
+    generator_versions:
+      fernapi/fern-ruby-sdk: 1.1.13
+current_generation: 0dd219c7b903329d9db2fb5b9fb570f2fd6e1a39
+patches:
+  - id: patch-6a2db2b5
+    content_hash: sha256:630a8c3df9ae971e973e4dcb3d71d0d9f28b8da9877b0ff27ff3cca2a1eb924a
+    original_commit: 6a2db2b584601e13f90302155d37a22e45542fab
+    original_message: handle partial messages properly
+    original_author: Christopher Brady <chris@schematichq.com>
+    base_generation: e75de47f4e4f08f8e683366dd9b3936bc5c6452f
+    files:
+      - lib/schematic/datastream/merge.rb
+    patch_content: |
+      diff --git a/lib/schematic/datastream/merge.rb b/lib/schematic/datastream/merge.rb
+      index 0ab68fe..7f1084d 100644
+      --- a/lib/schematic/datastream/merge.rb
+      +++ b/lib/schematic/datastream/merge.rb
+      @@ -16,25 +16,42 @@ module Schematic
+             COMPANY_MAP_FIELDS = %i[credit_balances keys traits].freeze
+             COMPANY_ARRAY_FIELDS = %i[billing_product_ids entitlements plan_ids plan_version_ids rules].freeze
+       
+      +      # Partials don't carry refreshed entitlements, so when their derived
+      +      # fields change in another part of the company we sync them here to match
+      +      # server behavior (see schematic-python merge.partial_company):
+      +      #   - credit_remaining <- credit_balances[credit_id]
+      +      #   - usage            <- metric value matching (event_name, metric_period, month_reset)
+      +      # Both are skipped when the partial also sends entitlements wholesale.
+             def partial_company(existing, partial_data)
+               return existing unless partial_data.is_a?(Hash)
+       
+               result = deep_copy(existing)
+      +        entitlements_in_partial = partial_data.key?(:entitlements) || partial_data.key?("entitlements")
+      +        updated_balances = nil
+      +        metrics_updated = false
+       
+               partial_data.each do |key, value|
+                 sym_key = key.to_sym
+                 if COMPANY_MAP_FIELDS.include?(sym_key)
+                   result[sym_key] ||= {}
+                   result[sym_key] = result[sym_key].merge(value) if value.is_a?(Hash)
+      +            updated_balances = (value.is_a?(Hash) ? value : {}) if sym_key == :credit_balances
+                 elsif COMPANY_ARRAY_FIELDS.include?(sym_key)
+                   result[sym_key] = value if value.is_a?(Array)
+                 elsif sym_key == :metrics
+                   result[sym_key] = upsert_metrics(result[sym_key] || [], value || [])
+      +            metrics_updated = true
+                 else
+                   result[sym_key] = value
+                 end
+               end
+       
+      +        if (updated_balances || metrics_updated) && !entitlements_in_partial
+      +          result[:entitlements] = sync_entitlements(
+      +            result[:entitlements], result[:metrics], updated_balances, metrics_updated
+      +          )
+      +        end
+      +
+               result
+             end
+       
+      @@ -90,6 +107,60 @@ module Schematic
+             def get_metric_field(metric, field)
+               metric[field] || metric[field.to_s]
+             end
+      +
+      +      # Re-derive entitlement usage / credit_remaining from the merged metrics
+      +      # and the just-updated credit balances. Mirrors schematic-python so that
+      +      # entitlement usage reflects DataStream track events immediately.
+      +      def sync_entitlements(entitlements, metrics, updated_balances, metrics_updated)
+      +        return entitlements unless entitlements.is_a?(Array) && !entitlements.empty?
+      +
+      +        metrics_lookup = {}
+      +        if metrics_updated && metrics.is_a?(Array)
+      +          metrics.each do |metric|
+      +            next unless metric.is_a?(Hash)
+      +
+      +            key = [
+      +              get_metric_field(metric, :event_subtype) || "",
+      +              get_metric_field(metric, :period) || "",
+      +              get_metric_field(metric, :month_reset) || ""
+      +            ]
+      +            value = get_metric_field(metric, :value)
+      +            metrics_lookup[key] = value.nil? ? 0 : value
+      +          end
+      +        end
+      +
+      +        entitlements.map do |ent|
+      +          next ent unless ent.is_a?(Hash)
+      +
+      +          new_ent = deep_copy(ent)
+      +
+      +          credit_id = get_metric_field(ent, :credit_id)
+      +          if updated_balances && credit_id
+      +            present, balance = fetch_balance(updated_balances, credit_id)
+      +            new_ent[:credit_remaining] = balance if present
+      +          end
+      +
+      +          event_name = get_metric_field(ent, :event_name)
+      +          unless metrics_lookup.empty? || event_name.nil?
+      +            period = get_metric_field(ent, :metric_period) || "all_time"
+      +            month_reset = get_metric_field(ent, :month_reset) || "first_of_month"
+      +            matched = metrics_lookup[[event_name, period, month_reset]]
+      +            new_ent[:usage] = matched unless matched.nil?
+      +          end
+      +
+      +          new_ent
+      +        end
+      +      end
+      +
+      +      # credit_balances keys may be symbols (deep_copy symbolizes) while an
+      +      # entitlement's credit_id is always a string, so check both forms.
+      +      def fetch_balance(balances, credit_id)
+      +        return [true, balances[credit_id]] if balances.key?(credit_id)
+      +        return [true, balances[credit_id.to_sym]] if balances.key?(credit_id.to_sym)
+      +        return [true, balances[credit_id.to_s]] if balances.key?(credit_id.to_s)
+      +
+      +        [false, nil]
+      +      end
+           end
+         end
+       end
+    theirs_snapshot:
+      lib/schematic/datastream/merge.rb: |
+        # frozen_string_literal: true
+
+        require "json"
+
+        module Schematic
+          module DataStream
+            module Merge
+              module_function
+
+              def deep_copy(obj)
+                JSON.parse(JSON.generate(obj), symbolize_names: true)
+              rescue StandardError
+                obj.dup
+              end
+
+              COMPANY_MAP_FIELDS = %i[credit_balances keys traits].freeze
+              COMPANY_ARRAY_FIELDS = %i[billing_product_ids entitlements plan_ids plan_version_ids rules].freeze
+
+              # Partials don't carry refreshed entitlements, so when their derived
+              # fields change in another part of the company we sync them here to match
+              # server behavior (see schematic-python merge.partial_company):
+              #   - credit_remaining <- credit_balances[credit_id]
+              #   - usage            <- metric value matching (event_name, metric_period, month_reset)
+              # Both are skipped when the partial also sends entitlements wholesale.
+              def partial_company(existing, partial_data)
+                return existing unless partial_data.is_a?(Hash)
+
+                result = deep_copy(existing)
+                entitlements_in_partial = partial_data.key?(:entitlements) || partial_data.key?("entitlements")
+                updated_balances = nil
+                metrics_updated = false
+
+                partial_data.each do |key, value|
+                  sym_key = key.to_sym
+                  if COMPANY_MAP_FIELDS.include?(sym_key)
+                    result[sym_key] ||= {}
+                    result[sym_key] = result[sym_key].merge(value) if value.is_a?(Hash)
+                    updated_balances = (value.is_a?(Hash) ? value : {}) if sym_key == :credit_balances
+                  elsif COMPANY_ARRAY_FIELDS.include?(sym_key)
+                    result[sym_key] = value if value.is_a?(Array)
+                  elsif sym_key == :metrics
+                    result[sym_key] = upsert_metrics(result[sym_key] || [], value || [])
+                    metrics_updated = true
+                  else
+                    result[sym_key] = value
+                  end
+                end
+
+                if (updated_balances || metrics_updated) && !entitlements_in_partial
+                  result[:entitlements] = sync_entitlements(
+                    result[:entitlements], result[:metrics], updated_balances, metrics_updated
+                  )
+                end
+
+                result
+              end
+
+              USER_MAP_FIELDS = %i[keys traits].freeze
+
+              def partial_user(existing, partial_data)
+                return existing unless partial_data.is_a?(Hash)
+
+                result = deep_copy(existing)
+
+                partial_data.each do |key, value|
+                  sym_key = key.to_sym
+                  if USER_MAP_FIELDS.include?(sym_key)
+                    result[sym_key] ||= {}
+                    result[sym_key] = result[sym_key].merge(value) if value.is_a?(Hash)
+                  elsif sym_key == :rules
+                    result[sym_key] = value if value.is_a?(Array)
+                  else
+                    result[sym_key] = value
+                  end
+                end
+
+                result
+              end
+
+              def upsert_metrics(existing, incoming)
+                return incoming if existing.nil? || existing.empty?
+                return existing if incoming.nil? || incoming.empty?
+
+                result = existing.map { |metric| deep_copy(metric) }
+
+                incoming.each do |inc_metric|
+                  match_idx = result.index do |ex|
+                    metrics_match?(ex, inc_metric)
+                  end
+
+                  if match_idx
+                    result[match_idx] = inc_metric
+                  else
+                    result << inc_metric
+                  end
+                end
+
+                result
+              end
+
+              def metrics_match?(left, right)
+                get_metric_field(left, :event_subtype) == get_metric_field(right, :event_subtype) &&
+                  get_metric_field(left, :period) == get_metric_field(right, :period) &&
+                  get_metric_field(left, :month_reset) == get_metric_field(right, :month_reset)
+              end
+
+              def get_metric_field(metric, field)
+                metric[field] || metric[field.to_s]
+              end
+
+              # Re-derive entitlement usage / credit_remaining from the merged metrics
+              # and the just-updated credit balances. Mirrors schematic-python so that
+              # entitlement usage reflects DataStream track events immediately.
+              def sync_entitlements(entitlements, metrics, updated_balances, metrics_updated)
+                return entitlements unless entitlements.is_a?(Array) && !entitlements.empty?
+
+                metrics_lookup = {}
+                if metrics_updated && metrics.is_a?(Array)
+                  metrics.each do |metric|
+                    next unless metric.is_a?(Hash)
+
+                    key = [
+                      get_metric_field(metric, :event_subtype) || "",
+                      get_metric_field(metric, :period) || "",
+                      get_metric_field(metric, :month_reset) || ""
+                    ]
+                    value = get_metric_field(metric, :value)
+                    metrics_lookup[key] = value.nil? ? 0 : value
+                  end
+                end
+
+                entitlements.map do |ent|
+                  next ent unless ent.is_a?(Hash)
+
+                  new_ent = deep_copy(ent)
+
+                  credit_id = get_metric_field(ent, :credit_id)
+                  if updated_balances && credit_id
+                    present, balance = fetch_balance(updated_balances, credit_id)
+                    new_ent[:credit_remaining] = balance if present
+                  end
+
+                  event_name = get_metric_field(ent, :event_name)
+                  unless metrics_lookup.empty? || event_name.nil?
+                    period = get_metric_field(ent, :metric_period) || "all_time"
+                    month_reset = get_metric_field(ent, :month_reset) || "first_of_month"
+                    matched = metrics_lookup[[event_name, period, month_reset]]
+                    new_ent[:usage] = matched unless matched.nil?
+                  end
+
+                  new_ent
+                end
+              end
+
+              # credit_balances keys may be symbols (deep_copy symbolizes) while an
+              # entitlement's credit_id is always a string, so check both forms.
+              def fetch_balance(balances, credit_id)
+                return [true, balances[credit_id]] if balances.key?(credit_id)
+                return [true, balances[credit_id.to_sym]] if balances.key?(credit_id.to_sym)
+                return [true, balances[credit_id.to_s]] if balances.key?(credit_id.to_s)
+
+                [false, nil]
+              end
+            end
+          end
+        end
+    status: unresolved
+  - id: patch-46462128
+    content_hash: sha256:94f06e4e687a0908d3f305a4d605d9dc1271db6ed83014a10b86be900187dd83
+    original_commit: 46462128cacb25b73fac7770060cf427ff0d9e6d
+    original_message: add tests and address nits
+    original_author: Christopher Brady <chris@schematichq.com>
+    base_generation: e75de47f4e4f08f8e683366dd9b3936bc5c6452f
+    files:
+      - lib/schematic/datastream/merge.rb
+    patch_content: |
+      diff --git a/lib/schematic/datastream/merge.rb b/lib/schematic/datastream/merge.rb
+      index 7f1084d..f4dd4e5 100644
+      --- a/lib/schematic/datastream/merge.rb
+      +++ b/lib/schematic/datastream/merge.rb
+      @@ -46,7 +46,7 @@ module Schematic
+                 end
+               end
+       
+      -        if (updated_balances || metrics_updated) && !entitlements_in_partial
+      +        if (updated_balances&.any? || metrics_updated) && !entitlements_in_partial
+                 result[:entitlements] = sync_entitlements(
+                   result[:entitlements], result[:metrics], updated_balances, metrics_updated
+                 )
+      @@ -152,12 +152,12 @@ module Schematic
+               end
+             end
+       
+      -      # credit_balances keys may be symbols (deep_copy symbolizes) while an
+      -      # entitlement's credit_id is always a string, so check both forms.
+      +      # The partial's credit_balances may be keyed by string or symbol depending
+      +      # on how the message was parsed, while an entitlement's credit_id is a
+      +      # string value, so check both key forms.
+             def fetch_balance(balances, credit_id)
+               return [true, balances[credit_id]] if balances.key?(credit_id)
+               return [true, balances[credit_id.to_sym]] if balances.key?(credit_id.to_sym)
+      -        return [true, balances[credit_id.to_s]] if balances.key?(credit_id.to_s)
+       
+               [false, nil]
+             end
+    theirs_snapshot:
+      lib/schematic/datastream/merge.rb: |
+        # frozen_string_literal: true
+
+        require "json"
+
+        module Schematic
+          module DataStream
+            module Merge
+              module_function
+
+              def deep_copy(obj)
+                JSON.parse(JSON.generate(obj), symbolize_names: true)
+              rescue StandardError
+                obj.dup
+              end
+
+              COMPANY_MAP_FIELDS = %i[credit_balances keys traits].freeze
+              COMPANY_ARRAY_FIELDS = %i[billing_product_ids entitlements plan_ids plan_version_ids rules].freeze
+
+              # Partials don't carry refreshed entitlements, so when their derived
+              # fields change in another part of the company we sync them here to match
+              # server behavior (see schematic-python merge.partial_company):
+              #   - credit_remaining <- credit_balances[credit_id]
+              #   - usage            <- metric value matching (event_name, metric_period, month_reset)
+              # Both are skipped when the partial also sends entitlements wholesale.
+              def partial_company(existing, partial_data)
+                return existing unless partial_data.is_a?(Hash)
+
+                result = deep_copy(existing)
+                entitlements_in_partial = partial_data.key?(:entitlements) || partial_data.key?("entitlements")
+                updated_balances = nil
+                metrics_updated = false
+
+                partial_data.each do |key, value|
+                  sym_key = key.to_sym
+                  if COMPANY_MAP_FIELDS.include?(sym_key)
+                    result[sym_key] ||= {}
+                    result[sym_key] = result[sym_key].merge(value) if value.is_a?(Hash)
+                    updated_balances = (value.is_a?(Hash) ? value : {}) if sym_key == :credit_balances
+                  elsif COMPANY_ARRAY_FIELDS.include?(sym_key)
+                    result[sym_key] = value if value.is_a?(Array)
+                  elsif sym_key == :metrics
+                    result[sym_key] = upsert_metrics(result[sym_key] || [], value || [])
+                    metrics_updated = true
+                  else
+                    result[sym_key] = value
+                  end
+                end
+
+                if (updated_balances&.any? || metrics_updated) && !entitlements_in_partial
+                  result[:entitlements] = sync_entitlements(
+                    result[:entitlements], result[:metrics], updated_balances, metrics_updated
+                  )
+                end
+
+                result
+              end
+
+              USER_MAP_FIELDS = %i[keys traits].freeze
+
+              def partial_user(existing, partial_data)
+                return existing unless partial_data.is_a?(Hash)
+
+                result = deep_copy(existing)
+
+                partial_data.each do |key, value|
+                  sym_key = key.to_sym
+                  if USER_MAP_FIELDS.include?(sym_key)
+                    result[sym_key] ||= {}
+                    result[sym_key] = result[sym_key].merge(value) if value.is_a?(Hash)
+                  elsif sym_key == :rules
+                    result[sym_key] = value if value.is_a?(Array)
+                  else
+                    result[sym_key] = value
+                  end
+                end
+
+                result
+              end
+
+              def upsert_metrics(existing, incoming)
+                return incoming if existing.nil? || existing.empty?
+                return existing if incoming.nil? || incoming.empty?
+
+                result = existing.map { |metric| deep_copy(metric) }
+
+                incoming.each do |inc_metric|
+                  match_idx = result.index do |ex|
+                    metrics_match?(ex, inc_metric)
+                  end
+
+                  if match_idx
+                    result[match_idx] = inc_metric
+                  else
+                    result << inc_metric
+                  end
+                end
+
+                result
+              end
+
+              def metrics_match?(left, right)
+                get_metric_field(left, :event_subtype) == get_metric_field(right, :event_subtype) &&
+                  get_metric_field(left, :period) == get_metric_field(right, :period) &&
+                  get_metric_field(left, :month_reset) == get_metric_field(right, :month_reset)
+              end
+
+              def get_metric_field(metric, field)
+                metric[field] || metric[field.to_s]
+              end
+
+              # Re-derive entitlement usage / credit_remaining from the merged metrics
+              # and the just-updated credit balances. Mirrors schematic-python so that
+              # entitlement usage reflects DataStream track events immediately.
+              def sync_entitlements(entitlements, metrics, updated_balances, metrics_updated)
+                return entitlements unless entitlements.is_a?(Array) && !entitlements.empty?
+
+                metrics_lookup = {}
+                if metrics_updated && metrics.is_a?(Array)
+                  metrics.each do |metric|
+                    next unless metric.is_a?(Hash)
+
+                    key = [
+                      get_metric_field(metric, :event_subtype) || "",
+                      get_metric_field(metric, :period) || "",
+                      get_metric_field(metric, :month_reset) || ""
+                    ]
+                    value = get_metric_field(metric, :value)
+                    metrics_lookup[key] = value.nil? ? 0 : value
+                  end
+                end
+
+                entitlements.map do |ent|
+                  next ent unless ent.is_a?(Hash)
+
+                  new_ent = deep_copy(ent)
+
+                  credit_id = get_metric_field(ent, :credit_id)
+                  if updated_balances && credit_id
+                    present, balance = fetch_balance(updated_balances, credit_id)
+                    new_ent[:credit_remaining] = balance if present
+                  end
+
+                  event_name = get_metric_field(ent, :event_name)
+                  unless metrics_lookup.empty? || event_name.nil?
+                    period = get_metric_field(ent, :metric_period) || "all_time"
+                    month_reset = get_metric_field(ent, :month_reset) || "first_of_month"
+                    matched = metrics_lookup[[event_name, period, month_reset]]
+                    new_ent[:usage] = matched unless matched.nil?
+                  end
+
+                  new_ent
+                end
+              end
+
+              # The partial's credit_balances may be keyed by string or symbol depending
+              # on how the message was parsed, while an entitlement's credit_id is a
+              # string value, so check both key forms.
+              def fetch_balance(balances, credit_id)
+                return [true, balances[credit_id]] if balances.key?(credit_id)
+                return [true, balances[credit_id.to_sym]] if balances.key?(credit_id.to_sym)
+
+                [false, nil]
+              end
+            end
+          end
+        end
+    status: unresolved

data/WASM_VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/schematic/accounts/client.rb

@@ -86,6 +86,50 @@ module Schematic
         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, nil] :ids
+      # @option params [String, nil] :q
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Accounts::Types::CountAccountMembersResponse]
+      def count_account_members(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[ids q limit offset]
+        query_params = {}
+        query_params["ids"] = params[:ids] if params.key?(:ids)
+        query_params["q"] = params[:q] if params.key?(:q)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+        params.except(*query_param_names)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "account-members/count",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Accounts::Types::CountAccountMembersResponse.load(response.body)
+        else
+          error_class = Schematic::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

data/lib/schematic/accounts/types/count_account_members_params.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Accounts
+    module Types
+      # Input parameters
+      class CountAccountMembersParams < Internal::Types::Model
+        field :ids, -> { Internal::Types::Array[String] }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+        field :q, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/accounts/types/count_account_members_request.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Accounts
+    module Types
+      class CountAccountMembersRequest < Internal::Types::Model
+        field :ids, -> { String }, optional: true, nullable: false
+        field :q, -> { String }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/accounts/types/count_account_members_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Accounts
+    module Types
+      class CountAccountMembersResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::CountResponse }, optional: false, nullable: false
+        field :params, -> { Schematic::Accounts::Types::CountAccountMembersParams }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/client.rb

@@ -10,7 +10,7 @@ module Schematic
       @raw_client = Schematic::Internal::Http::RawClient.new(
         base_url: base_url || Schematic::Environment::DEFAULT,
         headers: {
-          "User-Agent" => "schematichq/1.4.3",
+          "User-Agent" => "schematichq/1.4.5",
           "X-Fern-Language" => "Ruby",
           "X-Schematic-Api-Key" => api_key.to_s
         }