n8n-nodes-base 2.43.1 → 2.44.0

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

@@ -4,12 +4,14 @@
  * Re-exports all version-specific types and provides combined union type.
  */
 
+import type { IfV24Node } from './v24';
 import type { IfV23Node } from './v23';
 import type { IfV22Node } from './v22';
 import type { IfV21Node } from './v21';
 import type { IfV2Node } from './v2';
 import type { IfV1Node } from './v1';
 
+export * from './v24';
 export * from './v23';
 export * from './v22';
 export * from './v21';
@@ -17,4 +19,4 @@ export * from './v2';
 export * from './v1';
 
 // Combined union type for all versions
-export type IfNode = IfV23Node | IfV22Node | IfV21Node | IfV2Node | IfV1Node;
+export type IfNode = IfV24Node | IfV23Node | IfV22Node | IfV21Node | IfV2Node | IfV1Node;

package/dist/node-definitions/nodes/n8n-nodes-base/if/v24.schema.js

@@ -0,0 +1,26 @@
+/**
+ * If Node - Version 2.4 - 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 }) {
+
+  // Parameters schema
+  const parametersSchema = z.object({
+    conditions: filterValueSchema.optional(),
+    looseTypeValidation: booleanOrExpression.optional(),
+    options: z.object({ ignoreCase: booleanOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/if/v24.ts

@@ -0,0 +1,45 @@
+/**
+ * If Node - Version 2.4
+ * Route items to different branches (true/false)
+ */
+
+
+// Helper types for special n8n fields
+type FilterOptionsValue = { caseSensitive?: boolean; leftValue?: string; typeValidation?: 'strict' | 'loose' };
+type FilterConditionValue = { id?: string; leftValue: unknown; operator: { type: string; operation: string }; rightValue: unknown };
+type FilterValue = { options: FilterOptionsValue; conditions: FilterConditionValue[]; combinator: 'and' | 'or' };
+
+export interface IfV24Params {
+/**
+ * Conditions
+ * @builderHint Must always contain these three sibling keys:
+- combinator: 'and' or 'or', default to 'and'
+- conditions: [ a list of condition objects ]
+- options: { caseSensitive: true, leftValue: '', typeValidation: 'strict', version: 1 }
+e.g.: { combinator: 'and', options: { caseSensitive: true, leftValue: '', typeValidation: 'strict', version: 2 }, conditions: [{ leftValue: expr('{{ $json.field }}'), rightValue: 'value', operator: { type: 'string', operation: 'equals' } }] }
+ * @default {}
+ */
+    conditions?: FilterValue;
+/**
+ * If the type of an expression doesn't match the type of the comparison, n8n will try to cast the expression to the required type. E.g. for booleans <code>"false"</code> or <code>0</code> will be cast to <code>false</code>
+ * @default false
+ */
+    looseTypeValidation?: boolean | Expression<boolean>;
+  options?: {
+    /** Whether to ignore letter case when evaluating conditions
+     * @default true
+     */
+    ignoreCase?: boolean | Expression<boolean>;
+  };
+}
+
+interface IfV24NodeBase {
+  type: 'n8n-nodes-base.if';
+  version: 2.4;
+}
+
+export type IfV24ParamsNode = IfV24NodeBase & {
+  config: NodeConfig<IfV24Params>;
+};
+
+export type IfV24Node = IfV24ParamsNode;

package/dist/node-definitions/nodes/n8n-nodes-base/jinaAi/v1/resource_reader/operation_read.ts

@@ -137,6 +137,9 @@ export type JinaAiV1ReaderReadOutput = {
   title?: string;
   url?: string;
   usage?: {
+    measuredTokens?: number;
+    outputTokens?: number;
+    scaledTokens?: number;
     tokens?: number;
   };
 };

package/dist/node-definitions/nodes/n8n-nodes-base/jinaAi/v1/resource_research/operation_deep_research.ts

@@ -71,8 +71,27 @@ export type JinaAiV1ResearchDeepResearchParams = {
   };
 };
 
+export type JinaAiV1ResearchDeepResearchOutput = {
+  annotations?: Array<{
+    type?: string;
+    url_citation?: {
+      dateTime?: string;
+      exactQuote?: string;
+      title?: string;
+      url?: string;
+    };
+  }>;
+  content?: string;
+  usage?: {
+    completion_tokens?: number;
+    prompt_tokens?: number;
+    total_tokens?: number;
+  };
+};
+
 export type JinaAiV1ResearchDeepResearchNode = {
   type: 'n8n-nodes-base.jinaAi';
   version: 1;
   config: NodeConfig<JinaAiV1ResearchDeepResearchParams> & { credentials?: Credentials };
+  output?: Items<JinaAiV1ResearchDeepResearchOutput>;
 };

package/dist/node-definitions/nodes/n8n-nodes-base/jira/v1/resource_issue/operation_get.ts

@@ -108,6 +108,7 @@ export type JiraV1IssueGetOutput = {
       content?: string;
       created?: string;
       filename?: string;
+      fixture_path?: string;
       id?: string;
       mimeType?: string;
       self?: string;
@@ -409,6 +410,7 @@ export type JiraV1IssueGetOutput = {
             '48x48'?: string;
           };
           displayName?: string;
+          emailAddress?: string;
           self?: string;
           timeZone?: string;
         };
@@ -431,6 +433,7 @@ export type JiraV1IssueGetOutput = {
             '48x48'?: string;
           };
           displayName?: string;
+          emailAddress?: string;
           self?: string;
           timeZone?: string;
         };

package/dist/node-definitions/nodes/n8n-nodes-base/mailchimp/v1/resource_campaign/operation_send.ts

@@ -20,8 +20,13 @@ export type MailchimpV1CampaignSendParams = {
     campaignId: string | Expression<string>;
 };
 
+export type MailchimpV1CampaignSendOutput = {
+  success?: boolean;
+};
+
 export type MailchimpV1CampaignSendNode = {
   type: 'n8n-nodes-base.mailchimp';
   version: 1;
   config: NodeConfig<MailchimpV1CampaignSendParams> & { credentials?: Credentials };
+  output?: Items<MailchimpV1CampaignSendOutput>;
 };

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

@@ -0,0 +1,18 @@
+/**
+ * Message an Agent Node Types
+ *
+ * Re-exports all version-specific types and provides combined union type.
+ */
+
+import type { MessageAnAgentV31Node } from './v31';
+import type { MessageAnAgentV3Node } from './v3';
+import type { MessageAnAgentV2Node } from './v2';
+import type { MessageAnAgentV1Node } from './v1';
+
+export * from './v31';
+export * from './v3';
+export * from './v2';
+export * from './v1';
+
+// Combined union type for all versions
+export type MessageAnAgentNode = MessageAnAgentV31Node | MessageAnAgentV3Node | MessageAnAgentV2Node | MessageAnAgentV1Node;

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

@@ -0,0 +1,28 @@
+/**
+ * Message an Agent Node - Version 1 - 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({
+    agentId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+    message: stringOrExpression,
+    useStructuredOutput: booleanOrExpression.optional(),
+    outputSchema: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true]}}, defaults: {"useStructuredOutput":false} }),
+    advanced: z.object({ enableStreaming: booleanOrExpression.optional(), invokeMode: z.union([z.literal('allItems'), z.literal('perItem')]).optional(), sessionId: stringOrExpression.optional(), allowOtherNodesData: booleanOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Message an Agent Node - Version 1
+ * Send a message to a n8n agent
+ */
+
+
+export interface MessageAnAgentV1Params {
+/**
+ * The agent to send the message to
+ * @searchListMethod listAgents
+ * @default {"mode":"list","value":""}
+ */
+    agentId?: { __rl: true; mode: 'list' | 'id'; value: string; cachedResultName?: string };
+/**
+ * The message to send to the agent
+ */
+    message: string | Expression<string>;
+/**
+ * Whether to constrain the agent response to a JSON Schema you provide. The conforming object is returned on the "structuredOutput" field.
+ * @default false
+ */
+    useStructuredOutput?: boolean | Expression<boolean>;
+/**
+ * The JSON Schema that the agent response must conform to
+ * @hint Use &lt;a target="_blank" href="https://json-schema.org/"&gt;JSON Schema&lt;/a&gt; format
+ * @displayOptions.show { useStructuredOutput: [true] }
+ */
+    outputSchema?: IDataObject | string | Expression<string>;
+  advanced?: {
+    /** Whether to stream the agent's response as it generates text
+     * @default true
+     */
+    enableStreaming?: boolean | Expression<boolean>;
+    /** Whether to call the agent once per input item or a single time for all items
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default allItems
+     */
+    invokeMode?: 'allItems' | 'perItem';
+    /** Reuse an agent session to keep memory across runs. Leave empty to start a fresh session per execution.
+     */
+    sessionId?: string | Expression<string>;
+    /** Whether to give the agent a tool to read other workflow nodes' execution data, beyond its own input
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default false
+     */
+    allowOtherNodesData?: boolean | Expression<boolean>;
+  };
+}
+
+interface MessageAnAgentV1NodeBase {
+  type: 'n8n-nodes-base.messageAnAgent';
+  version: 1;
+}
+
+export type MessageAnAgentV1ParamsNode = MessageAnAgentV1NodeBase & {
+  config: NodeConfig<MessageAnAgentV1Params>;
+};
+
+export type MessageAnAgentV1Node = MessageAnAgentV1ParamsNode;

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

@@ -0,0 +1,30 @@
+/**
+ * Message an Agent 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({
+    agentSource: z.unknown().optional(),
+    agentId: resolveSchema({ parameters, schema: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]), required: false, displayOptions: {"show":{"agentSource":["referenced"]}}, defaults: {"agentSource":"referenced"} }),
+    inlineAgent: z.unknown().optional(),
+    message: stringOrExpression,
+    useStructuredOutput: booleanOrExpression.optional(),
+    outputSchema: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true]}}, defaults: {"useStructuredOutput":false} }),
+    advanced: z.object({ enableStreaming: booleanOrExpression.optional(), invokeMode: z.union([z.literal('allItems'), z.literal('perItem')]).optional(), sessionId: stringOrExpression.optional(), allowOtherNodesData: booleanOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

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

@@ -0,0 +1,61 @@
+/**
+ * Message an Agent Node - Version 2
+ * Send a message to a n8n agent
+ */
+
+
+export interface MessageAnAgentV2Params {
+  agentSource?: unknown;
+/**
+ * The agent to send the message to
+ * @displayOptions.show { agentSource: ["referenced"] }
+ * @default {"__rl":true,"mode":"list","value":""}
+ */
+    agentId?: { __rl: true; mode: 'list' | 'id'; value: string | number; cachedResultName?: string; cachedResultUrl?: string } | Expression<string>;
+  inlineAgent?: unknown;
+/**
+ * The message to send to the agent
+ */
+    message: string | Expression<string>;
+/**
+ * Whether to constrain the agent response to a JSON Schema you provide. The conforming object is returned on the "structuredOutput" field.
+ * @default false
+ */
+    useStructuredOutput?: boolean | Expression<boolean>;
+/**
+ * The JSON Schema that the agent response must conform to
+ * @hint Use &lt;a target="_blank" href="https://json-schema.org/"&gt;JSON Schema&lt;/a&gt; format
+ * @displayOptions.show { useStructuredOutput: [true] }
+ */
+    outputSchema?: IDataObject | string | Expression<string>;
+  advanced?: {
+    /** Whether to stream the agent's response as it generates text
+     * @default true
+     */
+    enableStreaming?: boolean | Expression<boolean>;
+    /** Whether to call the agent once per input item or a single time for all items
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default allItems
+     */
+    invokeMode?: 'allItems' | 'perItem';
+    /** Reuse an agent session to keep memory across runs. Leave empty to start a fresh session per execution.
+     */
+    sessionId?: string | Expression<string>;
+    /** Whether to give the agent a tool to read other workflow nodes' execution data, beyond its own input
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default false
+     */
+    allowOtherNodesData?: boolean | Expression<boolean>;
+  };
+}
+
+interface MessageAnAgentV2NodeBase {
+  type: 'n8n-nodes-base.messageAnAgent';
+  version: 2;
+}
+
+export type MessageAnAgentV2ParamsNode = MessageAnAgentV2NodeBase & {
+  config: NodeConfig<MessageAnAgentV2Params>;
+};
+
+export type MessageAnAgentV2Node = MessageAnAgentV2ParamsNode;

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

@@ -0,0 +1,32 @@
+/**
+ * Message an Agent Node - Version 3 - 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({
+    agentSource: z.unknown().optional(),
+    agentId: resolveSchema({ parameters, schema: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]), required: false, displayOptions: {"show":{"agentSource":["referenced"]}}, defaults: {"agentSource":"referenced"} }),
+    inlineAgent: z.unknown().optional(),
+    message: stringOrExpression,
+    useStructuredOutput: booleanOrExpression.optional(),
+    schemaType: resolveSchema({ parameters, schema: z.union([z.literal('fromJson'), z.literal('manual')]), required: false, displayOptions: {"show":{"useStructuredOutput":[true]}}, defaults: {"useStructuredOutput":false} }),
+    jsonSchemaExample: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true],"schemaType":["fromJson"]}}, defaults: {"useStructuredOutput":false,"schemaType":"fromJson"} }),
+    outputSchema: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true],"schemaType":["manual"]}}, defaults: {"useStructuredOutput":false,"schemaType":"fromJson"} }),
+    advanced: z.object({ enableStreaming: booleanOrExpression.optional(), invokeMode: z.union([z.literal('allItems'), z.literal('perItem')]).optional(), sessionId: stringOrExpression.optional(), allowOtherNodesData: booleanOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

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

@@ -0,0 +1,72 @@
+/**
+ * Message an Agent Node - Version 3
+ * Send a message to a n8n agent
+ */
+
+
+export interface MessageAnAgentV3Params {
+  agentSource?: unknown;
+/**
+ * The agent to send the message to
+ * @displayOptions.show { agentSource: ["referenced"] }
+ * @default {"__rl":true,"mode":"list","value":""}
+ */
+    agentId?: { __rl: true; mode: 'list' | 'id'; value: string | number; cachedResultName?: string; cachedResultUrl?: string } | Expression<string>;
+  inlineAgent?: unknown;
+/**
+ * The message to send to the agent
+ */
+    message: string | Expression<string>;
+/**
+ * Whether to constrain the agent response to a JSON Schema you provide. The conforming object is returned on the "structuredOutput" field.
+ * @default false
+ */
+    useStructuredOutput?: boolean | Expression<boolean>;
+/**
+ * How to specify the structured output schema
+ * @displayOptions.show { useStructuredOutput: [true] }
+ * @default fromJson
+ */
+    schemaType?: 'fromJson' | 'manual';
+/**
+ * Example JSON object used to generate the output schema
+ * @displayOptions.show { useStructuredOutput: [true], schemaType: ["fromJson"] }
+ */
+    jsonSchemaExample?: IDataObject | string | Expression<string>;
+/**
+ * The JSON Schema that the agent response must conform to
+ * @hint Use &lt;a target="_blank" href="https://json-schema.org/"&gt;JSON Schema&lt;/a&gt; format
+ * @displayOptions.show { useStructuredOutput: [true], schemaType: ["manual"] }
+ */
+    outputSchema?: IDataObject | string | Expression<string>;
+  advanced?: {
+    /** Whether to stream the agent's response as it generates text
+     * @default true
+     */
+    enableStreaming?: boolean | Expression<boolean>;
+    /** Whether to call the agent once per input item or a single time for all items
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default allItems
+     */
+    invokeMode?: 'allItems' | 'perItem';
+    /** Reuse an agent session to keep memory across runs. Leave empty to start a fresh session per execution.
+     */
+    sessionId?: string | Expression<string>;
+    /** Whether to give the agent a tool to read other workflow nodes' execution data, beyond its own input
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default false
+     */
+    allowOtherNodesData?: boolean | Expression<boolean>;
+  };
+}
+
+interface MessageAnAgentV3NodeBase {
+  type: 'n8n-nodes-base.messageAnAgent';
+  version: 3;
+}
+
+export type MessageAnAgentV3ParamsNode = MessageAnAgentV3NodeBase & {
+  config: NodeConfig<MessageAnAgentV3Params>;
+};
+
+export type MessageAnAgentV3Node = MessageAnAgentV3ParamsNode;

package/dist/node-definitions/nodes/n8n-nodes-base/messageAnAgent/v31.schema.js

@@ -0,0 +1,32 @@
+/**
+ * Message an Agent Node - Version 3.1 - 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({
+    agentSource: z.unknown().optional(),
+    agentId: resolveSchema({ parameters, schema: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]), required: false, displayOptions: {"show":{"agentSource":["referenced"]}}, defaults: {"agentSource":"referenced"} }),
+    inlineAgent: z.unknown().optional(),
+    message: stringOrExpression,
+    useStructuredOutput: booleanOrExpression.optional(),
+    schemaType: resolveSchema({ parameters, schema: z.union([z.literal('fromJson'), z.literal('manual')]), required: false, displayOptions: {"show":{"useStructuredOutput":[true]}}, defaults: {"useStructuredOutput":false} }),
+    jsonSchemaExample: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true],"schemaType":["fromJson"]}}, defaults: {"useStructuredOutput":false,"schemaType":"fromJson"} }),
+    outputSchema: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"useStructuredOutput":[true],"schemaType":["manual"]}}, defaults: {"useStructuredOutput":false,"schemaType":"fromJson"} }),
+    advanced: z.object({ enableStreaming: booleanOrExpression.optional(), invokeMode: z.union([z.literal('allItems'), z.literal('perItem')]).optional(), session: z.object({ session: z.object({ sessionIdType: z.union([z.literal('fromInput'), z.literal('customKey'), expressionSchema]).optional(), sessionKey: stringOrExpression.optional() }).optional() }).optional(), allowOtherNodesData: booleanOrExpression.optional() }).optional(),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

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

@@ -0,0 +1,87 @@
+/**
+ * Message an Agent Node - Version 3.1
+ * Send a message to a n8n agent
+ */
+
+
+export interface MessageAnAgentV31Params {
+  agentSource?: unknown;
+/**
+ * The agent to send the message to
+ * @displayOptions.show { agentSource: ["referenced"] }
+ * @default {"__rl":true,"mode":"list","value":""}
+ */
+    agentId?: { __rl: true; mode: 'list' | 'id'; value: string | number; cachedResultName?: string; cachedResultUrl?: string } | Expression<string>;
+  inlineAgent?: unknown;
+/**
+ * The message to send to the agent
+ */
+    message: string | Expression<string>;
+/**
+ * Whether to constrain the agent response to a JSON Schema you provide. The conforming object is returned on the "structuredOutput" field.
+ * @default false
+ */
+    useStructuredOutput?: boolean | Expression<boolean>;
+/**
+ * How to specify the structured output schema
+ * @displayOptions.show { useStructuredOutput: [true] }
+ * @default fromJson
+ */
+    schemaType?: 'fromJson' | 'manual';
+/**
+ * Example JSON object used to generate the output schema
+ * @displayOptions.show { useStructuredOutput: [true], schemaType: ["fromJson"] }
+ */
+    jsonSchemaExample?: IDataObject | string | Expression<string>;
+/**
+ * The JSON Schema that the agent response must conform to
+ * @hint Use &lt;a target="_blank" href="https://json-schema.org/"&gt;JSON Schema&lt;/a&gt; format
+ * @displayOptions.show { useStructuredOutput: [true], schemaType: ["manual"] }
+ */
+    outputSchema?: IDataObject | string | Expression<string>;
+  advanced?: {
+    /** Whether to stream the agent's response as it generates text
+     * @default true
+     */
+    enableStreaming?: boolean | Expression<boolean>;
+    /** Whether to call the agent once per input item or a single time for all items
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default allItems
+     */
+    invokeMode?: 'allItems' | 'perItem';
+    /** Session
+     * @default {"session":{}}
+     */
+    session?: {
+        /** Session
+     */
+    session?: {
+      /** Session ID
+       * @default fromInput
+       */
+      sessionIdType?: 'fromInput' | 'customKey' | Expression<string>;
+      /** Session Key From Previous Node
+       * @displayOptions.show { sessionIdType: ["fromInput", "customKey"] }
+       * @default ={{ $json.sessionId }}
+       */
+      sessionKey?: string | Expression<string>;
+    };
+  };
+    /** Whether to give the agent a tool to read other workflow nodes' execution data, beyond its own input
+     * @displayOptions.hide { /agentSource: ["inline"] }
+     * @default false
+     */
+    allowOtherNodesData?: boolean | Expression<boolean>;
+  };
+}
+
+interface MessageAnAgentV31NodeBase {
+  type: 'n8n-nodes-base.messageAnAgent';
+  version: 3.1;
+}
+
+export type MessageAnAgentV31ParamsNode = MessageAnAgentV31NodeBase & {
+  config: NodeConfig<MessageAnAgentV31Params>;
+};
+
+export type MessageAnAgentV31Node = MessageAnAgentV31ParamsNode;

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftOutlook/v2/resource_draft/operation_get.ts

@@ -67,6 +67,12 @@ export type MicrosoftOutlookV2DraftGetOutput = {
   hasAttachments?: boolean;
   id?: string;
   subject?: string;
+  toRecipients?: Array<{
+    emailAddress?: {
+      address?: string;
+      name?: string;
+    };
+  }>;
 };
 
 export type MicrosoftOutlookV2DraftGetNode = {

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftOutlook/v2/resource_event/operation_create.ts

@@ -33,12 +33,12 @@ export type MicrosoftOutlookV2EventCreateParams = {
     subject: string | Expression<string>;
 /**
  * Start
- * @default 2026-10-09T07:16:48.839+00:00
+ * @default 2026-10-13T07:14:58.351+00:00
  */
     startDateTime?: string | Expression<string>;
 /**
  * End
- * @default 2026-10-09T07:46:48.839+00:00
+ * @default 2026-10-13T07:44:58.351+00:00
  */
     endDateTime?: string | Expression<string>;
 /**

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftOutlook/v2/resource_folder/operation_create.ts

@@ -48,6 +48,7 @@ export type MicrosoftOutlookV2FolderCreateOutput = {
   sizeInBytes?: number;
   totalItemCount?: number;
   unreadItemCount?: number;
+  wellKnownName?: null;
 };
 
 export type MicrosoftOutlookV2FolderCreateNode = {

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

@@ -0,0 +1,12 @@
+/**
+ * Microsoft SharePoint Trigger Node Types
+ *
+ * Re-exports all version-specific types and provides combined union type.
+ */
+
+import type { MicrosoftSharePointTriggerV1Node } from './v1';
+
+export * from './v1';
+
+// Combined union type for all versions
+export type MicrosoftSharePointTriggerNode = MicrosoftSharePointTriggerV1Node;