n8n-nodes-base 2.21.2 → 2.22.0

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_enable.ts

@@ -0,0 +1,37 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=userGroup, operation=enable
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25UserGroupEnableParams = {
+  resource: 'userGroup';
+  operation: 'enable';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The encoded ID of the User Group to update
+ */
+    userGroupId: string | Expression<string>;
+/**
+ * Options
+ * @default {}
+ */
+    option?: {
+    /** Whether to include the number of users in each User Group
+     * @default true
+     */
+    include_count?: boolean | Expression<boolean>;
+  };
+};
+
+export type SlackV25UserGroupEnableNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25UserGroupEnableParams>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_get_all.schema.js

@@ -0,0 +1,25 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=userGroup, operation=getAll
+ *
+ * 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 }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('userGroup'),
+      operation: z.literal('getAll'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      returnAll: booleanOrExpression.optional(),
+      limit: resolveSchema({ parameters, schema: numberOrExpression, required: false, displayOptions: {"show":{"returnAll":[false]}}, defaults: {"returnAll":false} }),
+      options: z.object({ include_count: booleanOrExpression.optional(), include_disabled: booleanOrExpression.optional(), include_users: booleanOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_get_all.ts

@@ -0,0 +1,53 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=userGroup, operation=getAll
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+/** Get many channels in a Slack team */
+export type SlackV25UserGroupGetAllParams = {
+  resource: 'userGroup';
+  operation: 'getAll';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * Whether to return all results or only up to a given limit
+ * @default false
+ */
+    returnAll?: boolean | Expression<boolean>;
+/**
+ * Max number of results to return
+ * @displayOptions.show { returnAll: [false] }
+ * @default 100
+ */
+    limit?: number | Expression<number>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to include the number of users in each User Group
+     * @default true
+     */
+    include_count?: boolean | Expression<boolean>;
+    /** Whether to include disabled User Groups
+     * @default true
+     */
+    include_disabled?: boolean | Expression<boolean>;
+    /** Whether to include the list of users for each User Group
+     * @default true
+     */
+    include_users?: boolean | Expression<boolean>;
+  };
+};
+
+export type SlackV25UserGroupGetAllNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25UserGroupGetAllParams>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_get_users.schema.js

@@ -0,0 +1,24 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=userGroup, operation=getUsers
+ *
+ * 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 }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('userGroup'),
+      operation: z.literal('getUsers'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      userGroupId: stringOrExpression,
+      options: z.object({ resolveData: booleanOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_get_users.ts

@@ -0,0 +1,37 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=userGroup, operation=getUsers
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25UserGroupGetUsersParams = {
+  resource: 'userGroup';
+  operation: 'getUsers';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The encoded ID of the User Group
+ */
+    userGroupId: string | Expression<string>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to return full user objects instead of just user IDs
+     * @default true
+     */
+    resolveData?: boolean | Expression<boolean>;
+  };
+};
+
+export type SlackV25UserGroupGetUsersNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25UserGroupGetUsersParams>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_update.schema.js

@@ -0,0 +1,24 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=userGroup, operation=update
+ *
+ * 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 }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('userGroup'),
+      operation: z.literal('update'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      userGroupId: stringOrExpression,
+      updateFields: z.object({ channels: z.array(z.string()).optional(), description: stringOrExpression.optional(), handle: stringOrExpression.optional(), include_count: booleanOrExpression.optional(), name: stringOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_update.ts

@@ -0,0 +1,51 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=userGroup, operation=update
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25UserGroupUpdateParams = {
+  resource: 'userGroup';
+  operation: 'update';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The encoded ID of the User Group to update
+ */
+    userGroupId: string | Expression<string>;
+/**
+ * Update Fields
+ * @default {}
+ */
+    updateFields?: {
+    /** A comma-separated string of encoded channel IDs for which the User Group uses as a default. Choose from the list, or specify IDs using an &lt;a href="https://docs.n8n.io/code/expressions/"&gt;expression&lt;/a&gt;.
+     * @loadOptionsMethod getChannels
+     * @default []
+     */
+    channels?: string[];
+    /** A short description of the User Group
+     */
+    description?: string | Expression<string>;
+    /** A mention handle. Must be unique among channels, users and User Groups.
+     */
+    handle?: string | Expression<string>;
+    /** Whether to include the number of users in each User Group
+     * @default true
+     */
+    include_count?: boolean | Expression<boolean>;
+    /** A name for the User Group. Must be unique among User Groups.
+     */
+    name?: string | Expression<string>;
+  };
+};
+
+export type SlackV25UserGroupUpdateNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25UserGroupUpdateParams>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_update_users.schema.js

@@ -0,0 +1,25 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=userGroup, operation=updateUsers
+ *
+ * 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 }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('userGroup'),
+      operation: z.literal('updateUsers'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      userGroupId: stringOrExpression,
+      users: z.array(z.string()),
+      options: z.object({ include_count: booleanOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_user_group/operation_update_users.ts

@@ -0,0 +1,43 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=userGroup, operation=updateUsers
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25UserGroupUpdateUsersParams = {
+  resource: 'userGroup';
+  operation: 'updateUsers';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The encoded ID of the User Group to update
+ */
+    userGroupId: string | Expression<string>;
+/**
+ * Users to add to the User Group. Existing users will be preserved. Choose from the list, or specify IDs using an &lt;a href="https://docs.n8n.io/code/expressions/"&gt;expression&lt;/a&gt;.
+ * @loadOptionsMethod getUsers
+ * @default []
+ */
+    users: string[];
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to include the number of users in the User Group
+     * @default true
+     */
+    include_count?: boolean | Expression<boolean>;
+  };
+};
+
+export type SlackV25UserGroupUpdateUsersNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25UserGroupUpdateUsersParams>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/snowflake/v1.schema.js

@@ -14,6 +14,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
 
   // Parameters schema
   const parametersSchema = z.object({
+    authentication: z.union([z.literal('credentials'), z.literal('oAuth2'), expressionSchema]).optional(),
     operation: z.union([z.literal('executeQuery'), z.literal('insert'), z.literal('update')]).optional(),
     query: resolveSchema({ parameters, schema: z.string(), required: true, displayOptions: {"show":{"operation":["executeQuery"]}}, defaults: {"operation":"insert"} }),
     table: resolveSchema({ parameters, schema: stringOrExpression, required: true, displayOptions: {"show":{"operation":["insert","update"]}}, defaults: {"operation":"insert"} }),

package/dist/node-definitions/nodes/n8n-nodes-base/snowflake/v1.ts

@@ -5,6 +5,7 @@
 
 
 export interface SnowflakeV1Params {
+  authentication?: 'credentials' | 'oAuth2' | Expression<string>;
   operation?: 'executeQuery' | 'insert' | 'update';
 /**
  * The SQL query to execute
@@ -31,6 +32,7 @@ export interface SnowflakeV1Params {
 
 export interface SnowflakeV1Credentials {
   snowflake: CredentialReference;
+  snowflakeOAuth2Api: CredentialReference;
 }
 
 interface SnowflakeV1NodeBase {

package/dist/node-definitions/nodes/n8n-nodes-base/supabase/v1/resource_row/operation_get_all.schema.js

@@ -21,6 +21,7 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
       tableId: stringOrExpression,
       returnAll: z.boolean().optional(),
       limit: resolveSchema({ parameters, schema: numberOrExpression, required: false, displayOptions: {"show":{"returnAll":[false]}}, defaults: {"returnAll":false} }),
+      orderBy: stringOrExpression.optional(),
       filterType: z.union([z.literal('none'), z.literal('manual'), z.literal('string'), expressionSchema]).optional(),
       matchType: resolveSchema({ parameters, schema: z.union([z.literal('anyFilter'), z.literal('allFilters'), expressionSchema]), required: false, displayOptions: {"show":{"filterType":["manual"]}}, defaults: {"filterType":"manual"} }),
       filters: resolveSchema({ parameters, schema: z.object({ conditions: z.array(z.object({ keyName: stringOrExpression.optional(), condition: z.union([z.literal('eq'), z.literal('fullText'), z.literal('gt'), z.literal('gte'), z.literal('ilike'), z.literal('is'), z.literal('lt'), z.literal('lte'), z.literal('like'), z.literal('neq'), expressionSchema]).optional(), searchFunction: z.union([z.literal('fts'), z.literal('plfts'), z.literal('phfts'), z.literal('wfts'), expressionSchema]).optional(), keyValue: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"filterType":["manual"]}}, defaults: {"filterType":"manual"} }),

package/dist/node-definitions/nodes/n8n-nodes-base/supabase/v1/resource_row/operation_get_all.ts

@@ -39,6 +39,10 @@ export type SupabaseV1RowGetAllParams = {
  * @default 50
  */
     limit?: number | Expression<number>;
+/**
+ * Column(s) to order results by, e.g. &lt;code&gt;ID&lt;/code&gt; or &lt;code&gt;created_at.desc&lt;/code&gt;. Recommended when using Return All or Limit ≥ 1000 to avoid duplicate or missing records.
+ */
+    orderBy?: string | Expression<string>;
 /**
  * Filter
  * @default manual

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

@@ -6,9 +6,55 @@
 
 /** Build a matching rule for each output */
 export type SwitchV3RulesParams = {
+  /**
+   * <patterns>
+   * <pattern title="Switch with two cases plus a default branch">
+   * const routeByPriority = switchCase({
+   *   version: 3.2,
+   *   config: {
+   *     name: 'Route by Priority',
+   *     parameters: {
+   *       rules: {
+   *         values: [
+   *           {
+   *             outputKey: 'urgent',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'urgent' }],
+   *               combinator: 'and'
+   *             }
+   *           },
+   *           {
+   *             outputKey: 'normal',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'normal' }],
+   *               combinator: 'and'
+   *             }
+   *           }
+   *         ]
+   *       },
+   *       options: {
+   *         fallbackOutput: 'extra',
+   *         renameFallbackOutput: 'Fallback'
+   *       }
+   *     }
+   *   }
+   * });
+   * 
+   * export default workflow('id', 'name')
+   *   .add(startTrigger)
+   *   .to(routeByPriority
+   *     .onCase(0, processUrgent.to(notifyTeam))
+   *     .onCase(1, processNormal)
+   *     .onCase(2, archive));
+   * </pattern>
+   * </patterns>
+   */
   mode: 'rules';
 /**
  * Routing Rules
+ * @builderHint Use `rules.values` (NOT `rules.rules`). Each rule needs `outputKey` and a complete `conditions` object with these three sibling keys: `combinator` ('and' | 'or'), `conditions` (array of condition objects), `options` (`{ caseSensitive, leftValue, typeValidation }`). Same shape as IF. Wire rule outputs by zero-based index with `.onCase(index, target)`; `outputKey` is the visible output label, not the `.onCase()` argument. Unwired cases silently drop their items.
  * @default {"values":[{"conditions":{"options":{"caseSensitive":true,"leftValue":"","typeValidation":"strict"},"conditions":[{"leftValue":"","rightValue":"","operator":{"type":"string","operation":"equals"}}],"combinator":"and"}}]}
  */
     rules?: {
@@ -35,6 +81,7 @@ export type SwitchV3RulesParams = {
  */
     options?: {
     /** If no rule matches the item will be sent to this output, by default they will be ignored
+     * @builderHint Set this to `'extra'` before wiring a catch-all/default branch. In rules mode, `'extra'` creates a fallback output at index `rules.values.length`; default `'none'` creates no fallback output and drops unmatched items. Numeric values route unmatched items to an existing rule output and do not create a new port.
      * @loadOptionsMethod getFallbackOutputOptions
      * @default none
      */
@@ -48,6 +95,7 @@ export type SwitchV3RulesParams = {
      */
     looseTypeValidation?: boolean | Expression<boolean>;
     /** Rename Fallback Output
+     * @builderHint Only labels the extra fallback output. Use it together with `fallbackOutput: 'extra'`; it does not create a fallback output by itself.
      * @displayOptions.show { fallbackOutput: ["extra"] }
      */
     renameFallbackOutput?: string | Expression<string>;

package/dist/node-definitions/nodes/n8n-nodes-base/switch/v31/mode_rules.ts

@@ -6,9 +6,55 @@
 
 /** Build a matching rule for each output */
 export type SwitchV31RulesParams = {
+  /**
+   * <patterns>
+   * <pattern title="Switch with two cases plus a default branch">
+   * const routeByPriority = switchCase({
+   *   version: 3.2,
+   *   config: {
+   *     name: 'Route by Priority',
+   *     parameters: {
+   *       rules: {
+   *         values: [
+   *           {
+   *             outputKey: 'urgent',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'urgent' }],
+   *               combinator: 'and'
+   *             }
+   *           },
+   *           {
+   *             outputKey: 'normal',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'normal' }],
+   *               combinator: 'and'
+   *             }
+   *           }
+   *         ]
+   *       },
+   *       options: {
+   *         fallbackOutput: 'extra',
+   *         renameFallbackOutput: 'Fallback'
+   *       }
+   *     }
+   *   }
+   * });
+   * 
+   * export default workflow('id', 'name')
+   *   .add(startTrigger)
+   *   .to(routeByPriority
+   *     .onCase(0, processUrgent.to(notifyTeam))
+   *     .onCase(1, processNormal)
+   *     .onCase(2, archive));
+   * </pattern>
+   * </patterns>
+   */
   mode: 'rules';
 /**
  * Routing Rules
+ * @builderHint Use `rules.values` (NOT `rules.rules`). Each rule needs `outputKey` and a complete `conditions` object with these three sibling keys: `combinator` ('and' | 'or'), `conditions` (array of condition objects), `options` (`{ caseSensitive, leftValue, typeValidation }`). Same shape as IF. Wire rule outputs by zero-based index with `.onCase(index, target)`; `outputKey` is the visible output label, not the `.onCase()` argument. Unwired cases silently drop their items.
  * @default {"values":[{"conditions":{"options":{"caseSensitive":true,"leftValue":"","typeValidation":"strict"},"conditions":[{"leftValue":"","rightValue":"","operator":{"type":"string","operation":"equals"}}],"combinator":"and"}}]}
  */
     rules?: {
@@ -40,6 +86,7 @@ export type SwitchV31RulesParams = {
  */
     options?: {
     /** If no rule matches the item will be sent to this output, by default they will be ignored
+     * @builderHint Set this to `'extra'` before wiring a catch-all/default branch. In rules mode, `'extra'` creates a fallback output at index `rules.values.length`; default `'none'` creates no fallback output and drops unmatched items. Numeric values route unmatched items to an existing rule output and do not create a new port.
      * @loadOptionsMethod getFallbackOutputOptions
      * @default none
      */
@@ -53,6 +100,7 @@ export type SwitchV31RulesParams = {
      */
     looseTypeValidation?: boolean | Expression<boolean>;
     /** Rename Fallback Output
+     * @builderHint Only labels the extra fallback output. Use it together with `fallbackOutput: 'extra'`; it does not create a fallback output by itself.
      * @displayOptions.show { fallbackOutput: ["extra"] }
      */
     renameFallbackOutput?: string | Expression<string>;

package/dist/node-definitions/nodes/n8n-nodes-base/switch/v32/mode_rules.ts

@@ -6,9 +6,55 @@
 
 /** Build a matching rule for each output */
 export type SwitchV32RulesParams = {
+  /**
+   * <patterns>
+   * <pattern title="Switch with two cases plus a default branch">
+   * const routeByPriority = switchCase({
+   *   version: 3.2,
+   *   config: {
+   *     name: 'Route by Priority',
+   *     parameters: {
+   *       rules: {
+   *         values: [
+   *           {
+   *             outputKey: 'urgent',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'urgent' }],
+   *               combinator: 'and'
+   *             }
+   *           },
+   *           {
+   *             outputKey: 'normal',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'normal' }],
+   *               combinator: 'and'
+   *             }
+   *           }
+   *         ]
+   *       },
+   *       options: {
+   *         fallbackOutput: 'extra',
+   *         renameFallbackOutput: 'Fallback'
+   *       }
+   *     }
+   *   }
+   * });
+   * 
+   * export default workflow('id', 'name')
+   *   .add(startTrigger)
+   *   .to(routeByPriority
+   *     .onCase(0, processUrgent.to(notifyTeam))
+   *     .onCase(1, processNormal)
+   *     .onCase(2, archive));
+   * </pattern>
+   * </patterns>
+   */
   mode: 'rules';
 /**
  * Routing Rules
+ * @builderHint Use `rules.values` (NOT `rules.rules`). Each rule needs `outputKey` and a complete `conditions` object with these three sibling keys: `combinator` ('and' | 'or'), `conditions` (array of condition objects), `options` (`{ caseSensitive, leftValue, typeValidation }`). Same shape as IF. Wire rule outputs by zero-based index with `.onCase(index, target)`; `outputKey` is the visible output label, not the `.onCase()` argument. Unwired cases silently drop their items.
  * @default {"values":[{"conditions":{"options":{"caseSensitive":true,"leftValue":"","typeValidation":"strict"},"conditions":[{"leftValue":"","rightValue":"","operator":{"type":"string","operation":"equals"}}],"combinator":"and"}}]}
  */
     rules?: {
@@ -40,6 +86,7 @@ export type SwitchV32RulesParams = {
  */
     options?: {
     /** If no rule matches the item will be sent to this output, by default they will be ignored
+     * @builderHint Set this to `'extra'` before wiring a catch-all/default branch. In rules mode, `'extra'` creates a fallback output at index `rules.values.length`; default `'none'` creates no fallback output and drops unmatched items. Numeric values route unmatched items to an existing rule output and do not create a new port.
      * @loadOptionsMethod getFallbackOutputOptions
      * @default none
      */
@@ -53,6 +100,7 @@ export type SwitchV32RulesParams = {
      */
     looseTypeValidation?: boolean | Expression<boolean>;
     /** Rename Fallback Output
+     * @builderHint Only labels the extra fallback output. Use it together with `fallbackOutput: 'extra'`; it does not create a fallback output by itself.
      * @displayOptions.show { fallbackOutput: ["extra"] }
      */
     renameFallbackOutput?: string | Expression<string>;

package/dist/node-definitions/nodes/n8n-nodes-base/switch/v33/mode_rules.ts

@@ -6,9 +6,55 @@
 
 /** Build a matching rule for each output */
 export type SwitchV33RulesParams = {
+  /**
+   * <patterns>
+   * <pattern title="Switch with two cases plus a default branch">
+   * const routeByPriority = switchCase({
+   *   version: 3.2,
+   *   config: {
+   *     name: 'Route by Priority',
+   *     parameters: {
+   *       rules: {
+   *         values: [
+   *           {
+   *             outputKey: 'urgent',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'urgent' }],
+   *               combinator: 'and'
+   *             }
+   *           },
+   *           {
+   *             outputKey: 'normal',
+   *             conditions: {
+   *               options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+   *               conditions: [{ leftValue: expr('{{ $json.priority }}'), operator: { type: 'string', operation: 'equals' }, rightValue: 'normal' }],
+   *               combinator: 'and'
+   *             }
+   *           }
+   *         ]
+   *       },
+   *       options: {
+   *         fallbackOutput: 'extra',
+   *         renameFallbackOutput: 'Fallback'
+   *       }
+   *     }
+   *   }
+   * });
+   * 
+   * export default workflow('id', 'name')
+   *   .add(startTrigger)
+   *   .to(routeByPriority
+   *     .onCase(0, processUrgent.to(notifyTeam))
+   *     .onCase(1, processNormal)
+   *     .onCase(2, archive));
+   * </pattern>
+   * </patterns>
+   */
   mode: 'rules';
 /**
  * Routing Rules
+ * @builderHint Use `rules.values` (NOT `rules.rules`). Each rule needs `outputKey` and a complete `conditions` object with these three sibling keys: `combinator` ('and' | 'or'), `conditions` (array of condition objects), `options` (`{ caseSensitive, leftValue, typeValidation }`). Same shape as IF. Wire rule outputs by zero-based index with `.onCase(index, target)`; `outputKey` is the visible output label, not the `.onCase()` argument. Unwired cases silently drop their items.
  * @default {"values":[{"conditions":{"options":{"caseSensitive":true,"leftValue":"","typeValidation":"strict"},"conditions":[{"leftValue":"","rightValue":"","operator":{"type":"string","operation":"equals"}}],"combinator":"and"}}]}
  */
     rules?: {
@@ -40,6 +86,7 @@ export type SwitchV33RulesParams = {
  */
     options?: {
     /** If no rule matches the item will be sent to this output, by default they will be ignored
+     * @builderHint Set this to `'extra'` before wiring a catch-all/default branch. In rules mode, `'extra'` creates a fallback output at index `rules.values.length`; default `'none'` creates no fallback output and drops unmatched items. Numeric values route unmatched items to an existing rule output and do not create a new port.
      * @loadOptionsMethod getFallbackOutputOptions
      * @default none
      */
@@ -53,6 +100,7 @@ export type SwitchV33RulesParams = {
      */
     looseTypeValidation?: boolean | Expression<boolean>;
     /** Rename Fallback Output
+     * @builderHint Only labels the extra fallback output. Use it together with `fallbackOutput: 'extra'`; it does not create a fallback output by itself.
      * @displayOptions.show { fallbackOutput: ["extra"] }
      */
     renameFallbackOutput?: string | Expression<string>;