n8n-nodes-steyi-ss 1.0.0

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheetApi.d.ts

@@ -0,0 +1,24 @@
+import { IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+export declare function listSheets(this: IExecuteFunctions | ILoadOptionsFunctions, includeAll?: boolean): Promise<any>;
+export declare function listColumns(this: IExecuteFunctions | ILoadOptionsFunctions, sheetId: number): Promise<any>;
+export declare function listWebhooks(this: IExecuteFunctions | ILoadOptionsFunctions): Promise<any>;
+export declare function createWebhook(this: IExecuteFunctions | ILoadOptionsFunctions, body: any): Promise<any>;
+export declare function updateWebhook(this: IExecuteFunctions | ILoadOptionsFunctions, webhookId: number, body: any): Promise<any>;
+export declare function deleteWebhook(this: IExecuteFunctions | ILoadOptionsFunctions, webhookId: number): Promise<any>;
+export declare function listReports(this: IExecuteFunctions | ILoadOptionsFunctions, includeAll?: boolean): Promise<any>;
+export declare function getReport(this: IExecuteFunctions | ILoadOptionsFunctions, reportId: number, include?: string[], exclude?: string[]): Promise<any>;
+export declare function listWorkspaces(this: IExecuteFunctions | ILoadOptionsFunctions): Promise<any>;
+export declare function listFolders(this: IExecuteFunctions | ILoadOptionsFunctions, workspaceId: number): Promise<any>;
+export declare function listUsers(this: IExecuteFunctions | ILoadOptionsFunctions, includeAll?: boolean): Promise<any>;
+export declare function getUser(this: IExecuteFunctions | ILoadOptionsFunctions, userId: number): Promise<any>;
+export declare function addUser(this: IExecuteFunctions | ILoadOptionsFunctions, body: any): Promise<any>;
+export declare function updateUser(this: IExecuteFunctions | ILoadOptionsFunctions, userId: number, body: any): Promise<any>;
+export declare function deleteUser(this: IExecuteFunctions | ILoadOptionsFunctions, userId: number): Promise<any>;
+export declare function listGroups(this: IExecuteFunctions | ILoadOptionsFunctions, includeAll?: boolean): Promise<any>;
+export declare function getGroup(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number): Promise<any>;
+export declare function createGroup(this: IExecuteFunctions | ILoadOptionsFunctions, body: any): Promise<any>;
+export declare function updateGroup(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number, body: any): Promise<any>;
+export declare function deleteGroup(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number): Promise<any>;
+export declare function listGroupMembers(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number): Promise<any>;
+export declare function addGroupMembers(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number, members: any[]): Promise<any>;
+export declare function removeGroupMember(this: IExecuteFunctions | ILoadOptionsFunctions, groupId: number, userId: number): Promise<any>;

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheetApi.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeGroupMember = exports.addGroupMembers = exports.listGroupMembers = exports.deleteGroup = exports.updateGroup = exports.createGroup = exports.getGroup = exports.listGroups = exports.deleteUser = exports.updateUser = exports.addUser = exports.getUser = exports.listUsers = exports.listFolders = exports.listWorkspaces = exports.getReport = exports.listReports = exports.deleteWebhook = exports.updateWebhook = exports.createWebhook = exports.listWebhooks = exports.listColumns = exports.listSheets = void 0;
+const SteyiGenericFunction_1 = require("./SteyiGenericFunction");
+async function listSheets(includeAll = true) {
+    let allSheets = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const endpoint = includeAll
+            ? `/sheets?page=${page}&pageSize=100&includeAll=true`
+            : `/sheets?page=${page}&pageSize=100`;
+        const response = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', endpoint, {}, 0);
+        if (response && response.data) {
+            allSheets = allSheets.concat(response.data);
+            totalPages = response.totalPages || 1;
+            page++;
+        }
+        else {
+            break;
+        }
+    } while (includeAll && page <= totalPages);
+    return { data: allSheets };
+}
+exports.listSheets = listSheets;
+async function listColumns(sheetId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/columns`, {}, 0);
+}
+exports.listColumns = listColumns;
+async function listWebhooks() {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', '/webhooks', {}, 0);
+}
+exports.listWebhooks = listWebhooks;
+async function createWebhook(body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', '/webhooks', body, 0);
+}
+exports.createWebhook = createWebhook;
+async function updateWebhook(webhookId, body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'PUT', `/webhooks/${webhookId}`, body, 0);
+}
+exports.updateWebhook = updateWebhook;
+async function deleteWebhook(webhookId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'DELETE', `/webhooks/${webhookId}`, {}, 0);
+}
+exports.deleteWebhook = deleteWebhook;
+async function listReports(includeAll = true) {
+    let allReports = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const endpoint = includeAll
+            ? `/reports?page=${page}&pageSize=100&includeAll=true`
+            : `/reports?page=${page}&pageSize=100`;
+        const response = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', endpoint, {}, 0);
+        if (response && response.data) {
+            allReports = allReports.concat(response.data);
+            totalPages = response.totalPages || 1;
+            page++;
+        }
+        else {
+            break;
+        }
+    } while (includeAll && page <= totalPages);
+    return { data: allReports };
+}
+exports.listReports = listReports;
+async function getReport(reportId, include, exclude) {
+    const queryParams = [];
+    if (include && include.length > 0) {
+        queryParams.push(`include=${include.join(',')}`);
+    }
+    if (exclude && exclude.length > 0) {
+        queryParams.push(`exclude=${exclude.join(',')}`);
+    }
+    const queryString = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/reports/${reportId}${queryString}`, {}, 0);
+}
+exports.getReport = getReport;
+async function listWorkspaces() {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', '/workspaces', {}, 0);
+}
+exports.listWorkspaces = listWorkspaces;
+async function listFolders(workspaceId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/workspaces/${workspaceId}/folders`, {}, 0);
+}
+exports.listFolders = listFolders;
+// Admin functions
+async function listUsers(includeAll = true) {
+    let allUsers = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const endpoint = includeAll
+            ? `/users?page=${page}&pageSize=100&includeAll=true`
+            : `/users?page=${page}&pageSize=100`;
+        const response = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', endpoint, {}, 0);
+        if (response && response.data) {
+            allUsers = allUsers.concat(response.data);
+            totalPages = response.totalPages || 1;
+            page++;
+        }
+        else {
+            break;
+        }
+    } while (includeAll && page <= totalPages);
+    return { data: allUsers };
+}
+exports.listUsers = listUsers;
+async function getUser(userId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/users/${userId}`, {}, 0);
+}
+exports.getUser = getUser;
+async function addUser(body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', '/users', body, 0);
+}
+exports.addUser = addUser;
+async function updateUser(userId, body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'PUT', `/users/${userId}`, body, 0);
+}
+exports.updateUser = updateUser;
+async function deleteUser(userId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'DELETE', `/users/${userId}`, {}, 0);
+}
+exports.deleteUser = deleteUser;
+async function listGroups(includeAll = true) {
+    let allGroups = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const endpoint = includeAll
+            ? `/groups?page=${page}&pageSize=100&includeAll=true`
+            : `/groups?page=${page}&pageSize=100`;
+        const response = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', endpoint, {}, 0);
+        if (response && response.data) {
+            allGroups = allGroups.concat(response.data);
+            totalPages = response.totalPages || 1;
+            page++;
+        }
+        else {
+            break;
+        }
+    } while (includeAll && page <= totalPages);
+    return { data: allGroups };
+}
+exports.listGroups = listGroups;
+async function getGroup(groupId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/groups/${groupId}`, {}, 0);
+}
+exports.getGroup = getGroup;
+async function createGroup(body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', '/groups', body, 0);
+}
+exports.createGroup = createGroup;
+async function updateGroup(groupId, body) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'PUT', `/groups/${groupId}`, body, 0);
+}
+exports.updateGroup = updateGroup;
+async function deleteGroup(groupId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'DELETE', `/groups/${groupId}`, {}, 0);
+}
+exports.deleteGroup = deleteGroup;
+async function listGroupMembers(groupId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/groups/${groupId}/members`, {}, 0);
+}
+exports.listGroupMembers = listGroupMembers;
+async function addGroupMembers(groupId, members) {
+    // Smartsheet API expects the body to be an array directly, not wrapped in an object
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/groups/${groupId}/members`, members, 0);
+}
+exports.addGroupMembers = addGroupMembers;
+async function removeGroupMember(groupId, userId) {
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'DELETE', `/groups/${groupId}/members/${userId}`, {}, 0);
+}
+exports.removeGroupMember = removeGroupMember;

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheetTrigger.node.d.ts

@@ -0,0 +1,17 @@
+import { IWebhookFunctions, IHookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare class SteyiSmartsheetTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getSheets(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheetTrigger.node.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteyiSmartsheetTrigger = void 0;
+const SteyiSmartsheetApi_1 = require("./SteyiSmartsheetApi");
+class SteyiSmartsheetTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Steyi Smartsheet Trigger',
+            name: 'steyiSmartsheetTrigger',
+            icon: 'file:steyi-smartsheet.svg',
+            group: ['trigger'],
+            version: 1,
+            description: 'Starts the workflow when Smartsheet events occur (Steyi)',
+            defaults: {
+                name: 'Steyi Smartsheet Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'steyiSmartsheetCreds',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Type',
+                    name: 'webhookType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Sheet',
+                            value: 'sheet',
+                        },
+                    ],
+                    default: 'sheet',
+                    required: true,
+                },
+                {
+                    displayName: 'Sheet Name or ID',
+                    name: 'sheetId',
+                    type: 'options',
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSheets',
+                    },
+                    displayOptions: {
+                        show: {
+                            webhookType: ['sheet'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getSheets() {
+                    const sheets = await SteyiSmartsheetApi_1.listSheets.call(this, true);
+                    if (!sheets || !sheets.data) {
+                        return [];
+                    }
+                    return sheets.data.map((sheet) => ({
+                        name: sheet.name,
+                        value: sheet.id ? String(sheet.id) : '',
+                    }));
+                },
+            },
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhooks = await SteyiSmartsheetApi_1.listWebhooks.call(this);
+                    if (!webhooks || !webhooks.data) {
+                        return false;
+                    }
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    for (const webhook of webhooks.data) {
+                        if (webhook.callbackUrl === webhookUrl) {
+                            const webhookData = this.getWorkflowStaticData('node');
+                            webhookData.webhookId = webhook.id || webhook.webhookId;
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    if (webhookUrl === undefined || webhookUrl === null) {
+                        return false;
+                    }
+                    const sheetId = this.getNodeParameter('sheetId');
+                    if (sheetId === undefined || sheetId === null || sheetId === '') {
+                        return false;
+                    }
+                    const sheetIdNum = typeof sheetId === 'string' ? parseInt(sheetId, 10) : sheetId;
+                    if (isNaN(sheetIdNum)) {
+                        return false;
+                    }
+                    const body = {
+                        name: `n8n - Webhook [Sheet ID: ${sheetIdNum}]`,
+                        callbackUrl: webhookUrl,
+                        events: ['*.*'],
+                        version: 1,
+                        scopeObjectId: sheetIdNum,
+                        scope: 'sheet',
+                    };
+                    const responseData = await SteyiSmartsheetApi_1.createWebhook.call(this, body);
+                    if (!responseData || responseData.message !== 'SUCCESS') {
+                        return false;
+                    }
+                    const createdWebhookId = responseData.result?.id || responseData.result?.webhookId || responseData.id;
+                    if (!createdWebhookId) {
+                        return false;
+                    }
+                    const updateResponseData = await SteyiSmartsheetApi_1.updateWebhook.call(this, createdWebhookId, { enabled: true });
+                    if (!updateResponseData || updateResponseData.message !== 'SUCCESS') {
+                        return false;
+                    }
+                    const webhookData = this.getWorkflowStaticData('node');
+                    webhookData.webhookId = createdWebhookId;
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const webhookId = webhookData.webhookId;
+                    if (webhookId === undefined || webhookId === null) {
+                        return false;
+                    }
+                    // Safely convert webhookId to number
+                    const webhookIdNum = typeof webhookId === 'number'
+                        ? webhookId
+                        : (typeof webhookId === 'string' ? parseInt(webhookId, 10) : Number(webhookId));
+                    if (isNaN(webhookIdNum)) {
+                        return false;
+                    }
+                    const response = await SteyiSmartsheetApi_1.deleteWebhook.call(this, webhookIdNum);
+                    if (!response || response.message !== 'SUCCESS') {
+                        return false;
+                    }
+                    delete webhookData.webhookId;
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const headers = this.getHeaderData();
+        let response = req.body;
+        // Handle webhook challenge
+        if (response.challenge) {
+            const challenge = headers['smartsheet-hook-challenge'];
+            const webhookResponse = JSON.stringify({ smartsheetHookResponse: challenge });
+            return {
+                webhookResponse,
+            };
+        }
+        return {
+            workflowData: [this.helpers.returnJsonArray(response)],
+        };
+    }
+}
+exports.SteyiSmartsheetTrigger = SteyiSmartsheetTrigger;

package/dist/nodes/SteyiSmartsheet/executors/Admin.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeAdminOperation(this: IExecuteFunctions, operation: string, itemIndex: number): Promise<INodeExecutionData>;

package/dist/nodes/SteyiSmartsheet/executors/Admin.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAdminOperation = void 0;
+const SteyiSmartsheetApi_1 = require("../SteyiSmartsheetApi");
+async function executeAdminOperation(operation, itemIndex) {
+    let responseData;
+    switch (operation) {
+        case 'user': {
+            const userOperation = this.getNodeParameter('userOperation', itemIndex);
+            switch (userOperation) {
+                case 'listUsers': {
+                    responseData = await SteyiSmartsheetApi_1.listUsers.call(this, true);
+                    break;
+                }
+                case 'getUser': {
+                    const userInputMethod = this.getNodeParameter('userInputMethod', itemIndex, 'list');
+                    const userId = userInputMethod === 'id'
+                        ? this.getNodeParameter('userIdManual', itemIndex)
+                        : this.getNodeParameter('userId', itemIndex);
+                    responseData = await SteyiSmartsheetApi_1.getUser.call(this, parseInt(userId.toString()));
+                    break;
+                }
+                case 'addUser': {
+                    const email = this.getNodeParameter('email', itemIndex);
+                    const firstName = this.getNodeParameter('firstName', itemIndex, '');
+                    const lastName = this.getNodeParameter('lastName', itemIndex, '');
+                    const admin = this.getNodeParameter('admin', itemIndex, false);
+                    const licensedSheetCreator = this.getNodeParameter('licensedSheetCreator', itemIndex, false);
+                    const body = {
+                        email,
+                    };
+                    if (firstName)
+                        body.firstName = firstName;
+                    if (lastName)
+                        body.lastName = lastName;
+                    if (admin !== undefined)
+                        body.admin = admin;
+                    if (licensedSheetCreator !== undefined)
+                        body.licensedSheetCreator = licensedSheetCreator;
+                    responseData = await SteyiSmartsheetApi_1.addUser.call(this, body);
+                    break;
+                }
+                case 'updateUser': {
+                    const userInputMethod = this.getNodeParameter('userInputMethod', itemIndex, 'list');
+                    const userId = userInputMethod === 'id'
+                        ? this.getNodeParameter('userIdManual', itemIndex)
+                        : this.getNodeParameter('userId', itemIndex);
+                    const firstName = this.getNodeParameter('firstName', itemIndex, '');
+                    const lastName = this.getNodeParameter('lastName', itemIndex, '');
+                    const admin = this.getNodeParameter('admin', itemIndex, undefined);
+                    const licensedSheetCreator = this.getNodeParameter('licensedSheetCreator', itemIndex, undefined);
+                    const body = {};
+                    if (firstName)
+                        body.firstName = firstName;
+                    if (lastName)
+                        body.lastName = lastName;
+                    if (admin !== undefined)
+                        body.admin = admin;
+                    if (licensedSheetCreator !== undefined)
+                        body.licensedSheetCreator = licensedSheetCreator;
+                    responseData = await SteyiSmartsheetApi_1.updateUser.call(this, parseInt(userId.toString()), body);
+                    break;
+                }
+                case 'deleteUser': {
+                    const userInputMethod = this.getNodeParameter('userInputMethod', itemIndex, 'list');
+                    const userId = userInputMethod === 'id'
+                        ? this.getNodeParameter('userIdManual', itemIndex)
+                        : this.getNodeParameter('userId', itemIndex);
+                    await SteyiSmartsheetApi_1.deleteUser.call(this, parseInt(userId.toString()));
+                    responseData = { success: true, message: 'User deleted successfully' };
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown user operation: ${userOperation}`);
+            }
+            break;
+        }
+        case 'group': {
+            const groupOperation = this.getNodeParameter('groupOperation', itemIndex);
+            switch (groupOperation) {
+                case 'listGroups': {
+                    responseData = await SteyiSmartsheetApi_1.listGroups.call(this, true);
+                    break;
+                }
+                case 'getGroup': {
+                    const groupInputMethod = this.getNodeParameter('groupInputMethod', itemIndex, 'list');
+                    const groupId = groupInputMethod === 'id'
+                        ? this.getNodeParameter('groupIdManual', itemIndex)
+                        : this.getNodeParameter('groupId', itemIndex);
+                    responseData = await SteyiSmartsheetApi_1.getGroup.call(this, parseInt(groupId.toString()));
+                    break;
+                }
+                case 'createGroup': {
+                    const groupName = this.getNodeParameter('groupName', itemIndex);
+                    const description = this.getNodeParameter('description', itemIndex, '');
+                    const body = {
+                        name: groupName,
+                    };
+                    if (description)
+                        body.description = description;
+                    responseData = await SteyiSmartsheetApi_1.createGroup.call(this, body);
+                    break;
+                }
+                case 'updateGroup': {
+                    const groupInputMethod = this.getNodeParameter('groupInputMethod', itemIndex, 'list');
+                    const groupId = groupInputMethod === 'id'
+                        ? this.getNodeParameter('groupIdManual', itemIndex)
+                        : this.getNodeParameter('groupId', itemIndex);
+                    const groupName = this.getNodeParameter('groupName', itemIndex);
+                    const description = this.getNodeParameter('description', itemIndex, '');
+                    const body = {
+                        name: groupName,
+                    };
+                    if (description)
+                        body.description = description;
+                    responseData = await SteyiSmartsheetApi_1.updateGroup.call(this, parseInt(groupId.toString()), body);
+                    break;
+                }
+                case 'deleteGroup': {
+                    const groupInputMethod = this.getNodeParameter('groupInputMethod', itemIndex, 'list');
+                    const groupId = groupInputMethod === 'id'
+                        ? this.getNodeParameter('groupIdManual', itemIndex)
+                        : this.getNodeParameter('groupId', itemIndex);
+                    await SteyiSmartsheetApi_1.deleteGroup.call(this, parseInt(groupId.toString()));
+                    responseData = { success: true, message: 'Group deleted successfully' };
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown group operation: ${groupOperation}`);
+            }
+            break;
+        }
+        case 'groupMember': {
+            const groupMemberOperation = this.getNodeParameter('groupMemberOperation', itemIndex);
+            const groupInputMethod = this.getNodeParameter('groupInputMethod', itemIndex, 'list');
+            const groupId = groupInputMethod === 'id'
+                ? this.getNodeParameter('groupIdManual', itemIndex)
+                : this.getNodeParameter('groupId', itemIndex);
+            switch (groupMemberOperation) {
+                case 'listGroupMembers': {
+                    responseData = await SteyiSmartsheetApi_1.listGroupMembers.call(this, parseInt(groupId.toString()));
+                    break;
+                }
+                case 'addGroupMembers': {
+                    const membersData = this.getNodeParameter('members', itemIndex, {});
+                    if (!membersData.member || !Array.isArray(membersData.member) || membersData.member.length === 0) {
+                        throw new Error('At least one member is required');
+                    }
+                    // Smartsheet API expects an array of objects with email property
+                    const membersArray = membersData.member
+                        .map((m) => ({
+                        email: m.email || undefined,
+                    }))
+                        .filter((m) => m.email);
+                    if (membersArray.length === 0) {
+                        throw new Error('At least one valid email address is required');
+                    }
+                    responseData = await SteyiSmartsheetApi_1.addGroupMembers.call(this, parseInt(groupId.toString()), membersArray);
+                    break;
+                }
+                case 'removeGroupMember': {
+                    const memberUserId = this.getNodeParameter('memberUserId', itemIndex);
+                    await SteyiSmartsheetApi_1.removeGroupMember.call(this, parseInt(groupId.toString()), parseInt(memberUserId.toString()));
+                    responseData = { success: true, message: 'Group member removed successfully' };
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown group member operation: ${groupMemberOperation}`);
+            }
+            break;
+        }
+        default:
+            throw new Error(`Unknown admin operation: ${operation}`);
+    }
+    return {
+        json: responseData,
+        pairedItem: { item: itemIndex },
+    };
+}
+exports.executeAdminOperation = executeAdminOperation;

package/dist/nodes/SteyiSmartsheet/executors/Columns.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeColumnOperation(this: IExecuteFunctions, operation: string, itemIndex: number): Promise<INodeExecutionData>;

package/dist/nodes/SteyiSmartsheet/executors/Columns.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeColumnOperation = void 0;
+const SteyiGenericFunction_1 = require("../SteyiGenericFunction");
+const SteyiSmartsheetApi_1 = require("../SteyiSmartsheetApi");
+async function executeColumnOperation(operation, itemIndex) {
+    let responseData;
+    // Helper function to get sheetId
+    const getSheetId = (index) => {
+        return this.getNodeParameter('sheetId', index);
+    };
+    switch (operation) {
+        case 'getColumns': {
+            const sheetId = getSheetId(itemIndex);
+            responseData = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId));
+            break;
+        }
+        case 'updateColumn': {
+            const sheetId = getSheetId(itemIndex);
+            const columnId = this.getNodeParameter('columnId', itemIndex);
+            const title = this.getNodeParameter('title', itemIndex, '');
+            const index = this.getNodeParameter('index', itemIndex, null);
+            const columnType = this.getNodeParameter('columnType', itemIndex);
+            const optionsData = this.getNodeParameter('options', itemIndex, {});
+            const body = {
+                type: columnType,
+            };
+            if (title) {
+                body.title = title;
+            }
+            if (index !== null && index !== undefined) {
+                body.index = index;
+            }
+            // Add options for PICKLIST and MULTI_PICKLIST types
+            if (optionsData.option && Array.isArray(optionsData.option) && optionsData.option.length > 0) {
+                body.options = optionsData.option.map((opt) => {
+                    if (typeof opt === 'string')
+                        return opt;
+                    return opt.option || opt;
+                });
+            }
+            responseData = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'PUT', `/sheets/${sheetId}/columns/${columnId}`, body, itemIndex);
+            break;
+        }
+        default:
+            throw new Error(`Unknown column operation: ${operation}`);
+    }
+    return {
+        json: responseData,
+        pairedItem: { item: itemIndex },
+    };
+}
+exports.executeColumnOperation = executeColumnOperation;

package/dist/nodes/SteyiSmartsheet/executors/Reports.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeReportOperation(this: IExecuteFunctions, operation: string, itemIndex: number): Promise<INodeExecutionData>;

package/dist/nodes/SteyiSmartsheet/executors/Reports.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeReportOperation = void 0;
+const SteyiSmartsheetApi_1 = require("../SteyiSmartsheetApi");
+async function executeReportOperation(operation, itemIndex) {
+    let responseData;
+    switch (operation) {
+        case 'listReports': {
+            responseData = await SteyiSmartsheetApi_1.listReports.call(this, true);
+            break;
+        }
+        case 'getReport': {
+            const reportId = this.getNodeParameter('reportId', itemIndex);
+            const include = this.getNodeParameter('include', itemIndex, []);
+            const exclude = this.getNodeParameter('exclude', itemIndex, []);
+            responseData = await SteyiSmartsheetApi_1.getReport.call(this, parseInt(reportId.toString()), include.length > 0 ? include : undefined, exclude.length > 0 ? exclude : undefined);
+            break;
+        }
+        default:
+            throw new Error(`Unknown report operation: ${operation}`);
+    }
+    return {
+        json: responseData,
+        pairedItem: { item: itemIndex },
+    };
+}
+exports.executeReportOperation = executeReportOperation;

package/dist/nodes/SteyiSmartsheet/executors/Rows.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeRowOperation(this: IExecuteFunctions, operation: string, itemIndex: number): Promise<INodeExecutionData>;