schematichq 1.4.0

data/lib/schematic/features/client.rb

@@ -0,0 +1,610 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    class Client
+      # @param client [Schematic::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      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 [String, nil] :without_company_override_for
+      # @option params [String, nil] :plan_version_id
+      # @option params [String, nil] :without_plan_entitlement_for
+      # @option params [Schematic::Types::FeatureType, nil] :feature_type
+      # @option params [Boolean, nil] :boolean_require_event
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Features::Types::ListFeaturesResponse]
+      def list_features(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[ids q without_company_override_for plan_version_id without_plan_entitlement_for feature_type boolean_require_event limit offset]
+        query_params = {}
+        query_params["ids"] = params[:ids] if params.key?(:ids)
+        query_params["q"] = params[:q] if params.key?(:q)
+        query_params["without_company_override_for"] = params[:without_company_override_for] if params.key?(:without_company_override_for)
+        query_params["plan_version_id"] = params[:plan_version_id] if params.key?(:plan_version_id)
+        query_params["without_plan_entitlement_for"] = params[:without_plan_entitlement_for] if params.key?(:without_plan_entitlement_for)
+        query_params["feature_type"] = params[:feature_type] if params.key?(:feature_type)
+        query_params["boolean_require_event"] = params[:boolean_require_event] if params.key?(:boolean_require_event)
+        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: "features",
+          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::Features::Types::ListFeaturesResponse.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 [Schematic::Features::Types::CreateFeatureRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Features::Types::CreateFeatureResponse]
+      def create_feature(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "features",
+          body: Schematic::Features::Types::CreateFeatureRequestBody.new(params).to_h,
+          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::Features::Types::CreateFeatureResponse.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
+      # @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] :feature_id
+      #
+      # @return [Schematic::Features::Types::GetFeatureResponse]
+      def get_feature(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "features/#{URI.encode_uri_component(params[:feature_id].to_s)}",
+          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::Features::Types::GetFeatureResponse.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 [Schematic::Features::Types::UpdateFeatureRequestBody]
+      # @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] :feature_id
+      #
+      # @return [Schematic::Features::Types::UpdateFeatureResponse]
+      def update_feature(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request_data = Schematic::Features::Types::UpdateFeatureRequestBody.new(params).to_h
+        non_body_param_names = ["feature_id"]
+        body = request_data.except(*non_body_param_names)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "features/#{URI.encode_uri_component(params[:feature_id].to_s)}",
+          body: body,
+          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::Features::Types::UpdateFeatureResponse.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
+      # @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] :feature_id
+      #
+      # @return [Schematic::Features::Types::DeleteFeatureResponse]
+      def delete_feature(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "features/#{URI.encode_uri_component(params[:feature_id].to_s)}",
+          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::Features::Types::DeleteFeatureResponse.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
+      # @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 [String, nil] :without_company_override_for
+      # @option params [String, nil] :plan_version_id
+      # @option params [String, nil] :without_plan_entitlement_for
+      # @option params [Schematic::Types::FeatureType, nil] :feature_type
+      # @option params [Boolean, nil] :boolean_require_event
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Features::Types::CountFeaturesResponse]
+      def count_features(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[ids q without_company_override_for plan_version_id without_plan_entitlement_for feature_type boolean_require_event limit offset]
+        query_params = {}
+        query_params["ids"] = params[:ids] if params.key?(:ids)
+        query_params["q"] = params[:q] if params.key?(:q)
+        query_params["without_company_override_for"] = params[:without_company_override_for] if params.key?(:without_company_override_for)
+        query_params["plan_version_id"] = params[:plan_version_id] if params.key?(:plan_version_id)
+        query_params["without_plan_entitlement_for"] = params[:without_plan_entitlement_for] if params.key?(:without_plan_entitlement_for)
+        query_params["feature_type"] = params[:feature_type] if params.key?(:feature_type)
+        query_params["boolean_require_event"] = params[:boolean_require_event] if params.key?(:boolean_require_event)
+        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: "features/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::Features::Types::CountFeaturesResponse.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
+      # @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] :feature_id
+      # @option params [String, nil] :ids
+      # @option params [String, nil] :q
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Features::Types::ListFlagsResponse]
+      def list_flags(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[feature_id ids q limit offset]
+        query_params = {}
+        query_params["feature_id"] = params[:feature_id] if params.key?(:feature_id)
+        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: "flags",
+          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::Features::Types::ListFlagsResponse.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 [Schematic::Types::CreateFlagRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Features::Types::CreateFlagResponse]
+      def create_flag(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "flags",
+          body: Schematic::Types::CreateFlagRequestBody.new(params).to_h,
+          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::Features::Types::CreateFlagResponse.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
+      # @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] :flag_id
+      #
+      # @return [Schematic::Features::Types::GetFlagResponse]
+      def get_flag(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "flags/#{URI.encode_uri_component(params[:flag_id].to_s)}",
+          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::Features::Types::GetFlagResponse.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 [Schematic::Types::CreateFlagRequestBody]
+      # @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] :flag_id
+      #
+      # @return [Schematic::Features::Types::UpdateFlagResponse]
+      def update_flag(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "flags/#{URI.encode_uri_component(params[:flag_id].to_s)}",
+          body: Schematic::Types::CreateFlagRequestBody.new(params).to_h,
+          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::Features::Types::UpdateFlagResponse.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
+      # @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] :flag_id
+      #
+      # @return [Schematic::Features::Types::DeleteFlagResponse]
+      def delete_flag(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "flags/#{URI.encode_uri_component(params[:flag_id].to_s)}",
+          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::Features::Types::DeleteFlagResponse.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 [Schematic::Features::Types::UpdateFlagRulesRequestBody]
+      # @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] :flag_id
+      #
+      # @return [Schematic::Features::Types::UpdateFlagRulesResponse]
+      def update_flag_rules(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request_data = Schematic::Features::Types::UpdateFlagRulesRequestBody.new(params).to_h
+        non_body_param_names = ["flag_id"]
+        body = request_data.except(*non_body_param_names)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "flags/#{URI.encode_uri_component(params[:flag_id].to_s)}/rules",
+          body: body,
+          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::Features::Types::UpdateFlagRulesResponse.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 [Schematic::Types::CheckFlagRequestBody]
+      # @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] :key
+      #
+      # @return [Schematic::Features::Types::CheckFlagResponse]
+      def check_flag(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "flags/#{URI.encode_uri_component(params[:key].to_s)}/check",
+          body: Schematic::Types::CheckFlagRequestBody.new(params).to_h,
+          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::Features::Types::CheckFlagResponse.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 [Schematic::Types::CheckFlagRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Features::Types::CheckFlagsResponse]
+      def check_flags(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "flags/check",
+          body: Schematic::Types::CheckFlagRequestBody.new(params).to_h,
+          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::Features::Types::CheckFlagsResponse.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 [Schematic::Features::Types::CheckFlagsBulkRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Features::Types::CheckFlagsBulkResponse]
+      def check_flags_bulk(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "flags/check-bulk",
+          body: Schematic::Features::Types::CheckFlagsBulkRequestBody.new(params).to_h,
+          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::Features::Types::CheckFlagsBulkResponse.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
+      # @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] :feature_id
+      # @option params [String, nil] :ids
+      # @option params [String, nil] :q
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Features::Types::CountFlagsResponse]
+      def count_flags(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[feature_id ids q limit offset]
+        query_params = {}
+        query_params["feature_id"] = params[:feature_id] if params.key?(:feature_id)
+        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: "flags/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::Features::Types::CountFlagsResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/schematic/features/types/check_flag_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    module Types
+      class CheckFlagResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::CheckFlagResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/features/types/check_flags_bulk_request_body.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    module Types
+      class CheckFlagsBulkRequestBody < Internal::Types::Model
+        field :contexts, -> { Internal::Types::Array[Schematic::Types::CheckFlagRequestBody] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/features/types/check_flags_bulk_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    module Types
+      class CheckFlagsBulkResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::CheckFlagsBulkResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/features/types/check_flags_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    module Types
+      class CheckFlagsResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::CheckFlagsResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/features/types/count_features_params.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Features
+    module Types
+      # Input parameters
+      class CountFeaturesParams < Internal::Types::Model
+        field :boolean_require_event, -> { Internal::Types::Boolean }, optional: true, nullable: false
+        field :feature_type, -> { Internal::Types::Array[Schematic::Types::FeatureType] }, optional: true, nullable: false
+        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 :plan_version_id, -> { String }, optional: true, nullable: false
+        field :q, -> { String }, optional: true, nullable: false
+        field :without_company_override_for, -> { String }, optional: true, nullable: false
+        field :without_plan_entitlement_for, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end