n8n-nodes-base 2.34.2 → 2.35.0

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v2.schema.js

@@ -16,7 +16,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
   const parametersSchema = z.object({
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     requestMethod: z.union([z.literal('DELETE'), z.literal('GET'), z.literal('HEAD'), z.literal('OPTIONS'), z.literal('PATCH'), z.literal('POST'), z.literal('PUT'), expressionSchema]).optional(),
     url: stringOrExpression,
     allowUnauthorizedCerts: booleanOrExpression.optional(),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v2.ts

@@ -12,10 +12,10 @@ export interface HttpRequestV2Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
 /**
  * The request method to use
  * @default GET
@@ -190,6 +190,7 @@ export interface HttpRequestV2Credentials {
   /** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */
   httpBearerAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
 }
 
 interface HttpRequestV2NodeBase {

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v3.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v3.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV3Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV3Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v4.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v4.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV4Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV4Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v41.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v41.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV41Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV41Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v42.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v42.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV42Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV42Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v43.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v43.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV43Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV43Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v44.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v44.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV44Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV44Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v45.schema.js

@@ -18,7 +18,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
     url: stringOrExpression,
     authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
     nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
-    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('httpTemplatedCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
     provideSslCertificates: booleanOrExpression.optional(),
     sendQuery: z.boolean().optional(),
     specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v45.ts

@@ -26,16 +26,16 @@ export interface HttpRequestV45Params {
  */
     nodeCredentialType?: string;
 /**
- * Generic Auth Type
- * @builderHint Pick by how the API authenticates, not by what the user calls it:
-- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
-- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+ * For NEW credentials prefer 'httpTemplatedCustomAuth' whenever the auth fits header/query/body values — `Authorization: Bearer <token>` becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}; do NOT use httpBearerAuth for it. Plain generic types are only for reusing an existing credential or for what a template cannot express (basic, digest, OAuth).
+ * @builderHint For a NEW credential default to httpTemplatedCustomAuth whenever the auth fits header/query/body values — API keys and bearer tokens alike ("Authorization: Bearer <token>" becomes the template {"headers":{"Authorization":"Bearer {{api_key}}"}}). Setup rejects new plain generic credentials on this node UNLESS the user explicitly asked for that type — an explicit user choice always wins, don't argue with it.
+Pick a plain generic type when reusing an existing credential of that type, or when the user explicitly asks for one, matching how the API authenticates:
+- "Authorization: Bearer <token>" → httpBearerAuth.
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth.
 - API key in the query string (?api_key=...) → httpQueryAuth.
-- username + password → httpBasicAuth.
-A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+For what a template cannot express, use the matching type for new and existing credentials alike: username + password → httpBasicAuth, digest → httpDigestAuth, OAuth → oAuth2Api/oAuth1Api.
  * @displayOptions.show { authentication: ["genericCredentialType"] }
  */
-    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'httpTemplatedCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
   provideSslCertificates?: boolean | Expression<boolean>;
 /**
  * Whether the request has query params or not
@@ -409,6 +409,7 @@ export interface HttpRequestV45Credentials {
   httpHeaderAuth?: CredentialReference;
   httpQueryAuth?: CredentialReference;
   httpCustomAuth?: CredentialReference;
+  httpTemplatedCustomAuth?: CredentialReference;
   oAuth1Api?: CredentialReference;
   oAuth2Api?: CredentialReference;
 }

package/dist/node-definitions/nodes/n8n-nodes-base/kafka/index.ts

@@ -4,9 +4,11 @@
  * Re-exports all version-specific types and provides combined union type.
  */
 
+import type { KafkaV2Node } from './v2';
 import type { KafkaV1Node } from './v1';
 
+export * from './v2';
 export * from './v1';
 
 // Combined union type for all versions
-export type KafkaNode = KafkaV1Node;
+export type KafkaNode = KafkaV2Node | KafkaV1Node;

package/dist/node-definitions/nodes/n8n-nodes-base/kafka/v2.schema.js

@@ -0,0 +1,35 @@
+/**
+ * Kafka Node - Version 2 - Zod Validation Schemas
+ *
+ * These schemas validate node configuration at runtime.
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, resolveOneOfSchemas }) {
+
+  // Parameters schema
+  const parametersSchema = z.object({
+    topic: stringOrExpression.optional(),
+    sendInputData: booleanOrExpression.optional(),
+    message: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"sendInputData":[false]}}, defaults: {"sendInputData":true} }),
+    jsonParameters: booleanOrExpression.optional(),
+    useSchemaRegistry: booleanOrExpression.optional(),
+    schemaRegistryUrl: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"useSchemaRegistry":[true]}}, defaults: {"useSchemaRegistry":false} }),
+    useKey: booleanOrExpression.optional(),
+    key: resolveSchema({ parameters, schema: stringOrExpression, required: true, displayOptions: {"show":{"useKey":[true]}}, defaults: {"useKey":false} }),
+    eventName: resolveSchema({ parameters, schema: stringOrExpression, required: true, displayOptions: {"show":{"useSchemaRegistry":[true]}}, defaults: {"useSchemaRegistry":false} }),
+    headersUi: resolveSchema({ parameters, schema: z.object({ headerValues: z.array(z.object({ key: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"jsonParameters":[false]}}, defaults: {"jsonParameters":false} }),
+    headerParametersJson: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"jsonParameters":[true]}}, defaults: {"jsonParameters":false} }),
+    options: z.object({ acks: booleanOrExpression.optional(), compression: z.union([z.literal('gzip'), z.literal('lz4'), z.literal('snappy'), z.literal('zstd'), z.literal('none'), expressionSchema]).optional(), timeout: numberOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/kafka/v2.ts

@@ -0,0 +1,100 @@
+/**
+ * Kafka Node - Version 2
+ * Sends messages to a Kafka topic
+ */
+
+
+export interface KafkaV2Params {
+/**
+ * Name of the queue of topic to publish to
+ */
+    topic?: string | Expression<string>;
+/**
+ * Whether to send the data the node receives as JSON to Kafka
+ * @default true
+ */
+    sendInputData?: boolean | Expression<boolean>;
+/**
+ * The message to be sent
+ * @displayOptions.show { sendInputData: [false] }
+ */
+    message?: string | Expression<string>;
+  jsonParameters?: boolean | Expression<boolean>;
+/**
+ * Whether to use Confluent Schema Registry
+ * @default false
+ */
+    useSchemaRegistry?: boolean | Expression<boolean>;
+/**
+ * URL of the schema registry. Only used when no Schema Registry credential is selected.
+ * @displayOptions.show { useSchemaRegistry: [true] }
+ */
+    schemaRegistryUrl?: string | Expression<string>;
+/**
+ * Whether to use a message key
+ * @default false
+ */
+    useKey?: boolean | Expression<boolean>;
+/**
+ * The message key
+ * @displayOptions.show { useKey: [true] }
+ */
+    key: string | Expression<string>;
+/**
+ * Namespace and Name of Schema in Schema Registry (namespace.name)
+ * @displayOptions.show { useSchemaRegistry: [true] }
+ */
+    eventName: string | Expression<string>;
+/**
+ * Headers
+ * @displayOptions.show { jsonParameters: [false] }
+ * @default {}
+ */
+    headersUi?: {
+        /** Header
+     */
+    headerValues?: Array<{
+      /** Key
+       */
+      key?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+/**
+ * Header parameters as JSON (flat object)
+ * @displayOptions.show { jsonParameters: [true] }
+ */
+    headerParametersJson?: IDataObject | string | Expression<string>;
+  options?: {
+    /** Whether or not producer must wait for acknowledgement from all replicas
+     * @default false
+     */
+    acks?: boolean | Expression<boolean>;
+    /** Codec used to compress messages. Version 1 of the Kafka Trigger cannot read Snappy, LZ4 or Zstd — use GZIP or None while version 1 triggers consume this topic.
+     * @default none
+     */
+    compression?: 'gzip' | 'lz4' | 'snappy' | 'zstd' | 'none' | Expression<string>;
+    /** The time to await a response in ms
+     * @default 30000
+     */
+    timeout?: number | Expression<number>;
+  };
+}
+
+export interface KafkaV2Credentials {
+  kafka: CredentialReference;
+  schemaRegistryApi?: CredentialReference;
+}
+
+interface KafkaV2NodeBase {
+  type: 'n8n-nodes-base.kafka';
+  version: 2;
+}
+
+export type KafkaV2ParamsNode = KafkaV2NodeBase & {
+  config: NodeConfig<KafkaV2Params> & { credentials?: KafkaV2Credentials };
+};
+
+export type KafkaV2Node = KafkaV2ParamsNode;

package/dist/node-definitions/nodes/n8n-nodes-base/kafkaTrigger/index.ts

@@ -4,15 +4,17 @@
  * Re-exports all version-specific types and provides combined union type.
  */
 
+import type { KafkaTriggerV2Node } from './v2';
 import type { KafkaTriggerV13Node } from './v13';
 import type { KafkaTriggerV12Node } from './v12';
 import type { KafkaTriggerV11Node } from './v11';
 import type { KafkaTriggerV1Node } from './v1';
 
+export * from './v2';
 export * from './v13';
 export * from './v12';
 export * from './v11';
 export * from './v1';
 
 // Combined union type for all versions
-export type KafkaTriggerNode = KafkaTriggerV13Node | KafkaTriggerV12Node | KafkaTriggerV11Node | KafkaTriggerV1Node;
+export type KafkaTriggerNode = KafkaTriggerV2Node | KafkaTriggerV13Node | KafkaTriggerV12Node | KafkaTriggerV11Node | KafkaTriggerV1Node;

package/dist/node-definitions/nodes/n8n-nodes-base/kafkaTrigger/v2.schema.js

@@ -0,0 +1,30 @@
+/**
+ * Kafka Trigger Node - Version 2 - Zod Validation Schemas
+ *
+ * These schemas validate node configuration at runtime.
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, resolveOneOfSchemas }) {
+
+  // Parameters schema
+  const parametersSchema = z.object({
+    topic: stringOrExpression,
+    groupId: stringOrExpression,
+    resolveOffset: z.union([z.literal('onCompletion'), z.literal('onSuccess'), z.literal('onStatus'), z.literal('immediately'), expressionSchema]).optional(),
+    allowedStatuses: resolveSchema({ parameters, schema: z.array(z.union([z.literal('canceled'), z.literal('crashed'), z.literal('error'), z.literal('new'), z.literal('running'), z.literal('success'), z.literal('unknown'), z.literal('waiting')])), required: false, displayOptions: {"show":{"resolveOffset":["onStatus"]}}, defaults: {"resolveOffset":"onCompletion"} }),
+    useSchemaRegistry: booleanOrExpression.optional(),
+    schemaRegistryUrl: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"useSchemaRegistry":[true]}}, defaults: {"useSchemaRegistry":false} }),
+    options: z.object({ autoCommitInterval: numberOrExpression.optional(), batchSize: numberOrExpression.optional(), fetchMaxBytes: numberOrExpression.optional(), fetchMinBytes: numberOrExpression.optional(), heartbeatInterval: numberOrExpression.optional(), maxInFlightRequests: numberOrExpression.optional(), fromBeginning: booleanOrExpression.optional(), jsonParseMessage: booleanOrExpression.optional(), keepBinaryData: booleanOrExpression.optional(), partitionsConsumedConcurrently: numberOrExpression.optional(), onlyMessage: booleanOrExpression.optional(), returnHeaders: booleanOrExpression.optional(), rebalanceTimeout: numberOrExpression.optional(), errorRetryDelay: numberOrExpression.optional(), sessionTimeout: numberOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};