@n8n/n8n-nodes-langchain 2.18.1 → 2.18.3

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/index.ts

@@ -0,0 +1,21 @@
+/**
+ * MiniMax Node - Version 1
+ * Re-exports all discriminator combinations.
+ */
+
+import type { LcMinimaxV1AudioNode } from './resource_audio';
+import type { LcMinimaxV1ImageNode } from './resource_image';
+import type { LcMinimaxV1TextNode } from './resource_text';
+import type { LcMinimaxV1VideoNode } from './resource_video';
+
+export * from './resource_audio';
+export * from './resource_image';
+export * from './resource_text';
+export * from './resource_video';
+
+export type LcMinimaxV1Node =
+  | LcMinimaxV1AudioNode
+  | LcMinimaxV1ImageNode
+  | LcMinimaxV1TextNode
+  | LcMinimaxV1VideoNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_audio/index.schema.js

@@ -0,0 +1,18 @@
+/**
+ * MiniMax - Audio 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 getTextToSpeechSchema = require('./operation_text_to_speech.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'textToSpeech' } : parameters;
+  return getTextToSpeechSchema({ ...helpers, parameters: effectiveParams });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_audio/index.ts

@@ -0,0 +1,10 @@
+/**
+ * MiniMax - Audio Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcMinimaxV1AudioTextToSpeechNode } from './operation_text_to_speech';
+
+export * from './operation_text_to_speech';
+
+export type LcMinimaxV1AudioNode = LcMinimaxV1AudioTextToSpeechNode;

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_audio/operation_text_to_speech.schema.js

@@ -0,0 +1,32 @@
+/**
+ * MiniMax Node - Version 1 - Zod Schema
+ * Discriminator: resource=audio, operation=textToSpeech
+ *
+ * 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, toolInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('audio'),
+      operation: z.literal('textToSpeech').default('textToSpeech'),
+      modelId: z.union([z.literal('speech-02-hd'), z.literal('speech-02-turbo'), z.literal('speech-2.6-hd'), z.literal('speech-2.6-turbo'), z.literal('speech-2.8-hd'), z.literal('speech-2.8-turbo'), expressionSchema]).optional(),
+      text: stringOrExpression.optional(),
+      voiceId: stringOrExpression.optional(),
+      downloadAudio: booleanOrExpression.optional(),
+      options: z.object({ audioFormat: z.union([z.literal('mp3'), z.literal('pcm'), z.literal('flac'), z.literal('wav'), expressionSchema]).optional(), emotion: z.union([z.literal('angry'), z.literal('calm'), z.literal('disgusted'), z.literal('fearful'), z.literal('happy'), z.literal('sad'), z.literal('surprised'), expressionSchema]).optional(), languageBoost: z.union([z.literal('Arabic'), z.literal('auto'), z.literal('Chinese'), z.literal('English'), z.literal('French'), z.literal('German'), z.literal('Indonesian'), z.literal('Italian'), z.literal('Japanese'), z.literal('Korean'), z.literal('Portuguese'), z.literal('Russian'), z.literal('Spanish'), z.literal('Thai'), z.literal('Turkish'), z.literal('Vietnamese'), expressionSchema]).optional(), pitch: numberOrExpression.optional(), speed: numberOrExpression.optional(), volume: numberOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_audio/operation_text_to_speech.ts

@@ -0,0 +1,75 @@
+/**
+ * MiniMax Node - Version 1
+ * Discriminator: resource=audio, operation=textToSpeech
+ */
+
+
+interface Credentials {
+  minimaxApi: CredentialReference;
+}
+
+/** Generate speech audio from text input */
+export type LcMinimaxV1AudioTextToSpeechParams = {
+  resource: 'audio';
+  operation: 'textToSpeech';
+/**
+ * The speech synthesis model to use
+ * @default speech-2.8-hd
+ */
+    modelId?: 'speech-02-hd' | 'speech-02-turbo' | 'speech-2.6-hd' | 'speech-2.6-turbo' | 'speech-2.8-hd' | 'speech-2.8-turbo' | Expression<string>;
+/**
+ * The text to convert to speech (max 10,000 characters)
+ */
+    text?: string | Expression<string> | PlaceholderValue;
+/**
+ * Voice ID to use for speech synthesis. Browse available voices in the &lt;a href="https://platform.minimax.io/docs/faq/system-voice-id"&gt;MiniMax documentation&lt;/a&gt;.
+ * @default English_Graceful_Lady
+ */
+    voiceId?: string | Expression<string> | PlaceholderValue;
+/**
+ * Whether to download the generated audio as binary data. When disabled, only the audio URL is returned.
+ * @default true
+ */
+    downloadAudio?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Output audio format. WAV is only supported in non-streaming mode.
+     * @default mp3
+     */
+    audioFormat?: 'mp3' | 'pcm' | 'flac' | 'wav' | Expression<string>;
+    /** Emotion for synthesized speech. By default the model auto-selects the most natural emotion.
+     * @default calm
+     */
+    emotion?: 'angry' | 'calm' | 'disgusted' | 'fearful' | 'happy' | 'sad' | 'surprised' | Expression<string>;
+    /** Enhance recognition for a specific language
+     * @default auto
+     */
+    languageBoost?: 'Arabic' | 'auto' | 'Chinese' | 'English' | 'French' | 'German' | 'Indonesian' | 'Italian' | 'Japanese' | 'Korean' | 'Portuguese' | 'Russian' | 'Spanish' | 'Thai' | 'Turkish' | 'Vietnamese' | Expression<string>;
+    /** Speech pitch adjustment (-12 to 12, 0 = original pitch)
+     * @default 0
+     */
+    pitch?: number | Expression<number>;
+    /** Speech speed (0.5-2, higher = faster)
+     * @default 1
+     */
+    speed?: number | Expression<number>;
+    /** Speech volume (0.1-10, higher = louder)
+     * @default 1
+     */
+    volume?: number | Expression<number>;
+  };
+};
+
+export interface LcMinimaxV1AudioTextToSpeechSubnodeConfig {
+  tools?: ToolInstance[];
+}
+
+export type LcMinimaxV1AudioTextToSpeechNode = {
+  type: '@n8n/n8n-nodes-langchain.minimax';
+  version: 1;
+  credentials?: Credentials;
+  config: NodeConfig<LcMinimaxV1AudioTextToSpeechParams> & { subnodes?: LcMinimaxV1AudioTextToSpeechSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_image/index.schema.js

@@ -0,0 +1,18 @@
+/**
+ * MiniMax - Image 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 getGenerateSchema = require('./operation_generate.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'textToSpeech' } : parameters;
+  return getGenerateSchema({ ...helpers, parameters: effectiveParams });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_image/index.ts

@@ -0,0 +1,10 @@
+/**
+ * MiniMax - Image Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcMinimaxV1ImageGenerateNode } from './operation_generate';
+
+export * from './operation_generate';
+
+export type LcMinimaxV1ImageNode = LcMinimaxV1ImageGenerateNode;

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_image/operation_generate.schema.js

@@ -0,0 +1,33 @@
+/**
+ * MiniMax Node - Version 1 - Zod Schema
+ * Discriminator: resource=image, operation=generate
+ *
+ * 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, toolInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('image'),
+      operation: z.literal('generate'),
+      modelId: z.union([z.literal('image-01'), expressionSchema]).optional(),
+      prompt: stringOrExpression.optional(),
+      aspectRatio: z.union([z.literal('1:1'), z.literal('16:9'), z.literal('2:3'), z.literal('21:9'), z.literal('3:2'), z.literal('3:4'), z.literal('4:3'), z.literal('9:16'), expressionSchema]).optional(),
+      numberOfImages: numberOrExpression.optional(),
+      downloadImage: booleanOrExpression.optional(),
+      options: z.object({ promptOptimizer: booleanOrExpression.optional(), seed: numberOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_image/operation_generate.ts

@@ -0,0 +1,64 @@
+/**
+ * MiniMax Node - Version 1
+ * Discriminator: resource=image, operation=generate
+ */
+
+
+interface Credentials {
+  minimaxApi: CredentialReference;
+}
+
+/** Create an image from a text prompt */
+export type LcMinimaxV1ImageGenerateParams = {
+  resource: 'image';
+  operation: 'generate';
+/**
+ * The model to use for image generation
+ * @default image-01
+ */
+    modelId?: 'image-01' | Expression<string>;
+/**
+ * Text description of the image to generate (max 1500 characters)
+ */
+    prompt?: string | Expression<string> | PlaceholderValue;
+/**
+ * Aspect ratio of the generated image
+ * @default 1:1
+ */
+    aspectRatio?: '1:1' | '16:9' | '2:3' | '21:9' | '3:2' | '3:4' | '4:3' | '9:16' | Expression<string>;
+/**
+ * Number of images to generate per request (1-9)
+ * @default 1
+ */
+    numberOfImages?: number | Expression<number>;
+/**
+ * Whether to download the generated image as binary data. When disabled, only the image URL is returned.
+ * @default true
+ */
+    downloadImage?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to automatically optimize the prompt for better results
+     * @default false
+     */
+    promptOptimizer?: boolean | Expression<boolean>;
+    /** Random seed for reproducible outputs. Using the same seed and parameters produces the same image.
+     * @default 0
+     */
+    seed?: number | Expression<number>;
+  };
+};
+
+export interface LcMinimaxV1ImageGenerateSubnodeConfig {
+  tools?: ToolInstance[];
+}
+
+export type LcMinimaxV1ImageGenerateNode = {
+  type: '@n8n/n8n-nodes-langchain.minimax';
+  version: 1;
+  credentials?: Credentials;
+  config: NodeConfig<LcMinimaxV1ImageGenerateParams> & { subnodes?: LcMinimaxV1ImageGenerateSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_text/index.schema.js

@@ -0,0 +1,18 @@
+/**
+ * MiniMax - Text 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 getMessageSchema = require('./operation_message.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'textToSpeech' } : parameters;
+  return getMessageSchema({ ...helpers, parameters: effectiveParams });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_text/index.ts

@@ -0,0 +1,10 @@
+/**
+ * MiniMax - Text Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcMinimaxV1TextMessageNode } from './operation_message';
+
+export * from './operation_message';
+
+export type LcMinimaxV1TextNode = LcMinimaxV1TextMessageNode;

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_text/operation_message.schema.js

@@ -0,0 +1,31 @@
+/**
+ * MiniMax Node - Version 1 - Zod Schema
+ * Discriminator: resource=text, operation=message
+ *
+ * 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, toolInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('text').default('text'),
+      operation: z.literal('message'),
+      modelId: z.union([z.literal('MiniMax-M2'), z.literal('MiniMax-M2.1'), z.literal('MiniMax-M2.1-highspeed'), z.literal('MiniMax-M2.5'), z.literal('MiniMax-M2.5-highspeed'), z.literal('MiniMax-M2.7'), z.literal('MiniMax-M2.7-highspeed'), expressionSchema]).optional(),
+      messages: z.object({ values: z.array(z.object({ content: stringOrExpression.optional(), role: z.union([z.literal('user'), z.literal('assistant'), expressionSchema]).optional() })).optional() }).optional(),
+      simplify: booleanOrExpression.optional(),
+      options: z.object({ hideThinking: booleanOrExpression.optional(), maxTokens: numberOrExpression.optional(), maxToolsIterations: numberOrExpression.optional(), temperature: numberOrExpression.optional(), topP: numberOrExpression.optional(), system: stringOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_text/operation_message.ts

@@ -0,0 +1,82 @@
+/**
+ * MiniMax Node - Version 1
+ * Discriminator: resource=text, operation=message
+ */
+
+
+interface Credentials {
+  minimaxApi: CredentialReference;
+}
+
+/** Send a message and get a response from a MiniMax model */
+export type LcMinimaxV1TextMessageParams = {
+  resource: 'text';
+  operation: 'message';
+/**
+ * The model to use for generating the response
+ * @default MiniMax-M2.7
+ */
+    modelId?: 'MiniMax-M2' | 'MiniMax-M2.1' | 'MiniMax-M2.1-highspeed' | 'MiniMax-M2.5' | 'MiniMax-M2.5-highspeed' | 'MiniMax-M2.7' | 'MiniMax-M2.7-highspeed' | Expression<string>;
+/**
+ * Messages
+ * @default {"values":[{"content":"","role":"user"}]}
+ */
+    messages?: {
+        /** Values
+     */
+    values?: Array<{
+      /** The content of the message to be sent
+       */
+      content?: string | Expression<string> | PlaceholderValue;
+      /** Role in shaping the model's response, it tells the model how it should behave and interact with the user
+       * @default user
+       */
+      role?: 'user' | 'assistant' | Expression<string>;
+    }>;
+  };
+/**
+ * Whether to return a simplified version of the response instead of the raw data
+ * @default true
+ */
+    simplify?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to strip chain-of-thought reasoning from the response, returning only the final answer
+     * @default true
+     */
+    hideThinking?: boolean | Expression<boolean>;
+    /** The maximum number of tokens to generate in the completion
+     * @default 1024
+     */
+    maxTokens?: number | Expression<number>;
+    /** The maximum number of tool iteration cycles the LLM will run before stopping. A single iteration can contain multiple tool calls. Set to 0 for no limit.
+     * @default 15
+     */
+    maxToolsIterations?: number | Expression<number>;
+    /** Controls the randomness of the output. Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.
+     * @default 0.7
+     */
+    temperature?: number | Expression<number>;
+    /** The maximum cumulative probability of tokens to consider when sampling
+     * @default 0.95
+     */
+    topP?: number | Expression<number>;
+    /** System Message
+     */
+    system?: string | Expression<string> | PlaceholderValue;
+  };
+};
+
+export interface LcMinimaxV1TextMessageSubnodeConfig {
+  tools?: ToolInstance[];
+}
+
+export type LcMinimaxV1TextMessageNode = {
+  type: '@n8n/n8n-nodes-langchain.minimax';
+  version: 1;
+  credentials?: Credentials;
+  config: NodeConfig<LcMinimaxV1TextMessageParams> & { subnodes?: LcMinimaxV1TextMessageSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_video/index.schema.js

@@ -0,0 +1,22 @@
+/**
+ * MiniMax - Video 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 getImageToVideoSchema = require('./operation_image_to_video.schema');
+const getTextToVideoSchema = require('./operation_text_to_video.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'textToSpeech' } : parameters;
+  return z.union([
+    getImageToVideoSchema({ ...helpers, parameters: effectiveParams }),
+    getTextToVideoSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_video/index.ts

@@ -0,0 +1,15 @@
+/**
+ * MiniMax - Video Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcMinimaxV1VideoImageToVideoNode } from './operation_image_to_video';
+import type { LcMinimaxV1VideoTextToVideoNode } from './operation_text_to_video';
+
+export * from './operation_image_to_video';
+export * from './operation_text_to_video';
+
+export type LcMinimaxV1VideoNode =
+  | LcMinimaxV1VideoImageToVideoNode
+  | LcMinimaxV1VideoTextToVideoNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_video/operation_image_to_video.schema.js

@@ -0,0 +1,36 @@
+/**
+ * MiniMax Node - Version 1 - Zod Schema
+ * Discriminator: resource=video, operation=imageToVideo
+ *
+ * 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, toolInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('video'),
+      operation: z.literal('imageToVideo'),
+      modelId: z.union([z.literal('I2V-01'), z.literal('I2V-01-Director'), z.literal('I2V-01-live'), z.literal('MiniMax-Hailuo-02'), z.literal('MiniMax-Hailuo-2.3'), z.literal('MiniMax-Hailuo-2.3-Fast'), expressionSchema]).optional(),
+      imageInputType: z.union([z.literal('url'), z.literal('binary'), expressionSchema]).optional(),
+      imageUrl: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"imageInputType":["url"]}}, defaults: {"imageInputType":"url"} }),
+      binaryPropertyName: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"imageInputType":["binary"]}}, defaults: {"imageInputType":"url"} }),
+      prompt: stringOrExpression.optional(),
+      duration: z.union([z.literal(6), z.literal(10), expressionSchema]).optional(),
+      resolution: z.union([z.literal('512P'), z.literal('720P'), z.literal('768P'), z.literal('1080P'), expressionSchema]).optional(),
+      downloadVideo: booleanOrExpression.optional(),
+      options: z.object({ promptOptimizer: booleanOrExpression.optional(), lastFrameInputType: z.union([z.literal('none'), z.literal('url'), z.literal('binary'), expressionSchema]).optional(), lastFrameImageUrl: stringOrExpression.optional(), lastFrameBinaryPropertyName: stringOrExpression.optional(), subjectReferenceInputType: z.union([z.literal('none'), z.literal('url'), z.literal('binary'), expressionSchema]).optional(), subjectReferenceImageUrl: stringOrExpression.optional(), subjectReferenceBinaryPropertyName: stringOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_video/operation_image_to_video.ts

@@ -0,0 +1,103 @@
+/**
+ * MiniMax Node - Version 1
+ * Discriminator: resource=video, operation=imageToVideo
+ */
+
+
+interface Credentials {
+  minimaxApi: CredentialReference;
+}
+
+/** Generate a video from an image, with optional last frame and subject reference */
+export type LcMinimaxV1VideoImageToVideoParams = {
+  resource: 'video';
+  operation: 'imageToVideo';
+/**
+ * The model to use for video generation
+ * @default MiniMax-Hailuo-2.3
+ */
+    modelId?: 'I2V-01' | 'I2V-01-Director' | 'I2V-01-live' | 'MiniMax-Hailuo-02' | 'MiniMax-Hailuo-2.3' | 'MiniMax-Hailuo-2.3-Fast' | Expression<string>;
+/**
+ * How to provide the first frame image
+ * @default url
+ */
+    imageInputType?: 'url' | 'binary' | Expression<string>;
+/**
+ * Public URL of the image to use as first frame (JPG, JPEG, PNG, WebP, &lt;20MB)
+ * @displayOptions.show { imageInputType: ["url"] }
+ */
+    imageUrl?: string | Expression<string> | PlaceholderValue;
+/**
+ * Input Data Field Name
+ * @hint The name of the input field containing the binary image data
+ * @displayOptions.show { imageInputType: ["binary"] }
+ * @default data
+ */
+    binaryPropertyName?: string | Expression<string> | PlaceholderValue;
+/**
+ * Optional text description of the video (max 2000 characters). Camera movements can be controlled using [command] syntax.
+ */
+    prompt?: string | Expression<string> | PlaceholderValue;
+/**
+ * Duration of the generated video
+ * @default 6
+ */
+    duration?: 6 | 10 | Expression<number>;
+/**
+ * Resolution of the generated video. Available options depend on the model.
+ * @default 768P
+ */
+    resolution?: '512P' | '720P' | '768P' | '1080P' | Expression<string>;
+/**
+ * Whether to download the generated video as binary data. When disabled, only the video URL is returned.
+ * @default true
+ */
+    downloadVideo?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Whether to automatically optimize the prompt
+     * @default true
+     */
+    promptOptimizer?: boolean | Expression<boolean>;
+    /** Provide a last frame image to generate a first-and-last-frame video. Only supported by MiniMax-Hailuo-2.3 and MiniMax-Hailuo-02.
+     * @default none
+     */
+    lastFrameInputType?: 'none' | 'url' | 'binary' | Expression<string>;
+    /** Last Frame Image URL
+     * @displayOptions.show { lastFrameInputType: ["url"] }
+     */
+    lastFrameImageUrl?: string | Expression<string> | PlaceholderValue;
+    /** Last Frame Data Field Name
+     * @displayOptions.show { lastFrameInputType: ["binary"] }
+     * @default lastFrame
+     */
+    lastFrameBinaryPropertyName?: string | Expression<string> | PlaceholderValue;
+    /** Provide a face photo for facial consistency in the generated video. Only supported by MiniMax-Hailuo-2.3.
+     * @default none
+     */
+    subjectReferenceInputType?: 'none' | 'url' | 'binary' | Expression<string>;
+    /** Subject Reference Image URL
+     * @displayOptions.show { subjectReferenceInputType: ["url"] }
+     */
+    subjectReferenceImageUrl?: string | Expression<string> | PlaceholderValue;
+    /** Subject Reference Data Field Name
+     * @displayOptions.show { subjectReferenceInputType: ["binary"] }
+     * @default subjectReference
+     */
+    subjectReferenceBinaryPropertyName?: string | Expression<string> | PlaceholderValue;
+  };
+};
+
+export interface LcMinimaxV1VideoImageToVideoSubnodeConfig {
+  tools?: ToolInstance[];
+}
+
+export type LcMinimaxV1VideoImageToVideoNode = {
+  type: '@n8n/n8n-nodes-langchain.minimax';
+  version: 1;
+  credentials?: Credentials;
+  config: NodeConfig<LcMinimaxV1VideoImageToVideoParams> & { subnodes?: LcMinimaxV1VideoImageToVideoSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/minimax/v1/resource_video/operation_text_to_video.schema.js

@@ -0,0 +1,33 @@
+/**
+ * MiniMax Node - Version 1 - Zod Schema
+ * Discriminator: resource=video, operation=textToVideo
+ *
+ * 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, toolInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('video'),
+      operation: z.literal('textToVideo'),
+      modelId: z.union([z.literal('MiniMax-Hailuo-2.3'), z.literal('MiniMax-Hailuo-02'), z.literal('T2V-01-Director'), z.literal('T2V-01'), expressionSchema]).optional(),
+      prompt: stringOrExpression.optional(),
+      duration: z.union([z.literal(6), z.literal(10), expressionSchema]).optional(),
+      resolution: z.union([z.literal('720P'), z.literal('768P'), z.literal('1080P'), expressionSchema]).optional(),
+      downloadVideo: booleanOrExpression.optional(),
+      options: z.object({ promptOptimizer: booleanOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};