@apollo-deploy/tesseract 1.9.0 → 2.1.0

package/templates/ruby/transport.hbs

@@ -2,89 +2,91 @@
 
 require "faraday"
 require "json"
+require "time"
+require "uri"
 require_relative "errors"
 
-module {{pascalCase meta.clientName}}
+module {{moduleName}}
   # HTTP transport layer built on Faraday.
   class Transport
+    RETRYABLE_METHODS = %i[get head options put delete].freeze
+    RETRYABLE_STATUSES = [408, 425, 429, 500, 502, 503, 504].freeze
+
     attr_reader :config
     attr_reader :connection
 
     def initialize(config)
       @config = config
-      @connection = Faraday.new(url: config.base_url) do |f|
-        f.request :json
-        f.response :raise_error
-        f.options.timeout = config.timeout
-        f.options.open_timeout = [config.timeout / 3, 2].max
-        config.default_headers.each do |key, value|
-          f.headers[key] = value
-        end
-        f.adapter Faraday.default_adapter
+      @connection = Faraday.new(url: config.base_url) do |faraday|
+        faraday.request :json
+        faraday.response :raise_error
+        faraday.options.timeout = config.timeout
+        faraday.options.open_timeout = [config.timeout / 3.0, 2.0].max
+        faraday.headers["Accept"] = "application/json"
+        faraday.headers["User-Agent"] = "{{gemName}}-ruby-sdk/{{meta.packageVersion}}"
+        config.default_headers.each { |key, value| faraday.headers[key] = value }
+        faraday.adapter Faraday.default_adapter
       end
     end
 
     def request(method:, path:, path_params: {}, query: nil, body: nil, headers: {}, content_type: nil)
       url = build_url(path, path_params)
-      attempts = 0
-      max_attempts = [(@config.retries[:attempts] || 3), 1].max
-      backoff = @config.retries[:backoff] || 0.4
-      jitter = @config.retries.fetch(:jitter, true)
-      max_backoff = @config.retries[:max_backoff] || 30.0
+      body = body.to_h if body.respond_to?(:to_h)
+      method = method.to_sym
+      max_retries = [(@config.retries[:attempts] || 3).to_i, 0].max
+      attempt = 0
+
       begin
-        attempts += 1
         response = @connection.run_request(
-          method.to_sym, url, body, build_headers(headers, content_type)
-        ) do |req|
-          req.params.merge!(query) if query && !query.empty?
+          method, url, body, build_headers(headers, content_type)
+        ) do |request|
+          request.params.merge!(query) if query && !query.empty?
         end
         parse_response(response)
-      rescue Faraday::Error => e
-        raise map_error(e, method: method, path: path) unless should_retry?(e, attempts, max_attempts)
-        sleep(retry_delay(backoff, attempts, jitter, max_backoff))
+      rescue Faraday::Error => error
+        mapped = map_error(error, method: method, path: path)
+        unless retryable_request?(method, headers) && mapped.retryable? && attempt < max_retries
+          raise mapped
+        end
+
+        sleep(retry_delay(error, attempt))
+        attempt += 1
         retry
       end
     end
 
-    def get(path:, path_params: {}, query: nil, headers: {})
-      request(method: :get, path: path, path_params: path_params, query: query, headers: headers)
-    end
-
-    def post(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
-      request(method: :post, path: path, body: body, path_params: path_params,
-              query: query, headers: headers, content_type: content_type)
-    end
-
-    def put(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
-      request(method: :put, path: path, body: body, path_params: path_params,
-              query: query, headers: headers, content_type: content_type)
-    end
-
-    def patch(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
-      request(method: :patch, path: path, body: body, path_params: path_params,
-              query: query, headers: headers, content_type: content_type)
-    end
-
-    def delete(path:, path_params: {}, query: nil, headers: {})
-      request(method: :delete, path: path, path_params: path_params, query: query, headers: headers)
+    def stream(method:, path:, path_params: {}, query: nil, body: nil, headers: {}, content_type: nil)
+      Enumerator.new do |output|
+        url = build_url(path, path_params)
+        @connection.run_request(
+          method.to_sym,
+          url,
+          body&.respond_to?(:to_h) ? body.to_h : body,
+          build_headers(headers, content_type)
+        ) do |request|
+          request.params.merge!(query) if query && !query.empty?
+          request.options.on_data = proc { |chunk, _bytes| output << chunk }
+        end
+      rescue Faraday::Error => error
+        raise map_error(error, method: method, path: path)
+      end
     end
 
     private
 
     def build_url(path, path_params)
       return path if path_params.empty?
-      path.gsub(/\{(\w+)\}/) do |_match|
-        key = ::Regexp.last_match(1)
+
+      path.gsub(/(?:\$\{(\w+)\}|:(\w+))/) do |match|
+        key = Regexp.last_match(1) || Regexp.last_match(2)
         value = path_params[key.to_sym] || path_params[key]
-        value.nil? ? _match : value.to_s
+        value.nil? ? match : URI.encode_www_form_component(value.to_s)
       end
     end
 
     def build_headers(extra_headers = {}, content_type = nil)
       headers = {}
-      if content_type
-        headers["Content-Type"] = content_type
-      end
+      headers["Content-Type"] = content_type if content_type
 {{#each securitySchemes}}
 {{#if (eq type "apiKey")}}
 {{#if (eq in "header")}}
@@ -92,13 +94,13 @@ module {{pascalCase meta.clientName}}
 {{/if}}
 {{/if}}
 {{#if (and (eq type "http") (eq scheme "bearer"))}}
-      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+      headers["Authorization"] = "Bearer " + @config.{{camelCase name}} if @config.{{camelCase name}}
 {{/if}}
 {{#if (eq type "oauth2")}}
-      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+      headers["Authorization"] = "Bearer " + @config.{{camelCase name}} if @config.{{camelCase name}}
 {{/if}}
 {{#if (eq type "openIdConnect")}}
-      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+      headers["Authorization"] = "Bearer " + @config.{{camelCase name}} if @config.{{camelCase name}}
 {{/if}}
 {{/each}}
       headers.merge!(extra_headers)
@@ -108,70 +110,94 @@ module {{pascalCase meta.clientName}}
     def parse_response(response)
       body = response.body
       return nil if body.nil? || (body.is_a?(String) && body.strip.empty?)
-      if body.is_a?(String)
-        begin
-          JSON.parse(body)
-        rescue JSON::ParserError
-          body
-        end
-      else
-        body
+      return body unless body.is_a?(String)
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      body
+    end
+
+    def retryable_request?(method, headers)
+      return true if @config.retry_unsafe_requests
+      return true if RETRYABLE_METHODS.include?(method)
+
+      @config.default_headers.merge(headers).any? do |key, value|
+        key.to_s.casecmp("X-Idempotency-Key").zero? && !value.to_s.empty?
+      end
+    end
+
+    def retry_delay(error, attempt)
+      retry_after = retry_after_seconds(error)
+      return retry_after unless retry_after.nil?
+
+      base = (@config.retries[:backoff] || 0.4).to_f
+      max_backoff = (@config.retries[:max_backoff] || 30.0).to_f
+      delay = [base * (2**attempt), max_backoff].min
+      @config.retries.fetch(:jitter, true) ? rand * delay : delay
+    end
+
+    def retry_after_seconds(error)
+      headers = error.response&.[](:headers) || {}
+      value = headers["retry-after"] || headers["Retry-After"]
+      return nil if value.nil? || value.to_s.empty?
+
+      [Float(value), (@config.retries[:max_backoff] || 30.0).to_f].min
+    rescue ArgumentError, TypeError
+      begin
+        [
+          [Time.httpdate(value.to_s) - Time.now, 0.0].max,
+          (@config.retries[:max_backoff] || 30.0).to_f
+        ].min
+      rescue ArgumentError
+        nil
       end
     end
 
     def map_error(error, method:, path:)
+      status = error.response&.[](:status).to_i
+      headers = error.response&.[](:headers) || {}
+      request_id = headers["x-request-id"] || headers["X-Request-ID"] || headers["request-id"]
+
       case error
       when Faraday::TimeoutError
-        SDKError.new("Request timed out", 0, "network_error", method: method, path: path)
+        SDKError.new("Request timed out", 0, "timeout", method: method, path: path)
       when Faraday::ConnectionFailed
-        SDKError.new("Connection failed: " + error.message, 0, "network_error", method: method, path: path)
-      when Faraday::ResourceNotFound
-        SDKError.new("Not found: " + error.message, 404, "not_found", method: method, path: path)
-      when Faraday::ClientError
-        status = error.response&.[](:status) || 400
-        begin
-          body = error.response&.[](:body)
-          envelope = body.is_a?(String) ? JSON.parse(body) : body
-          if envelope.is_a?(Hash)
-            SDKError.new(
-              envelope["message"] || envelope["error"] || "Request failed",
-              status,
-              envelope["error"] || envelope["code"] || "unknown_error",
-              request_id: envelope["request_id"],
-              method: method, path: path
-            )
-          else
-            SDKError.new("Request failed with status " + status.to_s, status, "unknown_error", method: method, path: path)
-          end
-        rescue
-          SDKError.new("Request failed with status " + status.to_s, status, "unknown_error", method: method, path: path)
-        end
-      when Faraday::ServerError
-        status = error.response&.[](:status) || 500
-        SDKError.new("Server error: " + error.message, status, "internal_server_error", method: method, path: path)
+        SDKError.new("Connection failed: #{error.message}", 0, "network_error", method: method, path: path)
       else
-        SDKError.new(error.message, 0, "unknown_error", method: method, path: path)
+        body = error.response&.[](:body)
+        envelope = parse_error_body(body)
+        message = envelope["message"] || envelope.dig("error", "message") || error.message
+        code = envelope["code"] || envelope.dig("error", "code")
+        code ||= envelope["error"] if envelope["error"].is_a?(String)
+        SDKError.new(
+          message,
+          status,
+          code || default_error_code(status),
+          request_id: envelope["request_id"] || request_id,
+          method: method,
+          path: path,
+          details: envelope["details"]
+        )
       end
     end
 
-    def should_retry?(_error, attempts, max_attempts)
-      return false if attempts >= max_attempts
-      case _error
-      when Faraday::TimeoutError, Faraday::ConnectionFailed, Faraday::ServerError
-        true
-      when Faraday::ClientError
-        status = _error.response&.[](:status)
-        status == 429
-      else
-        false
-      end
+    def parse_error_body(body)
+      return body if body.is_a?(Hash)
+      return {} unless body.is_a?(String) && !body.empty?
+
+      parsed = JSON.parse(body)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
     end
 
-    def retry_delay(base, attempt, jitter, max_backoff)
-      delay = base * (2**(attempt - 1))
-      delay = max_backoff if delay > max_backoff
-      delay *= (0.5 + rand * 0.5) if jitter
-      delay
+    def default_error_code(status)
+      return "network_error" if status.zero?
+      return "rate_limit_exceeded" if status == 429
+      return "request_timeout" if status == 408
+      return "internal_server_error" if status >= 500
+
+      "http_error"
     end
   end
 end

package/templates/ruby/types.hbs

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module {{pascalCase meta.clientName}}
+module {{moduleName}}
 {{#each schemas}}
 {{#if isEnum}}
   # {{#if description}}{{description}}{{else}}Enum for {{name}} values.{{/if}}
@@ -34,13 +34,8 @@ module {{pascalCase meta.clientName}}
   end
 
 {{else if isTypeAlias}}
-  {{#if unionMembers}}
-  # {{pascalCase name}} — type alias for: {{#each unionMembers}}{{this}}{{#unless @last}} | {{/unless}}{{/each}}
-  {{pascalCase name}} = Class.new
-  {{else}}
-  # {{pascalCase name}} — schema type alias
-  {{pascalCase name}} = Class.new
-  {{/if}}
+  # {{pascalCase name}} — type alias for {{aliasDocType}}
+  {{pascalCase name}} = {{aliasTarget}}
 
 {{else if isUnionType}}
   # {{pascalCase name}} — union type: {{#each unionMembers}}{{this}}{{#unless @last}} | {{/unless}}{{/each}}
@@ -56,14 +51,14 @@ module {{pascalCase meta.clientName}}
   # {{#if description}}{{description}}{{else}}Schema type: {{name}}{{/if}}
   class {{pascalCase name}}
     {{#each properties}}
-    # @return [{{type}}{{#if nullable}}, nil{{/if}}]{{#if description}} {{description}}{{/if}}
-    attr_accessor :{{snakeCase name}}
+    # @return [{{docType}}]{{#if description}} {{description}}{{/if}}
+    attr_accessor :{{propertyName}}
     {{/each}}
 
-    # @param {{#each properties}}{{snakeCase name}} [{{type}}{{#if nullable}}, nil{{/if}}]{{#unless @last}}, {{/unless}}{{/each}}
-    def initialize({{#each properties}}{{snakeCase name}}: {{^required}}nil{{/required}}{{#unless @last}}, {{/unless}}{{/each}})
+    # @param {{#each properties}}{{propertyName}} [{{docType}}]{{#unless @last}}, {{/unless}}{{/each}}
+    def initialize({{#each properties}}{{propertyName}}: {{^required}}nil{{/required}}{{#unless @last}}, {{/unless}}{{/each}})
       {{#each properties}}
-      @{{snakeCase name}} = {{snakeCase name}}
+      @{{propertyName}} = {{propertyName}}
       {{/each}}
     end
 
@@ -72,9 +67,9 @@ module {{pascalCase meta.clientName}}
       {
         {{#each properties}}
         {{#if (eq type "DateTime")}}
-        {{snakeCase name}}: @{{snakeCase name}}&.iso8601,
+        {{propertyName}}: @{{propertyName}}&.iso8601,
         {{else}}
-        {{snakeCase name}}: @{{snakeCase name}},
+        {{propertyName}}: @{{propertyName}},
         {{/if}}
         {{/each}}
       }.compact
@@ -88,7 +83,7 @@ module {{pascalCase meta.clientName}}
 
       new(
         {{#each properties}}
-        {{snakeCase name}}: attributes["{{snakeCase name}}"] || attributes["{{originalName}}"] || attributes[:{{snakeCase name}}],
+        {{propertyName}}: attributes.key?("{{name}}") ? attributes["{{name}}"] : attributes[:{{propertyName}}],
         {{/each}}
       )
     end

package/templates/ruby/version.hbs

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module {{pascalCase snakeModule}}
+module {{moduleName}}
   VERSION = "{{#if meta.packageVersion}}{{meta.packageVersion}}{{else}}{{meta.version}}{{/if}}"
 end

package/templates/rust/cargo.hbs

@@ -13,6 +13,8 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 tokio = { version = "1", features = ["full"] }
 thiserror = "2"
 url = "2"
+urlencoding = "2"
+httpdate = "1"
 {{#if hasSSE}}
 futures-core = "0.3"
 tokio-stream = "0.1"

package/templates/rust/client.hbs

@@ -2,6 +2,7 @@ use crate::transport::{Transport, TransportConfig};
 {{#each groups}}
 use crate::api::{{snakeCase fileName}}::{{interfaceName}};
 {{/each}}
+use std::collections::HashMap;
 use std::time::Duration;
 
 /// Configuration for the {{title}} API client.
@@ -31,6 +32,10 @@ pub struct ClientConfig {
     pub timeout: Duration,
     /// Maximum number of retry attempts.
     pub max_retries: u32,
+    /// Allow automatic retries for unsafe methods without an idempotency key.
+    pub retry_unsafe_requests: bool,
+    /// Headers sent with every request.
+    pub default_headers: HashMap<String, String>,
 }
 
 impl Default for ClientConfig {
@@ -42,6 +47,8 @@ impl Default for ClientConfig {
 {{/each}}
             timeout: Duration::from_secs(15),
             max_retries: 3,
+            retry_unsafe_requests: false,
+            default_headers: HashMap::new(),
         }
     }
 }
@@ -77,13 +84,15 @@ impl Client {
     /// let client = Client::new(config);
     /// ```
     pub fn new(config: ClientConfig) -> Self {
-        let mut transport_config = TransportConfig {
+        let transport_config = TransportConfig {
             base_url: config.base_url,
 {{#each securitySchemes}}
             {{snakeCase configKey}}: config.{{snakeCase configKey}},
 {{/each}}
             timeout: config.timeout,
             max_retries: config.max_retries,
+            retry_unsafe_requests: config.retry_unsafe_requests,
+            default_headers: config.default_headers,
         };
 
         let transport = Transport::new(transport_config);

package/templates/rust/domain.hbs

@@ -1,6 +1,7 @@
-use crate::transport::Transport;
 use crate::error::SdkError;
+use crate::transport::Transport;
 use reqwest::Method;
+use serde::Serialize;
 {{#if imports.length}}
 use crate::types::{ {{join imports ", "}} };
 {{/if}}
@@ -16,79 +17,95 @@ impl {{interfaceName}} {
     }
 
 {{#each operations}}
-    {{#if summary}}
+{{#if summary}}
     /// {{summary}}{{#if description}}
     ///
     /// {{description}}{{/if}}
-    {{/if}}
-    {{#if deprecated}}
+{{/if}}
+{{#if deprecated}}
     #[deprecated{{#if deprecationMessage}}(note = "{{deprecationMessage}}"){{/if}}]
-    {{/if}}
-    pub async fn {{snakeCase name}}(
-        &self,
+{{/if}}
+    pub async fn {{methodName}}(
+        &self{{#if hasParameters}},
+        {{{signature}}}{{/if}},
+    ) -> Result<{{targetResponseType}}, SdkError> {
+        let mut path = "{{path}}".to_string();
 {{#each pathParams}}
-        {{snakeCase name}}: {{{rustParamType type}}},
+        path = path.replace("{{placeholder}}", &encode_path(&{{parameterName}}.to_string()));
 {{/each}}
-{{#if requestBody}}
-        body: &{{{requestBody.rustType}}},
-{{/if}}
-{{#if queryType}}
-        query: Option<&{{{rustQueryType queryType}}}>,
-{{/if}}
-    ) -> Result<{{#if isEventStream}}Vec<{{#if eventSchema}}{{{rustType eventSchema}}}{{else}}serde_json::Value{{/if}}>{{else}}{{{rustResponseType}}}{{/if}}, SdkError> {
-        let path = format!("{{path}}"{{#each pathParams}}, {{snakeCase name}} = {{#if (isRustCopyType type)}}{{snakeCase name}}{{else}}{{snakeCase name}}{{/if}}{{/each}});
-{{#if (hasQueryParams this)}}
+
         let mut query_params: Vec<(String, String)> = Vec::new();
-        if let Some(q) = query {
-{{#each _queryParams}}
-            if let Some(ref v) = q.{{snakeCase name}} {
-                query_params.push(("{{originalName}}".to_string(), v.to_string()));
-            }
-{{/each}}
-        }
-        let query_slice: Option<&[(String, String)]> = if query_params.is_empty() { None } else { Some(&query_params) };
-{{else if queryType}}
-        // Query params from typed query object
-        let query_slice: Option<&[(String, String)]> = None; // TODO: serialize query type
+{{#each queryParams}}
+{{#if required}}
+        query_params.push(("{{originalName}}".to_string(), encode_value(&{{parameterName}})?));
 {{else}}
-        let query_slice: Option<&[(String, String)]> = None;
+        if let Some(value) = {{parameterName}}.as_ref() {
+            query_params.push(("{{originalName}}".to_string(), encode_value(value)?));
+        }
 {{/if}}
+{{/each}}
+        let query = (!query_params.is_empty()).then_some(query_params.as_slice());
 
-{{#if (or (hasRequestBody this) (needsRequestHeaders this))}}
         let mut headers: Vec<(String, String)> = Vec::new();
-{{#if (hasRequestBody this)}}
-{{#if (and (neq requestBody.contentType "application/json") (neq requestBody.contentType "multipart/form-data"))}}
-        headers.push(("Content-Type".to_string(), "{{requestBody.contentType}}".to_string()));
-{{/if}}
-{{/if}}
-{{#if (and headerParams.length headerType)}}
-        // Header params injected from header options
-{{/if}}
 {{#each headerParams}}
-        if let Some(ref h) = header_options.{{snakeCase name}} {
-            headers.push(("{{originalName}}".to_string(), h.to_string()));
+{{#if required}}
+        headers.push(("{{originalName}}".to_string(), encode_value(&{{parameterName}})?));
+{{else}}
+        if let Some(value) = {{parameterName}}.as_ref() {
+            headers.push(("{{originalName}}".to_string(), encode_value(value)?));
         }
-{{/each}}
-{{#if cookieParams}}
-        // Cookie params
 {{/if}}
-        let headers_slice: Option<&[(String, String)]> = if headers.is_empty() { None } else { Some(&headers) };
+{{/each}}
+{{#each cookieParams}}
+{{#if required}}
+        headers.push(("Cookie".to_string(), format!("{{originalName}}={}", encode_value(&{{parameterName}})?)));
 {{else}}
-        let headers_slice: Option<&[(String, String)]> = None;
+        if let Some(value) = {{parameterName}}.as_ref() {
+            headers.push(("Cookie".to_string(), format!("{{originalName}}={}", encode_value(value)?)));
+        }
 {{/if}}
+{{/each}}
+        let headers = (!headers.is_empty()).then_some(headers.as_slice());
 
-        self.transport.execute::<{{#if isEventStream}}Vec<{{#if eventSchema}}{{{rustType eventSchema}}}{{else}}serde_json::Value{{/if}}>{{else}}{{{rustResponseType}}}{{/if}}>(
+{{#if isEventStream}}
+        self.transport.execute_raw(
+            Method::{{httpMethod}},
+            &path,
+            query,
+            {{{bodyArgument}}},
+            headers,
+        ).await
+{{else if isVoid}}
+        self.transport.execute_raw(
             Method::{{httpMethod}},
             &path,
-            query_slice,
-{{#if requestBody}}
-            Some(body),
+            query,
+            {{{bodyArgument}}},
+            headers,
+        ).await.map(|_| ())
 {{else}}
-            None::<&serde_json::Value>,
-{{/if}}
-            headers_slice,
+        self.transport.execute::<{{targetResponseType}}>(
+            Method::{{httpMethod}},
+            &path,
+            query,
+            {{{bodyArgument}}},
+            headers,
         ).await
+{{/if}}
     }
 
 {{/each}}
 }
+
+fn encode_path(value: &str) -> String {
+    urlencoding::encode(value).into_owned()
+}
+
+fn encode_value<T: Serialize>(value: &T) -> Result<String, SdkError> {
+    match serde_json::to_value(value)
+        .map_err(|error| SdkError::ValidationError(error.to_string()))?
+    {
+        serde_json::Value::String(value) => Ok(value),
+        value => Ok(value.to_string()),
+    }
+}

package/templates/rust/error.hbs

@@ -14,6 +14,8 @@ pub enum SdkError {
         code: Option<String>,
         /// Human-readable error message.
         message: String,
+        /// Server-provided request identifier.
+        request_id: Option<String>,
         /// Raw response body for debugging.
         body: String,
     },
@@ -56,7 +58,7 @@ impl SdkError {
             self,
             Self::NetworkError(_)
                 | Self::ApiError {
-                    status: 429 | 502 | 503 | 504,
+                    status: 408 | 425 | 429 | 500 | 502 | 503 | 504,
                     ..
                 }
         )

package/templates/rust/lib.hbs

@@ -59,12 +59,11 @@
 //! - **DeserializationError** — response body could not be parsed
 //! - **ValidationError** — invalid request parameters
 //!
-//! ```rust
-//! match client.some_domain.some_method().await {
+//! ```rust,ignore
+//! let result = client.resource.some_method().await;
+//! match result {
 //!     Ok(response) => println!("Success: {:?}", response),
-//!     Err(SdkError::ApiError { status, .. }) => eprintln!("API error ({}): {}", status, error),
-//!     Err(SdkError::NetworkError(e)) => eprintln!("Network error: {}", e),
-//!     Err(e) => eprintln!("Other error: {}", e),
+//!     Err(error) => eprintln!("SDK error: {}", error),
 //! }
 //! ```