runtype 0.1.0

data/generated/lib/runtype/products/client.rb

@@ -0,0 +1,1719 @@
+# frozen_string_literal: true
+
+module Runtype
+  module Products
+    class Client
+      # @param client [Runtype::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # List all products for the authenticated user with search and cursor pagination.
+      #
+      # @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] :limit
+      # @option params [String, nil] :cursor
+      # @option params [String, nil] :search
+      # @option params [Runtype::Products::Types::GetV1ProductsRequestView, nil] :view
+      #
+      # @example
+      #   client.products.list_products
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsResponse]
+      def list_products(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["search"] = params[:search] if params.key?(:search)
+        query_params["view"] = params[:view] if params.key?(:view)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a new product with optional canvas and spec configuration.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsRequest]
+      # @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
+      #
+      # @example
+      #   client.products.create_product(
+      #     description: "AI-powered customer support",
+      #     name: "Customer Support Bot"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsResponse]
+      def create_product(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products",
+          body: Runtype::Products::Types::PostV1ProductsRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Assemble a product from a validated Full Product Object (FPO). Materializes secret bindings, so API keys must
+      # carry the SECRETS:WRITE permission.
+      #
+      # @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
+      #
+      # @example
+      #   client.products.assemble_product_from_fpo(request: {
+      #     _meta: {
+      #       catalogVersion: "1.0.0",
+      #       generatedAt: "2026-06-01T00:00:00.000Z",
+      #       generatorVersion: "1.0.0",
+      #       planHash: "abc123",
+      #       schemaVersion: "2.0"
+      #     },
+      #     capabilities: [{
+      #       agent: {
+      #         config: {
+      #           model: "claude-sonnet-4-5",
+      #           systemPrompt: "You are a helpful support agent."
+      #         },
+      #         description: "A helpful customer support agent",
+      #         name: "Support Agent"
+      #       },
+      #       description: "Handles customer support conversations",
+      #       id: "support-chat",
+      #       name: "Support Chat"
+      #     }],
+      #     product: {
+      #       description: "An AI-powered customer support product",
+      #       name: "My AI Product"
+      #     },
+      #     surfaces: [{
+      #       config: {},
+      #       id: "support-widget",
+      #       name: "Support Widget",
+      #       routes: [{
+      #         capabilityId: "support-chat"
+      #       }],
+      #       type: "chat"
+      #     }],
+      #     version: "2.0"
+      #   })
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsAssembleResponse]
+      def assemble_product_from_fpo(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/assemble",
+          body: params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsAssembleResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Idempotently converge a repo-defined product definition onto the platform. Identity is name + account scope.
+      # Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not
+      # an error); full requests create the product or update it when the canonical content hash differs. The converge
+      # covers the top-level product record only (description, icon, spec) — not nested capabilities/surfaces/tools or
+      # canvas layout. The response always carries the server-computed canonical hash. Set dryRun to plan without
+      # writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Products have no
+      # version snapshots, so there is no publish option.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsEnsureRequest]
+      # @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
+      #
+      # @example
+      #   client.products.ensure_product_config_as_code_converge(name: "name")
+      #
+      # @return [Runtype::Types::ProductEnsureResponse]
+      def ensure_product_config_as_code_converge(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/ensure",
+          body: Runtype::Products::Types::PostV1ProductsEnsureRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::ProductEnsureResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Idempotently converge an entire Full Product Object (the nested product graph) in one shot. Fans out to the
+      # per-entity ensure services in dependency order (product → capability backing flows/agents → capability-as-tool
+      # composition → capability links → surfaces + surface items → records → schedules → secret bindings), returning a
+      # per-entity report. Identity is the product name + account scope. NON-atomic by design: a per-entity failure is
+      # reported in `entities[].result = "failed"` (and `hasFailures`) and a re-run self-heals; only a top-level product
+      # reject aborts. Set dryRun to plan without writing. Set prune to remove product-scoped capabilities/surfaces (and
+      # their items) absent from the FPO (account-scoped flows/agents/tools/records are never removed). Whole-FPO
+      # fast-probe is not yet supported (PR3).
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsEnsureFpoRequest]
+      # @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
+      #
+      # @example
+      #   client.products.ensure_full_product_config_as_code_converge_of_the_whole_fpo(fpo: {
+      #     key: "value"
+      #   })
+      #
+      # @return [Runtype::Types::ProductFpoEnsureResponse]
+      def ensure_full_product_config_as_code_converge_of_the_whole_fpo(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/ensure-fpo",
+          body: Runtype::Products::Types::PostV1ProductsEnsureFpoRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::ProductFpoEnsureResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return the canonical config-as-code definition and provenance for a product by name — the absorb-drift direction
+      # of the ensure protocol. The contentHash is recomputed from the live product state, so it is accurate even
+      # immediately after a dashboard edit. Returns the top-level product record only (description, icon, spec); nested
+      # capabilities/surfaces and canvas layout are not included.
+      #
+      # @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] :name
+      #
+      # @example
+      #   client.products.pull_product_definition_config_as_code(name: "name")
+      #
+      # @return [Runtype::Types::ProductPullResponse]
+      def pull_product_definition_config_as_code(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["name"] = params[:name] if params.key?(:name)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/pull",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::ProductPullResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reconstruct a self-contained Full Product Object from the live product graph — the absorb-drift direction of
+      # ensure-fpo. Composes the per-entity pulls (product, backing flows/agents, surfaces) and mints deterministic
+      # FPO-local ids, so feeding the result back into POST /products/ensure-fpo converges to `unchanged`.
+      # records/schedules/secrets are NOT reconstructed and `tools` is emitted empty (tool refs are portable
+      # `tool:<name>`); see `warnings` for per-pull caveats. The contentHash is recomputed from the live graph, so it is
+      # accurate immediately after a dashboard edit.
+      #
+      # @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] :name
+      #
+      # @example
+      #   client.products.pull_full_product_reconstruct_the_whole_fpo_from_the_live_graph(name: "name")
+      #
+      # @return [Runtype::Types::ProductFpoPullResponse]
+      def pull_full_product_reconstruct_the_whole_fpo_from_the_live_graph(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["name"] = params[:name] if params.key?(:name)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/pull-fpo",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::ProductFpoPullResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get a product by ID including its capabilities and surfaces.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String, nil] :include_editor_context
+      #
+      # @example
+      #   client.products.get_product_details(id: "id")
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDResponse]
+      def get_product_details(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["includeEditorContext"] = params[:include_editor_context] if params.key?(:include_editor_context)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing product. Supports partial updates with deep-merging for canvas and spec.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PutV1ProductsIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.update_product(id: "id")
+      #
+      # @return [Runtype::Products::Types::PutV1ProductsIDResponse]
+      def update_product(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PutV1ProductsIDRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PutV1ProductsIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete a product (cascades to capabilities, surfaces, items, keys). Optionally cleans up associated flows/agents
+      # via cleanupFlowIds/cleanupAgentIds in the request body.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.delete_product(id: "id")
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDResponse]
+      def delete_product(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Add a capability (flow or agent binding) to a product. Requires either flowId or agentId.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDCapabilitiesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.add_capability_to_product(
+      #     id: "id",
+      #     capability_description: "Answer user questions about products and services",
+      #     capability_name: "answer-questions",
+      #     flow_id: "flow_01jv0000000000000000000001"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDCapabilitiesResponse]
+      def add_capability_to_product(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDCapabilitiesRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/capabilities",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDCapabilitiesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing product capability. Supports partial updates and schema refresh.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PutV1ProductsIDCapabilitiesCapabilityIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :capability_id
+      #
+      # @example
+      #   client.products.update_capability(
+      #     id: "id",
+      #     capability_id: "capabilityId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PutV1ProductsIDCapabilitiesCapabilityIDResponse]
+      def update_capability(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PutV1ProductsIDCapabilitiesCapabilityIDRequest.new(params).to_h
+        non_body_param_names = %w[id capabilityId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/capabilities/#{URI.encode_uri_component(params[:capability_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PutV1ProductsIDCapabilitiesCapabilityIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Remove a capability from a product.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :capability_id
+      #
+      # @example
+      #   client.products.remove_capability(
+      #     id: "id",
+      #     capability_id: "capabilityId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDCapabilitiesCapabilityIDResponse]
+      def remove_capability(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/capabilities/#{URI.encode_uri_component(params[:capability_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDCapabilitiesCapabilityIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Preview the flows and agents associated with a product that could be cleaned up on deletion, including whether
+      # each is referenced elsewhere.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.preview_cleanup_resources(id: "id")
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDCleanupPreviewResponse]
+      def preview_cleanup_resources(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/cleanup-preview",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDCleanupPreviewResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get the secret configuration summary for a product. Never returns secret values — used to decide whether to show
+      # a "Configure secrets" prompt.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.get_product_configuration_summary(id: "id")
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDConfigurationResponse]
+      def get_product_configuration_summary(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/configuration",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDConfigurationResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get structured, headless-first next steps to make a product live: pending secrets plus every surface's install
+      # steps, folded into a product-level readiness result. A sibling of the secrets-only configuration endpoint.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.get_product_setup_readiness(id: "id")
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSetupResponse]
+      def get_product_setup_readiness(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/setup",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSetupResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List the surfaces for a product with filtering and cursor pagination.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :cursor
+      # @option params [String, nil] :type
+      # @option params [String, nil] :status
+      #
+      # @example
+      #   client.products.list_surfaces(id: "id")
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesResponse]
+      def list_surfaces(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["type"] = params[:type] if params.key?(:type)
+        query_params["status"] = params[:status] if params.key?(:status)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a new surface for a product.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDSurfacesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.create_surface(
+      #     id: "id",
+      #     config: {
+      #       rateLimit: {
+      #         perDay: 5000,
+      #         perMinute: 60
+      #       },
+      #       type: "api"
+      #     },
+      #     name: "Public API",
+      #     status: "active",
+      #     type: "api"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesResponse]
+      def create_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDSurfacesRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Idempotently converge a repo-defined surface definition onto a product. Identity is name + product. Hash-only
+      # probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an
+      # error); full requests create the surface or update it when the canonical content hash differs. The response
+      # always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), and
+      # onConflict: "overwrite" to converge over dashboard/API edits. Surfaces have no version snapshots, so there is no
+      # publish option.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDSurfacesEnsureRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.products.ensure_surface_config_as_code_converge(
+      #     id: "id",
+      #     name: "name"
+      #   )
+      #
+      # @return [Runtype::Types::SurfaceEnsureResponse]
+      def ensure_surface_config_as_code_converge(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDSurfacesEnsureRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/ensure",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::SurfaceEnsureResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return the canonical config-as-code definition and provenance for a surface by name within a product — the
+      # absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live surface state, so it
+      # is accurate even immediately after a dashboard edit.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :name
+      #
+      # @example
+      #   client.products.pull_surface_definition_config_as_code(
+      #     id: "id",
+      #     name: "name"
+      #   )
+      #
+      # @return [Runtype::Types::SurfacePullResponse]
+      def pull_surface_definition_config_as_code(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["name"] = params[:name] if params.key?(:name)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/pull",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::SurfacePullResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get a surface by ID including its items and keys.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.get_surface_details(
+      #     id: "id",
+      #     surface_id: "surfaceId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDResponse]
+      def get_surface_details(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing surface. Supports partial updates with shallow-merge for behavior.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.update_surface(
+      #     id: "id",
+      #     surface_id: "surfaceId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDResponse]
+      def update_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete a surface (cascades to items, keys, and orthogonal endpoint registrations).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.delete_surface(
+      #     id: "id",
+      #     surface_id: "surfaceId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDResponse]
+      def delete_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Add a capability item to a surface.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDItemsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.add_item_to_surface(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     capability_id: "prodcap_abc123",
+      #     exposed_name: "answer-questions"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDItemsResponse]
+      def add_item_to_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDItemsRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/items",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDItemsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing surface item. Config updates are deep-merged.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDItemsItemIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :item_id
+      #
+      # @example
+      #   client.products.update_surface_item(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     item_id: "itemId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDItemsItemIDResponse]
+      def update_surface_item(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDItemsItemIDRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId itemId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/items/#{URI.encode_uri_component(params[:item_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDItemsItemIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Remove an item from a surface (cleans up any Orthogonal API registration).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :item_id
+      #
+      # @example
+      #   client.products.remove_surface_item(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     item_id: "itemId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDItemsItemIDResponse]
+      def remove_surface_item(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/items/#{URI.encode_uri_component(params[:item_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDItemsItemIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a new API key for a surface. The plaintext key is only returned on creation.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDKeysRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.create_surface_api_key(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     name: "Production Key",
+      #     rate_limit_per_day: 5000,
+      #     rate_limit_per_minute: 60,
+      #     scopes: %w[surfitem_01jexampleanswer surfitem_01jexampleticket]
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDKeysResponse]
+      def create_surface_api_key(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDKeysRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/keys",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDKeysResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete an API key for a surface.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :key_id
+      #
+      # @example
+      #   client.products.delete_surface_api_key(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     key_id: "keyId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDKeysKeyIDResponse]
+      def delete_surface_api_key(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/keys/#{URI.encode_uri_component(params[:key_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDKeysKeyIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reveal the plaintext of a test surface key. Session-only — API key authentication is rejected.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :key_id
+      #
+      # @example
+      #   client.products.reveal_test_surface_key(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     key_id: "keyId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDKeysKeyIDRevealResponse]
+      def reveal_test_surface_key(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/keys/#{URI.encode_uri_component(params[:key_id].to_s)}/reveal",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDKeysKeyIDRevealResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List the schedules attached to a schedule-type surface.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.list_schedules_for_surface(
+      #     id: "id",
+      #     surface_id: "surfaceId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSchedulesResponse]
+      def list_schedules_for_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSchedulesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a new schedule (one-time or recurring) for a schedule-type surface.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.create_schedule_for_surface(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     flow_id: "flowId",
+      #     trigger_type: "one_time"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesResponse]
+      def create_schedule_for_surface(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get a schedule by ID including recent runs.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.get_schedule_details(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse]
+      def get_schedule_details(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing schedule. Recomputes next run time when trigger settings change.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.update_schedule(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse]
+      def update_schedule(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDRequest.new(params).to_h
+        non_body_param_names = %w[id surfaceId scheduleId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PutV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete a schedule from a schedule-type surface.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.delete_schedule(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse]
+      def delete_schedule(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::DeleteV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Pause a schedule (sets enabled to false).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.pause_schedule(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDPauseResponse]
+      def pause_schedule(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}/pause",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDPauseResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Resume a schedule (sets enabled to true).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.resume_schedule(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResumeResponse]
+      def resume_schedule(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}/resume",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDResumeResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Trigger an immediate batch run of a schedule, resolving its records and submitting a batch.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      # @option params [String] :schedule_id
+      #
+      # @example
+      #   client.products.run_schedule_immediately(
+      #     id: "id",
+      #     surface_id: "surfaceId",
+      #     schedule_id: "scheduleId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDRunNowResponse]
+      def run_schedule_immediately(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/schedules/#{URI.encode_uri_component(params[:schedule_id].to_s)}/run-now",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::PostV1ProductsIDSurfacesSurfaceIDSchedulesScheduleIDRunNowResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get the headless-first next steps to make a single surface live. Secret steps are product-scoped and therefore
+      # only appear on the product-level setup endpoint.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :surface_id
+      #
+      # @example
+      #   client.products.get_surface_setup_readiness(
+      #     id: "id",
+      #     surface_id: "surfaceId"
+      #   )
+      #
+      # @return [Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSetupResponse]
+      def get_surface_setup_readiness(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/products/#{URI.encode_uri_component(params[:id].to_s)}/surfaces/#{URI.encode_uri_component(params[:surface_id].to_s)}/setup",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Products::Types::GetV1ProductsIDSurfacesSurfaceIDSetupResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end