n8n-nodes-upload-post 0.1.21 → 0.1.30

package/dist/nodes/UploadPost/UploadPost.node.js

@@ -6,6 +6,829 @@ const MANUAL_USER_VALUE = '__manual_user__';
 const MANUAL_FACEBOOK_VALUE = '__manual_facebook__';
 const MANUAL_LINKEDIN_VALUE = '__manual_linkedin__';
 const MANUAL_PINTEREST_VALUE = '__manual_pinterest__';
+const isBinaryFormField = (value) => {
+    return typeof value === 'object' && value !== null && 'value' in value;
+};
+const normalizeFormField = (value) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isBinaryFormField(value)) {
+        return value;
+    }
+    return String(value);
+};
+const buildMultipartPayload = (rawFormData) => {
+    const payload = {};
+    for (const [key, rawValue] of Object.entries(rawFormData)) {
+        if (rawValue === undefined || rawValue === null)
+            continue;
+        if (Array.isArray(rawValue)) {
+            const normalizedItems = rawValue
+                .map(item => normalizeFormField(item))
+                .filter((item) => item !== undefined);
+            if (normalizedItems.length > 0) {
+                payload[key] = normalizedItems;
+            }
+            continue;
+        }
+        const normalizedValue = normalizeFormField(rawValue);
+        if (normalizedValue !== undefined) {
+            payload[key] = normalizedValue;
+        }
+    }
+    return payload;
+};
+const parseJsonIfNeeded = (data) => {
+    if (typeof data === 'string') {
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            return data;
+        }
+    }
+    return data;
+};
+const API_BASE_URL = 'https://api.upload-post.com/api';
+const normalizeDateInput = (value) => {
+    if (!value)
+        return undefined;
+    const hasTimezone = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(value);
+    return hasTimezone ? value : `${value}Z`;
+};
+const ensureArrayFromCommaSeparated = (value) => {
+    return value
+        .split(',')
+        .map(item => item.trim())
+        .filter(item => item.length > 0);
+};
+const getBinaryFieldFromItem = async (ctx, propertyName, errorLabel) => {
+    var _a, _b;
+    const { node, itemIndex, items } = ctx;
+    try {
+        const binaryBuffer = await node.helpers.getBinaryDataBuffer(itemIndex, propertyName);
+        const binaryDetails = (_a = items[itemIndex].binary) === null || _a === void 0 ? void 0 : _a[propertyName];
+        return {
+            value: binaryBuffer,
+            options: {
+                filename: (_b = binaryDetails === null || binaryDetails === void 0 ? void 0 : binaryDetails.fileName) !== null && _b !== void 0 ? _b : propertyName,
+                contentType: binaryDetails === null || binaryDetails === void 0 ? void 0 : binaryDetails.mimeType,
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '';
+        const details = message ? ` (${message})` : '';
+        throw new n8n_workflow_1.NodeOperationError(node.getNode(), `${errorLabel} '${propertyName}' was not found in item ${itemIndex}.${details}`, {
+            itemIndex,
+        });
+    }
+};
+const PLATFORM_SUPPORT = {
+    uploadPhotos: ['facebook', 'instagram', 'linkedin', 'pinterest', 'threads', 'tiktok', 'x'],
+    uploadVideo: ['facebook', 'instagram', 'linkedin', 'pinterest', 'threads', 'tiktok', 'x', 'youtube'],
+    uploadText: ['facebook', 'linkedin', 'reddit', 'threads', 'x'],
+};
+const DESCRIPTION_ENABLED_PLATFORMS = new Set(['linkedin', 'facebook', 'youtube', 'pinterest', 'tiktok']);
+const TITLE_OVERRIDES = [
+    { platform: 'instagram', param: 'instagramTitle', field: 'instagram_title' },
+    { platform: 'facebook', param: 'facebookTitle', field: 'facebook_title' },
+    { platform: 'tiktok', param: 'tiktokTitle', field: 'tiktok_title' },
+    { platform: 'linkedin', param: 'linkedinTitle', field: 'linkedin_title' },
+    { platform: 'x', param: 'xTitle', field: 'x_title' },
+    { platform: 'youtube', param: 'youtubeTitle', field: 'youtube_title', operations: ['uploadVideo'] },
+    { platform: 'pinterest', param: 'pinterestTitle', field: 'pinterest_title' },
+    { platform: 'threads', param: 'threadsTitle', field: 'threads_title', operations: ['uploadText'] },
+];
+const DESCRIPTION_OVERRIDES = [
+    { platform: 'linkedin', param: 'linkedinDescription', field: 'linkedin_description', operations: ['uploadPhotos', 'uploadVideo'] },
+    { platform: 'youtube', param: 'youtubeDescription', field: 'youtube_description', operations: ['uploadVideo'] },
+    { platform: 'facebook', param: 'facebookDescription', field: 'facebook_description', operations: ['uploadPhotos', 'uploadVideo'] },
+    { platform: 'tiktok', param: 'tiktokDescription', field: 'tiktok_description', operations: ['uploadPhotos'] },
+    { platform: 'pinterest', param: 'pinterestDescription', field: 'pinterest_description', operations: ['uploadPhotos', 'uploadVideo'] },
+];
+const getFilteredPlatforms = (operation, platforms) => {
+    var _a;
+    const allowed = (_a = PLATFORM_SUPPORT[operation]) !== null && _a !== void 0 ? _a : [];
+    return platforms.filter(platform => allowed.includes(platform));
+};
+const applyTitleOverrides = (ctx, operation, platforms, formData) => {
+    for (const override of TITLE_OVERRIDES) {
+        if (!platforms.includes(override.platform))
+            continue;
+        if (override.operations && !override.operations.includes(operation))
+            continue;
+        const value = ctx.node.getNodeParameter(override.param, ctx.itemIndex, '');
+        if (value) {
+            formData[override.field] = value;
+        }
+    }
+};
+const applyDescriptionOverrides = (ctx, operation, platforms, formData) => {
+    const genericDescription = ctx.node.getNodeParameter('description', ctx.itemIndex, '');
+    if (genericDescription &&
+        (operation === 'uploadPhotos' || operation === 'uploadVideo') &&
+        platforms.some(platform => DESCRIPTION_ENABLED_PLATFORMS.has(platform))) {
+        formData.description = genericDescription;
+    }
+    for (const override of DESCRIPTION_OVERRIDES) {
+        if (!platforms.includes(override.platform))
+            continue;
+        if (override.operations && !override.operations.includes(operation))
+            continue;
+        const value = ctx.node.getNodeParameter(override.param, ctx.itemIndex, '');
+        if (value) {
+            formData[override.field] = value;
+        }
+    }
+};
+const getUserForOperation = (ctx, needsUser) => {
+    if (!needsUser) {
+        return '';
+    }
+    const selection = ctx.node.getNodeParameter('user', ctx.itemIndex);
+    if (selection === MANUAL_USER_VALUE) {
+        return ctx.node.getNodeParameter('userManual', ctx.itemIndex);
+    }
+    return selection;
+};
+const prepareUploadBase = (ctx, operation) => {
+    const formData = {};
+    const user = getUserForOperation(ctx, true);
+    const title = ctx.node.getNodeParameter('title', ctx.itemIndex);
+    formData.user = user;
+    formData.title = title;
+    const scheduledDate = normalizeDateInput(ctx.node.getNodeParameter('scheduledDate', ctx.itemIndex, ''));
+    if (scheduledDate) {
+        formData.scheduled_date = scheduledDate;
+    }
+    const uploadAsync = ctx.node.getNodeParameter('uploadAsync', ctx.itemIndex);
+    if (uploadAsync !== undefined) {
+        formData.async_upload = String(uploadAsync);
+    }
+    const rawPlatforms = ctx.node.getNodeParameter('platform', ctx.itemIndex);
+    const platforms = getFilteredPlatforms(operation, Array.isArray(rawPlatforms) ? rawPlatforms : []);
+    formData['platform[]'] = platforms;
+    applyTitleOverrides(ctx, operation, platforms, formData);
+    applyDescriptionOverrides(ctx, operation, platforms, formData);
+    const waitForCompletion = ctx.node.getNodeParameter('waitForCompletion', ctx.itemIndex, false);
+    const pollInterval = ctx.node.getNodeParameter('pollInterval', ctx.itemIndex, 10);
+    const pollTimeout = ctx.node.getNodeParameter('pollTimeout', ctx.itemIndex, 600);
+    return {
+        formData,
+        platforms,
+        waitForCompletion,
+        pollInterval,
+        pollTimeout,
+    };
+};
+const applyPinterestOptions = (ctx, operation, formData) => {
+    const selection = ctx.node.getNodeParameter('pinterestBoardId', ctx.itemIndex, '');
+    const pinterestBoardId = selection === MANUAL_PINTEREST_VALUE
+        ? ctx.node.getNodeParameter('pinterestBoardIdManual', ctx.itemIndex)
+        : selection;
+    if (pinterestBoardId) {
+        formData.pinterest_board_id = pinterestBoardId;
+    }
+    const pinterestLink = ctx.node.getNodeParameter('pinterestLink', ctx.itemIndex, '');
+    if (pinterestLink) {
+        formData.pinterest_link = pinterestLink;
+    }
+    if (operation === 'uploadVideo') {
+        const pinterestCoverImageUrl = ctx.node.getNodeParameter('pinterestCoverImageUrl', ctx.itemIndex, '');
+        const pinterestCoverImageContentType = ctx.node.getNodeParameter('pinterestCoverImageContentType', ctx.itemIndex, '');
+        const pinterestCoverImageData = ctx.node.getNodeParameter('pinterestCoverImageData', ctx.itemIndex, '');
+        const pinterestCoverImageKeyFrameTime = ctx.node.getNodeParameter('pinterestCoverImageKeyFrameTime', ctx.itemIndex, 0);
+        if (pinterestCoverImageUrl) {
+            formData.pinterest_cover_image_url = pinterestCoverImageUrl;
+        }
+        else if (pinterestCoverImageContentType && pinterestCoverImageData) {
+            formData.pinterest_cover_image_content_type = pinterestCoverImageContentType;
+            formData.pinterest_cover_image_data = pinterestCoverImageData;
+        }
+        else if (pinterestCoverImageKeyFrameTime !== undefined) {
+            formData.pinterest_cover_image_key_frame_time = pinterestCoverImageKeyFrameTime;
+        }
+        if (pinterestLink) {
+            formData.pinterest_link = pinterestLink;
+        }
+    }
+};
+const applyLinkedinOptions = (ctx, operation, formData) => {
+    const selection = ctx.node.getNodeParameter('targetLinkedinPageId', ctx.itemIndex, '');
+    const resolvedValue = selection === MANUAL_LINKEDIN_VALUE
+        ? ctx.node.getNodeParameter('targetLinkedinPageIdManual', ctx.itemIndex)
+        : selection;
+    if (resolvedValue && resolvedValue !== 'me') {
+        const match = resolvedValue.match(/(\d+)$/);
+        formData.target_linkedin_page_id = match ? match[1] : resolvedValue;
+    }
+    if (operation === 'uploadPhotos') {
+        const linkedinVisibility = ctx.node.getNodeParameter('linkedinVisibility', ctx.itemIndex, 'PUBLIC');
+        if (linkedinVisibility === 'PUBLIC') {
+            formData.visibility = 'PUBLIC';
+        }
+    }
+    else if (operation === 'uploadVideo') {
+        const linkedinVisibility = ctx.node.getNodeParameter('linkedinVisibility', ctx.itemIndex, 'PUBLIC');
+        formData.visibility = linkedinVisibility;
+    }
+};
+const applyFacebookOptions = (ctx, operation, formData) => {
+    const selection = ctx.node.getNodeParameter('facebookPageId', ctx.itemIndex);
+    const resolvedValue = selection === MANUAL_FACEBOOK_VALUE
+        ? ctx.node.getNodeParameter('facebookPageIdManual', ctx.itemIndex)
+        : selection;
+    formData.facebook_page_id = resolvedValue;
+    if (operation === 'uploadVideo') {
+        const facebookVideoState = ctx.node.getNodeParameter('facebookVideoState', ctx.itemIndex, '');
+        const facebookMediaType = ctx.node.getNodeParameter('facebookMediaType', ctx.itemIndex, '');
+        if (facebookVideoState) {
+            formData.video_state = facebookVideoState;
+        }
+        if (facebookMediaType) {
+            formData.facebook_media_type = facebookMediaType;
+        }
+    }
+    else if (operation === 'uploadText') {
+        const facebookLink = ctx.node.getNodeParameter('facebookLink', ctx.itemIndex, '');
+        if (facebookLink) {
+            formData.facebook_link_url = facebookLink;
+        }
+    }
+};
+const applyTiktokOptions = (ctx, operation, formData) => {
+    if (operation === 'uploadPhotos') {
+        const autoAddMusic = ctx.node.getNodeParameter('tiktokAutoAddMusic', ctx.itemIndex, false);
+        const disableComment = ctx.node.getNodeParameter('tiktokDisableComment', ctx.itemIndex, false);
+        const brandContentToggle = ctx.node.getNodeParameter('brand_content_toggle', ctx.itemIndex, false);
+        const brandOrganicToggle = ctx.node.getNodeParameter('brand_organic_toggle', ctx.itemIndex, false);
+        const photoCoverIndex = ctx.node.getNodeParameter('tiktokPhotoCoverIndex', ctx.itemIndex, 0);
+        const photoDescription = ctx.node.getNodeParameter('tiktokPhotoDescription', ctx.itemIndex, '');
+        formData.auto_add_music = String(autoAddMusic);
+        formData.disable_comment = String(disableComment);
+        formData.brand_content_toggle = String(brandContentToggle);
+        formData.brand_organic_toggle = String(brandOrganicToggle);
+        formData.photo_cover_index = photoCoverIndex;
+        if (photoDescription && formData.description === undefined) {
+            formData.description = photoDescription;
+        }
+    }
+    else if (operation === 'uploadVideo') {
+        const privacyLevel = ctx.node.getNodeParameter('tiktokPrivacyLevel', ctx.itemIndex, '');
+        const disableDuet = ctx.node.getNodeParameter('tiktokDisableDuet', ctx.itemIndex, false);
+        const disableComment = ctx.node.getNodeParameter('tiktokDisableComment', ctx.itemIndex, false);
+        const disableStitch = ctx.node.getNodeParameter('tiktokDisableStitch', ctx.itemIndex, false);
+        const coverTimestamp = ctx.node.getNodeParameter('tiktokCoverTimestamp', ctx.itemIndex, 1000);
+        const brandContentToggle = ctx.node.getNodeParameter('brand_content_toggle', ctx.itemIndex, false);
+        const brandOrganicToggle = ctx.node.getNodeParameter('brand_organic_toggle', ctx.itemIndex, false);
+        const isAigc = ctx.node.getNodeParameter('tiktokIsAigc', ctx.itemIndex, false);
+        const postMode = ctx.node.getNodeParameter('tiktokPostMode', ctx.itemIndex, '');
+        if (privacyLevel)
+            formData.privacy_level = privacyLevel;
+        formData.disable_duet = String(disableDuet);
+        formData.disable_comment = String(disableComment);
+        formData.disable_stitch = String(disableStitch);
+        formData.cover_timestamp = coverTimestamp;
+        formData.brand_content_toggle = String(brandContentToggle);
+        formData.brand_organic_toggle = String(brandOrganicToggle);
+        formData.is_aigc = String(isAigc);
+        if (postMode)
+            formData.post_mode = postMode;
+    }
+};
+const applyInstagramOptions = (ctx, operation, formData) => {
+    const providedMediaType = ctx.node.getNodeParameter('instagramMediaType', ctx.itemIndex, '');
+    let finalMediaType = providedMediaType;
+    if (operation === 'uploadPhotos') {
+        if (!['IMAGE', 'STORIES'].includes(providedMediaType)) {
+            finalMediaType = 'IMAGE';
+        }
+    }
+    else if (operation === 'uploadVideo') {
+        if (!['REELS', 'STORIES'].includes(providedMediaType)) {
+            finalMediaType = 'REELS';
+        }
+    }
+    if (finalMediaType) {
+        formData.media_type = finalMediaType;
+    }
+    if (operation === 'uploadVideo') {
+        const shareToFeed = ctx.node.getNodeParameter('instagramShareToFeed', ctx.itemIndex, true);
+        const collaborators = ctx.node.getNodeParameter('instagramCollaborators', ctx.itemIndex, '');
+        const coverUrl = ctx.node.getNodeParameter('instagramCoverUrl', ctx.itemIndex, '');
+        const audioName = ctx.node.getNodeParameter('instagramAudioName', ctx.itemIndex, '');
+        const userTags = ctx.node.getNodeParameter('instagramUserTags', ctx.itemIndex, '');
+        const locationId = ctx.node.getNodeParameter('instagramLocationId', ctx.itemIndex, '');
+        const thumbOffset = ctx.node.getNodeParameter('instagramThumbOffset', ctx.itemIndex, '');
+        formData.share_to_feed = String(shareToFeed);
+        if (collaborators)
+            formData.collaborators = collaborators;
+        if (coverUrl)
+            formData.cover_url = coverUrl;
+        if (audioName)
+            formData.audio_name = audioName;
+        if (userTags)
+            formData.user_tags = userTags;
+        if (locationId)
+            formData.location_id = locationId;
+        if (thumbOffset)
+            formData.thumb_offset = thumbOffset;
+    }
+};
+const applyYoutubeOptions = async (ctx, formData) => {
+    const tagsRaw = ctx.node.getNodeParameter('youtubeTags', ctx.itemIndex, '');
+    const categoryId = ctx.node.getNodeParameter('youtubeCategoryId', ctx.itemIndex, '');
+    const privacyStatus = ctx.node.getNodeParameter('youtubePrivacyStatus', ctx.itemIndex, '');
+    const embeddable = ctx.node.getNodeParameter('youtubeEmbeddable', ctx.itemIndex, true);
+    const license = ctx.node.getNodeParameter('youtubeLicense', ctx.itemIndex, '');
+    const publicStatsViewable = ctx.node.getNodeParameter('youtubePublicStatsViewable', ctx.itemIndex, true);
+    const madeForKids = ctx.node.getNodeParameter('youtubeMadeForKids', ctx.itemIndex, false);
+    const thumbnailInput = ctx.node.getNodeParameter('youtubeThumbnail', ctx.itemIndex, '');
+    if (tagsRaw)
+        formData['tags[]'] = ensureArrayFromCommaSeparated(tagsRaw);
+    if (categoryId)
+        formData.categoryId = categoryId;
+    if (privacyStatus)
+        formData.privacyStatus = privacyStatus;
+    formData.embeddable = String(embeddable);
+    if (license)
+        formData.license = license;
+    formData.publicStatsViewable = String(publicStatsViewable);
+    formData.madeForKids = String(madeForKids);
+    if (thumbnailInput) {
+        if (thumbnailInput.toLowerCase().startsWith('http://') || thumbnailInput.toLowerCase().startsWith('https://')) {
+            formData.thumbnail_url = thumbnailInput;
+        }
+        else {
+            const thumbnailBinary = await getBinaryFieldFromItem(ctx, thumbnailInput, 'Binary data for YouTube thumbnail property');
+            formData.thumbnail = thumbnailBinary;
+        }
+    }
+    const selfDeclaredMadeForKids = ctx.node.getNodeParameter('youtubeSelfDeclaredMadeForKids', ctx.itemIndex, false);
+    const containsSyntheticMedia = ctx.node.getNodeParameter('youtubeContainsSyntheticMedia', ctx.itemIndex, false);
+    const defaultLanguage = ctx.node.getNodeParameter('youtubeDefaultLanguage', ctx.itemIndex, '');
+    const defaultAudioLanguage = ctx.node.getNodeParameter('youtubeDefaultAudioLanguage', ctx.itemIndex, '');
+    const allowedCountries = ctx.node.getNodeParameter('youtubeAllowedCountries', ctx.itemIndex, '');
+    const blockedCountries = ctx.node.getNodeParameter('youtubeBlockedCountries', ctx.itemIndex, '');
+    const hasPaidProductPlacement = ctx.node.getNodeParameter('youtubeHasPaidProductPlacement', ctx.itemIndex, false);
+    const recordingDate = ctx.node.getNodeParameter('youtubeRecordingDate', ctx.itemIndex, '');
+    formData.selfDeclaredMadeForKids = String(selfDeclaredMadeForKids);
+    formData.containsSyntheticMedia = String(containsSyntheticMedia);
+    if (defaultLanguage)
+        formData.defaultLanguage = defaultLanguage;
+    if (defaultAudioLanguage)
+        formData.defaultAudioLanguage = defaultAudioLanguage;
+    if (allowedCountries)
+        formData.allowedCountries = allowedCountries;
+    if (blockedCountries)
+        formData.blockedCountries = blockedCountries;
+    formData.hasPaidProductPlacement = String(hasPaidProductPlacement);
+    if (recordingDate)
+        formData.recordingDate = recordingDate;
+};
+const validateXPollConfiguration = (ctx, operation, formData) => {
+    if (operation !== 'uploadText') {
+        return;
+    }
+    const pollOptionsRaw = ctx.node.getNodeParameter('xPollOptions', ctx.itemIndex, '');
+    const hasPollOptions = pollOptionsRaw.trim().length > 0;
+    if (!hasPollOptions) {
+        return;
+    }
+    const conflictingFields = [];
+    const cardUri = ctx.node.getNodeParameter('xCardUri', ctx.itemIndex, '');
+    const quoteTweetId = ctx.node.getNodeParameter('xQuoteTweetId', ctx.itemIndex, '');
+    const directMessageDeepLink = ctx.node.getNodeParameter('xDirectMessageDeepLink', ctx.itemIndex, '');
+    if (cardUri.trim().length > 0)
+        conflictingFields.push('X Card URI');
+    if (quoteTweetId.trim().length > 0)
+        conflictingFields.push('X Quote Tweet ID');
+    if (directMessageDeepLink.trim().length > 0)
+        conflictingFields.push('X Direct Message Deep Link');
+    if (conflictingFields.length > 0) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `X Poll Options cannot be used with: ${conflictingFields.join(', ')}. These fields are mutually exclusive.`);
+    }
+    const pollOptions = ensureArrayFromCommaSeparated(pollOptionsRaw);
+    if (pollOptions.length < 2 || pollOptions.length > 4) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `X Poll Options must contain between 2 and 4 non-empty options. Found: ${pollOptions.length}`);
+    }
+    const invalidOptions = pollOptions.filter(option => option.length > 25);
+    if (invalidOptions.length > 0) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `X Poll Options cannot exceed 25 characters each. Invalid options: ${invalidOptions.join(', ')}`);
+    }
+    const pollDuration = ctx.node.getNodeParameter('xPollDuration', ctx.itemIndex, 1440);
+    if (pollDuration < 5 || pollDuration > 10080) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `X Poll Duration must be between 5 and 10080 minutes (5 minutes to 7 days). Provided: ${pollDuration}`);
+    }
+    formData['poll_options[]'] = pollOptions;
+    formData.poll_duration = pollDuration;
+    const pollReplySettings = ctx.node.getNodeParameter('xPollReplySettings', ctx.itemIndex, 'following');
+    formData.poll_reply_settings = pollReplySettings;
+};
+const applyXOptions = (ctx, operation, formData) => {
+    const quoteTweetId = ctx.node.getNodeParameter('xQuoteTweetId', ctx.itemIndex, '');
+    const geoPlaceId = ctx.node.getNodeParameter('xGeoPlaceId', ctx.itemIndex, '');
+    const forSuperFollowersOnly = ctx.node.getNodeParameter('xForSuperFollowersOnly', ctx.itemIndex, false);
+    const communityId = ctx.node.getNodeParameter('xCommunityId', ctx.itemIndex, '');
+    const shareWithFollowers = ctx.node.getNodeParameter('xShareWithFollowers', ctx.itemIndex, false);
+    const directMessageDeepLink = ctx.node.getNodeParameter('xDirectMessageDeepLink', ctx.itemIndex, '');
+    const cardUri = ctx.node.getNodeParameter('xCardUri', ctx.itemIndex, '');
+    if (quoteTweetId)
+        formData.quote_tweet_id = quoteTweetId;
+    if (geoPlaceId)
+        formData.geo_place_id = geoPlaceId;
+    if (forSuperFollowersOnly)
+        formData.for_super_followers_only = String(forSuperFollowersOnly);
+    if (communityId)
+        formData.community_id = communityId;
+    if (shareWithFollowers)
+        formData.share_with_followers = String(shareWithFollowers);
+    if (directMessageDeepLink)
+        formData.direct_message_deep_link = directMessageDeepLink;
+    if (cardUri)
+        formData.card_uri = cardUri;
+    if (operation === 'uploadText') {
+        const postUrl = ctx.node.getNodeParameter('xPostUrlText', ctx.itemIndex, '');
+        const replySettings = ctx.node.getNodeParameter('xReplySettings', ctx.itemIndex, 'everyone');
+        if (postUrl)
+            formData.post_url = postUrl;
+        if (replySettings && replySettings !== 'everyone')
+            formData.reply_settings = replySettings;
+        validateXPollConfiguration(ctx, operation, formData);
+        const xLongTextAsPost = ctx.node.getNodeParameter('xLongTextAsPost', ctx.itemIndex, false);
+        if (xLongTextAsPost) {
+            formData.x_long_text_as_post = String(xLongTextAsPost);
+        }
+        delete formData.nullcast;
+        delete formData.place_id;
+    }
+    else {
+        const taggedUserIds = ctx.node.getNodeParameter('xTaggedUserIds', ctx.itemIndex, '');
+        const replySettings = ctx.node.getNodeParameter('xReplySettings', ctx.itemIndex, 'everyone');
+        const nullcast = ctx.node.getNodeParameter('xNullcastVideo', ctx.itemIndex, false);
+        if (taggedUserIds) {
+            formData['tagged_user_ids[]'] = ensureArrayFromCommaSeparated(taggedUserIds);
+        }
+        if (replySettings && replySettings !== 'everyone')
+            formData.reply_settings = replySettings;
+        formData.nullcast = String(nullcast);
+        if (operation === 'uploadVideo') {
+            const xLongTextAsPost = ctx.node.getNodeParameter('xLongTextAsPost', ctx.itemIndex, false);
+            if (xLongTextAsPost) {
+                formData.x_long_text_as_post = String(xLongTextAsPost);
+            }
+        }
+        const xPlaceIdVideo = ctx.node.getNodeParameter('xPlaceIdVideo', ctx.itemIndex, '');
+        if (operation === 'uploadVideo' && xPlaceIdVideo) {
+            formData.place_id = xPlaceIdVideo;
+        }
+    }
+};
+const applyThreadsOptions = (ctx, formData) => {
+    const threadsLongTextAsPost = ctx.node.getNodeParameter('threadsLongTextAsPost', ctx.itemIndex, false);
+    if (threadsLongTextAsPost) {
+        formData.threads_long_text_as_post = String(threadsLongTextAsPost);
+    }
+};
+const applyRedditOptions = (ctx, formData) => {
+    const subreddit = ctx.node.getNodeParameter('redditSubreddit', ctx.itemIndex);
+    const flairId = ctx.node.getNodeParameter('redditFlairId', ctx.itemIndex, '');
+    formData.subreddit = subreddit;
+    if (flairId) {
+        formData.flair_id = flairId;
+    }
+};
+const applyUploadPlatformOptions = async (ctx, operation, prep) => {
+    const { formData, platforms } = prep;
+    if (platforms.includes('pinterest')) {
+        applyPinterestOptions(ctx, operation, formData);
+    }
+    if (platforms.includes('linkedin')) {
+        applyLinkedinOptions(ctx, operation, formData);
+    }
+    if (platforms.includes('facebook')) {
+        applyFacebookOptions(ctx, operation, formData);
+    }
+    if (platforms.includes('tiktok')) {
+        applyTiktokOptions(ctx, operation, formData);
+    }
+    if (platforms.includes('instagram')) {
+        applyInstagramOptions(ctx, operation, formData);
+    }
+    if (platforms.includes('youtube') && operation === 'uploadVideo') {
+        await applyYoutubeOptions(ctx, formData);
+    }
+    if (platforms.includes('x')) {
+        applyXOptions(ctx, operation, formData);
+    }
+    if (operation === 'uploadText' && platforms.includes('threads')) {
+        applyThreadsOptions(ctx, formData);
+    }
+    if (operation === 'uploadText' && platforms.includes('reddit')) {
+        applyRedditOptions(ctx, formData);
+    }
+};
+const buildUploadPhotosRequest = async (ctx) => {
+    const prep = prepareUploadBase(ctx, 'uploadPhotos');
+    const photosInput = ctx.node.getNodeParameter('photos', ctx.itemIndex, '');
+    let photosToProcess = [];
+    if (Array.isArray(photosInput)) {
+        photosToProcess = photosInput.filter(item => typeof item === 'string' && item.trim().length > 0).map(item => item.trim());
+    }
+    else if (typeof photosInput === 'string') {
+        photosToProcess = ensureArrayFromCommaSeparated(photosInput);
+    }
+    const photoArray = [];
+    for (const photoItem of photosToProcess) {
+        if (photoItem.toLowerCase().startsWith('http://') || photoItem.toLowerCase().startsWith('https://')) {
+            photoArray.push(photoItem);
+            continue;
+        }
+        const binaryField = await getBinaryFieldFromItem(ctx, photoItem, 'Binary data for property');
+        photoArray.push(binaryField);
+    }
+    if (photoArray.length > 0) {
+        prep.formData['photos[]'] = photoArray;
+    }
+    await applyUploadPlatformOptions(ctx, 'uploadPhotos', prep);
+    return {
+        endpoint: '/upload_photos',
+        method: 'POST',
+        formData: prep.formData,
+        isUploadOperation: true,
+        waitForCompletion: prep.waitForCompletion,
+        pollInterval: prep.pollInterval,
+        pollTimeout: prep.pollTimeout,
+    };
+};
+const buildUploadVideoRequest = async (ctx) => {
+    const prep = prepareUploadBase(ctx, 'uploadVideo');
+    const videoInput = ctx.node.getNodeParameter('video', ctx.itemIndex, '');
+    if (videoInput) {
+        if (videoInput.toLowerCase().startsWith('http://') || videoInput.toLowerCase().startsWith('https://')) {
+            prep.formData.video = videoInput;
+        }
+        else {
+            const binaryField = await getBinaryFieldFromItem(ctx, videoInput, 'Binary data for video property');
+            prep.formData.video = binaryField;
+        }
+    }
+    await applyUploadPlatformOptions(ctx, 'uploadVideo', prep);
+    return {
+        endpoint: '/upload',
+        method: 'POST',
+        formData: prep.formData,
+        isUploadOperation: true,
+        waitForCompletion: prep.waitForCompletion,
+        pollInterval: prep.pollInterval,
+        pollTimeout: prep.pollTimeout,
+    };
+};
+const buildUploadTextRequest = async (ctx) => {
+    const prep = prepareUploadBase(ctx, 'uploadText');
+    await applyUploadPlatformOptions(ctx, 'uploadText', prep);
+    return {
+        endpoint: '/upload_text',
+        method: 'POST',
+        formData: prep.formData,
+        isUploadOperation: true,
+        waitForCompletion: prep.waitForCompletion,
+        pollInterval: prep.pollInterval,
+        pollTimeout: prep.pollTimeout,
+    };
+};
+const buildMonitoringRequest = (ctx) => {
+    switch (ctx.operation) {
+        case 'getStatus': {
+            const requestId = ctx.node.getNodeParameter('requestId', ctx.itemIndex);
+            return {
+                endpoint: '/uploadposts/status',
+                method: 'GET',
+                qs: { request_id: requestId },
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'getHistory': {
+            const page = ctx.node.getNodeParameter('historyPage', ctx.itemIndex, 1);
+            const limit = ctx.node.getNodeParameter('historyLimit', ctx.itemIndex, 20);
+            return {
+                endpoint: '/uploadposts/history',
+                method: 'GET',
+                qs: { page, limit },
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'getAnalytics': {
+            const profileUsername = ctx.node.getNodeParameter('analyticsProfileUsername', ctx.itemIndex);
+            const analyticsPlatforms = ctx.node.getNodeParameter('analyticsPlatforms', ctx.itemIndex, []);
+            const qs = {};
+            if (Array.isArray(analyticsPlatforms) && analyticsPlatforms.length > 0) {
+                qs.platforms = analyticsPlatforms.join(',');
+            }
+            return {
+                endpoint: `/analytics/${encodeURIComponent(profileUsername)}`,
+                method: 'GET',
+                qs,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'listScheduled': {
+            return {
+                endpoint: '/uploadposts/schedule',
+                method: 'GET',
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'cancelScheduled': {
+            const jobId = ctx.node.getNodeParameter('scheduleJobId', ctx.itemIndex);
+            return {
+                endpoint: `/uploadposts/schedule/${jobId}`,
+                method: 'DELETE',
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'editScheduled': {
+            const jobId = ctx.node.getNodeParameter('scheduleJobId', ctx.itemIndex);
+            const newScheduledDateRaw = ctx.node.getNodeParameter('newScheduledDate', ctx.itemIndex, '');
+            const normalizedDate = normalizeDateInput(newScheduledDateRaw);
+            const body = {};
+            if (normalizedDate) {
+                body.scheduled_date = normalizedDate;
+            }
+            return {
+                endpoint: `/uploadposts/schedule/${jobId}`,
+                method: 'POST',
+                body,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        default:
+            throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `Unsupported monitoring operation: ${ctx.operation}`, {
+                itemIndex: ctx.itemIndex,
+            });
+    }
+};
+const buildUserRequest = (ctx) => {
+    switch (ctx.operation) {
+        case 'listUsers':
+            return {
+                endpoint: '/uploadposts/users',
+                method: 'GET',
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        case 'createUser': {
+            const username = ctx.node.getNodeParameter('newUser', ctx.itemIndex);
+            return {
+                endpoint: '/uploadposts/users',
+                method: 'POST',
+                body: { username },
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'deleteUser': {
+            const username = ctx.node.getNodeParameter('deleteUserId', ctx.itemIndex);
+            return {
+                endpoint: '/uploadposts/users',
+                method: 'DELETE',
+                body: { username },
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'generateJwt': {
+            const username = getUserForOperation(ctx, true);
+            const redirectUrl = ctx.node.getNodeParameter('redirectUrl', ctx.itemIndex, '');
+            const logoImage = ctx.node.getNodeParameter('logoImage', ctx.itemIndex, '');
+            const redirectButtonText = ctx.node.getNodeParameter('redirectButtonText', ctx.itemIndex, '');
+            const platforms = ctx.node.getNodeParameter('jwtPlatforms', ctx.itemIndex, []);
+            const body = { username };
+            if (redirectUrl)
+                body.redirect_url = redirectUrl;
+            if (logoImage)
+                body.logo_image = logoImage;
+            if (redirectButtonText)
+                body.redirect_button_text = redirectButtonText;
+            if (Array.isArray(platforms) && platforms.length > 0)
+                body.platforms = platforms;
+            return {
+                endpoint: '/uploadposts/users/generate-jwt',
+                method: 'POST',
+                body,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'validateJwt': {
+            const jwt = ctx.node.getNodeParameter('jwtToken', ctx.itemIndex);
+            return {
+                endpoint: '/uploadposts/users/validate-jwt',
+                method: 'POST',
+                body: { jwt },
+                headers: { Authorization: `Bearer ${jwt}` },
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        default:
+            throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `Unsupported user operation: ${ctx.operation}`, {
+                itemIndex: ctx.itemIndex,
+            });
+    }
+};
+const buildRequestConfig = async (ctx) => {
+    if (ctx.operation === 'uploadPhotos') {
+        return buildUploadPhotosRequest(ctx);
+    }
+    if (ctx.operation === 'uploadVideo') {
+        return buildUploadVideoRequest(ctx);
+    }
+    if (ctx.operation === 'uploadText') {
+        return buildUploadTextRequest(ctx);
+    }
+    const resource = ctx.node.getNodeParameter('resource', ctx.itemIndex);
+    if (resource === 'monitoring') {
+        return buildMonitoringRequest(ctx);
+    }
+    if (resource === 'users') {
+        return buildUserRequest(ctx);
+    }
+    throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `Unsupported operation: ${ctx.operation}`, {
+        itemIndex: ctx.itemIndex,
+    });
+};
+const buildNativeFormData = (payload, node) => {
+    if (typeof FormData === 'undefined') {
+        throw new n8n_workflow_1.NodeOperationError(node.getNode(), 'FormData is not supported in this runtime environment');
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(payload)) {
+        if (Array.isArray(value)) {
+            value.forEach(item => appendValue(form, key, item));
+        }
+        else {
+            appendValue(form, key, value);
+        }
+    }
+    return form;
+};
+const appendValue = (form, key, value) => {
+    if (isBinaryFormField(value)) {
+        appendBinaryValue(form, key, value);
+    }
+    else {
+        form.append(key, value);
+    }
+};
+const appendBinaryValue = (form, key, field) => {
+    var _a, _b;
+    const { value, options } = field;
+    if (typeof value === 'string') {
+        form.append(key, value);
+        return;
+    }
+    const filename = (_a = options === null || options === void 0 ? void 0 : options.filename) !== null && _a !== void 0 ? _a : 'upload.bin';
+    const contentType = (_b = options === null || options === void 0 ? void 0 : options.contentType) !== null && _b !== void 0 ? _b : 'application/octet-stream';
+    if (typeof Blob !== 'undefined') {
+        const blob = new Blob([value], { type: contentType });
+        form.append(key, blob, filename);
+        return;
+    }
+    form.append(key, value, { filename, contentType });
+};
+const pollUploadStatus = async (node, requestId, pollInterval, pollTimeout) => {
+    const start = Date.now();
+    let finalData = { success: false, message: 'Polling timed out', request_id: requestId };
+    while (true) {
+        await (0, n8n_workflow_1.sleep)(Math.max(1, pollInterval) * 1000);
+        if (Date.now() - start > Math.max(5, pollTimeout) * 1000) {
+            break;
+        }
+        const statusOptions = {
+            url: `${API_BASE_URL}/uploadposts/status`,
+            method: 'GET',
+            qs: { request_id: requestId },
+            json: true,
+        };
+        const statusData = await node.helpers.httpRequestWithAuthentication.call(node, 'uploadPostApi', statusOptions);
+        finalData = statusData;
+        const statusValue = (statusData && statusData.status);
+        if ((statusData && statusData.success === true) ||
+            (statusValue && ['success', 'completed', 'failed', 'error'].includes(statusValue.toLowerCase()))) {
+            break;
+        }
+    }
+    return finalData;
+};
 class UploadPost {
     constructor() {
         this.description = {
@@ -1532,20 +2355,17 @@ class UploadPost {
                 },
                 async getFacebookPages() {
                     try {
-                        const credentials = await this.getCredentials('uploadPostApi');
-                        const apiKey = credentials.apiKey;
                         const profile = this.getCurrentNodeParameter('user') || '';
                         const qs = {};
                         if (profile)
                             qs.profile = profile;
                         const options = {
-                            uri: 'https://api.upload-post.com/api/uploadposts/facebook/pages',
+                            url: 'https://api.upload-post.com/api/uploadposts/facebook/pages',
                             method: 'GET',
-                            headers: { Authorization: `ApiKey ${apiKey}` },
                             qs,
                             json: true,
                         };
-                        const resp = await this.helpers.request(options);
+                        const resp = await this.helpers.httpRequestWithAuthentication.call(this, 'uploadPostApi', options);
                         const pages = (resp && (resp.pages || resp.data || []));
                         const pageOptions = (pages || []).map(p => ({ name: p.name ? `${p.name} (${p.id})` : p.id, value: p.id }));
                         return [
@@ -1561,20 +2381,17 @@ class UploadPost {
                 },
                 async getLinkedinPages() {
                     try {
-                        const credentials = await this.getCredentials('uploadPostApi');
-                        const apiKey = credentials.apiKey;
                         const profile = this.getCurrentNodeParameter('user') || '';
                         const qs = {};
                         if (profile)
                             qs.profile = profile;
                         const options = {
-                            uri: 'https://api.upload-post.com/api/uploadposts/linkedin/pages',
+                            url: 'https://api.upload-post.com/api/uploadposts/linkedin/pages',
                             method: 'GET',
-                            headers: { Authorization: `ApiKey ${apiKey}` },
                             qs,
                             json: true,
                         };
-                        const resp = await this.helpers.request(options);
+                        const resp = await this.helpers.httpRequestWithAuthentication.call(this, 'uploadPostApi', options);
                         const pages = (resp && (resp.pages || resp.data || []));
                         const pageOptions = (pages || []).map(p => ({ name: p.name ? `${p.name} (${p.id})` : p.id, value: p.id }));
                         return [
@@ -1592,20 +2409,17 @@ class UploadPost {
                 },
                 async getPinterestBoards() {
                     try {
-                        const credentials = await this.getCredentials('uploadPostApi');
-                        const apiKey = credentials.apiKey;
                         const profile = this.getCurrentNodeParameter('user') || '';
                         const qs = {};
                         if (profile)
                             qs.profile = profile;
                         const options = {
-                            uri: 'https://api.upload-post.com/api/uploadposts/pinterest/boards',
+                            url: 'https://api.upload-post.com/api/uploadposts/pinterest/boards',
                             method: 'GET',
-                            headers: { Authorization: `ApiKey ${apiKey}` },
                             qs,
                             json: true,
                         };
-                        const resp = await this.helpers.request(options);
+                        const resp = await this.helpers.httpRequestWithAuthentication.call(this, 'uploadPostApi', options);
                         const boards = (resp && (resp.boards || resp.data || []));
                         const boardOptions = (boards || []).map(b => ({ name: b.name ? `${b.name} (${b.id})` : b.id, value: b.id }));
                         return [
@@ -1621,15 +2435,12 @@ class UploadPost {
                 },
                 async getUserProfiles() {
                     try {
-                        const credentials = await this.getCredentials('uploadPostApi');
-                        const apiKey = credentials.apiKey;
                         const options = {
-                            uri: 'https://api.upload-post.com/api/uploadposts/users',
+                            url: 'https://api.upload-post.com/api/uploadposts/users',
                             method: 'GET',
-                            headers: { Authorization: `ApiKey ${apiKey}` },
                             json: true,
                         };
-                        const resp = await this.helpers.request(options);
+                        const resp = await this.helpers.httpRequestWithAuthentication.call(this, 'uploadPostApi', options);
                         const profiles = (resp && resp.profiles);
                         const profileOptions = (profiles || []).map(profile => {
                             const connectedPlatforms = Object.keys(profile.social_accounts || {})
@@ -1658,742 +2469,55 @@ class UploadPost {
         };
     }
     async execute() {
-        var _a, _b, _c;
+        var _a, _b;
         const items = this.getInputData();
         const returnData = [];
-        for (let i = 0; i < items.length; i++) {
-            const operation = this.getNodeParameter('operation', i);
-            const isUploadOperation = ['uploadPhotos', 'uploadVideo', 'uploadText'].includes(operation);
-            const needsUser = isUploadOperation || operation === 'generateJwt';
-            const userSelection = needsUser ? this.getNodeParameter('user', i) : '';
-            const userManualValue = needsUser && userSelection === MANUAL_USER_VALUE
-                ? this.getNodeParameter('userManual', i)
-                : '';
-            const user = needsUser
-                ? (userSelection === MANUAL_USER_VALUE ? userManualValue : userSelection)
-                : '';
-            let platforms = isUploadOperation ? this.getNodeParameter('platform', i) : [];
-            const title = isUploadOperation ? this.getNodeParameter('title', i) : '';
-            let endpoint = '';
-            let method = 'POST';
-            const formData = {};
-            const qs = {};
-            const body = {};
-            if (isUploadOperation) {
-                formData.user = user;
-                formData.title = title;
-                const scheduledDate = this.getNodeParameter('scheduledDate', i);
-                if (scheduledDate) {
-                    let normalizedDate = scheduledDate;
-                    const hasTimezone = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(normalizedDate);
-                    if (!hasTimezone) {
-                        normalizedDate = `${normalizedDate}Z`;
-                    }
-                    formData.scheduled_date = normalizedDate;
-                }
-                const uploadAsync = this.getNodeParameter('uploadAsync', i);
-                if (uploadAsync !== undefined) {
-                    formData.async_upload = String(uploadAsync);
-                }
-            }
-            if (isUploadOperation) {
-                try {
-                    if (platforms.includes('instagram')) {
-                        const instagramTitle = this.getNodeParameter('instagramTitle', i, '');
-                        if (instagramTitle)
-                            formData.instagram_title = instagramTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('facebook')) {
-                        const facebookTitle = this.getNodeParameter('facebookTitle', i, '');
-                        if (facebookTitle)
-                            formData.facebook_title = facebookTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('tiktok')) {
-                        const tiktokTitle = this.getNodeParameter('tiktokTitle', i, '');
-                        if (tiktokTitle)
-                            formData.tiktok_title = tiktokTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('linkedin')) {
-                        const linkedinTitle = this.getNodeParameter('linkedinTitle', i, '');
-                        if (linkedinTitle)
-                            formData.linkedin_title = linkedinTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('x')) {
-                        const xTitle = this.getNodeParameter('xTitle', i, '');
-                        if (xTitle)
-                            formData.x_title = xTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('youtube')) {
-                        const youtubeTitle = this.getNodeParameter('youtubeTitle', i, '');
-                        if (youtubeTitle)
-                            formData.youtube_title = youtubeTitle;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('pinterest')) {
-                        const pinterestTitle = this.getNodeParameter('pinterestTitle', i, '');
-                        if (pinterestTitle)
-                            formData.pinterest_title = pinterestTitle;
-                    }
-                }
-                catch { }
-            }
-            if (isUploadOperation) {
-                const genericDescription = this.getNodeParameter('description', i, '');
-                const descriptionPlatforms = new Set(['linkedin', 'facebook', 'youtube', 'pinterest', 'tiktok']);
-                if (genericDescription && platforms.some(p => descriptionPlatforms.has(p))) {
-                    formData.description = genericDescription;
-                }
-                try {
-                    if (platforms.includes('linkedin')) {
-                        const linkedinDescription = this.getNodeParameter('linkedinDescription', i, '');
-                        if (linkedinDescription)
-                            formData.linkedin_description = linkedinDescription;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('youtube')) {
-                        const youtubeDescription = this.getNodeParameter('youtubeDescription', i, '');
-                        if (youtubeDescription)
-                            formData.youtube_description = youtubeDescription;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('facebook')) {
-                        const facebookDescription = this.getNodeParameter('facebookDescription', i, '');
-                        if (facebookDescription)
-                            formData.facebook_description = facebookDescription;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('tiktok')) {
-                        const tiktokDescription = this.getNodeParameter('tiktokDescription', i, '');
-                        if (tiktokDescription)
-                            formData.tiktok_description = tiktokDescription;
-                    }
-                }
-                catch { }
-                try {
-                    if (platforms.includes('pinterest')) {
-                        const pinterestDescription = this.getNodeParameter('pinterestDescription', i, '');
-                        if (pinterestDescription)
-                            formData.pinterest_description = pinterestDescription;
-                    }
-                }
-                catch { }
-            }
-            switch (operation) {
-                case 'uploadPhotos':
-                    endpoint = '/upload_photos';
-                    let photosInput = this.getNodeParameter('photos', i, []);
-                    let photosToProcess;
-                    if (typeof photosInput === 'string') {
-                        photosToProcess = photosInput.split(',').map(item => item.trim()).filter(item => item !== '');
-                    }
-                    else {
-                        photosToProcess = photosInput.filter(item => typeof item === 'string' && item.trim() !== '');
-                    }
-                    const allowedPhotoPlatforms = ['tiktok', 'instagram', 'linkedin', 'facebook', 'x', 'threads', 'pinterest'];
-                    platforms = platforms.filter(p => allowedPhotoPlatforms.includes(p));
-                    formData['platform[]'] = platforms;
-                    if (photosToProcess.length > 0) {
-                        const photoArray = [];
-                        for (const photoItem of photosToProcess) {
-                            if (typeof photoItem === 'string' && photoItem) {
-                                if (photoItem.toLowerCase().startsWith('http://') || photoItem.toLowerCase().startsWith('https://')) {
-                                    photoArray.push(photoItem);
-                                }
-                                else {
-                                    const binaryPropertyName = photoItem;
-                                    try {
-                                        const binaryBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                                        const binaryFileDetails = items[i].binary[binaryPropertyName];
-                                        photoArray.push({
-                                            value: binaryBuffer,
-                                            options: {
-                                                filename: (_a = binaryFileDetails.fileName) !== null && _a !== void 0 ? _a : binaryPropertyName,
-                                                contentType: binaryFileDetails.mimeType,
-                                            },
-                                        });
-                                    }
-                                    catch (error) {
-                                        this.logger.warn(`[UploadPost Node] Could not find binary data for property '${binaryPropertyName}' in item ${i}. Error: ${error.message}`);
-                                    }
-                                }
-                            }
-                        }
-                        if (photoArray.length > 0) {
-                            formData['photos[]'] = photoArray;
-                        }
-                    }
-                    break;
-                case 'uploadVideo':
-                    endpoint = '/upload';
-                    const videoInput = this.getNodeParameter('video', i);
-                    const allowedVideoPlatforms = ['tiktok', 'instagram', 'linkedin', 'youtube', 'facebook', 'x', 'threads', 'pinterest'];
-                    platforms = platforms.filter(p => allowedVideoPlatforms.includes(p));
-                    formData['platform[]'] = platforms;
-                    if (videoInput) {
-                        if (videoInput.toLowerCase().startsWith('http://') || videoInput.toLowerCase().startsWith('https://')) {
-                            formData.video = videoInput;
-                        }
-                        else {
-                            const binaryPropertyName = videoInput;
-                            try {
-                                const binaryBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                                const binaryFileDetails = items[i].binary[binaryPropertyName];
-                                formData.video = {
-                                    value: binaryBuffer,
-                                    options: {
-                                        filename: (_b = binaryFileDetails.fileName) !== null && _b !== void 0 ? _b : binaryPropertyName,
-                                        contentType: binaryFileDetails.mimeType,
-                                    },
-                                };
-                            }
-                            catch (error) {
-                                this.logger.warn(`[UploadPost Node] Could not find binary data for video property '${binaryPropertyName}' in item ${i}. Error: ${error.message}`);
-                            }
-                        }
-                    }
-                    break;
-                case 'uploadText':
-                    endpoint = '/upload_text';
-                    const allowedTextPlatforms = ['x', 'linkedin', 'facebook', 'threads', 'reddit'];
-                    platforms = platforms.filter(p => allowedTextPlatforms.includes(p));
-                    formData['platform[]'] = platforms;
-                    break;
-                case 'getStatus':
-                    method = 'GET';
-                    endpoint = '/uploadposts/status';
-                    qs.request_id = this.getNodeParameter('requestId', i);
-                    break;
-                case 'getHistory':
-                    method = 'GET';
-                    endpoint = '/uploadposts/history';
-                    const historyPage = this.getNodeParameter('historyPage', i);
-                    qs.page = historyPage !== null && historyPage !== void 0 ? historyPage : 1;
-                    const historyLimit = this.getNodeParameter('historyLimit', i);
-                    qs.limit = historyLimit !== null && historyLimit !== void 0 ? historyLimit : 20;
-                    break;
-                case 'getAnalytics':
-                    method = 'GET';
-                    {
-                        const analyticsPlatforms = this.getNodeParameter('analyticsPlatforms', i, []);
-                        const profileUsername = this.getNodeParameter('analyticsProfileUsername', i);
-                        endpoint = `/analytics/${encodeURIComponent(profileUsername)}`;
-                        if (Array.isArray(analyticsPlatforms) && analyticsPlatforms.length > 0) {
-                            qs.platforms = analyticsPlatforms.join(',');
-                        }
-                    }
-                    break;
-                case 'listScheduled':
-                    method = 'GET';
-                    endpoint = '/uploadposts/schedule';
-                    break;
-                case 'cancelScheduled':
-                    method = 'DELETE';
-                    {
-                        const jobId = this.getNodeParameter('scheduleJobId', i);
-                        endpoint = `/uploadposts/schedule/${jobId}`;
-                    }
-                    break;
-                case 'editScheduled':
-                    method = 'POST';
-                    {
-                        const jobId = this.getNodeParameter('scheduleJobId', i);
-                        endpoint = `/uploadposts/schedule/${jobId}`;
-                        const newScheduledDate = this.getNodeParameter('newScheduledDate', i, '');
-                        if (newScheduledDate) {
-                            let normalizedDate = newScheduledDate;
-                            const hasTimezone = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(normalizedDate);
-                            if (!hasTimezone)
-                                normalizedDate = `${normalizedDate}Z`;
-                            body.scheduled_date = normalizedDate;
-                        }
-                    }
-                    break;
-                case 'listUsers':
-                    method = 'GET';
-                    endpoint = '/uploadposts/users';
-                    break;
-                case 'createUser':
-                    method = 'POST';
-                    endpoint = '/uploadposts/users';
-                    body.username = this.getNodeParameter('newUser', i);
-                    break;
-                case 'deleteUser':
-                    method = 'DELETE';
-                    endpoint = '/uploadposts/users';
-                    body.username = this.getNodeParameter('deleteUserId', i);
-                    break;
-                case 'generateJwt':
-                    method = 'POST';
-                    endpoint = '/uploadposts/users/generate-jwt';
-                    body.username = user;
-                    const redirectUrl = this.getNodeParameter('redirectUrl', i, '');
-                    const logoImage = this.getNodeParameter('logoImage', i, '');
-                    const redirectButtonText = this.getNodeParameter('redirectButtonText', i, '');
-                    const jwtPlatforms = this.getNodeParameter('jwtPlatforms', i, []);
-                    if (redirectUrl)
-                        body.redirect_url = redirectUrl;
-                    if (logoImage)
-                        body.logo_image = logoImage;
-                    if (redirectButtonText)
-                        body.redirect_button_text = redirectButtonText;
-                    if (Array.isArray(jwtPlatforms) && jwtPlatforms.length > 0)
-                        body.platforms = jwtPlatforms;
-                    break;
-                case 'validateJwt':
-                    method = 'POST';
-                    endpoint = '/uploadposts/users/validate-jwt';
-                    body.jwt = this.getNodeParameter('jwtToken', i);
-                    break;
-            }
-            if (isUploadOperation && platforms.includes('pinterest')) {
-                const pinterestSelection = this.getNodeParameter('pinterestBoardId', i);
-                const pinterestManual = pinterestSelection === MANUAL_PINTEREST_VALUE
-                    ? this.getNodeParameter('pinterestBoardIdManual', i)
-                    : '';
-                const pinterestBoardId = pinterestSelection === MANUAL_PINTEREST_VALUE ? pinterestManual : pinterestSelection;
-                if (pinterestBoardId)
-                    formData.pinterest_board_id = pinterestBoardId;
-                const pinterestLink = this.getNodeParameter('pinterestLink', i);
-                if (pinterestLink)
-                    formData.pinterest_link = pinterestLink;
-                if (operation === 'uploadVideo') {
-                    const pinterestCoverImageUrl = this.getNodeParameter('pinterestCoverImageUrl', i);
-                    const pinterestCoverImageContentType = this.getNodeParameter('pinterestCoverImageContentType', i);
-                    const pinterestCoverImageData = this.getNodeParameter('pinterestCoverImageData', i);
-                    const pinterestCoverImageKeyFrameTime = this.getNodeParameter('pinterestCoverImageKeyFrameTime', i);
-                    const pinterestLink = this.getNodeParameter('pinterestLink', i);
-                    if (pinterestCoverImageUrl) {
-                        formData.pinterest_cover_image_url = pinterestCoverImageUrl;
-                    }
-                    else {
-                        if (pinterestCoverImageContentType && pinterestCoverImageData) {
-                            formData.pinterest_cover_image_content_type = pinterestCoverImageContentType;
-                            formData.pinterest_cover_image_data = pinterestCoverImageData;
-                        }
-                        else if (pinterestCoverImageKeyFrameTime !== undefined) {
-                            formData.pinterest_cover_image_key_frame_time = pinterestCoverImageKeyFrameTime;
-                        }
-                    }
-                    if (pinterestLink)
-                        formData.pinterest_link = pinterestLink;
-                }
-            }
-            if (isUploadOperation && platforms.includes('linkedin')) {
-                const targetLinkedinSelection = this.getNodeParameter('targetLinkedinPageId', i);
-                const targetLinkedinManual = targetLinkedinSelection === MANUAL_LINKEDIN_VALUE
-                    ? this.getNodeParameter('targetLinkedinPageIdManual', i)
-                    : '';
-                const targetLinkedinPageId = targetLinkedinSelection === MANUAL_LINKEDIN_VALUE ? targetLinkedinManual : targetLinkedinSelection;
-                if (targetLinkedinPageId && targetLinkedinPageId !== 'me') {
-                    const match = targetLinkedinPageId.match(/(\d+)$/);
-                    if (match) {
-                        formData.target_linkedin_page_id = match[1];
-                    }
-                    else {
-                        formData.target_linkedin_page_id = targetLinkedinPageId;
-                    }
-                }
-                if (operation === 'uploadPhotos') {
-                    const linkedinVisibility = this.getNodeParameter('linkedinVisibility', i);
-                    if (linkedinVisibility === 'PUBLIC') {
-                        formData.visibility = 'PUBLIC';
-                    }
-                }
-                else if (operation === 'uploadVideo') {
-                    const linkedinVisibility = this.getNodeParameter('linkedinVisibility', i);
-                    formData.visibility = linkedinVisibility;
-                }
-            }
-            if (isUploadOperation && platforms.includes('facebook')) {
-                const facebookPageSelection = this.getNodeParameter('facebookPageId', i);
-                const facebookPageManual = facebookPageSelection === MANUAL_FACEBOOK_VALUE
-                    ? this.getNodeParameter('facebookPageIdManual', i)
-                    : '';
-                const facebookPageId = facebookPageSelection === MANUAL_FACEBOOK_VALUE ? facebookPageManual : facebookPageSelection;
-                formData.facebook_page_id = facebookPageId;
-                if (operation === 'uploadVideo') {
-                    const facebookVideoState = this.getNodeParameter('facebookVideoState', i);
-                    if (facebookVideoState)
-                        formData.video_state = facebookVideoState;
-                    try {
-                        const facebookMediaType = this.getNodeParameter('facebookMediaType', i);
-                        if (facebookMediaType)
-                            formData.facebook_media_type = facebookMediaType;
-                    }
-                    catch { }
-                }
-                else if (operation === 'uploadText') {
-                    const facebookLink = this.getNodeParameter('facebookLink', i);
-                    if (facebookLink)
-                        formData.facebook_link_url = facebookLink;
-                }
-            }
-            if (isUploadOperation && platforms.includes('tiktok')) {
-                if (operation === 'uploadPhotos') {
-                    const tiktokAutoAddMusic = this.getNodeParameter('tiktokAutoAddMusic', i);
-                    const tiktokDisableComment = this.getNodeParameter('tiktokDisableComment', i);
-                    const brandContentToggle = this.getNodeParameter('brand_content_toggle', i);
-                    const brandOrganicToggle = this.getNodeParameter('brand_organic_toggle', i);
-                    const tiktokPhotoCoverIndex = this.getNodeParameter('tiktokPhotoCoverIndex', i);
-                    const tiktokPhotoDescription = this.getNodeParameter('tiktokPhotoDescription', i);
-                    if (tiktokAutoAddMusic !== undefined)
-                        formData.auto_add_music = String(tiktokAutoAddMusic);
-                    if (tiktokDisableComment !== undefined)
-                        formData.disable_comment = String(tiktokDisableComment);
-                    if (brandContentToggle !== undefined)
-                        formData.brand_content_toggle = String(brandContentToggle);
-                    if (brandOrganicToggle !== undefined)
-                        formData.brand_organic_toggle = String(brandOrganicToggle);
-                    if (tiktokPhotoCoverIndex !== undefined)
-                        formData.photo_cover_index = tiktokPhotoCoverIndex;
-                    if (tiktokPhotoDescription && formData.description === undefined)
-                        formData.description = tiktokPhotoDescription;
-                }
-                else if (operation === 'uploadVideo') {
-                    const tiktokPrivacyLevel = this.getNodeParameter('tiktokPrivacyLevel', i);
-                    const tiktokDisableDuet = this.getNodeParameter('tiktokDisableDuet', i);
-                    const tiktokDisableComment = this.getNodeParameter('tiktokDisableComment', i);
-                    const tiktokDisableStitch = this.getNodeParameter('tiktokDisableStitch', i);
-                    const tiktokCoverTimestamp = this.getNodeParameter('tiktokCoverTimestamp', i);
-                    const brandContentToggle = this.getNodeParameter('brand_content_toggle', i);
-                    const brandOrganicToggle = this.getNodeParameter('brand_organic_toggle', i);
-                    const tiktokIsAigc = this.getNodeParameter('tiktokIsAigc', i);
-                    const tiktokPostMode = this.getNodeParameter('tiktokPostMode', i);
-                    if (tiktokPrivacyLevel)
-                        formData.privacy_level = tiktokPrivacyLevel;
-                    if (tiktokDisableDuet !== undefined)
-                        formData.disable_duet = String(tiktokDisableDuet);
-                    if (tiktokDisableComment !== undefined)
-                        formData.disable_comment = String(tiktokDisableComment);
-                    if (tiktokDisableStitch !== undefined)
-                        formData.disable_stitch = String(tiktokDisableStitch);
-                    if (tiktokCoverTimestamp !== undefined)
-                        formData.cover_timestamp = tiktokCoverTimestamp;
-                    if (brandContentToggle !== undefined)
-                        formData.brand_content_toggle = String(brandContentToggle);
-                    if (brandOrganicToggle !== undefined)
-                        formData.brand_organic_toggle = String(brandOrganicToggle);
-                    if (tiktokIsAigc !== undefined)
-                        formData.is_aigc = String(tiktokIsAigc);
-                    if (tiktokPostMode)
-                        formData.post_mode = tiktokPostMode;
-                }
-            }
-            if (isUploadOperation && platforms.includes('instagram')) {
-                const instagramMediaTypeInput = this.getNodeParameter('instagramMediaType', i);
-                let finalInstagramMediaType = instagramMediaTypeInput;
-                if (operation === 'uploadPhotos') {
-                    if (!instagramMediaTypeInput || !['IMAGE', 'STORIES'].includes(instagramMediaTypeInput)) {
-                        finalInstagramMediaType = 'IMAGE';
-                    }
-                }
-                else if (operation === 'uploadVideo') {
-                    if (!instagramMediaTypeInput || !['REELS', 'STORIES'].includes(instagramMediaTypeInput)) {
-                        finalInstagramMediaType = 'REELS';
-                    }
-                }
-                if (finalInstagramMediaType)
-                    formData.media_type = finalInstagramMediaType;
-                if (operation === 'uploadVideo') {
-                    const instagramShareToFeed = this.getNodeParameter('instagramShareToFeed', i);
-                    const instagramCollaborators = this.getNodeParameter('instagramCollaborators', i);
-                    const instagramCoverUrl = this.getNodeParameter('instagramCoverUrl', i);
-                    const instagramAudioName = this.getNodeParameter('instagramAudioName', i);
-                    const instagramUserTags = this.getNodeParameter('instagramUserTags', i);
-                    const instagramLocationId = this.getNodeParameter('instagramLocationId', i);
-                    const instagramThumbOffset = this.getNodeParameter('instagramThumbOffset', i);
-                    if (instagramShareToFeed !== undefined)
-                        formData.share_to_feed = String(instagramShareToFeed);
-                    if (instagramCollaborators)
-                        formData.collaborators = instagramCollaborators;
-                    if (instagramCoverUrl)
-                        formData.cover_url = instagramCoverUrl;
-                    if (instagramAudioName)
-                        formData.audio_name = instagramAudioName;
-                    if (instagramUserTags)
-                        formData.user_tags = instagramUserTags;
-                    if (instagramLocationId)
-                        formData.location_id = instagramLocationId;
-                    if (instagramThumbOffset)
-                        formData.thumb_offset = instagramThumbOffset;
-                }
-            }
-            if (isUploadOperation && platforms.includes('youtube') && operation === 'uploadVideo') {
-                const youtubeTagsRaw = this.getNodeParameter('youtubeTags', i);
-                const youtubeCategoryId = this.getNodeParameter('youtubeCategoryId', i);
-                const youtubePrivacyStatus = this.getNodeParameter('youtubePrivacyStatus', i);
-                const youtubeEmbeddable = this.getNodeParameter('youtubeEmbeddable', i);
-                const youtubeLicense = this.getNodeParameter('youtubeLicense', i);
-                const youtubePublicStatsViewable = this.getNodeParameter('youtubePublicStatsViewable', i);
-                const youtubeMadeForKids = this.getNodeParameter('youtubeMadeForKids', i);
-                const youtubeThumbnail = this.getNodeParameter('youtubeThumbnail', i);
-                if (youtubeTagsRaw)
-                    formData['tags[]'] = youtubeTagsRaw.split(',').map(tag => tag.trim());
-                if (youtubeCategoryId)
-                    formData.categoryId = youtubeCategoryId;
-                if (youtubePrivacyStatus)
-                    formData.privacyStatus = youtubePrivacyStatus;
-                if (youtubeEmbeddable !== undefined)
-                    formData.embeddable = String(youtubeEmbeddable);
-                if (youtubeLicense)
-                    formData.license = youtubeLicense;
-                if (youtubePublicStatsViewable !== undefined)
-                    formData.publicStatsViewable = String(youtubePublicStatsViewable);
-                if (youtubeMadeForKids !== undefined)
-                    formData.madeForKids = String(youtubeMadeForKids);
-                if (youtubeThumbnail) {
-                    if (youtubeThumbnail.toLowerCase().startsWith('http://') || youtubeThumbnail.toLowerCase().startsWith('https://')) {
-                        formData.thumbnail_url = youtubeThumbnail;
-                    }
-                    else {
-                        const binaryPropertyName = youtubeThumbnail;
-                        try {
-                            const binaryBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
-                            const binaryFileDetails = items[i].binary[binaryPropertyName];
-                            formData.thumbnail = {
-                                value: binaryBuffer,
-                                options: {
-                                    filename: (_c = binaryFileDetails.fileName) !== null && _c !== void 0 ? _c : binaryPropertyName,
-                                    contentType: binaryFileDetails.mimeType,
-                                },
-                            };
-                        }
-                        catch (error) {
-                            this.logger.warn(`[UploadPost Node] Could not find binary data for YouTube thumbnail property '${binaryPropertyName}' in item ${i}. Error: ${error.message}`);
-                        }
-                    }
-                }
-                const youtubeSelfDeclaredMadeForKids = this.getNodeParameter('youtubeSelfDeclaredMadeForKids', i);
-                const youtubeContainsSyntheticMedia = this.getNodeParameter('youtubeContainsSyntheticMedia', i);
-                const youtubeDefaultLanguage = this.getNodeParameter('youtubeDefaultLanguage', i);
-                const youtubeDefaultAudioLanguage = this.getNodeParameter('youtubeDefaultAudioLanguage', i);
-                const youtubeAllowedCountries = this.getNodeParameter('youtubeAllowedCountries', i);
-                const youtubeBlockedCountries = this.getNodeParameter('youtubeBlockedCountries', i);
-                const youtubeHasPaidProductPlacement = this.getNodeParameter('youtubeHasPaidProductPlacement', i);
-                const youtubeRecordingDate = this.getNodeParameter('youtubeRecordingDate', i);
-                if (youtubeSelfDeclaredMadeForKids !== undefined)
-                    formData.selfDeclaredMadeForKids = String(youtubeSelfDeclaredMadeForKids);
-                if (youtubeContainsSyntheticMedia !== undefined)
-                    formData.containsSyntheticMedia = String(youtubeContainsSyntheticMedia);
-                if (youtubeDefaultLanguage)
-                    formData.defaultLanguage = youtubeDefaultLanguage;
-                if (youtubeDefaultAudioLanguage)
-                    formData.defaultAudioLanguage = youtubeDefaultAudioLanguage;
-                if (youtubeAllowedCountries)
-                    formData.allowedCountries = youtubeAllowedCountries;
-                if (youtubeBlockedCountries)
-                    formData.blockedCountries = youtubeBlockedCountries;
-                if (youtubeHasPaidProductPlacement !== undefined)
-                    formData.hasPaidProductPlacement = String(youtubeHasPaidProductPlacement);
-                if (youtubeRecordingDate)
-                    formData.recordingDate = youtubeRecordingDate;
-            }
-            if (isUploadOperation && platforms.includes('x')) {
-                const xQuoteTweetId = this.getNodeParameter('xQuoteTweetId', i, '');
-                const xGeoPlaceId = this.getNodeParameter('xGeoPlaceId', i, '');
-                const xForSuperFollowersOnly = this.getNodeParameter('xForSuperFollowersOnly', i, false);
-                const xCommunityId = this.getNodeParameter('xCommunityId', i, '');
-                const xShareWithFollowers = this.getNodeParameter('xShareWithFollowers', i, false);
-                const xDirectMessageDeepLink = this.getNodeParameter('xDirectMessageDeepLink', i, '');
-                const xCardUri = this.getNodeParameter('xCardUri', i, '');
-                if (xQuoteTweetId)
-                    formData.quote_tweet_id = xQuoteTweetId;
-                if (xGeoPlaceId)
-                    formData.geo_place_id = xGeoPlaceId;
-                if (xForSuperFollowersOnly)
-                    formData.for_super_followers_only = String(xForSuperFollowersOnly);
-                if (xCommunityId)
-                    formData.community_id = xCommunityId;
-                if (xShareWithFollowers)
-                    formData.share_with_followers = String(xShareWithFollowers);
-                if (xDirectMessageDeepLink)
-                    formData.direct_message_deep_link = xDirectMessageDeepLink;
-                if (xCardUri)
-                    formData.card_uri = xCardUri;
-                if (operation === 'uploadText') {
-                    const xPostUrlText = this.getNodeParameter('xPostUrlText', i);
-                    if (xPostUrlText)
-                        formData.post_url = xPostUrlText;
-                    const xReplySettingsText = this.getNodeParameter('xReplySettings', i);
-                    if (xReplySettingsText && xReplySettingsText !== 'everyone')
-                        formData.reply_settings = xReplySettingsText;
-                    const xPollDuration = this.getNodeParameter('xPollDuration', i, 1440);
-                    const xPollOptionsRaw = this.getNodeParameter('xPollOptions', i, '');
-                    const xPollReplySettings = this.getNodeParameter('xPollReplySettings', i, 'following');
-                    const xCardUri = this.getNodeParameter('xCardUri', i, '');
-                    const xQuoteTweetId = this.getNodeParameter('xQuoteTweetId', i, '');
-                    const xDirectMessageDeepLink = this.getNodeParameter('xDirectMessageDeepLink', i, '');
-                    const hasPollOptions = xPollOptionsRaw && xPollOptionsRaw.trim();
-                    const hasCardUri = xCardUri && xCardUri.trim();
-                    const hasQuoteTweetId = xQuoteTweetId && xQuoteTweetId.trim();
-                    const hasDirectMessageDeepLink = xDirectMessageDeepLink && xDirectMessageDeepLink.trim();
-                    if (hasPollOptions && (hasCardUri || hasQuoteTweetId || hasDirectMessageDeepLink)) {
-                        const conflictingFields = [];
-                        if (hasCardUri)
-                            conflictingFields.push('X Card URI');
-                        if (hasQuoteTweetId)
-                            conflictingFields.push('X Quote Tweet ID');
-                        if (hasDirectMessageDeepLink)
-                            conflictingFields.push('X Direct Message Deep Link');
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `X Poll Options cannot be used with: ${conflictingFields.join(', ')}. These fields are mutually exclusive.`);
-                    }
-                    if (hasPollOptions) {
-                        const pollOptions = xPollOptionsRaw.split(',').map(opt => opt.trim()).filter(opt => opt.length > 0);
-                        if (pollOptions.length < 2 || pollOptions.length > 4) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `X Poll Options must contain between 2 and 4 non-empty options. Found: ${pollOptions.length}`);
-                        }
-                        const invalidOptions = pollOptions.filter(opt => opt.length > 25);
-                        if (invalidOptions.length > 0) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `X Poll Options cannot exceed 25 characters each. Invalid options: ${invalidOptions.join(', ')}`);
-                        }
-                        if (xPollDuration < 5 || xPollDuration > 10080) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `X Poll Duration must be between 5 and 10080 minutes (5 minutes to 7 days). Provided: ${xPollDuration}`);
-                        }
-                        formData['poll_options[]'] = pollOptions;
-                        formData.poll_duration = xPollDuration;
-                        formData.poll_reply_settings = xPollReplySettings;
-                    }
-                    try {
-                        const xLongTextAsPostText = this.getNodeParameter('xLongTextAsPost', i, false);
-                        if (xLongTextAsPostText)
-                            formData.x_long_text_as_post = String(xLongTextAsPostText);
-                    }
-                    catch { }
-                    delete formData.nullcast;
-                    delete formData.place_id;
-                }
-                else if (operation === 'uploadVideo' || operation === 'uploadPhotos') {
-                    const xTaggedUserIds = this.getNodeParameter('xTaggedUserIds', i);
-                    const xReplySettings = this.getNodeParameter('xReplySettings', i);
-                    const xNullcastVideo = this.getNodeParameter('xNullcastVideo', i);
-                    if (xTaggedUserIds)
-                        formData['tagged_user_ids[]'] = xTaggedUserIds.split(',').map(id => id.trim());
-                    if (xReplySettings && xReplySettings !== 'everyone')
-                        formData.reply_settings = xReplySettings;
-                    if (xNullcastVideo !== undefined)
-                        formData.nullcast = String(xNullcastVideo);
-                    if (operation === 'uploadVideo') {
-                        try {
-                            const xLongTextAsPost = this.getNodeParameter('xLongTextAsPost', i, false);
-                            if (xLongTextAsPost)
-                                formData.x_long_text_as_post = String(xLongTextAsPost);
-                        }
-                        catch { }
-                    }
-                }
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            const operation = this.getNodeParameter('operation', itemIndex);
+            const ctx = {
+                node: this,
+                items,
+                itemIndex,
+                operation,
+            };
+            const config = await buildRequestConfig(ctx);
+            const requestOptions = {
+                url: `${API_BASE_URL}${config.endpoint}`,
+                method: config.method,
+            };
+            if (config.headers) {
+                requestOptions.headers = config.headers;
             }
-            if (isUploadOperation && platforms.includes('threads')) {
-                if (operation === 'uploadText') {
-                    const threadsTitle = this.getNodeParameter('threadsTitle', i, '');
-                    if (threadsTitle)
-                        formData.threads_title = threadsTitle;
-                    const threadsLongTextAsPost = this.getNodeParameter('threadsLongTextAsPost', i, false);
-                    if (threadsLongTextAsPost)
-                        formData.threads_long_text_as_post = String(threadsLongTextAsPost);
-                }
+            if (config.qs) {
+                requestOptions.qs = config.qs;
             }
-            if (isUploadOperation && platforms.includes('reddit')) {
-                if (operation === 'uploadText') {
-                    const redditSubreddit = this.getNodeParameter('redditSubreddit', i);
-                    formData.subreddit = redditSubreddit;
-                    const redditFlairId = this.getNodeParameter('redditFlairId', i, '');
-                    if (redditFlairId)
-                        formData.flair_id = redditFlairId;
-                }
+            if (config.formData) {
+                const multipartPayload = buildMultipartPayload(config.formData);
+                const nativeFormData = buildNativeFormData(multipartPayload, this);
+                requestOptions.body = nativeFormData;
+                requestOptions.json = false;
             }
-            const credentials = await this.getCredentials('uploadPostApi');
-            const apiKey = credentials.apiKey;
-            const options = {
-                uri: `https://api.upload-post.com/api${endpoint}`,
-                method,
-                headers: {},
-                json: true,
-            };
-            if (operation === 'validateJwt') {
-                const jwt = this.getNodeParameter('jwtToken', i);
-                options.headers['Authorization'] = `Bearer ${jwt}`;
+            else if (config.body) {
+                requestOptions.body = config.body;
+                requestOptions.json = true;
             }
             else {
-                options.headers['Authorization'] = `ApiKey ${apiKey}`;
-            }
-            if (method === 'POST') {
-                if (operation === 'uploadPhotos' || operation === 'uploadVideo' || operation === 'uploadText') {
-                    options.formData = formData;
-                }
-                else {
-                    options.body = body;
-                }
-            }
-            else if (method === 'GET' || method === 'DELETE') {
-                if (operation === 'deleteUser') {
-                    options.body = body;
-                }
-                else {
-                    options.qs = qs;
-                }
+                requestOptions.json = true;
             }
-            this.logger.info(`Operation: ${operation}, Is Upload Operation: ${isUploadOperation}`);
-            const responseData = await this.helpers.request(options);
-            const shouldConsiderPolling = operation === 'uploadPhotos' || operation === 'uploadVideo' || operation === 'uploadText';
-            const waitForCompletion = shouldConsiderPolling ? this.getNodeParameter('waitForCompletion', i, false) : false;
+            const rawResponse = await this.helpers.httpRequestWithAuthentication.call(this, 'uploadPostApi', requestOptions);
+            const responseData = parseJsonIfNeeded(rawResponse);
             let finalData = responseData;
-            if (shouldConsiderPolling && waitForCompletion) {
-                const maybeRequestId = (responseData && responseData.request_id) ? responseData.request_id : undefined;
-                if (maybeRequestId) {
-                    const requestId = maybeRequestId;
-                    const pollIntervalSec = this.getNodeParameter('pollInterval', i, 10);
-                    const pollTimeoutSec = this.getNodeParameter('pollTimeout', i, 600);
-                    const start = Date.now();
-                    while (true) {
-                        await (0, n8n_workflow_1.sleep)(Math.max(1, pollIntervalSec) * 1000);
-                        if (Date.now() - start > Math.max(5, pollTimeoutSec) * 1000) {
-                            finalData = { success: false, message: 'Polling timed out', request_id: requestId };
-                            break;
-                        }
-                        const statusOptions = {
-                            uri: `https://api.upload-post.com/api/uploadposts/status`,
-                            method: 'GET',
-                            headers: { 'Authorization': `ApiKey ${apiKey}` },
-                            qs: { request_id: requestId },
-                            json: true,
-                        };
-                        const statusData = await this.helpers.request(statusOptions);
-                        finalData = statusData;
-                        const statusValue = (statusData && statusData.status);
-                        if (statusData.success === true || (statusValue && ['success', 'completed', 'failed', 'error'].includes(statusValue.toLowerCase()))) {
-                            break;
-                        }
-                    }
+            if (config.isUploadOperation && config.waitForCompletion) {
+                const requestId = responseData && responseData.request_id
+                    ? responseData.request_id
+                    : undefined;
+                if (requestId) {
+                    finalData = await pollUploadStatus(this, requestId, (_a = config.pollInterval) !== null && _a !== void 0 ? _a : 10, (_b = config.pollTimeout) !== null && _b !== void 0 ? _b : 600);
                 }
             }
             returnData.push({
                 json: finalData,
-                pairedItem: {
-                    item: i,
-                },
+                pairedItem: { item: itemIndex },
             });
         }
         return [returnData];