@celigo/api-specs 0.2.208 → 0.2.210

package/dist/api.yml

@@ -8116,26 +8116,36 @@ components:
     PGP:
       type: object
       description: |-
-        PGP encryption settings for file-based connections (ftp, s3, and similar). When set, files are
-        PGP-encrypted before upload and/or decrypted after download. Supply at least one of `publicKey`
-        (to encrypt outbound files) or `privateKey` (to decrypt inbound files); set `passphrase` whenever
-        `privateKey` is provided.
+        PGP keys and options for the file transports — `ftp`, `s3`, the on-premise file system and the
+        cloud file-provider connections such as Box, Dropbox, Google Drive, Azure Blob Storage and
+        Celigo file storage. `publicKey` encrypts the files the connection's imports write,
+        record-generated files and transferred (blob) files alike; `privateKey` with its `passphrase`
+        decrypts the files its exports read and signs encrypted output. Supply at least one of the two.
       properties:
         publicKey:
           type: string
           description: |-
-            ASCII-armored PGP public key used to encrypt outbound files before upload.
-            Set this when the connection sends encrypted files; omit it for decrypt-only connections.
+            ASCII-armored PGP public key of the recipient, used to encrypt every file an import on this
+            connection writes with `file.encrypt: pgp`; omit it for decrypt-only connections. Returned
+            in clear on reads.
           x-celigo-ai-guidance:
             - |-
-              Public key for JWT verification. Optional — used when the API requires
-              the public key to be registered for signature verification.
+              An import on this connection cannot save `file.encrypt: pgp` without it — the save fails
+              with 422 `missing_required_field` on `file.encrypt` ("pgp publicKey is required when
+              encrypt is selected to perform file encryption."); the import form disables its Encrypt
+              files control until the connection holds a key.
         privateKey:
           type: string
           writeOnly: true
           description: |-
             ASCII-armored PGP private key used to decrypt inbound files after download (encrypted at rest;
-            returned masked as `"******"`). Set this when the connection receives encrypted files.
+            returned masked as `"******"`). Set this when the connection receives encrypted files, or
+            when its imports sign what they encrypt (`file.pgp.hashAlgorithm`).
+          x-celigo-ai-guidance:
+            - |-
+              Signing needs it: an import that sets `file.pgp.hashAlgorithm` on a connection without a
+              private key fails to save with 422 `missing_required_field` on `file.pgp.hashAlgorithm`
+              ("pgp privateKey is required when hashAlgorithm is selected to perform file signature.").
         passphrase:
           type: string
           writeOnly: true
@@ -9917,10 +9927,11 @@ components:
         retryHeader:
           type: string
           description: |
-            HTTP response header name that contains the retry delay (in seconds) when rate-limited.
-
-            Defaults to "Retry-After" which is the HTTP standard. Only change this if the API
-            uses a non-standard header name for retry-after values.
+            Response header the retry reads for its wait once a response has been recognized
+            as rate-limited — a delay in seconds or an HTTP date. It only sets the wait: a
+            response carrying the header is not treated as throttled unless a status, header
+            or body rule under `rateLimit` matches it. Change it only when the API names its
+            retry-after header differently.
           default: Retry-After
         formType:
           type: string
@@ -10650,42 +10661,60 @@ components:
         rateLimit:
           type: object
           description: |
-            Rate limiting configuration. Defines how the system detects and handles
-            API rate limit responses.
-
-            When rate limiting is detected, the system pauses requests and waits for
-            the retry-after period before resuming. The retryHeader field on the parent
-            HTTP object controls which response header contains the wait time.
+            Rules for recognizing a throttled response. When any rule is set, every response
+            through the connection is checked against the status code, the header rules and
+            the body rule, and the first match marks the request rate-limited; the retry then
+            waits for the header named by the parent `retryHeader` (`Retry-After` by default).
+            A 429 is recognized with no rules at all; a 2xx response is recognized only through
+            a matching `failHeaders` rule or a matching `failPath` + `failValues` pair, which is
+            how APIs that throttle inside a 200 body (GraphQL, Shopify among them) are handled.
           properties:
             failStatusCode:
               type: number
               description: |
-                HTTP status code that indicates the API is rate-limiting requests.
-                Defaults to 429 (Too Many Requests) which is the HTTP standard.
-                Change only if the API uses a non-standard status code for rate limits.
+                Status code that marks a response rate-limited in place of the standard 429.
+                Set it only when the API throttles with another non-success code; a 2xx value
+                does not make successful responses count as throttled on its own.
               default: 429
             failPath:
               type: string
               description: |
-                JSON path or XPath to check in response bodies for rate limit indicators.
-                Used when APIs return 200 OK but embed rate limit errors in the response body.
+                JSON path or XPath to the body field that carries the API's throttle indicator,
+                for APIs that answer 200 with the error inside the body. Point at the field
+                itself (`errors.0.extensions.code`), not at the array or object around it, and
+                pair it with `failValues`, which supplies the values that mean "throttled".
               examples:
-                - errors[0].code
+                - errors.0.extensions.code
+              x-celigo-ai-guidance:
+                - |-
+                  Saves on its own (the probe shows a `failPath` with no `failValues` is accepted),
+                  and the documented contract recognizes a 200 as throttled only when `failValues`
+                  is set as well. For Shopify GraphQL the platform's own example is
+                  `errors.0.extensions.code` with `failValues: ["THROTTLED"]`.
             failValues:
               type: array
               items:
                 type: string
               description: |
-                Values at failPath that indicate rate limiting. Requires failPath to be set.
+                Values at `failPath` that mean the request was throttled; a match on any of them
+                marks the response rate-limited.
               examples:
-                - - rate_limit_exceeded
-                  - too_many_requests
+                - - THROTTLED
+                  - MAX_COST_EXCEEDED
+              x-celigo-ai-guidance:
+                - |-
+                  Needs `failPath`: `failValues` without it fails the save with 422
+                  `dependent_field` ("The field: failValues should not be specified without the
+                  field: failPath for the Connection.").
             failHeaders:
               type: array
               description: |
-                Response-header rules for detecting rate limiting, each a header `name` with an
-                optional `value`. A rule with an empty `name` fails the save with 422
-                `invalid_header_format`.
+                Response-header rules for recognizing a throttled response, each a header `name`
+                with an optional `value`. A rule with a `value` matches when the response header
+                carries that value — the stored text is compared with the header as received; a
+                rule with no `value` matches whenever the header is present at all, so a header
+                the API sends on every response (a remaining-quota counter) would mark every
+                response throttled — give such a header a value.
               items:
                 type: object
                 required:
@@ -10696,18 +10725,32 @@ components:
                     description: Response header the rule checks.
                   value:
                     type: string
-                    description: Header value the rule checks; omit to check the header alone.
+                    description: Header value the rule compares with the response header; omit to match on the header's presence alone. Stored as sent.
               examples:
                 - - name: X-RateLimit-Remaining
                     value: '0'
+              x-celigo-ai-guidance:
+                - |-
+                  A rule without a `name` fails the save with 422 `invalid_header_format`; a rule
+                  with a name and no value saves and matches on presence. The value is stored as
+                  sent and not validated at save time.
             limit:
               type: number
               minimum: 1
+              x-celigo-ui-override: Semantics mirror the connection form, which labels the field "Wait time between HTTP requests" and requires the value in milliseconds (fieldDefinitions/resources/connection.js 'http.rateLimit.limit').
               description: |
-                Maximum number of requests per rate-limit window. When set, the connection's
-                effective concurrency level must be 1 to ensure proper rate limit enforcement.
+                Minimum spacing between consecutive requests through the connection, in
+                milliseconds, for APIs that cap request rate rather than concurrency. It only
+                applies when the connection runs one request at a time.
               examples:
                 - 1000
+              x-celigo-ai-guidance:
+                - |-
+                  Saves only when `concurrencyLevel` is 1 — and, with `autoRecoverRateLimitErrors`
+                  on, `targetConcurrencyLevel` is 1 as well; otherwise the save fails with 422
+                  `invalid_concurrency_level` ("The field "connection.http.concurrencyLevel"
+                  should be set to 1 when the field "connection.http.rateLimit.limit" is
+                  populated."). A numeric string is stored as a number.
         headers:
           type: array
           description: |

package/dist/connection.yml

@@ -1027,7 +1027,7 @@ paths:
         | `/_borrowConcurrencyFromConnectionId` | Share another connection's concurrency budget. `remove` clears it |
         | `/autoRecoverRateLimitErrors` | Rate-limit auto-recovery toggle. Turning it on copies the current level into the target; turning it off unsets the target and leaves the level at its current value |
         | `/http/rateLimit/failStatusCode`, `/http/rateLimit/failPath`, `/http/rateLimit/failHeaders` | Rate-limit detection rules. Send `failHeaders` as the whole array; on one element only `replace` of an existing entry works (e.g. `/http/rateLimit/failHeaders/0`), and `add` or `remove` on an element fails with 422 |
-        | `/http/rateLimit/limit` | Requests per rate-limit window. Accepted only at a concurrency of 1: set `/http/targetConcurrencyLevel` (while `autoRecoverRateLimitErrors` is true) or `/http/concurrencyLevel` (while it is false) to 1 in the same patch; at any other level it fails with 422 `invalid_concurrency_level` |
+        | `/http/rateLimit/limit` | Wait between consecutive requests, in milliseconds. Accepted only at a concurrency of 1: set `/http/targetConcurrencyLevel` (while `autoRecoverRateLimitErrors` is true) or `/http/concurrencyLevel` (while it is false) to 1 in the same patch; at any other level it fails with 422 `invalid_concurrency_level` |
         | `/endUserProvidedFields` | Dot-paths MCP end users must supply on their own child copy of this connection. `replace` with `[]` or `remove` clears the list, and `add` on `/endUserProvidedFields/-` appends one path; a path the account owns (`type`, `_agentId`, `wrapper._stackId`, any `<adaptor>._iClientId`) is rejected |
 
         `replace` and `add` both set the value (a currently unset field is fine);
@@ -3949,26 +3949,36 @@ components:
     PGP:
       type: object
       description: |-
-        PGP encryption settings for file-based connections (ftp, s3, and similar). When set, files are
-        PGP-encrypted before upload and/or decrypted after download. Supply at least one of `publicKey`
-        (to encrypt outbound files) or `privateKey` (to decrypt inbound files); set `passphrase` whenever
-        `privateKey` is provided.
+        PGP keys and options for the file transports — `ftp`, `s3`, the on-premise file system and the
+        cloud file-provider connections such as Box, Dropbox, Google Drive, Azure Blob Storage and
+        Celigo file storage. `publicKey` encrypts the files the connection's imports write,
+        record-generated files and transferred (blob) files alike; `privateKey` with its `passphrase`
+        decrypts the files its exports read and signs encrypted output. Supply at least one of the two.
       properties:
         publicKey:
           type: string
           description: |-
-            ASCII-armored PGP public key used to encrypt outbound files before upload.
-            Set this when the connection sends encrypted files; omit it for decrypt-only connections.
+            ASCII-armored PGP public key of the recipient, used to encrypt every file an import on this
+            connection writes with `file.encrypt: pgp`; omit it for decrypt-only connections. Returned
+            in clear on reads.
           x-celigo-ai-guidance:
             - |-
-              Public key for JWT verification. Optional — used when the API requires
-              the public key to be registered for signature verification.
+              An import on this connection cannot save `file.encrypt: pgp` without it — the save fails
+              with 422 `missing_required_field` on `file.encrypt` ("pgp publicKey is required when
+              encrypt is selected to perform file encryption."); the import form disables its Encrypt
+              files control until the connection holds a key.
         privateKey:
           type: string
           writeOnly: true
           description: |-
             ASCII-armored PGP private key used to decrypt inbound files after download (encrypted at rest;
-            returned masked as `"******"`). Set this when the connection receives encrypted files.
+            returned masked as `"******"`). Set this when the connection receives encrypted files, or
+            when its imports sign what they encrypt (`file.pgp.hashAlgorithm`).
+          x-celigo-ai-guidance:
+            - |-
+              Signing needs it: an import that sets `file.pgp.hashAlgorithm` on a connection without a
+              private key fails to save with 422 `missing_required_field` on `file.pgp.hashAlgorithm`
+              ("pgp privateKey is required when hashAlgorithm is selected to perform file signature.").
         passphrase:
           type: string
           writeOnly: true
@@ -5750,10 +5760,11 @@ components:
         retryHeader:
           type: string
           description: |
-            HTTP response header name that contains the retry delay (in seconds) when rate-limited.
-
-            Defaults to "Retry-After" which is the HTTP standard. Only change this if the API
-            uses a non-standard header name for retry-after values.
+            Response header the retry reads for its wait once a response has been recognized
+            as rate-limited — a delay in seconds or an HTTP date. It only sets the wait: a
+            response carrying the header is not treated as throttled unless a status, header
+            or body rule under `rateLimit` matches it. Change it only when the API names its
+            retry-after header differently.
           default: Retry-After
         formType:
           type: string
@@ -6483,42 +6494,60 @@ components:
         rateLimit:
           type: object
           description: |
-            Rate limiting configuration. Defines how the system detects and handles
-            API rate limit responses.
-
-            When rate limiting is detected, the system pauses requests and waits for
-            the retry-after period before resuming. The retryHeader field on the parent
-            HTTP object controls which response header contains the wait time.
+            Rules for recognizing a throttled response. When any rule is set, every response
+            through the connection is checked against the status code, the header rules and
+            the body rule, and the first match marks the request rate-limited; the retry then
+            waits for the header named by the parent `retryHeader` (`Retry-After` by default).
+            A 429 is recognized with no rules at all; a 2xx response is recognized only through
+            a matching `failHeaders` rule or a matching `failPath` + `failValues` pair, which is
+            how APIs that throttle inside a 200 body (GraphQL, Shopify among them) are handled.
           properties:
             failStatusCode:
               type: number
               description: |
-                HTTP status code that indicates the API is rate-limiting requests.
-                Defaults to 429 (Too Many Requests) which is the HTTP standard.
-                Change only if the API uses a non-standard status code for rate limits.
+                Status code that marks a response rate-limited in place of the standard 429.
+                Set it only when the API throttles with another non-success code; a 2xx value
+                does not make successful responses count as throttled on its own.
               default: 429
             failPath:
               type: string
               description: |
-                JSON path or XPath to check in response bodies for rate limit indicators.
-                Used when APIs return 200 OK but embed rate limit errors in the response body.
+                JSON path or XPath to the body field that carries the API's throttle indicator,
+                for APIs that answer 200 with the error inside the body. Point at the field
+                itself (`errors.0.extensions.code`), not at the array or object around it, and
+                pair it with `failValues`, which supplies the values that mean "throttled".
               examples:
-                - errors[0].code
+                - errors.0.extensions.code
+              x-celigo-ai-guidance:
+                - |-
+                  Saves on its own (the probe shows a `failPath` with no `failValues` is accepted),
+                  and the documented contract recognizes a 200 as throttled only when `failValues`
+                  is set as well. For Shopify GraphQL the platform's own example is
+                  `errors.0.extensions.code` with `failValues: ["THROTTLED"]`.
             failValues:
               type: array
               items:
                 type: string
               description: |
-                Values at failPath that indicate rate limiting. Requires failPath to be set.
+                Values at `failPath` that mean the request was throttled; a match on any of them
+                marks the response rate-limited.
               examples:
-                - - rate_limit_exceeded
-                  - too_many_requests
+                - - THROTTLED
+                  - MAX_COST_EXCEEDED
+              x-celigo-ai-guidance:
+                - |-
+                  Needs `failPath`: `failValues` without it fails the save with 422
+                  `dependent_field` ("The field: failValues should not be specified without the
+                  field: failPath for the Connection.").
             failHeaders:
               type: array
               description: |
-                Response-header rules for detecting rate limiting, each a header `name` with an
-                optional `value`. A rule with an empty `name` fails the save with 422
-                `invalid_header_format`.
+                Response-header rules for recognizing a throttled response, each a header `name`
+                with an optional `value`. A rule with a `value` matches when the response header
+                carries that value — the stored text is compared with the header as received; a
+                rule with no `value` matches whenever the header is present at all, so a header
+                the API sends on every response (a remaining-quota counter) would mark every
+                response throttled — give such a header a value.
               items:
                 type: object
                 required:
@@ -6529,18 +6558,32 @@ components:
                     description: Response header the rule checks.
                   value:
                     type: string
-                    description: Header value the rule checks; omit to check the header alone.
+                    description: Header value the rule compares with the response header; omit to match on the header's presence alone. Stored as sent.
               examples:
                 - - name: X-RateLimit-Remaining
                     value: '0'
+              x-celigo-ai-guidance:
+                - |-
+                  A rule without a `name` fails the save with 422 `invalid_header_format`; a rule
+                  with a name and no value saves and matches on presence. The value is stored as
+                  sent and not validated at save time.
             limit:
               type: number
               minimum: 1
+              x-celigo-ui-override: Semantics mirror the connection form, which labels the field "Wait time between HTTP requests" and requires the value in milliseconds (fieldDefinitions/resources/connection.js 'http.rateLimit.limit').
               description: |
-                Maximum number of requests per rate-limit window. When set, the connection's
-                effective concurrency level must be 1 to ensure proper rate limit enforcement.
+                Minimum spacing between consecutive requests through the connection, in
+                milliseconds, for APIs that cap request rate rather than concurrency. It only
+                applies when the connection runs one request at a time.
               examples:
                 - 1000
+              x-celigo-ai-guidance:
+                - |-
+                  Saves only when `concurrencyLevel` is 1 — and, with `autoRecoverRateLimitErrors`
+                  on, `targetConcurrencyLevel` is 1 as well; otherwise the save fails with 422
+                  `invalid_concurrency_level` ("The field "connection.http.concurrencyLevel"
+                  should be set to 1 when the field "connection.http.rateLimit.limit" is
+                  populated."). A numeric string is stored as a number.
         headers:
           type: array
           description: |

package/dist/enduser.yml

@@ -1974,26 +1974,36 @@ components:
     PGP:
       type: object
       description: |-
-        PGP encryption settings for file-based connections (ftp, s3, and similar). When set, files are
-        PGP-encrypted before upload and/or decrypted after download. Supply at least one of `publicKey`
-        (to encrypt outbound files) or `privateKey` (to decrypt inbound files); set `passphrase` whenever
-        `privateKey` is provided.
+        PGP keys and options for the file transports — `ftp`, `s3`, the on-premise file system and the
+        cloud file-provider connections such as Box, Dropbox, Google Drive, Azure Blob Storage and
+        Celigo file storage. `publicKey` encrypts the files the connection's imports write,
+        record-generated files and transferred (blob) files alike; `privateKey` with its `passphrase`
+        decrypts the files its exports read and signs encrypted output. Supply at least one of the two.
       properties:
         publicKey:
           type: string
           description: |-
-            ASCII-armored PGP public key used to encrypt outbound files before upload.
-            Set this when the connection sends encrypted files; omit it for decrypt-only connections.
+            ASCII-armored PGP public key of the recipient, used to encrypt every file an import on this
+            connection writes with `file.encrypt: pgp`; omit it for decrypt-only connections. Returned
+            in clear on reads.
           x-celigo-ai-guidance:
             - |-
-              Public key for JWT verification. Optional — used when the API requires
-              the public key to be registered for signature verification.
+              An import on this connection cannot save `file.encrypt: pgp` without it — the save fails
+              with 422 `missing_required_field` on `file.encrypt` ("pgp publicKey is required when
+              encrypt is selected to perform file encryption."); the import form disables its Encrypt
+              files control until the connection holds a key.
         privateKey:
           type: string
           writeOnly: true
           description: |-
             ASCII-armored PGP private key used to decrypt inbound files after download (encrypted at rest;
-            returned masked as `"******"`). Set this when the connection receives encrypted files.
+            returned masked as `"******"`). Set this when the connection receives encrypted files, or
+            when its imports sign what they encrypt (`file.pgp.hashAlgorithm`).
+          x-celigo-ai-guidance:
+            - |-
+              Signing needs it: an import that sets `file.pgp.hashAlgorithm` on a connection without a
+              private key fails to save with 422 `missing_required_field` on `file.pgp.hashAlgorithm`
+              ("pgp privateKey is required when hashAlgorithm is selected to perform file signature.").
         passphrase:
           type: string
           writeOnly: true
@@ -3775,10 +3785,11 @@ components:
         retryHeader:
           type: string
           description: |
-            HTTP response header name that contains the retry delay (in seconds) when rate-limited.
-
-            Defaults to "Retry-After" which is the HTTP standard. Only change this if the API
-            uses a non-standard header name for retry-after values.
+            Response header the retry reads for its wait once a response has been recognized
+            as rate-limited — a delay in seconds or an HTTP date. It only sets the wait: a
+            response carrying the header is not treated as throttled unless a status, header
+            or body rule under `rateLimit` matches it. Change it only when the API names its
+            retry-after header differently.
           default: Retry-After
         formType:
           type: string
@@ -4508,42 +4519,60 @@ components:
         rateLimit:
           type: object
           description: |
-            Rate limiting configuration. Defines how the system detects and handles
-            API rate limit responses.
-
-            When rate limiting is detected, the system pauses requests and waits for
-            the retry-after period before resuming. The retryHeader field on the parent
-            HTTP object controls which response header contains the wait time.
+            Rules for recognizing a throttled response. When any rule is set, every response
+            through the connection is checked against the status code, the header rules and
+            the body rule, and the first match marks the request rate-limited; the retry then
+            waits for the header named by the parent `retryHeader` (`Retry-After` by default).
+            A 429 is recognized with no rules at all; a 2xx response is recognized only through
+            a matching `failHeaders` rule or a matching `failPath` + `failValues` pair, which is
+            how APIs that throttle inside a 200 body (GraphQL, Shopify among them) are handled.
           properties:
             failStatusCode:
               type: number
               description: |
-                HTTP status code that indicates the API is rate-limiting requests.
-                Defaults to 429 (Too Many Requests) which is the HTTP standard.
-                Change only if the API uses a non-standard status code for rate limits.
+                Status code that marks a response rate-limited in place of the standard 429.
+                Set it only when the API throttles with another non-success code; a 2xx value
+                does not make successful responses count as throttled on its own.
               default: 429
             failPath:
               type: string
               description: |
-                JSON path or XPath to check in response bodies for rate limit indicators.
-                Used when APIs return 200 OK but embed rate limit errors in the response body.
+                JSON path or XPath to the body field that carries the API's throttle indicator,
+                for APIs that answer 200 with the error inside the body. Point at the field
+                itself (`errors.0.extensions.code`), not at the array or object around it, and
+                pair it with `failValues`, which supplies the values that mean "throttled".
               examples:
-                - errors[0].code
+                - errors.0.extensions.code
+              x-celigo-ai-guidance:
+                - |-
+                  Saves on its own (the probe shows a `failPath` with no `failValues` is accepted),
+                  and the documented contract recognizes a 200 as throttled only when `failValues`
+                  is set as well. For Shopify GraphQL the platform's own example is
+                  `errors.0.extensions.code` with `failValues: ["THROTTLED"]`.
             failValues:
               type: array
               items:
                 type: string
               description: |
-                Values at failPath that indicate rate limiting. Requires failPath to be set.
+                Values at `failPath` that mean the request was throttled; a match on any of them
+                marks the response rate-limited.
               examples:
-                - - rate_limit_exceeded
-                  - too_many_requests
+                - - THROTTLED
+                  - MAX_COST_EXCEEDED
+              x-celigo-ai-guidance:
+                - |-
+                  Needs `failPath`: `failValues` without it fails the save with 422
+                  `dependent_field` ("The field: failValues should not be specified without the
+                  field: failPath for the Connection.").
             failHeaders:
               type: array
               description: |
-                Response-header rules for detecting rate limiting, each a header `name` with an
-                optional `value`. A rule with an empty `name` fails the save with 422
-                `invalid_header_format`.
+                Response-header rules for recognizing a throttled response, each a header `name`
+                with an optional `value`. A rule with a `value` matches when the response header
+                carries that value — the stored text is compared with the header as received; a
+                rule with no `value` matches whenever the header is present at all, so a header
+                the API sends on every response (a remaining-quota counter) would mark every
+                response throttled — give such a header a value.
               items:
                 type: object
                 required:
@@ -4554,18 +4583,32 @@ components:
                     description: Response header the rule checks.
                   value:
                     type: string
-                    description: Header value the rule checks; omit to check the header alone.
+                    description: Header value the rule compares with the response header; omit to match on the header's presence alone. Stored as sent.
               examples:
                 - - name: X-RateLimit-Remaining
                     value: '0'
+              x-celigo-ai-guidance:
+                - |-
+                  A rule without a `name` fails the save with 422 `invalid_header_format`; a rule
+                  with a name and no value saves and matches on presence. The value is stored as
+                  sent and not validated at save time.
             limit:
               type: number
               minimum: 1
+              x-celigo-ui-override: Semantics mirror the connection form, which labels the field "Wait time between HTTP requests" and requires the value in milliseconds (fieldDefinitions/resources/connection.js 'http.rateLimit.limit').
               description: |
-                Maximum number of requests per rate-limit window. When set, the connection's
-                effective concurrency level must be 1 to ensure proper rate limit enforcement.
+                Minimum spacing between consecutive requests through the connection, in
+                milliseconds, for APIs that cap request rate rather than concurrency. It only
+                applies when the connection runs one request at a time.
               examples:
                 - 1000
+              x-celigo-ai-guidance:
+                - |-
+                  Saves only when `concurrencyLevel` is 1 — and, with `autoRecoverRateLimitErrors`
+                  on, `targetConcurrencyLevel` is 1 as well; otherwise the save fails with 422
+                  `invalid_concurrency_level` ("The field "connection.http.concurrencyLevel"
+                  should be set to 1 when the field "connection.http.rateLimit.limit" is
+                  populated."). A numeric string is stored as a number.
         headers:
           type: array
           description: |