runtype 0.1.0

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

@@ -0,0 +1,1639 @@
+# frozen_string_literal: true
+
+module Runtype
+  module Integrations
+    class Client
+      # @param client [Runtype::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # List all available integrations with the caller’s configuration status. Optionally filter credential status by
+      # environment.
+      #
+      # @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] :environment
+      #
+      # @example
+      #   client.integrations.list_integrations
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsResponse]
+      def list_integrations(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["environment"] = params[:environment] if params.key?(:environment)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations",
+          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::Integrations::Types::GetV1IntegrationsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reserve a new integration row server-side. Returns a pending row scoped to the authenticated owner whose id may
+      # be embedded in provider manifests before credentials are supplied.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsRequest]
+      # @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.integrations.reserve_a_new_integration(provider: "slack")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsResponse]
+      def reserve_a_new_integration(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/integrations",
+          body: Runtype::Integrations::Types::PostV1IntegrationsRequest.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::Integrations::Types::PostV1IntegrationsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List integrations within a given category along with the caller’s configuration status for each.
+      #
+      # @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] :category
+      #
+      # @example
+      #   client.integrations.list_integrations_by_category(category: "category")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsCategoryCategoryResponse]
+      def list_integrations_by_category(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/integrations/category/#{URI.encode_uri_component(params[:category].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::Integrations::Types::GetV1IntegrationsCategoryCategoryResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List connected integration accounts available in the caller's active personal or organization scope. Use an
+      # integration ID to pin a tool instance to a specific connection, e.g. a Granola tool's toolConfigs integrationId.
+      #
+      # @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] :provider
+      #
+      # @example
+      #   client.integrations.list_connected_integration_accounts(provider: "provider")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsConnectionsResponse]
+      def list_connected_integration_accounts(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["provider"] = params[:provider] if params.key?(:provider)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/connections",
+          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::Integrations::Types::GetV1IntegrationsConnectionsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return which environments have credentials configured for each integration for the authenticated caller.
+      #
+      # @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.integrations.get_integration_credential_status
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsCredentialsStatusResponse]
+      def get_integration_credential_status(request_options: {}, **_params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/credentials-status",
+          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::Integrations::Types::GetV1IntegrationsCredentialsStatusResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Install or upsert a Granola integration for the authenticated owner. Verifies the pasted API key against the
+      # Granola public API before storing it in the secret store. Re-pasting the same key updates the existing
+      # connection.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsGranolaInstallRequest]
+      # @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.integrations.install_granola_integration(api_key: "apiKey")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsGranolaInstallResponse]
+      def install_granola_integration(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/integrations/granola/install",
+          body: Runtype::Integrations::Types::PostV1IntegrationsGranolaInstallRequest.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::Integrations::Types::PostV1IntegrationsGranolaInstallResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Report whether Slack has sent an events-URL verification challenge to a surface's Slack webhook. Slack issues
+      # that challenge when an app is created from a manifest, so a verifiedAt newer than the one observed before the
+      # manifest was handed out is evidence the customer's Slack app now exists. Verification markers expire an hour
+      # after they are recorded, and the check is advisory: the OAuth install remains the authority on whether an
+      # integration is usable.
+      #
+      # @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] :surface_id
+      #
+      # @example
+      #   client.integrations.check_slack_app_creation_status(surface_id: "surfaceId")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsSlackAppStatusResponse]
+      def check_slack_app_creation_status(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["surfaceId"] = params[:surface_id] if params.key?(:surface_id)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/slack/app-status",
+          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::Integrations::Types::GetV1IntegrationsSlackAppStatusResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Install or upsert a Slack app integration for the authenticated owner, writing bot token and signing secret into
+      # the secret store.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsSlackInstallRequest]
+      # @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.integrations.install_slack_integration(
+      #     bot_token: "botToken",
+      #     signing_secret: "signingSecret",
+      #     team_id: "teamId"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsSlackInstallResponse]
+      def install_slack_integration(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/integrations/slack/install",
+          body: Runtype::Integrations::Types::PostV1IntegrationsSlackInstallRequest.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::Integrations::Types::PostV1IntegrationsSlackInstallResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Generate the Slack app manifest for a surface, with absolute API URLs (events webhook, interactivity webhook,
+      # and OAuth redirect), plus a link to Slack's app-creation page and a hosted connect-page handoff for the human
+      # credential + OAuth step. Paste the manifest into Slack's From a manifest option; Slack no longer accepts a
+      # manifest embedded in the URL. The redirect URL matches the OAuth start route byte-for-byte. When integrationId
+      # is omitted a pending Slack integration is reserved automatically (24h TTL) and returned as integrationId. A
+      # supplied integrationId must be a live pending reservation; an already-connected, revoked, or expired one is
+      # refused with 404, so omit it to get a fresh reservation. Credentials never pass through this route.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsSlackManifestRequest]
+      # @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.integrations.generate_slack_app_manifest(surface_id: "surfaceId")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsSlackManifestResponse]
+      def generate_slack_app_manifest(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/integrations/slack/manifest",
+          body: Runtype::Integrations::Types::PostV1IntegrationsSlackManifestRequest.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::Integrations::Types::PostV1IntegrationsSlackManifestResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Rotate any subset of bot token, signing secret, or app ID on an existing Slack integration without re-supplying
+      # the others.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsSlackRotateCredentialsRequest]
+      # @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.integrations.rotate_slack_credentials(integration_id: "integrationId")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsSlackRotateCredentialsResponse]
+      def rotate_slack_credentials(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/integrations/slack/rotate-credentials",
+          body: Runtype::Integrations::Types::PostV1IntegrationsSlackRotateCredentialsRequest.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::Integrations::Types::PostV1IntegrationsSlackRotateCredentialsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Install or upsert a Telegram bot integration for the authenticated owner, writing bot token and webhook secret
+      # into the secret store and registering the webhook with Telegram.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsTelegramInstallRequest]
+      # @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.integrations.install_telegram_integration(
+      #     bot_id: "botId",
+      #     bot_token: "botToken"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsTelegramInstallResponse]
+      def install_telegram_integration(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/integrations/telegram/install",
+          body: Runtype::Integrations::Types::PostV1IntegrationsTelegramInstallRequest.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::Integrations::Types::PostV1IntegrationsTelegramInstallResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Returns whether managed Telegram bot creation is configured on this deployment.
+      #
+      # @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.integrations.check_managed_telegram_bot_availability
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsTelegramManagedAvailableResponse]
+      def check_managed_telegram_bot_availability(request_options: {}, **_params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/telegram/managed/available",
+          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::Integrations::Types::GetV1IntegrationsTelegramManagedAvailableResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Initiate creation of a managed Telegram bot, returning a deep link to the manager bot and a pending request id.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedInitiateRequest]
+      # @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.integrations.initiate_managed_telegram_bot_creation(suggested_bot_name: "suggestedBotName")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedInitiateResponse]
+      def initiate_managed_telegram_bot_creation(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/integrations/telegram/managed/initiate",
+          body: Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedInitiateRequest.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::Integrations::Types::PostV1IntegrationsTelegramManagedInitiateResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Rotate the bot token of a managed Telegram bot via the manager bot and persist the new token in the secret
+      # store.
+      #
+      # @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] :integration_id
+      #
+      # @example
+      #   client.integrations.rotate_managed_telegram_bot_token(integration_id: "integrationId")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedIntegrationIDRotateTokenResponse]
+      def rotate_managed_telegram_bot_token(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/integrations/telegram/managed/#{URI.encode_uri_component(params[:integration_id].to_s)}/rotate-token",
+          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::Integrations::Types::PostV1IntegrationsTelegramManagedIntegrationIDRotateTokenResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Cancels an in-progress managed Telegram bot creation request.
+      #
+      # @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] :request_id
+      #
+      # @example
+      #   client.integrations.cancel_managed_telegram_bot_request(request_id: "requestId")
+      #
+      # @return [Runtype::Integrations::Types::DeleteV1IntegrationsTelegramManagedRequestIDResponse]
+      def cancel_managed_telegram_bot_request(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/integrations/telegram/managed/#{URI.encode_uri_component(params[:request_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::Integrations::Types::DeleteV1IntegrationsTelegramManagedRequestIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Confirm that a renamed managed Telegram bot belongs to the caller, clearing the dashboard rename 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] :request_id
+      #
+      # @example
+      #   client.integrations.confirm_managed_telegram_bot_rename(request_id: "requestId")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedRequestIDConfirmRenameResponse]
+      def confirm_managed_telegram_bot_rename(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/integrations/telegram/managed/#{URI.encode_uri_component(params[:request_id].to_s)}/confirm-rename",
+          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::Integrations::Types::PostV1IntegrationsTelegramManagedRequestIDConfirmRenameResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reject a renamed managed Telegram bot, tearing down its integration record and credentials so the user can
+      # retry.
+      #
+      # @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] :request_id
+      #
+      # @example
+      #   client.integrations.reject_managed_telegram_bot_rename(request_id: "requestId")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsTelegramManagedRequestIDRejectRenameResponse]
+      def reject_managed_telegram_bot_rename(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/integrations/telegram/managed/#{URI.encode_uri_component(params[:request_id].to_s)}/reject-rename",
+          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::Integrations::Types::PostV1IntegrationsTelegramManagedRequestIDRejectRenameResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Returns the current status of a managed Telegram bot creation request.
+      #
+      # @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] :request_id
+      #
+      # @example
+      #   client.integrations.get_managed_telegram_bot_request_status(request_id: "requestId")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsTelegramManagedRequestIDStatusResponse]
+      def get_managed_telegram_bot_request_status(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/integrations/telegram/managed/#{URI.encode_uri_component(params[:request_id].to_s)}/status",
+          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::Integrations::Types::GetV1IntegrationsTelegramManagedRequestIDStatusResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List all tools available from integrations that have valid credentials configured for the caller.
+      #
+      # @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.integrations.list_configured_integration_tools
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsToolsResponse]
+      def list_configured_integration_tools(request_options: {}, **_params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/tools",
+          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::Integrations::Types::GetV1IntegrationsToolsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get all Cloudflare Vectorize configurations for the authenticated user.
+      #
+      # @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.integrations.list_vectorize_configurations
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsVectorizeResponse]
+      def list_vectorize_configurations(request_options: {}, **_params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/vectorize",
+          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::Integrations::Types::GetV1IntegrationsVectorizeResponse.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 Cloudflare Vectorize configuration for the authenticated user.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsVectorizeRequest]
+      # @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.integrations.create_vectorize_configuration(
+      #     account_id: "abcdef1234567890abcdef1234567890",
+      #     api_token: "cf-api-token-here",
+      #     index_name: "my-embeddings",
+      #     name: "Production Vectorize",
+      #     timeout: 30000
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsVectorizeResponse]
+      def create_vectorize_configuration(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/integrations/vectorize",
+          body: Runtype::Integrations::Types::PostV1IntegrationsVectorizeRequest.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::Integrations::Types::PostV1IntegrationsVectorizeResponse.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 Vectorize index in a Cloudflare account using provided or stored credentials.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesCreateRequest]
+      # @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.integrations.create_vectorize_index(
+      #     account_id: "abcdef1234567890abcdef1234567890",
+      #     api_token: "cf-api-token-here",
+      #     description: "Embeddings for document search",
+      #     dimensions: 1536,
+      #     index_name: "new-embeddings",
+      #     metric: "cosine"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesCreateResponse]
+      def create_vectorize_index(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/integrations/vectorize/indexes/create",
+          body: Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesCreateRequest.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::Integrations::Types::PostV1IntegrationsVectorizeIndexesCreateResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List all Vectorize indexes in a Cloudflare account using provided or stored credentials.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesListRequest]
+      # @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.integrations.list_vectorize_indexes(
+      #     account_id: "abcdef1234567890abcdef1234567890",
+      #     api_token: "cf-api-token-here"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesListResponse]
+      def list_vectorize_indexes(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/integrations/vectorize/indexes/list",
+          body: Runtype::Integrations::Types::PostV1IntegrationsVectorizeIndexesListRequest.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::Integrations::Types::PostV1IntegrationsVectorizeIndexesListResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Test the connection to a Cloudflare Vectorize configuration before saving it.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsVectorizeTestRequest]
+      # @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.integrations.test_new_vectorize_configuration(
+      #     account_id: "abcdef1234567890abcdef1234567890",
+      #     api_token: "cf-api-token-here",
+      #     index_name: "my-embeddings",
+      #     name: "Test Connection"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsVectorizeTestResponse]
+      def test_new_vectorize_configuration(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/integrations/vectorize/test",
+          body: Runtype::Integrations::Types::PostV1IntegrationsVectorizeTestRequest.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::Integrations::Types::PostV1IntegrationsVectorizeTestResponse.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 specific Cloudflare Vectorize configuration by ID.
+      #
+      # @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.integrations.get_vectorize_configuration(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsVectorizeIDResponse]
+      def get_vectorize_configuration(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/integrations/vectorize/#{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::Integrations::Types::GetV1IntegrationsVectorizeIDResponse.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 Cloudflare Vectorize configuration by ID.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PutV1IntegrationsVectorizeIDRequest]
+      # @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.integrations.update_vectorize_configuration(
+      #     id: "id",
+      #     index_name: "new-embeddings-index",
+      #     name: "Updated Vectorize Config"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PutV1IntegrationsVectorizeIDResponse]
+      def update_vectorize_configuration(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Integrations::Types::PutV1IntegrationsVectorizeIDRequest.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/integrations/vectorize/#{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::Integrations::Types::PutV1IntegrationsVectorizeIDResponse.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 Cloudflare Vectorize configuration by ID.
+      #
+      # @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.integrations.delete_vectorize_configuration(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::DeleteV1IntegrationsVectorizeIDResponse]
+      def delete_vectorize_configuration(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/integrations/vectorize/#{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::Integrations::Types::DeleteV1IntegrationsVectorizeIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Test the connection to a saved Cloudflare Vectorize configuration.
+      #
+      # @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.integrations.test_saved_vectorize_configuration(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsVectorizeIDTestResponse]
+      def test_saved_vectorize_configuration(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/integrations/vectorize/#{URI.encode_uri_component(params[:id].to_s)}/test",
+          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::Integrations::Types::PostV1IntegrationsVectorizeIDTestResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get all Weaviate configurations for the authenticated user.
+      #
+      # @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.integrations.list_weaviate_configurations
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsWeaviateResponse]
+      def list_weaviate_configurations(request_options: {}, **_params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/integrations/weaviate",
+          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::Integrations::Types::GetV1IntegrationsWeaviateResponse.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 Weaviate configuration.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsWeaviateRequest]
+      # @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.integrations.create_weaviate_configuration(
+      #     api_key: "wv-your-api-key-here",
+      #     headers: {
+      #       key: "value"
+      #     },
+      #     name: "Production Weaviate",
+      #     settings: {
+      #       default_class: "Documents",
+      #       generative_module: "generative-openai",
+      #       vectorizer: "text2vec-openai"
+      #     },
+      #     url: "https://my-cluster.weaviate.network"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsWeaviateResponse]
+      def create_weaviate_configuration(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/integrations/weaviate",
+          body: Runtype::Integrations::Types::PostV1IntegrationsWeaviateRequest.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::Integrations::Types::PostV1IntegrationsWeaviateResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Test the connection to a Weaviate instance before saving the configuration.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PostV1IntegrationsWeaviateTestRequest]
+      # @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.integrations.test_new_weaviate_configuration(
+      #     api_key: "wv-your-api-key-here",
+      #     name: "Test Connection",
+      #     url: "https://my-cluster.weaviate.network"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsWeaviateTestResponse]
+      def test_new_weaviate_configuration(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/integrations/weaviate/test",
+          body: Runtype::Integrations::Types::PostV1IntegrationsWeaviateTestRequest.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::Integrations::Types::PostV1IntegrationsWeaviateTestResponse.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 specific Weaviate configuration by ID.
+      #
+      # @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.integrations.get_weaviate_configuration(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsWeaviateIDResponse]
+      def get_weaviate_configuration(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/integrations/weaviate/#{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::Integrations::Types::GetV1IntegrationsWeaviateIDResponse.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 Weaviate configuration.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Integrations::Types::PutV1IntegrationsWeaviateIDRequest]
+      # @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.integrations.update_weaviate_configuration(
+      #     id: "id",
+      #     name: "Updated Weaviate Config",
+      #     settings: {
+      #       default_class: "Articles",
+      #       vectorizer: "text2vec-cohere"
+      #     }
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PutV1IntegrationsWeaviateIDResponse]
+      def update_weaviate_configuration(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Integrations::Types::PutV1IntegrationsWeaviateIDRequest.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/integrations/weaviate/#{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::Integrations::Types::PutV1IntegrationsWeaviateIDResponse.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 Weaviate configuration by ID.
+      #
+      # @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.integrations.delete_weaviate_configuration(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::DeleteV1IntegrationsWeaviateIDResponse]
+      def delete_weaviate_configuration(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/integrations/weaviate/#{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::Integrations::Types::DeleteV1IntegrationsWeaviateIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List collections from a saved Weaviate configuration with vectorizer and dimension info.
+      #
+      # @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.integrations.list_weaviate_collections(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsWeaviateIDClassesResponse]
+      def list_weaviate_collections(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/integrations/weaviate/#{URI.encode_uri_component(params[:id].to_s)}/classes",
+          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::Integrations::Types::PostV1IntegrationsWeaviateIDClassesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Test the connection to a saved Weaviate instance.
+      #
+      # @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.integrations.test_weaviate_connection(id: "id")
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsWeaviateIDTestResponse]
+      def test_weaviate_connection(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/integrations/weaviate/#{URI.encode_uri_component(params[:id].to_s)}/test",
+          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::Integrations::Types::PostV1IntegrationsWeaviateIDTestResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get details for a specific integration including its tools and configuration status.
+      #
+      # @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] :integration_id
+      #
+      # @example
+      #   client.integrations.get_integration_details(integration_id: "integrationId")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsIntegrationIDResponse]
+      def get_integration_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/integrations/#{URI.encode_uri_component(params[:integration_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::Integrations::Types::GetV1IntegrationsIntegrationIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Save (insert or update) credentials for a specific integration, optionally scoped to a development or production
+      # environment.
+      #
+      # @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] :integration_id
+      #
+      # @example
+      #   client.integrations.save_integration_credentials(
+      #     integration_id: "integrationId",
+      #     body: {
+      #       apiKey: "lin_api_01jv0000000000000000000001",
+      #       environment: "production"
+      #     }
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::PostV1IntegrationsIntegrationIDCredentialsResponse]
+      def save_integration_credentials(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        path_param_names = %i[integration_id]
+        body_params = params.except(*path_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/integrations/#{URI.encode_uri_component(params[:integration_id].to_s)}/credentials",
+          body: 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::Integrations::Types::PostV1IntegrationsIntegrationIDCredentialsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete stored credentials for an integration. Without an environment query param, deletes the "all environments"
+      # credentials.
+      #
+      # @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] :integration_id
+      # @option params [String, nil] :environment
+      #
+      # @example
+      #   client.integrations.delete_integration_credentials(integration_id: "integrationId")
+      #
+      # @return [Runtype::Integrations::Types::DeleteV1IntegrationsIntegrationIDCredentialsResponse]
+      def delete_integration_credentials(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["environment"] = params[:environment] if params.key?(:environment)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/integrations/#{URI.encode_uri_component(params[:integration_id].to_s)}/credentials",
+          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::Integrations::Types::DeleteV1IntegrationsIntegrationIDCredentialsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List all tools defined by a specific integration along with their parameter schemas.
+      #
+      # @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] :integration_id
+      #
+      # @example
+      #   client.integrations.list_tools_for_an_integration(integration_id: "integrationId")
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsIntegrationIDToolsResponse]
+      def list_tools_for_an_integration(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/integrations/#{URI.encode_uri_component(params[:integration_id].to_s)}/tools",
+          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::Integrations::Types::GetV1IntegrationsIntegrationIDToolsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get details for a specific tool within an integration, including its parameter schema.
+      #
+      # @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] :integration_id
+      # @option params [String] :tool_name
+      #
+      # @example
+      #   client.integrations.get_an_integration_tool(
+      #     integration_id: "integrationId",
+      #     tool_name: "toolName"
+      #   )
+      #
+      # @return [Runtype::Integrations::Types::GetV1IntegrationsIntegrationIDToolsToolNameResponse]
+      def get_an_integration_tool(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/integrations/#{URI.encode_uri_component(params[:integration_id].to_s)}/tools/#{URI.encode_uri_component(params[:tool_name].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::Integrations::Types::GetV1IntegrationsIntegrationIDToolsToolNameResponse.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