@limetech/n8n-nodes-lime 3.11.0-dev.1 → 3.11.0

package/nodes/index.ts

@@ -3,3 +3,4 @@ export * from './lime-crm';
 export * from './modules';
 export * from './lime-forms';
 export * from './limeHeaders';
+export * from './lime-marketing';

package/nodes/lime-crm/resources/data/index.ts

@@ -24,7 +24,6 @@ const moduleHandler = new N8NOperationModuleHandler([
     operations.bulkCreateManyObjects,
     operations.bulkUpdateManyObjects,
     operations.bulkCreateOrUpdateManyObjects,
-    operations.iterateCsv,
 ]);
 
 /**
@@ -141,9 +140,6 @@ export async function dataOperations(
                 );
             return result && { json: result };
         }
-        case 'iterateCsv': {
-            return await operations.iterateCsv.execute.call(this, i);
-        }
     }
 
     throw new NodeOperationError(

package/nodes/lime-crm/resources/data/operations/index.ts

@@ -34,7 +34,3 @@ export * as bulkUpdateManyObjects from './bulkUpdateManyObjects.operation';
  * @group Resources
  */
 export * as bulkCreateOrUpdateManyObjects from './bulkCreateOrUpdateManyObjects.operation';
-/**
- * @group Resources
- */
-export * as iterateCsv from './iterateCsv';

package/nodes/lime-crm/transport/commons.ts

@@ -83,7 +83,7 @@ interface LimeAPIArguments {
         [key: string]: unknown;
     };
     json?: boolean;
-    errorMetadata?: Record<string, unknown>;
+    errorMetadata?: JsonObject;
 }
 
 /**
@@ -106,7 +106,7 @@ export async function callLimeApi<T>(
         const { headers: callerHeaders, ...restRequestOptions } =
             options.requestOptions ?? {};
         const response =
-            await nodeContext.helpers.requestWithAuthentication.call(
+            await nodeContext.helpers.httpRequestWithAuthentication.call(
                 nodeContext,
                 LIME_CRM_API_CREDENTIAL_KEY,
                 {
@@ -126,15 +126,16 @@ export async function callLimeApi<T>(
             data: response,
         };
     } catch (error) {
-        const errorBody = error?.cause?.error ?? error?.cause?.body;
+        const apiBody = error.context?.data;
         const errorContext: WorkflowErrorContext = {
-            message: error instanceof Error ? error.message : String(error),
-            status: error?.cause?.status,
-            ...(errorBody != null && { error: errorBody }),
+            message: error.description
+                ? `${error.message}. ${error.description}`
+                : error.message,
+            status: error.httpCode ?? undefined,
             metadata: {
-                ...options.requestOptions,
                 ...options.errorMetadata,
-            } as JsonObject,
+            },
+            ...(apiBody != null && { error: apiBody }),
         };
         return handleWorkflowError(nodeContext.getNode(), errorContext, true);
     }

package/nodes/lime-forms/LimeFormsTrigger.node.ts

@@ -22,8 +22,9 @@ import { ObservableActionType } from './types/enums/ObservableAction';
 import { ObservableType } from './types/enums/ObservableType';
 import { FORMS_API_CREDENTIALS_NAME } from '../../credentials';
 import { getWorkflowUrl } from './utils/workflow';
-import { verifyHmac } from '../crypto';
+import { decryptSecret, encryptSecret, verifyHmac } from '../crypto';
 import { handleWorkflowError } from '../errorHandling';
+import { randomBytes } from 'node:crypto';
 
 const FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX = 'N8N';
 
@@ -131,22 +132,26 @@ export class LimeFormsTrigger implements INodeType {
             },
 
             async create(this: IHookFunctions): Promise<boolean> {
-                const credentials = await this.getCredentials(
-                    FORMS_API_CREDENTIALS_NAME
-                );
+                const webhookData = this.getWorkflowStaticData('node');
+                // Generate a per-webhook secret, keep an encrypted copy in the
+                // workflow static data and only ever hand the plaintext to Lime
+                // Forms. The secret is decrypted on each incoming request to
+                // validate the signature. See {@link encryptSecret}.
+                const rawSecret = randomBytes(32).toString('hex');
+                webhookData.webhookSecret = encryptSecret(rawSecret);
+
                 const data = {
                     name: `${FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX}: ${this.getNodeParameter('name')}`,
                     observableType: ObservableType.FORM,
                     observableId: this.getNodeParameter('formId'),
                     action: ObservableActionType.FORM_SUBMITTED,
                     webhookUrl: this.getNodeWebhookUrl('default'),
-                    secret: credentials.webhookSecret as string,
+                    secret: rawSecret,
                     workflowUrl: getWorkflowUrl(
                         this.getNode(),
                         this.getWorkflow().id
                     ),
                 };
-                const webhookData = this.getWorkflowStaticData('node');
 
                 try {
                     const response =
@@ -164,22 +169,41 @@ export class LimeFormsTrigger implements INodeType {
 
                     return true;
                 } catch (error) {
-                    // 409 Indicates duplicate exists
+                    // 409 indicates a duplicate webhook already exists in Lime
+                    // Forms. Its secret was set on an earlier registration and
+                    // is unknown to us, so reusing it would resurrect the
+                    // "signatures do not match" failures. Delete the stale
+                    // webhook and recreate it with the freshly generated secret.
                     if (error?.httpCode == '409') {
-                        Logger.info(
-                            `Webhook ${webhookData.name} already exists in Lime Forms, retrieving existing webhook ID`,
-                            { errorResponse: error.context?.data }
-                        );
                         /**
                          * Error response structure reference:
                          * @see https://github.com/n8n-io/n8n/blob/n8n%401.120.0/packages/core/src/execution-engine/node-execution-context/utils/request-helper-functions.ts#L1280
                          */
                         const errorResponse = error.context?.data?.error;
-                        webhookData.id = errorResponse.id;
-                        webhookData.name = errorResponse.name.replace(
-                            `${FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX}: `,
-                            ''
+                        Logger.info(
+                            `Webhook ${errorResponse?.name} already exists in Lime Forms, recreating it with a fresh secret`,
+                            { errorResponse: error.context?.data }
+                        );
+
+                        await new LimeFormsRequest<ObservableWebhookSimpleResource>(
+                            this
+                        ).delete(
+                            `/api/v1/observable-webhooks/${errorResponse.id}`
                         );
+
+                        const response =
+                            await new LimeFormsRequest<ObservableWebhookDetailedResource>(
+                                this
+                            ).post('/api/v1/observable-webhooks', data);
+
+                        if (!response.success) {
+                            throw new NodeApiError(this.getNode(), {
+                                message:
+                                    'Failed to create webhook in Lime Forms',
+                            });
+                        }
+
+                        webhookData.id = response.data.id;
                         return true;
                     }
                     throw new NodeApiError(this.getNode(), {
@@ -207,7 +231,7 @@ export class LimeFormsTrigger implements INodeType {
                 }
 
                 delete webhookData.id;
-                delete webhookData.secret;
+                delete webhookData.webhookSecret;
 
                 return true;
             },
@@ -227,9 +251,17 @@ export class LimeFormsTrigger implements INodeType {
                 );
             }
 
-            const webhookSecret = await this.getCredentials(
-                FORMS_API_CREDENTIALS_NAME
-            ).then((c) => c.webhookSecret as string);
+            const webhookData = this.getWorkflowStaticData('node');
+            const encryptedSecret = webhookData.webhookSecret as
+                | string
+                | undefined;
+            if (!encryptedSecret) {
+                throw new NodeOperationError(
+                    this.getNode(),
+                    'Webhook is not registered: missing secret in static data'
+                );
+            }
+            const webhookSecret = decryptSecret(encryptedSecret);
             const isValidSignature = verifyHmac(
                 webhookSecret,
                 Buffer.from(JSON.stringify(body)),

package/nodes/lime-marketing/LimeMarketing.node.ts

@@ -0,0 +1,180 @@
+import {
+    IDataObject,
+    IExecuteFunctions,
+    INodeExecutionData,
+    INodeType,
+    INodeTypeDescription,
+    NodeApiError,
+    NodeConnectionTypes,
+    NodeOperationError,
+    NodePropertyTypes,
+} from 'n8n-workflow';
+import {
+    LIME_MARKETING_API_CREDENTIAL_KEY,
+    TRANSACTIONAL_EMAIL_RESOURCE,
+    TRANSACTIONAL_SMS_RESOURCE,
+} from './models';
+import {
+    transactionMailFields,
+    transactionMailOperations,
+} from './resources/transactionmail';
+import {
+    transactionSmsFields,
+    transactionSmsOperations,
+} from './resources/transactionsms';
+import { getTemplates, getTemplateMergeCodeMappingColumns } from './methods';
+import { getBaseUrl } from './utils';
+
+// What an OperationExecutor returns: either a raw API response object, an
+// array of them, or already-wrapped n8n execution items (single or many).
+// `undefined` means "no items emitted from this input".
+export type OperationExecutorResult =
+    | IDataObject
+    | IDataObject[]
+    | INodeExecutionData
+    | INodeExecutionData[]
+    | undefined;
+
+// Signature for a per-item operation. Receives the item index and a
+// pre-resolved baseURL so we don't re-fetch credentials on every call.
+export type OperationExecutor = (
+    this: IExecuteFunctions,
+    i: number,
+    baseURL: string
+) => Promise<OperationExecutorResult>;
+
+const OPERATIONS: Record<string, Record<string, OperationExecutor>> = {
+    [TRANSACTIONAL_EMAIL_RESOURCE]: transactionMailOperations,
+    [TRANSACTIONAL_SMS_RESOURCE]: transactionSmsOperations,
+};
+
+function hasJsonField(
+    value: IDataObject | INodeExecutionData
+): value is INodeExecutionData {
+    return 'json' in value;
+}
+
+// Wrap one raw response into an n8n execution item, preserving `json` if
+// already present and tagging `pairedItem`.
+function toExecutionItem(
+    raw: IDataObject | INodeExecutionData,
+    i: number
+): INodeExecutionData {
+    const base = hasJsonField(raw) ? raw : { json: raw };
+    return { ...base, pairedItem: { item: i } };
+}
+
+// Normalize a response (single value, array, or undefined) into an array
+// of execution items.
+function toExecutionItems(
+    responseData: OperationExecutorResult,
+    i: number
+): INodeExecutionData[] {
+    if (responseData === undefined) return [];
+    const list = Array.isArray(responseData) ? responseData : [responseData];
+    return list.map((item) => toExecutionItem(item, i));
+}
+
+// Build an error-flavored execution item for the `continueOnFail` branch,
+// attaching the original NodeError when available.
+function buildErrorItem(error: Error, i: number): INodeExecutionData {
+    const nodeError =
+        error instanceof NodeApiError || error instanceof NodeOperationError
+            ? error
+            : undefined;
+    // n8n's executor overwrites `json` with `{ error: error.message }` whenever
+    // an item has a top-level `error` field, so anything else in `json` would
+    // be discarded before downstream nodes see it.
+    return {
+        json: { error: error.message },
+        error: nodeError,
+        pairedItem: { item: i },
+    };
+}
+
+export class LimeMarketing implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'Lime CRM Marketing',
+        name: 'limeMarketing',
+        icon: 'file:assets/lime-crm.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle:
+            '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description:
+            'Send transactional emails and SMS via the Lime CRM Marketing API',
+        defaults: { name: 'Lime CRM Marketing' },
+        inputs: [NodeConnectionTypes.Main],
+        outputs: [NodeConnectionTypes.Main],
+        credentials: [
+            { name: LIME_MARKETING_API_CREDENTIAL_KEY, required: true },
+        ],
+        usableAsTool: true,
+        properties: [
+            {
+                displayName:
+                    'Tip: set On Error to "Continue (using error output)" in the Settings tab to route failed sends down a separate branch. The error output contains the API message as $json.error.',
+                name: 'errorHandlingHint',
+                type: 'notice',
+                default: '',
+            },
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options' as NodePropertyTypes,
+                noDataExpression: true,
+                options: [
+                    {
+                        name: 'Email',
+                        value: TRANSACTIONAL_EMAIL_RESOURCE,
+                        description: 'Send a transactional email',
+                    },
+                    {
+                        name: 'SMS',
+                        value: TRANSACTIONAL_SMS_RESOURCE,
+                        description: 'Send a transactional SMS',
+                    },
+                ],
+                default: TRANSACTIONAL_EMAIL_RESOURCE,
+            },
+
+            ...transactionMailFields,
+            ...transactionSmsFields,
+        ],
+    };
+
+    methods = {
+        loadOptions: {
+            getTemplates,
+        },
+        resourceMapping: {
+            getTemplateMergeCodeMappingColumns,
+        },
+    };
+
+    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+        const items = this.getInputData();
+        const resource = this.getNodeParameter('resource', 0) as string;
+        const operation = this.getNodeParameter('operation', 0) as string;
+        const executor = OPERATIONS[resource]?.[operation];
+        if (!executor) return [[]];
+
+        const baseURL = await getBaseUrl(this);
+        const returnData: INodeExecutionData[] = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const responseData = await executor.call(this, i, baseURL);
+                returnData.push(...toExecutionItems(responseData, i));
+            } catch (error_) {
+                if (!this.continueOnFail()) throw error_;
+                const error =
+                    error_ instanceof Error
+                        ? error_
+                        : new Error(String(error_));
+                returnData.push(buildErrorItem(error, i));
+            }
+        }
+
+        return [returnData];
+    }
+}

package/nodes/lime-marketing/assets/lime-crm.svg

@@ -0,0 +1 @@
+<svg viewBox="0 0 1024 1025" xmlns="http://www.w3.org/2000/svg" xml:space="preserve"><clipPath id="a"><path d="M0 .03h1024v1024H0z"/></clipPath><g clip-path="url(#a)"><path d="M92.399 480.888c0-257.059 208.719-465.779 465.78-465.779C815.28 15.109 1024 223.829 1024 480.888c0 133.713-55.806 271.139-193.403 385.355-166.779 138.45-390.39 157.35-736.15 134.525-102.653-6.785-117.502-24.319-64.468-63.444 166.694-123.047 62.42-217.167 62.42-456.436Z" style="fill:#bee034"/><clipPath id="b"><path d="M92.399 480.888c0-257.059 208.719-465.779 465.78-465.779C815.28 15.109 1024 223.829 1024 480.888c0 133.713-55.806 271.139-193.403 385.355-166.779 138.45-390.39 157.35-736.15 134.525-102.653-6.785-117.502-24.319-64.468-63.444 166.694-123.047 62.42-217.167 62.42-456.436Z"/></clipPath><g clip-path="url(#b)"><path d="M1023-361.59c0 784.587-711.326 1420.62-1588.79 1420.62C-1402.638-283.55 1023-1146.18 1023-361.59Z" style="fill:#a6efff;filter:blur(200px)"/></g><path d="M433.85 723.911c-24.702-12.757-47.23-29.226-66.813-48.596-9.088-9.002-23.765-8.959-32.768.129-9.001 9.087-8.916 23.763.171 32.766 22.911 22.698 49.236 41.941 78.121 56.873 11.392 5.888 25.385 1.409 31.231-9.94 5.888-11.349 1.409-25.344-9.942-31.232Zm367.266-363.98a270.163 270.163 0 0 1 25.556 78.547c2.048 12.629 13.952 21.206 26.581 19.158 12.586-2.006 21.204-13.951 19.156-26.539a316.387 316.387 0 0 0-29.907-92.029c-5.803-11.434-19.754-15.999-31.146-10.24-11.393 5.76-16 19.713-10.24 31.103Zm-51.497 315.384c-19.584 19.37-42.069 35.839-66.815 48.596-11.349 5.888-15.786 19.883-9.94 31.232 5.887 11.349 19.881 15.828 31.229 9.94 28.929-14.932 55.253-34.175 78.164-56.873 9.045-9.003 9.131-23.679.128-32.766-9.002-9.088-23.678-9.131-32.766-.129ZM517.006 213.546a274.904 274.904 0 0 1 41.343-3.114c14.036 0 27.861 1.066 41.343 3.114 12.629 1.919 24.448-6.784 26.367-19.413 1.962-12.628-6.741-24.446-19.371-26.409a322.626 322.626 0 0 0-48.339-3.627 322.201 322.201 0 0 0-48.34 3.627c-12.672 1.963-21.332 13.781-19.413 26.409 1.92 12.629 13.739 21.332 26.41 19.413Zm41.343 490.355c-40.489 0-73.385 32.853-73.385 73.342s32.896 73.385 73.385 73.385c40.489 0 73.342-32.896 73.342-73.385 0-40.489-32.853-73.342-73.342-73.342ZM290.025 438.478c4.481-27.818 13.227-54.227 25.514-78.547 5.761-11.39 1.195-25.343-10.239-31.103-11.392-5.759-25.343-1.194-31.104 10.24a313.893 313.893 0 0 0-29.908 92.029c-2.048 12.588 6.527 24.533 19.157 26.539 12.629 2.048 24.532-6.529 26.58-19.158Zm479.092 112.254c-12.501 38.527 8.618 79.955 47.102 92.456 38.528 12.502 79.956-8.618 92.457-47.104 12.501-38.525-8.619-79.953-47.103-92.455-38.527-12.501-79.955 8.619-92.456 47.103Zm-80.51-247.802c32.766 23.808 78.675 16.554 102.482-16.212 23.808-32.767 16.512-78.675-16.256-102.482-32.723-23.809-78.675-16.512-102.439 16.254-23.808 32.725-16.555 78.633 16.213 102.44Zm-260.558 0c32.766-23.807 40.063-69.715 16.254-102.44-23.807-32.766-69.715-40.063-102.482-16.254-32.766 23.807-40.02 69.715-16.255 102.482 23.806 32.766 69.758 40.02 102.483 16.212Zm-80.51 247.802c-12.501-38.484-53.929-59.604-92.415-47.103-38.526 12.502-59.645 53.93-47.102 92.455 12.501 38.486 53.929 59.606 92.413 47.104 38.528-12.501 59.605-53.929 47.104-92.456Z" style="fill:#fff"/></g></svg>

package/nodes/lime-marketing/index.ts

@@ -0,0 +1 @@
+export * from './LimeMarketing.node';

package/nodes/lime-marketing/methods/getTemplateMergeCodeMappingColumns.ts

@@ -0,0 +1,70 @@
+import { ILoadOptionsFunctions, ResourceMapperFields } from 'n8n-workflow';
+import { limeMarketingRequest } from '../transport';
+import { LoggerProxy as Logger } from 'n8n-workflow';
+
+type TemplateVariablesResponse = {
+    RecipientVariables?: { Property: string; RawValue: string }[];
+    CustomVariables?: { Property: string; RawValue: string }[];
+};
+
+const PLACEHOLDER_ID = '__noMergeCodes__';
+
+// True if `name` is the synthetic "no merge codes" sentinel produced for
+// templates without merge codes — must be filtered out before sending.
+export function isMergeCodePlaceholder(name: string): boolean {
+    return name === PLACEHOLDER_ID;
+}
+
+const noMergeCodesPlaceholder = {
+    id: PLACEHOLDER_ID,
+    displayName: 'No merge codes in this template',
+    required: false,
+    defaultMatch: false,
+    display: true,
+    type: 'string' as const,
+    canBeUsedToMatch: false,
+    readOnly: true,
+};
+
+// resourceMapping handler: fetch the merge codes (CustomVariables) for the
+// currently-selected template and expose each as a mappable field. Returns a
+// readOnly placeholder field when the template has none, since n8n's resource
+// mapper requires at least one field to render.
+export async function getTemplateMergeCodeMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const templateId = Number(this.getNodeParameter('templateId', 0));
+    if (!templateId) return { fields: [noMergeCodesPlaceholder] };
+
+    const tagsResponse = await limeMarketingRequest<TemplateVariablesResponse>(
+        this,
+        {
+            method: 'GET',
+            url: `mailtemplate/${templateId}/variables`,
+            json: true,
+            errorContext: 'load template merge codes',
+        }
+    );
+    if (!tagsResponse.success) {
+        Logger.error(
+            `There was an error with fetching merge codes: ${JSON.stringify(tagsResponse.data)}`
+        );
+        return { fields: [] };
+    }
+
+    const fields = (tagsResponse?.data.CustomVariables ?? [])
+        .map((v) => v?.RawValue)
+        .filter(Boolean)
+        .map((code) => ({
+            id: code,
+            displayName: code,
+            required: false,
+            defaultMatch: false,
+            display: true,
+            type: 'string' as const,
+            canBeUsedToMatch: false,
+        }));
+
+    if (fields.length === 0) return { fields: [noMergeCodesPlaceholder] };
+    return { fields };
+}

package/nodes/lime-marketing/methods/getTemplates.ts

@@ -0,0 +1,33 @@
+import {
+    ILoadOptionsFunctions,
+    INodePropertyOptions,
+    LoggerProxy as Logger,
+} from 'n8n-workflow';
+import { MailTemplate } from '../models';
+import { limeMarketingRequest } from '../transport';
+
+// loadOptions handler: fetch all mail templates and return them sorted by name
+// for the Template dropdown on the email send operation.
+export async function getTemplates(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    const templates = await limeMarketingRequest<MailTemplate[]>(this, {
+        method: 'GET',
+        url: 'mailtemplate',
+        json: true,
+        errorContext: 'load templates',
+    });
+    if (!templates.success) {
+        Logger.error(
+            `There was an error with fetching properties: ${JSON.stringify(templates.data)}`
+        );
+        return [];
+    }
+
+    return templates.data
+        .map((t) => ({
+            name: `${t.Name} (ID: ${t.Id})`,
+            value: t.Id,
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}

package/nodes/lime-marketing/methods/index.ts

@@ -0,0 +1,2 @@
+export { getTemplates } from './getTemplates';
+export { getTemplateMergeCodeMappingColumns } from './getTemplateMergeCodeMappingColumns';

package/nodes/lime-marketing/models/constants.ts

@@ -0,0 +1,12 @@
+export const LIME_MARKETING_API_CREDENTIAL_KEY = 'limeMarketingApi';
+export const TRANSACTIONAL_EMAIL_RESOURCE = 'email';
+export const TRANSACTIONAL_SMS_RESOURCE = 'sms';
+
+export const CONTENT_TYPE_TEMPLATE = 'template';
+export const CONTENT_TYPE_CUSTOM = 'html';
+export const CONTENT_TYPE_TEXT = 'text';
+
+export const MERGE_CODES_INPUT_FIELDS = 'fields';
+export const MERGE_CODES_INPUT_JSON = 'json';
+
+export const SEND_OPERATION = 'send';

package/nodes/lime-marketing/models/index.ts

@@ -0,0 +1,32 @@
+export {
+    LIME_MARKETING_API_CREDENTIAL_KEY,
+    TRANSACTIONAL_EMAIL_RESOURCE,
+    TRANSACTIONAL_SMS_RESOURCE,
+    CONTENT_TYPE_TEMPLATE,
+    CONTENT_TYPE_CUSTOM,
+    CONTENT_TYPE_TEXT,
+    MERGE_CODES_INPUT_FIELDS,
+    MERGE_CODES_INPUT_JSON,
+    SEND_OPERATION,
+} from './constants';
+export type { MailTemplate } from './template';
+export type {
+    AttachmentModel,
+    TagModel,
+    SendTransactionMailArgs,
+    SendTransactionMailBase,
+    SendTransactionMailTemplateArgs,
+    TransactionMailModel,
+} from './transactionMail';
+export type {
+    SendTransactionSmsArgs,
+    TransactionSmsModel,
+} from './transactionSms';
+export type {
+    TagListInput,
+    AttachmentsInput,
+    HeadersInput,
+    AdditionalMailOptions,
+    AdditionalSmsOptions,
+} from './operationInputs';
+export type { LimeMarketingErrorBody } from './transportError';

package/nodes/lime-marketing/models/operationInputs.ts

@@ -0,0 +1,40 @@
+// Named types for the shapes n8n's `getNodeParameter` returns for our
+// fixedCollection / collection inputs. The shapes are dictated by the
+// `properties[]` definitions in each send.operation.ts; lifting them here
+// gives us one source of truth and lets call sites avoid inline `as { ... }`
+// structures.
+
+export type TagListInput = {
+    tag?: { name: string; value?: string }[];
+};
+
+export type AttachmentsInput = {
+    attachment?: {
+        binaryPropertyName: string;
+        fileNameOverride?: string;
+    }[];
+};
+
+export type HeadersInput = {
+    header?: { name: string; value: string }[];
+};
+
+export type AdditionalMailOptions = {
+    senderName?: string;
+    senderEmail?: string;
+    replyTo?: string;
+    scheduledSendDate?: string;
+    externalId?: string;
+    excludePublicationOptouts?: boolean;
+    excludeTotalOptouts?: boolean;
+    excludePreviousBounce?: boolean;
+    linkBaseUrl?: string;
+    includeEmailDataInWebhookPayload?: boolean;
+    headers?: HeadersInput;
+};
+
+export type AdditionalSmsOptions = {
+    maxParts?: number | null;
+    deliveryTimeoutHours?: number | null;
+    scheduledSendDate?: string;
+};

package/nodes/lime-marketing/models/template.ts

@@ -0,0 +1,10 @@
+export type MailTemplate = {
+    Id: number;
+    HtmlLayoutId: number;
+    TextLayoutId: number;
+    CreatedByUserId: number;
+    Name: string;
+    Description: string;
+    CreationDate: string;
+    ModifiedDate: string;
+};

package/nodes/lime-marketing/models/transactionMail.ts

@@ -0,0 +1,65 @@
+export type AttachmentModel = {
+    FileData: string;
+    FileNameWithExtension: string;
+    MimeType: string;
+};
+
+export type TagModel = {
+    Name: string;
+    Value?: string;
+};
+
+export type SendTransactionMailBase = {
+    RecipientEmail: string;
+    RecipientName?: string;
+    SenderName?: string;
+    SenderEmail?: string;
+    FromName?: string;
+    FromEmail?: string;
+    ReplyTo?: string;
+    Subject?: string;
+    ScheduledSendDate?: string;
+    ExternalId?: string;
+    Attachments?: AttachmentModel[];
+    TrackOpenings?: boolean;
+    ExcludePublicationOptouts?: boolean;
+    ExcludeTotaloptouts?: boolean;
+    ExcludePreviousBounce?: boolean;
+    TrackLinkClicks?: boolean;
+    LinkBaseUrl?: string;
+    HtmlContentTagModels?: TagModel[];
+    TextContentTagModels?: TagModel[];
+    Headers?: Record<string, string>;
+    IncludeEmailDataInWebhookPayload?: boolean;
+};
+
+export type SendTransactionMailArgs = SendTransactionMailBase & {
+    HtmlContent?: number[];
+    TextContent?: number[];
+};
+
+export type SendTransactionMailTemplateArgs = SendTransactionMailBase & {
+    TemplateId: number;
+};
+
+export type TransactionMailModel = {
+    TransactionMailId: number;
+    RecipientName: string;
+    RecipientEmail: string;
+    SenderName: string;
+    SenderEmail: string;
+    FromName: string;
+    FromEmail: string;
+    ReplyTo: string;
+    Subject: string;
+    TrackOpenings: boolean;
+    TrackLinkClicks: boolean;
+    LinkBaseUrl: string;
+    ExternalId: string;
+    ExcludeTotalOptouts: boolean;
+    ExcludePublicationOptouts: boolean;
+    ExcludePreviousBounce: boolean;
+    IsInternalMail: boolean;
+    CreationDate: string;
+    IncludeEmailDataInWebhookPayload: boolean;
+};