n8n-nodes-base 2.21.2 → 2.22.0

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_message/operation_search.ts

@@ -0,0 +1,91 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=message, operation=search
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25MessageSearchParams = {
+  resource: 'message';
+  operation: 'search';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The text to search for within messages
+ */
+    query: string | Expression<string>;
+/**
+ * How search results should be sorted. You can sort by.
+ * @default desc
+ */
+    sort?: 'desc' | 'asc' | 'relevance' | 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 25
+ */
+    limit?: number | Expression<number>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Choose from the list, or specify IDs using an &lt;a href="https://docs.n8n.io/code/expressions/"&gt;expression&lt;/a&gt;
+     * @loadOptionsMethod getChannelsName
+     * @default []
+     */
+    searchChannel?: string[];
+  };
+};
+
+export type SlackV25MessageSearchOutput = {
+  blocks?: Array<{
+    block_id?: string;
+    elements?: Array<{
+      elements?: Array<{
+        text?: string;
+        type?: string;
+        user_id?: string;
+      }>;
+      type?: string;
+    }>;
+    type?: string;
+  }>;
+  channel?: {
+    id?: string;
+    is_channel?: boolean;
+    is_ext_shared?: boolean;
+    is_group?: boolean;
+    is_im?: boolean;
+    is_mpim?: boolean;
+    is_org_shared?: boolean;
+    is_pending_ext_shared?: boolean;
+    is_private?: boolean;
+    is_shared?: boolean;
+    name?: string;
+  };
+  iid?: string;
+  no_reactions?: boolean;
+  permalink?: string;
+  team?: string;
+  text?: string;
+  ts?: string;
+  type?: string;
+  username?: string;
+};
+
+export type SlackV25MessageSearchNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25MessageSearchParams>;
+  output?: Items<SlackV25MessageSearchOutput>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_message/operation_send_and_wait.schema.js

@@ -0,0 +1,32 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=message, operation=sendAndWait
+ *
+ * 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('message').default('message'),
+      operation: z.literal('sendAndWait'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      select: z.union([z.literal('channel'), z.literal('user'), expressionSchema]).optional(),
+      channelId: resolveSchema({ parameters, schema: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id'), z.literal('name'), z.literal('url')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]), required: false, displayOptions: {"show":{"select":["channel"]}}, defaults: {"select":"user"} }),
+      user: resolveSchema({ parameters, schema: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id'), z.literal('username')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]), required: false, displayOptions: {"show":{"select":["user"]}}, defaults: {"select":"user"} }),
+      message: stringOrExpression,
+      responseType: z.union([z.literal('approval'), z.literal('freeText'), z.literal('customForm'), expressionSchema]).optional(),
+      defineForm: resolveSchema({ parameters, schema: z.union([z.literal('fields'), z.literal('json')]), required: false, displayOptions: {"show":{"responseType":["customForm"]}}, defaults: {"responseType":"approval"} }),
+      jsonOutput: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"defineForm":["json"],"responseType":["customForm"]}}, defaults: {"defineForm":"fields","responseType":"approval"} }),
+      formFields: resolveSchema({ parameters, schema: z.object({ values: z.array(z.object({ fieldName: stringOrExpression.optional(), fieldLabel: stringOrExpression.optional(), fieldLabel: stringOrExpression.optional(), fieldName: stringOrExpression.optional(), fieldType: z.union([z.literal('checkbox'), z.literal('html'), z.literal('date'), z.literal('dropdown'), z.literal('email'), z.literal('file'), z.literal('hiddenField'), z.literal('number'), z.literal('password'), z.literal('radio'), z.literal('text'), z.literal('textarea'), expressionSchema]).optional(), elementName: stringOrExpression.optional(), fieldName: stringOrExpression.optional(), placeholder: stringOrExpression.optional(), defaultValue: stringOrExpression.optional(), defaultValue: stringOrExpression.optional(), defaultValue: stringOrExpression.optional(), defaultValue: stringOrExpression.optional(), fieldValue: stringOrExpression.optional(), fieldOptions: z.object({ values: z.array(z.object({ option: stringOrExpression.optional() })).optional() }).optional(), fieldOptions: z.object({ values: z.array(z.object({ option: stringOrExpression.optional() })).optional() }).optional(), fieldOptions: z.object({ values: z.array(z.object({ option: stringOrExpression.optional() })).optional() }).optional(), multiselect: booleanOrExpression.optional(), limitSelection: z.union([z.literal('exact'), z.literal('range'), z.literal('unlimited'), expressionSchema]).optional(), numberOfSelections: numberOrExpression.optional(), minSelections: numberOrExpression.optional(), maxSelections: numberOrExpression.optional(), html: z.string().optional(), multipleFiles: booleanOrExpression.optional(), acceptFileTypes: stringOrExpression.optional(), requiredField: booleanOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"defineForm":["fields"],"responseType":["customForm"]}}, defaults: {"defineForm":"fields","responseType":"approval"} }),
+      approvalOptions: resolveSchema({ parameters, schema: z.object({ values: z.object({ approvalType: z.union([z.literal('single'), z.literal('double'), expressionSchema]).optional(), approveLabel: stringOrExpression.optional(), buttonApprovalStyle: z.union([z.literal('primary'), z.literal('secondary'), expressionSchema]).optional(), disapproveLabel: stringOrExpression.optional(), buttonDisapprovalStyle: z.union([z.literal('primary'), z.literal('secondary'), expressionSchema]).optional() }).optional() }), required: false, displayOptions: {"show":{"responseType":["approval"]}}, defaults: {"responseType":"approval"} }),
+      options: resolveSchema({ parameters, schema: z.object({ limitWaitTime: z.object({ values: z.object({ limitType: z.union([z.literal('afterTimeInterval'), z.literal('atSpecifiedTime'), expressionSchema]).optional(), resumeAmount: numberOrExpression.optional(), resumeUnit: z.union([z.literal('minutes'), z.literal('hours'), z.literal('days'), expressionSchema]).optional(), maxDateAndTime: stringOrExpression.optional() }).optional() }).optional(), appendAttribution: booleanOrExpression.optional(), thread_ts: z.object({ replyValues: z.object({ thread_ts: numberOrExpression.optional(), reply_broadcast: booleanOrExpression.optional() }).optional() }).optional(), messageButtonLabel: stringOrExpression.optional(), responseFormTitle: stringOrExpression.optional(), responseFormDescription: stringOrExpression.optional(), responseFormButtonLabel: stringOrExpression.optional(), responseFormCustomCss: stringOrExpression.optional() }), required: false, displayOptions: {"show":{"responseType":["approval","freeText","customForm"]}}, defaults: {"responseType":"approval"} }),
+    }).optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_message/operation_send_and_wait.ts

@@ -0,0 +1,323 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=message, operation=sendAndWait
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25MessageSendAndWaitParams = {
+  resource: 'message';
+  operation: 'sendAndWait';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * Send Message To
+ * @default user
+ */
+    select?: 'channel' | 'user' | Expression<string>;
+/**
+ * The Slack channel to send to
+ * @searchListMethod getChannels
+ * @displayOptions.show { select: ["channel"] }
+ * @default {"mode":"list","value":""}
+ */
+    channelId?: { __rl: true; mode: 'list' | 'id' | 'name' | 'url'; value: string; cachedResultName?: string };
+/**
+ * User
+ * @searchListMethod getUsers
+ * @displayOptions.show { select: ["user"] }
+ * @default {"mode":"list","value":""}
+ */
+    user?: { __rl: true; mode: 'list' | 'id' | 'username'; value: string; cachedResultName?: string };
+/**
+ * Message
+ */
+    message: string | Expression<string>;
+/**
+ * Response Type
+ * @default approval
+ */
+    responseType?: 'approval' | 'freeText' | 'customForm' | Expression<string>;
+/**
+ * Define Form
+ * @displayOptions.show { responseType: ["customForm"] }
+ * @default fields
+ */
+    defineForm?: 'fields' | 'json';
+/**
+ * Form Fields
+ * @hint &lt;a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.form/" target="_blank"&gt;See docs&lt;/a&gt; for field syntax
+ * @displayOptions.show { defineForm: ["json"], responseType: ["customForm"] }
+ */
+    jsonOutput?: IDataObject | string | Expression<string>;
+/**
+ * Form Elements
+ * @displayOptions.show { defineForm: ["fields"], responseType: ["customForm"] }
+ * @default {}
+ */
+    formFields?: {
+        /** Values
+     */
+    values?: Array<{
+      /** The name of the field, used in input attributes and referenced by the workflow
+       * @displayOptions.hide { fieldType: ["html"] }
+       */
+      fieldName?: string | Expression<string>;
+      /** Label that appears above the input field
+       * @displayOptions.hide { fieldType: ["hiddenField", "html"] }
+       */
+      fieldLabel?: string | Expression<string>;
+      /** Label that appears above the input field
+       * @displayOptions.hide { fieldType: ["hiddenField", "html"] }
+       */
+      fieldLabel?: string | Expression<string>;
+      /** The name of the field, used in input attributes and referenced by the workflow
+       * @displayOptions.show { fieldType: ["hiddenField"] }
+       */
+      fieldName?: string | Expression<string>;
+      /** The type of field to add to the form
+       * @default text
+       */
+      fieldType?: 'checkbox' | 'html' | 'date' | 'dropdown' | 'email' | 'file' | 'hiddenField' | 'number' | 'password' | 'radio' | 'text' | 'textarea' | Expression<string>;
+      /** Optional field. It can be used to include the html in the output.
+       * @displayOptions.show { fieldType: ["html"] }
+       */
+      elementName?: string | Expression<string>;
+      /** The name of the field, used in input attributes and referenced by the workflow
+       * @displayOptions.hide { fieldType: ["html"] }
+       */
+      fieldName?: string | Expression<string>;
+      /** Sample text to display inside the field
+       * @displayOptions.hide { fieldType: ["dropdown", "date", "file", "html", "hiddenField", "radio", "checkbox"] }
+       */
+      placeholder?: string | Expression<string>;
+      /** Default value that will be pre-filled in the form field
+       * @displayOptions.show { fieldType: ["text", "number", "email", "textarea"] }
+       */
+      defaultValue?: string | Expression<string>;
+      /** Default date value that will be pre-filled in the form field (format: YYYY-MM-DD)
+       * @displayOptions.show { fieldType: ["date"] }
+       */
+      defaultValue?: string | Expression<string>;
+      /** Default value that will be pre-selected. Must match one of the option labels.
+       * @displayOptions.show { fieldType: ["dropdown", "radio"] }
+       */
+      defaultValue?: string | Expression<string>;
+      /** Default value(s) that will be pre-selected. Must match one or multiple of the option labels. Separate multiple pre-selected options with a comma.
+       * @displayOptions.show { fieldType: ["checkbox"] }
+       */
+      defaultValue?: string | Expression<string>;
+      /** Input value can be set here or will be passed as a query parameter via Field Name if no value is set
+       * @displayOptions.show { fieldType: ["hiddenField"] }
+       */
+      fieldValue?: string | Expression<string>;
+      /** List of options that can be selected from the dropdown
+       * @displayOptions.show { fieldType: ["dropdown"] }
+       * @default {"values":[{"option":""}]}
+       */
+      fieldOptions?: {
+        /** Values
+     */
+    values?: Array<{
+      /** Option
+       */
+      option?: string | Expression<string>;
+    }>;
+  };
+      /** Checkboxes
+       * @displayOptions.show { fieldType: ["checkbox"] }
+       * @default {"values":[{"option":""}]}
+       */
+      fieldOptions?: {
+        /** Values
+     */
+    values?: Array<{
+      /** Checkbox Label
+       */
+      option?: string | Expression<string>;
+    }>;
+  };
+      /** Radio Buttons
+       * @displayOptions.show { fieldType: ["radio"] }
+       * @default {"values":[{"option":""}]}
+       */
+      fieldOptions?: {
+        /** Values
+     */
+    values?: Array<{
+      /** Radio Button Label
+       */
+      option?: string | Expression<string>;
+    }>;
+  };
+      /** Whether to allow the user to select multiple options from the dropdown list
+       * @displayOptions.show { fieldType: ["dropdown"] }
+       * @default false
+       */
+      multiselect?: boolean | Expression<boolean>;
+      /** Limit Selection
+       * @displayOptions.show { fieldType: ["checkbox"] }
+       * @default unlimited
+       */
+      limitSelection?: 'exact' | 'range' | 'unlimited' | Expression<string>;
+      /** Number of Selections
+       * @displayOptions.show { fieldType: ["checkbox"], limitSelection: ["exact"] }
+       * @default 1
+       */
+      numberOfSelections?: number | Expression<number>;
+      /** Minimum Selections
+       * @displayOptions.show { fieldType: ["checkbox"], limitSelection: ["range"] }
+       * @default 0
+       */
+      minSelections?: number | Expression<number>;
+      /** Maximum Selections
+       * @displayOptions.show { fieldType: ["checkbox"], limitSelection: ["range"] }
+       * @default 1
+       */
+      maxSelections?: number | Expression<number>;
+      /** HTML elements to display on the form page
+       * @hint Does not accept &lt;code&gt;&lt;script&gt;&lt;/code&gt;, &lt;code&gt;&lt;style&gt;&lt;/code&gt; or &lt;code&gt;&lt;input&gt;&lt;/code&gt; tags
+       * @displayOptions.show { fieldType: ["html"] }
+       */
+      html?: string;
+      /** Whether to allow the user to select multiple files from the file input or just one
+       * @displayOptions.show { fieldType: ["file"] }
+       * @default true
+       */
+      multipleFiles?: boolean | Expression<boolean>;
+      /** Comma-separated list of allowed file extensions
+       * @hint Leave empty to allow all file types
+       * @displayOptions.show { fieldType: ["file"] }
+       */
+      acceptFileTypes?: string | Expression<string>;
+      /** Whether to require the user to enter a value for this field before submitting the form
+       * @displayOptions.hide { fieldType: ["html", "hiddenField"] }
+       * @default false
+       */
+      requiredField?: boolean | Expression<boolean>;
+    }>;
+  };
+/**
+ * Approval Options
+ * @displayOptions.show { responseType: ["approval"] }
+ * @default {}
+ */
+    approvalOptions?: {
+        /** Values
+     */
+    values?: {
+      /** Type of Approval
+       * @default single
+       */
+      approvalType?: 'single' | 'double' | Expression<string>;
+      /** Approve Button Label
+       * @displayOptions.show { approvalType: ["single", "double"] }
+       * @default Approve
+       */
+      approveLabel?: string | Expression<string>;
+      /** Approve Button Style
+       * @displayOptions.show { approvalType: ["single", "double"] }
+       * @default primary
+       */
+      buttonApprovalStyle?: 'primary' | 'secondary' | Expression<string>;
+      /** Disapprove Button Label
+       * @displayOptions.show { approvalType: ["double"] }
+       * @default Decline
+       */
+      disapproveLabel?: string | Expression<string>;
+      /** Disapprove Button Style
+       * @displayOptions.show { approvalType: ["double"] }
+       * @default secondary
+       */
+      buttonDisapprovalStyle?: 'primary' | 'secondary' | Expression<string>;
+    };
+  };
+/**
+ * Options
+ * @displayOptions.show { responseType: ["approval", "freeText", "customForm"] }
+ * @default {}
+ */
+    options?: {
+    /** Whether to limit the time this node should wait for a user response before execution resumes
+     * @default {"values":{"limitType":"afterTimeInterval","resumeAmount":45,"resumeUnit":"minutes"}}
+     */
+    limitWaitTime?: {
+        /** Values
+     */
+    values?: {
+      /** Sets the condition for the execution to resume. Can be a specified date or after some time.
+       * @default afterTimeInterval
+       */
+      limitType?: 'afterTimeInterval' | 'atSpecifiedTime' | Expression<string>;
+      /** The time to wait
+       * @displayOptions.show { limitType: ["afterTimeInterval"] }
+       * @default 1
+       */
+      resumeAmount?: number | Expression<number>;
+      /** Unit of the interval value
+       * @displayOptions.show { limitType: ["afterTimeInterval"] }
+       * @default hours
+       */
+      resumeUnit?: 'minutes' | 'hours' | 'days' | Expression<string>;
+      /** Continue execution after the specified date and time
+       * @displayOptions.show { limitType: ["atSpecifiedTime"] }
+       */
+      maxDateAndTime?: string | Expression<string>;
+    };
+  };
+    /** Whether to include the phrase "This message was sent automatically with n8n" to the end of the message
+     * @default true
+     */
+    appendAttribution?: boolean | Expression<boolean>;
+    /** Provide another message's Timestamp value to make this message a reply
+     * @default {}
+     */
+    thread_ts?: {
+        /** Reply to a Message
+     */
+    replyValues?: {
+      /** Message timestamps are included in output data of Slack nodes, abbreviated to ts
+       */
+      thread_ts?: number | Expression<number>;
+      /** Whether the reply should be made visible to everyone in the channel or conversation
+       * @default false
+       */
+      reply_broadcast?: boolean | Expression<boolean>;
+    };
+  };
+    /** Message Button Label
+     * @default Respond
+     */
+    messageButtonLabel?: string | Expression<string>;
+    /** Title of the form that the user can access to provide their response
+     */
+    responseFormTitle?: string | Expression<string>;
+    /** Description of the form that the user can access to provide their response
+     */
+    responseFormDescription?: string | Expression<string>;
+    /** Response Form Button Label
+     * @default Submit
+     */
+    responseFormButtonLabel?: string | Expression<string>;
+    /** Override default styling of the response form with CSS
+     */
+    responseFormCustomCss?: string | Expression<string>;
+  };
+};
+
+export type SlackV25MessageSendAndWaitOutput = {
+  data?: {
+    approved?: boolean;
+  };
+};
+
+export type SlackV25MessageSendAndWaitNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25MessageSendAndWaitParams>;
+  output?: Items<SlackV25MessageSendAndWaitOutput>;
+};

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

@@ -0,0 +1,29 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=message, 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, resolveSchema }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('message').default('message'),
+      operation: z.literal('update'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      channelId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id'), z.literal('url')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      ts: numberOrExpression,
+      messageType: z.union([z.literal('text'), z.literal('block'), z.literal('attachment'), expressionSchema]).optional(),
+      blocksUi: resolveSchema({ parameters, schema: stringOrExpression, required: true, displayOptions: {"show":{"messageType":["block"]}}, defaults: {"messageType":"text"} }),
+      text: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"messageType":["block","text"]}}, defaults: {"messageType":"text"} }),
+      updateFields: z.object({ link_names: booleanOrExpression.optional(), parse: z.union([z.literal('client'), z.literal('full'), z.literal('none'), expressionSchema]).optional() }).optional(),
+      otherOptions: z.object({ includeLinkToWorkflow: booleanOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};

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

@@ -0,0 +1,127 @@
+/**
+ * Slack Node - Version 2.5
+ * Discriminator: resource=message, operation=update
+ */
+
+
+interface Credentials {
+  slackApi: CredentialReference;
+  slackOAuth2Api: CredentialReference;
+}
+
+export type SlackV25MessageUpdateParams = {
+  resource: 'message';
+  operation: 'update';
+  authentication?: 'accessToken' | 'oAuth2' | Expression<string>;
+/**
+ * The Slack channel to update the message from
+ * @searchListMethod getChannels
+ * @default {"mode":"list","value":""}
+ */
+    channelId?: { __rl: true; mode: 'list' | 'id' | 'url'; value: string; cachedResultName?: string };
+/**
+ * Timestamp of the message to update
+ */
+    ts: number | Expression<number>;
+/**
+ * Whether to send a simple text message, or use Slack’s Blocks UI builder for more sophisticated messages that include form fields, sections and more
+ * @default text
+ */
+    messageType?: 'text' | 'block' | 'attachment' | Expression<string>;
+/**
+ * Enter the JSON output from Slack's visual Block Kit Builder here. You can then use expressions to add variable content to your blocks. To create blocks, use &lt;a target='_blank' href='https://app.slack.com/block-kit-builder'&gt;Slack's Block Kit Builder&lt;/a&gt;
+ * @hint To create blocks, use &lt;a target='_blank' href='https://app.slack.com/block-kit-builder'&gt;Slack's Block Kit Builder&lt;/a&gt;
+ * @displayOptions.show { messageType: ["block"] }
+ */
+    blocksUi: string | Expression<string>;
+/**
+ * Fallback text to display in slack notifications. Supports &lt;a href="https://api.slack.com/reference/surfaces/formatting"&gt;markdown&lt;/a&gt; by default - this can be disabled in "Options".
+ * @displayOptions.show { messageType: ["block", "text"] }
+ */
+    text?: string | Expression<string>;
+/**
+ * Update Fields
+ * @default {}
+ */
+    updateFields?: {
+    /** Whether to find and link channel names and usernames
+     * @default false
+     */
+    link_names?: boolean | Expression<boolean>;
+    /** Change how messages are treated
+     * @default client
+     */
+    parse?: 'client' | 'full' | 'none' | Expression<string>;
+  };
+/**
+ * Other options to set
+ * @default {}
+ */
+    otherOptions?: {
+    /** Whether to append a link to this workflow at the end of the message. This is helpful if you have many workflows sending Slack messages.
+     * @default true
+     */
+    includeLinkToWorkflow?: boolean | Expression<boolean>;
+  };
+};
+
+export type SlackV25MessageUpdateOutput = {
+  channel?: string;
+  message?: {
+    app_id?: string;
+    blocks?: Array<{
+      block_id?: string;
+      elements?: Array<{
+        elements?: Array<{
+          style?: {
+            bold?: boolean;
+            italic?: boolean;
+          };
+          text?: string;
+          type?: string;
+          url?: string;
+        }>;
+        type?: string;
+      }>;
+      text?: {
+        text?: string;
+        type?: string;
+        verbatim?: boolean;
+      };
+      type?: string;
+    }>;
+    bot_id?: string;
+    bot_profile?: {
+      app_id?: string;
+      deleted?: boolean;
+      icons?: {
+        image_36?: string;
+        image_48?: string;
+        image_72?: string;
+      };
+      id?: string;
+      name?: string;
+      team_id?: string;
+      updated?: number;
+    };
+    edited?: {
+      ts?: string;
+      user?: string;
+    };
+    team?: string;
+    text?: string;
+    type?: string;
+    user?: string;
+  };
+  message_timestamp?: string;
+  ok?: boolean;
+  text?: string;
+};
+
+export type SlackV25MessageUpdateNode = {
+  type: 'n8n-nodes-base.slack';
+  version: 2.5;
+  credentials?: Credentials;
+  config: NodeConfig<SlackV25MessageUpdateParams>;
+  output?: Items<SlackV25MessageUpdateOutput>;
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_reaction/index.schema.js

@@ -0,0 +1,24 @@
+/**
+ * Slack - Reaction Resource - Zod Schema Factory
+ * Exports a factory that unions all operation schemas for this resource.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getAddSchema = require('./operation_add.schema');
+const getGetSchema = require('./operation_get.schema');
+const getRemoveSchema = require('./operation_remove.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'create' } : parameters;
+  return z.union([
+    getAddSchema({ ...helpers, parameters: effectiveParams }),
+    getGetSchema({ ...helpers, parameters: effectiveParams }),
+    getRemoveSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_reaction/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Slack - Reaction Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { SlackV25ReactionAddNode } from './operation_add';
+import type { SlackV25ReactionGetNode } from './operation_get';
+import type { SlackV25ReactionRemoveNode } from './operation_remove';
+
+export * from './operation_add';
+export * from './operation_get';
+export * from './operation_remove';
+
+export type SlackV25ReactionNode =
+  | SlackV25ReactionAddNode
+  | SlackV25ReactionGetNode
+  | SlackV25ReactionRemoveNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-base/slack/v25/resource_reaction/operation_add.schema.js

@@ -0,0 +1,25 @@
+/**
+ * Slack Node - Version 2.5 - Zod Schema
+ * Discriminator: resource=reaction, operation=add
+ *
+ * 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('reaction'),
+      operation: z.literal('add'),
+      authentication: z.union([z.literal('accessToken'), z.literal('oAuth2'), expressionSchema]).optional(),
+      channelId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id'), z.literal('url')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      timestamp: numberOrExpression,
+      name: stringOrExpression,
+    }).optional(),
+  });
+};