n8n-nodes-upload-post 0.1.17 → 0.1.19

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UploadPost = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
+const MANUAL_USER_VALUE = '__manual_user__';
+const MANUAL_FACEBOOK_VALUE = '__manual_facebook__';
+const MANUAL_LINKEDIN_VALUE = '__manual_linkedin__';
+const MANUAL_PINTEREST_VALUE = '__manual_pinterest__';
 class UploadPost {
     constructor() {
         this.description = {
@@ -81,12 +85,14 @@ class UploadPost {
                     displayOptions: { show: { resource: ['users'] } },
                 },
                 {
-                    displayName: 'User Identifier',
+                    displayName: 'User Identifier Name or ID',
                     name: 'user',
-                    type: 'string',
+                    type: 'options',
+                    noDataExpression: true,
                     required: true,
                     default: '',
-                    description: 'The Profile Name you created in your upload-post.com account. You can find it in the \'Manage Users\' section (e.g., app.upload-post.com/manage-users).',
+                    description: 'Choose from your created profiles, or specify a profile name using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    typeOptions: { loadOptionsMethod: 'getUserProfiles' },
                     displayOptions: {
                         show: {
                             resource: ['uploads', 'users'],
@@ -95,22 +101,28 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'Platform(s)',
+                    displayName: 'User Identifier (Manual Entry)',
+                    name: 'userManual',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Provide a profile name or ID when it does not appear in the list',
+                    displayOptions: {
+                        show: {
+                            resource: ['uploads', 'users'],
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText', 'generateJwt'],
+                            user: [MANUAL_USER_VALUE]
+                        }
+                    },
+                },
+                {
+                    displayName: 'Platform Names or IDs',
                     name: 'platform',
                     type: 'multiOptions',
                     required: true,
-                    options: [
-                        { name: 'Facebook', value: 'facebook' },
-                        { name: 'Instagram', value: 'instagram' },
-                        { name: 'LinkedIn', value: 'linkedin' },
-                        { name: 'Pinterest', value: 'pinterest' },
-                        { name: 'Threads', value: 'threads' },
-                        { name: 'TikTok', value: 'tiktok' },
-                        { name: 'X (Twitter)', value: 'x' },
-                        { name: 'YouTube', value: 'youtube' },
-                    ],
+                    typeOptions: { loadOptionsMethod: 'getPlatforms' },
                     default: [],
-                    description: 'Platform(s) to upload to. Supported platforms vary by operation.',
+                    description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
                     displayOptions: { show: { resource: ['uploads'], operation: ['uploadPhotos', 'uploadVideo', 'uploadText'] } },
                 },
                 {
@@ -179,44 +191,32 @@ class UploadPost {
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo', 'uploadText'], platform: ['pinterest'] } },
                 },
                 {
-                    displayName: 'Photos (Files or URLs)',
-                    name: 'photos',
+                    displayName: 'Threads Title (Override)',
+                    name: 'threadsTitle',
                     type: 'string',
-                    required: true,
                     default: '',
-                    description: 'Provide photo files or URLs as a comma-separated list (e.g., data,https://example.com/image.jpg,otherImage). For files, enter the binary property name (e.g., data, myImage). For URLs, provide direct HTTP/HTTPS URLs.',
-                    displayOptions: {
-                        show: {
-                            operation: ['uploadPhotos'],
-                        },
-                    },
+                    description: 'Optional override for Threads title',
+                    displayOptions: { show: { operation: ['uploadText'], platform: ['threads'] } },
                 },
                 {
                     displayName: 'Description (Optional)',
                     name: 'description',
                     type: 'string',
                     default: '',
-                    description: 'Generic description to use across platforms when supported. Platform-specific overrides below take precedence.',
+                    description: 'Optional extended description used for LinkedIn commentary, Facebook description/message, YouTube video description, Pinterest description, and TikTok photo captions. Other platforms ignore it. When empty we fall back to the main title where a description is required. Platform-specific overrides below take precedence.',
                     displayOptions: {
                         show: {
-                            operation: ['uploadPhotos', 'uploadVideo']
+                            operation: ['uploadPhotos', 'uploadVideo'],
+                            platform: ['linkedin', 'facebook', 'youtube', 'pinterest', 'tiktok']
                         }
                     },
                 },
-                {
-                    displayName: 'Instagram Description (Override)',
-                    name: 'instagramDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'Optional description override for Instagram',
-                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['instagram'] } },
-                },
                 {
                     displayName: 'Facebook Description (Override)',
                     name: 'facebookDescription',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for Facebook',
+                    description: 'Override for Facebook description/message when supported (Reels/feed, albums). Falls back to the main title when empty.',
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['facebook'] } },
                 },
                 {
@@ -224,31 +224,23 @@ class UploadPost {
                     name: 'tiktokDescription',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for TikTok',
-                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['tiktok'] } },
+                    description: 'Override for TikTok photo post description. Video uploads ignore this value.',
+                    displayOptions: { show: { operation: ['uploadPhotos'], platform: ['tiktok'] } },
                 },
                 {
                     displayName: 'LinkedIn Description (Override)',
                     name: 'linkedinDescription',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for LinkedIn',
+                    description: 'Override for LinkedIn post commentary. When empty we repeat the main title.',
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['linkedin'] } },
                 },
-                {
-                    displayName: 'X Description (Override)',
-                    name: 'xDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'Optional description override for X',
-                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['x'] } },
-                },
                 {
                     displayName: 'YouTube Description (Override)',
                     name: 'youtubeDescription',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for YouTube',
+                    description: 'Override for YouTube video description. When empty we default to the main title.',
                     displayOptions: { show: { operation: ['uploadVideo'], platform: ['youtube'] } },
                 },
                 {
@@ -256,16 +248,21 @@ class UploadPost {
                     name: 'pinterestDescription',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for Pinterest',
+                    description: 'Override for Pinterest pin description (and alt text fallback). When empty we re-use the main title.',
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['pinterest'] } },
                 },
                 {
-                    displayName: 'Threads Description (Override)',
-                    name: 'threadsDescription',
+                    displayName: 'Photos (Files or URLs)',
+                    name: 'photos',
                     type: 'string',
+                    required: true,
                     default: '',
-                    description: 'Optional description override for Threads',
-                    displayOptions: { show: { operation: ['uploadVideo'], platform: ['threads'] } },
+                    description: 'Provide photo files or URLs as a comma-separated list (e.g., data,https://example.com/image.jpg,otherImage). For files, enter the binary property name (e.g., data, myImage). For URLs, provide direct HTTP/HTTPS URLs.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos'],
+                        },
+                    },
                 },
                 {
                     displayName: 'Video (File or URL)',
@@ -304,7 +301,7 @@ class UploadPost {
                     displayName: 'Wait for Completion',
                     name: 'waitForCompletion',
                     type: 'boolean',
-                    default: false,
+                    default: true,
                     description: 'Whether to perform best-effort sleeping between status checks within this node. Not guaranteed to finish; for reliable long polling use a separate Wait node plus Get Upload Status.',
                     displayOptions: {
                         show: {
@@ -510,9 +507,10 @@ class UploadPost {
                     displayName: 'Target LinkedIn Page Name or ID',
                     name: 'targetLinkedinPageId',
                     type: 'options',
+                    noDataExpression: true,
                     default: '',
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                    typeOptions: { loadOptionsMethod: 'getLinkedinPages' },
+                    typeOptions: { loadOptionsMethod: 'getLinkedinPages', loadOptionsDependsOn: ['user'] },
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
@@ -520,6 +518,21 @@ class UploadPost {
                         }
                     },
                 },
+                {
+                    displayName: 'LinkedIn Page Name or ID (Manual Entry)',
+                    name: 'targetLinkedinPageIdManual',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Provide the LinkedIn page identifier when it does not appear in the list',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['linkedin'],
+                            targetLinkedinPageId: [MANUAL_LINKEDIN_VALUE]
+                        }
+                    },
+                },
                 {
                     displayName: 'LinkedIn Video Description',
                     name: 'linkedinDescription',
@@ -537,10 +550,11 @@ class UploadPost {
                     displayName: 'Facebook Page Name or ID',
                     name: 'facebookPageId',
                     type: 'options',
+                    noDataExpression: true,
                     required: true,
                     default: '',
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                    typeOptions: { loadOptionsMethod: 'getFacebookPages' },
+                    typeOptions: { loadOptionsMethod: 'getFacebookPages', loadOptionsDependsOn: ['user'] },
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
@@ -548,6 +562,21 @@ class UploadPost {
                         }
                     },
                 },
+                {
+                    displayName: 'Facebook Page Name or ID (Manual Entry)',
+                    name: 'facebookPageIdManual',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Provide the Facebook page identifier when it does not appear in the list',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['facebook'],
+                            facebookPageId: [MANUAL_FACEBOOK_VALUE]
+                        }
+                    },
+                },
                 {
                     displayName: 'Facebook Link (Text)',
                     name: 'facebookLink',
@@ -581,10 +610,9 @@ class UploadPost {
                     options: [
                         { name: 'Published', value: 'PUBLISHED' },
                         { name: 'Draft', value: 'DRAFT' },
-                        { name: 'Scheduled', value: 'SCHEDULED' },
                     ],
                     default: 'PUBLISHED',
-                    description: 'State for Facebook Video (DRAFT, PUBLISHED, SCHEDULED). Not for Photos/Text.',
+                    description: 'State for Facebook Video (DRAFT or PUBLISHED). Use Scheduled Date field for scheduling.',
                     displayOptions: {
                         show: {
                             operation: ['uploadVideo'],
@@ -636,11 +664,12 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'TikTok Branded Content (Photo)',
-                    name: 'tiktokBrandedContentPhoto',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to indicate photo post is branded content (requires Disclose Commercial). Only for Upload Photos.',
+                    displayName: 'TikTok Photo Cover Index',
+                    name: 'tiktokPhotoCoverIndex',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: { minValue: 0 },
+                    description: 'Index (0-based) of photo to use as cover for TikTok photo post. Only for Upload Photos.',
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos'],
@@ -649,11 +678,11 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'TikTok Disclose Commercial (Photo)',
-                    name: 'tiktokDiscloseCommercialPhoto',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to disclose commercial nature of photo post. Only for Upload Photos.',
+                    displayName: 'TikTok Photo Description',
+                    name: 'tiktokPhotoDescription',
+                    type: 'string',
+                    default: '',
+                    description: 'Description for TikTok photo post. If not provided, Title is used. Only for Upload Photos.',
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos'],
@@ -662,12 +691,11 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'TikTok Photo Cover Index',
-                    name: 'tiktokPhotoCoverIndex',
-                    type: 'number',
-                    default: 0,
-                    typeOptions: { minValue: 0 },
-                    description: 'Index (0-based) of photo to use as cover for TikTok photo post. Only for Upload Photos.',
+                    displayName: 'TikTok Brand Content Toggle (Photo)',
+                    name: 'brand_content_toggle',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to set as true for paid partnerships that promote third-party brands',
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos'],
@@ -676,11 +704,11 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'TikTok Photo Description',
-                    name: 'tiktokPhotoDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'Description for TikTok photo post. If not provided, Title is used. Only for Upload Photos.',
+                    displayName: 'TikTok Brand Organic Toggle (Photo)',
+                    name: 'brand_organic_toggle',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to set as true when promoting the creator\'s own business',
                     displayOptions: {
                         show: {
                             operation: ['uploadPhotos'],
@@ -748,36 +776,10 @@ class UploadPost {
                 },
                 {
                     displayName: 'TikTok Brand Content Toggle (Video)',
-                    name: 'tiktokBrandContentToggle',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to enable branded content for TikTok video. Only for Upload Video.',
-                    displayOptions: {
-                        show: {
-                            operation: ['uploadVideo'],
-                            platform: ['tiktok']
-                        },
-                    },
-                },
-                {
-                    displayName: 'TikTok Brand Organic (Video)',
-                    name: 'tiktokBrandOrganic',
+                    name: 'brand_content_toggle',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to enable organic branded content for TikTok video. Only for Upload Video.',
-                    displayOptions: {
-                        show: {
-                            operation: ['uploadVideo'],
-                            platform: ['tiktok']
-                        },
-                    },
-                },
-                {
-                    displayName: 'TikTok Branded Content (Video)',
-                    name: 'tiktokBrandedContentVideo',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to enable branded content with disclosure for TikTok video. Only for Upload Video.',
+                    description: 'Whether to enable brand content toggle for paid partnerships that promote third-party brands',
                     displayOptions: {
                         show: {
                             operation: ['uploadVideo'],
@@ -787,10 +789,10 @@ class UploadPost {
                 },
                 {
                     displayName: 'TikTok Brand Organic Toggle (Video)',
-                    name: 'tiktokBrandOrganicToggle',
+                    name: 'brand_organic_toggle',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to enable organic branded content toggle for TikTok video. Only for Upload Video.',
+                    description: 'Whether to enable brand organic toggle when promoting the creator\'s own business',
                     displayOptions: {
                         show: {
                             operation: ['uploadVideo'],
@@ -938,17 +940,29 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'YouTube Video Description',
-                    name: 'youtubeDescription',
+                    displayName: 'Threads Long Text as Single Post',
+                    name: 'threadsLongTextAsPost',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether long text is published as a single post. If false (default), a thread is created if the text exceeds 500 characters.',
+                    displayOptions: { show: { operation: ['uploadText'], platform: ['threads'] } },
+                },
+                {
+                    displayName: 'Reddit Subreddit',
+                    name: 'redditSubreddit',
                     type: 'string',
+                    required: true,
                     default: '',
-                    description: 'Description of the video for YouTube. If not provided, Title is used. Only for Upload Video.',
-                    displayOptions: {
-                        show: {
-                            operation: ['uploadVideo'],
-                            platform: ['youtube']
-                        },
-                    },
+                    description: 'Destination subreddit, without r/ (e.g., python)',
+                    displayOptions: { show: { operation: ['uploadText'] } },
+                },
+                {
+                    displayName: 'Reddit Flair ID',
+                    name: 'redditFlairId',
+                    type: 'string',
+                    default: '',
+                    description: 'ID of the flair template to apply to the post',
+                    displayOptions: { show: { operation: ['uploadText'], platform: ['reddit'] } },
                 },
                 {
                     displayName: 'YouTube Tags',
@@ -1063,20 +1077,142 @@ class UploadPost {
                         },
                     },
                 },
+                {
+                    displayName: 'YouTube Self Declared Made For Kids',
+                    name: 'youtubeSelfDeclaredMadeForKids',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether this is an explicit declaration for children content (COPPA compliance). Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Contains Synthetic Media',
+                    name: 'youtubeContainsSyntheticMedia',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether this is a declaration for AI/synthetic content transparency. Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Default Language',
+                    name: 'youtubeDefaultLanguage',
+                    type: 'string',
+                    default: '',
+                    description: 'Title/description language (BCP-47 codes like "es", "en"). Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Default Audio Language',
+                    name: 'youtubeDefaultAudioLanguage',
+                    type: 'string',
+                    default: '',
+                    description: 'Video audio language (BCP-47 codes like "es-ES", "en-US"). Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Allowed Countries',
+                    name: 'youtubeAllowedCountries',
+                    type: 'string',
+                    default: '',
+                    description: 'Comma-separated country codes for allowed regions (ISO 3166-1 alpha-2). Cannot be used with blocked countries. Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Blocked Countries',
+                    name: 'youtubeBlockedCountries',
+                    type: 'string',
+                    default: '',
+                    description: 'Comma-separated country codes for blocked regions (ISO 3166-1 alpha-2). Cannot be used with allowed countries. Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Has Paid Product Placement',
+                    name: 'youtubeHasPaidProductPlacement',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether this is a declaration for paid product placements (FTC compliance). Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
+                {
+                    displayName: 'YouTube Recording Date',
+                    name: 'youtubeRecordingDate',
+                    type: 'dateTime',
+                    default: '',
+                    description: 'Recording timestamp (ISO 8601 format). Only for Upload Video.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['youtube']
+                        },
+                    },
+                },
                 {
                     displayName: 'Pinterest Board Name or ID',
                     name: 'pinterestBoardId',
                     type: 'options',
+                    noDataExpression: true,
                     default: '',
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                    typeOptions: { loadOptionsMethod: 'getPinterestBoards' },
+                    typeOptions: { loadOptionsMethod: 'getPinterestBoards', loadOptionsDependsOn: ['user'] },
                     displayOptions: {
                         show: {
                             resource: ['uploads'],
+                            operation: ['uploadPhotos', 'uploadVideo'],
                             platform: ['pinterest']
                         },
                     },
                 },
+                {
+                    displayName: 'Pinterest Board Name or ID (Manual Entry)',
+                    name: 'pinterestBoardIdManual',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Provide the Pinterest board identifier when it does not appear in the list',
+                    displayOptions: {
+                        show: {
+                            resource: ['uploads'],
+                            operation: ['uploadPhotos', 'uploadVideo'],
+                            platform: ['pinterest'],
+                            pinterestBoardId: [MANUAL_PINTEREST_VALUE]
+                        },
+                    },
+                },
                 {
                     displayName: 'Pinterest Link (Photo/Video)',
                     name: 'pinterestLink',
@@ -1149,58 +1285,47 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'Threads Video Description',
-                    name: 'threadsDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'User commentary for Threads video. If not provided, Title is used. Not for Photos/Text.',
-                    displayOptions: {
-                        show: {
-                            operation: ['uploadVideo'],
-                            platform: ['threads']
-                        },
-                    },
-                },
-                {
-                    displayName: 'X Tagged User IDs (Video/Text)',
+                    displayName: 'X Tagged User IDs',
                     name: 'xTaggedUserIds',
                     type: 'string',
                     default: '',
-                    description: 'Comma-separated list of user IDs to tag for X (Twitter). Not for Photos.',
+                    description: 'Comma-separated list of user IDs to tag for X (Twitter)',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo', 'uploadText'],
+                            operation: ['uploadPhotos', 'uploadVideo'],
                             platform: ['x']
                         },
                     },
                 },
                 {
-                    displayName: 'X Reply Settings (Video/Text)',
+                    displayName: 'X Reply Settings',
                     name: 'xReplySettings',
                     type: 'options',
                     options: [
+                        { name: 'Everyone', value: 'everyone' },
                         { name: 'Following', value: 'following' },
                         { name: 'Mentioned Users', value: 'mentionedUsers' },
-                        { name: 'Everyone', value: 'everyone' },
+                        { name: 'Subscribers', value: 'subscribers' },
+                        { name: 'Verified', value: 'verified' },
                     ],
-                    default: 'following',
-                    description: 'Who can reply to the post on X (Twitter) (following, mentionedUsers, everyone). Not for Photos.',
+                    default: 'everyone',
+                    description: 'Who can reply to the post on X (Twitter)',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo', 'uploadText'],
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
                             platform: ['x']
                         },
                     },
                 },
                 {
-                    displayName: 'X Nullcast (Video)',
+                    displayName: 'X Nullcast',
                     name: 'xNullcastVideo',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to publish X (Twitter) video without broadcasting. Not for Text/Photos.',
+                    description: 'Whether to publish X (Twitter) post without broadcasting (promoted-only posts)',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo'],
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
                             platform: ['x']
                         },
                     },
@@ -1219,47 +1344,48 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'X Poll Duration (Minutes, Video)',
-                    name: 'xPollDurationVideo',
+                    displayName: 'X Poll Duration (Minutes)',
+                    name: 'xPollDuration',
                     type: 'number',
                     default: 1440,
-                    description: 'Poll duration in minutes for X (Twitter) video post (requires Poll Options). Not for Text/Photos.',
+                    description: 'Poll duration in minutes for X (Twitter) post (requires Poll Options)',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo'],
+                            operation: ['uploadText'],
                             platform: ['x']
-                        },
+                        }
                     },
                 },
                 {
-                    displayName: 'X Poll Options (Video)',
-                    name: 'xPollOptionsVideo',
+                    displayName: 'X Poll Options',
+                    name: 'xPollOptions',
                     type: 'string',
                     default: '',
-                    description: 'Comma-separated list of poll options for X (Twitter) video post. Will be sent as an array. Not for Text/Photos.',
+                    description: 'Comma-separated list of poll options for X (Twitter) post',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo'],
+                            operation: ['uploadText'],
                             platform: ['x']
-                        },
+                        }
                     },
                 },
                 {
-                    displayName: 'X Poll Reply Settings (Video)',
-                    name: 'xPollReplySettingsVideo',
+                    displayName: 'X Poll Reply Settings',
+                    name: 'xPollReplySettings',
                     type: 'options',
                     options: [
                         { name: 'Following', value: 'following' },
                         { name: 'Mentioned Users', value: 'mentionedUsers' },
                         { name: 'Everyone', value: 'everyone' },
+                        { name: 'Subscribers', value: 'subscribers' },
                     ],
                     default: 'following',
-                    description: 'Who can reply to the poll in X (Twitter) video post (following, mentionedUsers, everyone). Not for Text/Photos.',
+                    description: 'Who can reply to the poll in X (Twitter) post',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo'],
+                            operation: ['uploadText'],
                             platform: ['x']
-                        },
+                        }
                     },
                 },
                 {
@@ -1276,111 +1402,257 @@ class UploadPost {
                     },
                 },
                 {
-                    displayName: 'X Long Text as Single Post',
-                    name: 'xLongTextAsPost',
+                    displayName: 'X Quote Tweet ID',
+                    name: 'xQuoteTweetId',
+                    type: 'string',
+                    default: '',
+                    description: 'ID of the tweet to quote in a quote tweet',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadText'],
+                            platform: ['x']
+                        }
+                    },
+                },
+                {
+                    displayName: 'X Geo Place ID',
+                    name: 'xGeoPlaceId',
+                    type: 'string',
+                    default: '',
+                    description: 'Geographic place ID to add location to the tweet',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['x']
+                        },
+                    },
+                },
+                {
+                    displayName: 'X For Super Followers Only',
+                    name: 'xForSuperFollowersOnly',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to post long text as a single post instead of splitting into a thread (if supported)',
+                    description: 'Whether the tweet is exclusive for super followers',
                     displayOptions: {
                         show: {
-                            operation: ['uploadVideo', 'uploadText'],
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
                             platform: ['x']
                         },
                     },
                 },
                 {
-                    displayName: 'Description (Optional)',
-                    name: 'description',
+                    displayName: 'X Community ID',
+                    name: 'xCommunityId',
                     type: 'string',
                     default: '',
-                    description: 'Generic description to use across platforms when supported. Platform-specific overrides below take precedence.',
+                    description: 'Community ID for posting in specific communities',
                     displayOptions: {
                         show: {
-                            operation: ['uploadPhotos', 'uploadVideo']
-                        }
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['x']
+                        },
                     },
                 },
                 {
-                    displayName: 'LinkedIn Description (Override)',
-                    name: 'linkedinDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'Optional description override for LinkedIn',
-                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['linkedin'] } },
+                    displayName: 'X Share with Followers',
+                    name: 'xShareWithFollowers',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to share community post with followers',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['x']
+                        },
+                    },
                 },
                 {
-                    displayName: 'YouTube Description (Override)',
-                    name: 'youtubeDescription',
+                    displayName: 'X Direct Message Deep Link',
+                    name: 'xDirectMessageDeepLink',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for YouTube',
-                    displayOptions: { show: { operation: ['uploadVideo'], platform: ['youtube'] } },
+                    description: 'Link to take the conversation from public timeline to private Direct Message',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadPhotos', 'uploadVideo', 'uploadText'],
+                            platform: ['x']
+                        }
+                    },
                 },
                 {
-                    displayName: 'Threads Description (Override)',
-                    name: 'threadsDescription',
+                    displayName: 'X Card URI',
+                    name: 'xCardUri',
                     type: 'string',
                     default: '',
-                    description: 'Optional description override for Threads',
-                    displayOptions: { show: { operation: ['uploadVideo'], platform: ['threads'] } },
+                    description: 'URI of card (for Twitter Cards/ads/promoted content)',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadText'],
+                            platform: ['x']
+                        }
+                    },
+                },
+                {
+                    displayName: 'X Long Text as Single Post',
+                    name: 'xLongTextAsPost',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to post long text as a single post instead of splitting into a thread (if supported)',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadText'],
+                            platform: ['x']
+                        },
+                    },
                 },
             ],
         };
         this.methods = {
             loadOptions: {
-                async getFacebookPages() {
-                    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',
-                        method: 'GET',
-                        headers: { Authorization: `ApiKey ${apiKey}` },
-                        qs,
-                        json: true,
+                async getPlatforms() {
+                    const operation = this.getCurrentNodeParameter('operation');
+                    const allPlatforms = [
+                        { name: 'Facebook', value: 'facebook' },
+                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'LinkedIn', value: 'linkedin' },
+                        { name: 'Pinterest', value: 'pinterest' },
+                        { name: 'Reddit', value: 'reddit' },
+                        { name: 'Threads', value: 'threads' },
+                        { name: 'TikTok', value: 'tiktok' },
+                        { name: 'X (Twitter)', value: 'x' },
+                        { name: 'YouTube', value: 'youtube' },
+                    ];
+                    const platformSupport = {
+                        uploadPhotos: ['facebook', 'instagram', 'linkedin', 'pinterest', 'threads', 'tiktok', 'x'],
+                        uploadVideo: ['facebook', 'instagram', 'linkedin', 'pinterest', 'threads', 'tiktok', 'x', 'youtube'],
+                        uploadText: ['facebook', 'linkedin', 'reddit', 'threads', 'x'],
                     };
-                    const resp = await this.helpers.request(options);
-                    const pages = (resp && (resp.pages || resp.data || []));
-                    return (pages || []).map(p => ({ name: p.name ? `${p.name} (${p.id})` : p.id, value: p.id }));
+                    const supportedPlatforms = platformSupport[operation] || [];
+                    return allPlatforms.filter(platform => supportedPlatforms.includes(platform.value));
+                },
+                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',
+                            method: 'GET',
+                            headers: { Authorization: `ApiKey ${apiKey}` },
+                            qs,
+                            json: true,
+                        };
+                        const resp = await this.helpers.request(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 [
+                            { name: 'Manual entry...', value: MANUAL_FACEBOOK_VALUE },
+                            ...pageOptions
+                        ];
+                    }
+                    catch (error) {
+                        return [
+                            { name: 'Manual entry...', value: MANUAL_FACEBOOK_VALUE }
+                        ];
+                    }
                 },
                 async getLinkedinPages() {
-                    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',
-                        method: 'GET',
-                        headers: { Authorization: `ApiKey ${apiKey}` },
-                        qs,
-                        json: true,
-                    };
-                    const resp = await this.helpers.request(options);
-                    const pages = (resp && (resp.pages || resp.data || []));
-                    return (pages || []).map(p => ({ name: p.name ? `${p.name} (${p.id})` : p.id, value: p.id }));
+                    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',
+                            method: 'GET',
+                            headers: { Authorization: `ApiKey ${apiKey}` },
+                            qs,
+                            json: true,
+                        };
+                        const resp = await this.helpers.request(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 [
+                            { name: 'Manual entry...', value: MANUAL_LINKEDIN_VALUE },
+                            { name: 'Me (Personal Profile)', value: 'me' },
+                            ...pageOptions
+                        ];
+                    }
+                    catch (error) {
+                        return [
+                            { name: 'Manual entry...', value: MANUAL_LINKEDIN_VALUE },
+                            { name: 'Me (Personal Profile)', value: 'me' }
+                        ];
+                    }
                 },
                 async getPinterestBoards() {
-                    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',
-                        method: 'GET',
-                        headers: { Authorization: `ApiKey ${apiKey}` },
-                        qs,
-                        json: true,
-                    };
-                    const resp = await this.helpers.request(options);
-                    const boards = (resp && (resp.boards || resp.data || []));
-                    return (boards || []).map(b => ({ name: b.name ? `${b.name} (${b.id})` : b.id, value: b.id }));
+                    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',
+                            method: 'GET',
+                            headers: { Authorization: `ApiKey ${apiKey}` },
+                            qs,
+                            json: true,
+                        };
+                        const resp = await this.helpers.request(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 [
+                            { name: 'Manual entry...', value: MANUAL_PINTEREST_VALUE },
+                            ...boardOptions
+                        ];
+                    }
+                    catch (error) {
+                        return [
+                            { name: 'Manual entry...', value: MANUAL_PINTEREST_VALUE }
+                        ];
+                    }
+                },
+                async getUserProfiles() {
+                    try {
+                        const credentials = await this.getCredentials('uploadPostApi');
+                        const apiKey = credentials.apiKey;
+                        const options = {
+                            uri: 'https://api.upload-post.com/api/uploadposts/users',
+                            method: 'GET',
+                            headers: { Authorization: `ApiKey ${apiKey}` },
+                            json: true,
+                        };
+                        const resp = await this.helpers.request(options);
+                        const profiles = (resp && resp.profiles);
+                        const profileOptions = (profiles || []).map(profile => {
+                            const connectedPlatforms = Object.keys(profile.social_accounts || {})
+                                .filter(platform => profile.social_accounts[platform] && typeof profile.social_accounts[platform] === 'object')
+                                .join(', ');
+                            const displayName = connectedPlatforms
+                                ? `${profile.username} (${connectedPlatforms})`
+                                : profile.username;
+                            return {
+                                name: displayName,
+                                value: profile.username
+                            };
+                        });
+                        return [
+                            { name: 'Manual entry...', value: MANUAL_USER_VALUE },
+                            ...profileOptions
+                        ];
+                    }
+                    catch (error) {
+                        return [
+                            { name: 'Manual entry...', value: MANUAL_USER_VALUE }
+                        ];
+                    }
                 },
             },
         };
@@ -1393,7 +1665,13 @@ class UploadPost {
             const operation = this.getNodeParameter('operation', i);
             const isUploadOperation = ['uploadPhotos', 'uploadVideo', 'uploadText'].includes(operation);
             const needsUser = isUploadOperation || operation === 'generateJwt';
-            const user = needsUser ? this.getNodeParameter('user', i) : '';
+            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 = '';
@@ -1478,8 +1756,10 @@ class UploadPost {
             }
             if (isUploadOperation) {
                 const genericDescription = this.getNodeParameter('description', i, '');
-                if (genericDescription)
+                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, '');
@@ -1496,14 +1776,6 @@ class UploadPost {
                     }
                 }
                 catch { }
-                try {
-                    if (platforms.includes('threads')) {
-                        const threadsDescription = this.getNodeParameter('threadsDescription', i, '');
-                        if (threadsDescription)
-                            formData.threads_description = threadsDescription;
-                    }
-                }
-                catch { }
                 try {
                     if (platforms.includes('facebook')) {
                         const facebookDescription = this.getNodeParameter('facebookDescription', i, '');
@@ -1512,14 +1784,6 @@ class UploadPost {
                     }
                 }
                 catch { }
-                try {
-                    if (platforms.includes('instagram')) {
-                        const instagramDescription = this.getNodeParameter('instagramDescription', i, '');
-                        if (instagramDescription)
-                            formData.instagram_description = instagramDescription;
-                    }
-                }
-                catch { }
                 try {
                     if (platforms.includes('tiktok')) {
                         const tiktokDescription = this.getNodeParameter('tiktokDescription', i, '');
@@ -1528,14 +1792,6 @@ class UploadPost {
                     }
                 }
                 catch { }
-                try {
-                    if (platforms.includes('x')) {
-                        const xDescription = this.getNodeParameter('xDescription', i, '');
-                        if (xDescription)
-                            formData.x_description = xDescription;
-                    }
-                }
-                catch { }
                 try {
                     if (platforms.includes('pinterest')) {
                         const pinterestDescription = this.getNodeParameter('pinterestDescription', i, '');
@@ -1621,7 +1877,7 @@ class UploadPost {
                     break;
                 case 'uploadText':
                     endpoint = '/upload_text';
-                    const allowedTextPlatforms = ['x', 'linkedin', 'facebook', 'threads'];
+                    const allowedTextPlatforms = ['x', 'linkedin', 'facebook', 'threads', 'reddit'];
                     platforms = platforms.filter(p => allowedTextPlatforms.includes(p));
                     formData['platform[]'] = platforms;
                     break;
@@ -1713,7 +1969,11 @@ class UploadPost {
                     break;
             }
             if (isUploadOperation && platforms.includes('pinterest')) {
-                const pinterestBoardId = this.getNodeParameter('pinterestBoardId', i);
+                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);
@@ -1742,8 +2002,12 @@ class UploadPost {
                 }
             }
             if (isUploadOperation && platforms.includes('linkedin')) {
-                const targetLinkedinPageId = this.getNodeParameter('targetLinkedinPageId', i);
-                if (targetLinkedinPageId) {
+                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];
@@ -1764,7 +2028,11 @@ class UploadPost {
                 }
             }
             if (isUploadOperation && platforms.includes('facebook')) {
-                const facebookPageId = this.getNodeParameter('facebookPageId', i);
+                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);
@@ -1780,25 +2048,25 @@ class UploadPost {
                 else if (operation === 'uploadText') {
                     const facebookLink = this.getNodeParameter('facebookLink', i);
                     if (facebookLink)
-                        formData.link = 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 tiktokBrandedContentPhoto = this.getNodeParameter('tiktokBrandedContentPhoto', i);
-                    const tiktokDiscloseCommercialPhoto = this.getNodeParameter('tiktokDiscloseCommercialPhoto', 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 (tiktokBrandedContentPhoto !== undefined)
-                        formData.branded_content = String(tiktokBrandedContentPhoto);
-                    if (tiktokDiscloseCommercialPhoto !== undefined)
-                        formData.disclose_commercial = String(tiktokDiscloseCommercialPhoto);
+                    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)
@@ -1810,10 +2078,8 @@ class UploadPost {
                     const tiktokDisableComment = this.getNodeParameter('tiktokDisableComment', i);
                     const tiktokDisableStitch = this.getNodeParameter('tiktokDisableStitch', i);
                     const tiktokCoverTimestamp = this.getNodeParameter('tiktokCoverTimestamp', i);
-                    const tiktokBrandContentToggle = this.getNodeParameter('tiktokBrandContentToggle', i);
-                    const tiktokBrandOrganic = this.getNodeParameter('tiktokBrandOrganic', i);
-                    const tiktokBrandedContentVideo = this.getNodeParameter('tiktokBrandedContentVideo', i);
-                    const tiktokBrandOrganicToggle = this.getNodeParameter('tiktokBrandOrganicToggle', 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)
@@ -1826,14 +2092,10 @@ class UploadPost {
                         formData.disable_stitch = String(tiktokDisableStitch);
                     if (tiktokCoverTimestamp !== undefined)
                         formData.cover_timestamp = tiktokCoverTimestamp;
-                    if (tiktokBrandContentToggle !== undefined)
-                        formData.brand_content_toggle = String(tiktokBrandContentToggle);
-                    if (tiktokBrandOrganic !== undefined)
-                        formData.brand_organic = String(tiktokBrandOrganic);
-                    if (tiktokBrandedContentVideo !== undefined)
-                        formData.branded_content = String(tiktokBrandedContentVideo);
-                    if (tiktokBrandOrganicToggle !== undefined)
-                        formData.brand_organic_toggle = String(tiktokBrandOrganicToggle);
+                    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)
@@ -1889,7 +2151,7 @@ class UploadPost {
                 const youtubeMadeForKids = this.getNodeParameter('youtubeMadeForKids', i);
                 const youtubeThumbnail = this.getNodeParameter('youtubeThumbnail', i);
                 if (youtubeTagsRaw)
-                    formData.tags = youtubeTagsRaw.split(',').map(tag => tag.trim());
+                    formData['tags[]'] = youtubeTagsRaw.split(',').map(tag => tag.trim());
                 if (youtubeCategoryId)
                     formData.categoryId = youtubeCategoryId;
                 if (youtubePrivacyStatus)
@@ -1924,18 +2186,96 @@ class UploadPost {
                         }
                     }
                 }
+                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 xTaggedUserIdsText = this.getNodeParameter('xTaggedUserIds', i);
                     const xReplySettingsText = this.getNodeParameter('xReplySettings', i);
-                    if (xTaggedUserIdsText)
-                        formData.tagged_user_ids = xTaggedUserIdsText.split(',').map(id => id.trim());
-                    if (xReplySettingsText)
+                    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)
@@ -1944,35 +2284,44 @@ class UploadPost {
                     catch { }
                     delete formData.nullcast;
                     delete formData.place_id;
-                    delete formData.poll_duration;
-                    delete formData.poll_options;
-                    delete formData.poll_reply_settings;
                 }
-                else if (operation === 'uploadVideo') {
+                else if (operation === 'uploadVideo' || operation === 'uploadPhotos') {
                     const xTaggedUserIds = this.getNodeParameter('xTaggedUserIds', i);
                     const xReplySettings = this.getNodeParameter('xReplySettings', i);
                     const xNullcastVideo = this.getNodeParameter('xNullcastVideo', i);
-                    const xPlaceIdVideo = this.getNodeParameter('xPlaceIdVideo', i);
-                    const xPollDurationVideo = this.getNodeParameter('xPollDurationVideo', i);
-                    const xPollOptionsVideoRaw = this.getNodeParameter('xPollOptionsVideo', i);
-                    const xPollReplySettingsVideo = this.getNodeParameter('xPollReplySettingsVideo', i);
-                    const xLongTextAsPost = this.getNodeParameter('xLongTextAsPost', i, false);
                     if (xTaggedUserIds)
-                        formData.tagged_user_ids = xTaggedUserIds.split(',').map(id => id.trim());
-                    if (xReplySettings)
+                        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 (xPlaceIdVideo)
-                        formData.place_id = xPlaceIdVideo;
-                    if (xPollDurationVideo !== undefined)
-                        formData.poll_duration = xPollDurationVideo;
-                    if (xPollOptionsVideoRaw)
-                        formData.poll_options = xPollOptionsVideoRaw.split(',').map(opt => opt.trim());
-                    if (xPollReplySettingsVideo)
-                        formData.poll_reply_settings = xPollReplySettingsVideo;
-                    if (xLongTextAsPost)
-                        formData.x_long_text_as_post = String(xLongTextAsPost);
+                    if (operation === 'uploadVideo') {
+                        try {
+                            const xLongTextAsPost = this.getNodeParameter('xLongTextAsPost', i, false);
+                            if (xLongTextAsPost)
+                                formData.x_long_text_as_post = String(xLongTextAsPost);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            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 (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;
                 }
             }
             const credentials = await this.getCredentials('uploadPostApi');
@@ -2006,6 +2355,8 @@ class UploadPost {
                     options.qs = qs;
                 }
             }
+            this.logger.info(`Operation: ${operation}, Is Upload Operation: ${isUploadOperation}`);
+            this.logger.info('Complete Form Data being sent (JSON): ' + JSON.stringify(formData, null, 2));
             const responseData = await this.helpers.request(options);
             const shouldConsiderPolling = operation === 'uploadPhotos' || operation === 'uploadVideo' || operation === 'uploadText';
             const waitForCompletion = shouldConsiderPolling ? this.getNodeParameter('waitForCompletion', i, false) : false;