@getlatedev/node 0.1.4 → 0.1.5

package/src/generated/types.gen.ts

@@ -1276,7 +1276,7 @@ export type Webhook = {
     /**
      * Events subscribed to
      */
-    events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected')>;
+    events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received')>;
     /**
      * Whether webhook delivery is enabled
      */
@@ -1310,7 +1310,7 @@ export type WebhookLog = {
      * Name of the webhook that was triggered
      */
     webhookName?: string;
-    event?: 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'webhook.test';
+    event?: 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received' | 'webhook.test';
     url?: string;
     status?: 'success' | 'failed';
     /**
@@ -1342,7 +1342,7 @@ export type WebhookLog = {
     createdAt?: string;
 };
 
-export type event = 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'webhook.test';
+export type event = 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received' | 'webhook.test';
 
 export type status5 = 'success' | 'failed';
 
@@ -1405,6 +1405,84 @@ export type event3 = 'account.disconnected';
  */
 export type disconnectionType = 'intentional' | 'unintentional';
 
+/**
+ * Webhook payload for message received events (DMs from Instagram, Facebook, Telegram)
+ */
+export type WebhookPayloadMessage = {
+    event?: 'message.received';
+    message?: {
+        /**
+         * Internal message ID
+         */
+        id?: string;
+        /**
+         * Internal conversation ID
+         */
+        conversationId?: string;
+        platform?: 'instagram' | 'facebook' | 'telegram';
+        /**
+         * Platform's message ID
+         */
+        platformMessageId?: string;
+        direction?: 'incoming';
+        /**
+         * Message text content
+         */
+        text?: (string) | null;
+        attachments?: Array<{
+            /**
+             * Attachment type (image, video, file, sticker, audio)
+             */
+            type?: string;
+            /**
+             * Attachment URL (may expire for Meta platforms)
+             */
+            url?: string;
+            /**
+             * Additional attachment metadata
+             */
+            payload?: {
+                [key: string]: unknown;
+            };
+        }>;
+        sender?: {
+            id?: string;
+            name?: string;
+            username?: string;
+            picture?: string;
+        };
+        sentAt?: string;
+        isRead?: boolean;
+    };
+    conversation?: {
+        id?: string;
+        platformConversationId?: string;
+        participantId?: string;
+        participantName?: string;
+        participantUsername?: string;
+        participantPicture?: string;
+        status?: 'active' | 'archived';
+    };
+    account?: {
+        /**
+         * Social account ID
+         */
+        id?: string;
+        platform?: string;
+        username?: string;
+        displayName?: string;
+    };
+    timestamp?: string;
+};
+
+export type event4 = 'message.received';
+
+export type platform2 = 'instagram' | 'facebook' | 'telegram';
+
+export type direction = 'incoming';
+
+export type status6 = 'active' | 'archived';
+
 /**
  * Webhook payload for post events
  */
@@ -1426,7 +1504,7 @@ export type WebhookPayloadPost = {
     timestamp?: string;
 };
 
-export type event4 = 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial';
+export type event5 = 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial';
 
 export type YouTubeDailyViewsResponse = {
     success?: boolean;
@@ -1473,6 +1551,7 @@ export type YouTubeDailyViewsResponse = {
  * - Custom thumbnails NOT supported for Shorts via API
  * - Scheduled videos are uploaded immediately as the specified visibility and published at scheduled time
  * - Visibility defaults to "public" if not specified
+ * - madeForKids defaults to false (not child-directed)
  * - Set containsSyntheticMedia: true if your video contains AI-generated content
  *
  */
@@ -1489,6 +1568,19 @@ export type YouTubePlatformData = {
      *
      */
     visibility?: 'public' | 'private' | 'unlisted';
+    /**
+     * COPPA compliance: Audience designation for the video.
+     * - true: Video is made for kids (child-directed content)
+     * - false: Video is NOT made for kids (default)
+     *
+     * This field maps to YouTube's `selfDeclaredMadeForKids` setting. Videos marked as made for kids
+     * have restricted features (no comments, no notifications, limited ad targeting).
+     *
+     * IMPORTANT: If not specified, defaults to false. YouTube requires this to be explicitly set,
+     * otherwise the video may be blocked from views until configured in YouTube Studio.
+     *
+     */
+    madeForKids?: boolean;
     /**
      * Optional first comment to post immediately after video upload. Up to 10,000 characters (YouTube's comment limit).
      */
@@ -2073,6 +2165,21 @@ export type CreatePostResponse = (PostCreateResponse);
 
 export type CreatePostError = ({
     error?: string;
+} | {
+    error?: string;
+    details?: {
+        accountId?: string;
+        platform?: string;
+        existingPostId?: string;
+    };
+} | {
+    error?: string;
+    /**
+     * Additional context about the rate limit
+     */
+    details?: {
+        [key: string]: unknown;
+    };
 });
 
 export type GetPostData = {
@@ -2137,6 +2244,11 @@ export type BulkUploadPostsResponse = ({
 
 export type BulkUploadPostsError = (unknown | {
     error?: string;
+} | {
+    error?: string;
+    details?: {
+        [key: string]: unknown;
+    };
 });
 
 export type RetryPostData = {
@@ -2149,6 +2261,11 @@ export type RetryPostResponse = (PostRetryResponse | unknown);
 
 export type RetryPostError = (unknown | {
     error?: string;
+} | {
+    error?: string;
+    details?: {
+        [key: string]: unknown;
+    };
 });
 
 export type ListUsersResponse = ({
@@ -2736,6 +2853,10 @@ export type SelectFacebookPageResponse = ({
      */
     redirect_url?: string;
     account?: {
+        /**
+         * ID of the created SocialAccount
+         */
+        accountId?: string;
         platform?: 'facebook';
         username?: string;
         displayName?: string;
@@ -2844,6 +2965,10 @@ export type SelectGoogleBusinessLocationResponse = ({
      */
     redirect_url?: string;
     account?: {
+        /**
+         * ID of the created SocialAccount
+         */
+        accountId?: string;
         platform?: 'googlebusiness';
         username?: string;
         displayName?: string;
@@ -3050,7 +3175,26 @@ export type SelectLinkedInOrganizationData = {
 
 export type SelectLinkedInOrganizationResponse = ({
     message?: string;
-    account?: SocialAccount;
+    /**
+     * The redirect URL with connection params appended (only if redirect_url was provided in request)
+     */
+    redirect_url?: string;
+    account?: {
+        /**
+         * ID of the created SocialAccount
+         */
+        accountId?: string;
+        platform?: 'linkedin';
+        username?: string;
+        displayName?: string;
+        profilePicture?: string;
+        isActive?: boolean;
+        accountType?: 'personal' | 'organization';
+    };
+    bulkRefresh?: {
+        updatedCount?: number;
+        errors?: number;
+    };
 });
 
 export type SelectLinkedInOrganizationError = (unknown | {
@@ -3147,6 +3291,10 @@ export type SelectPinterestBoardResponse = ({
      */
     redirect_url?: string;
     account?: {
+        /**
+         * ID of the created SocialAccount
+         */
+        accountId?: string;
         platform?: 'pinterest';
         username?: string;
         displayName?: string;
@@ -3277,6 +3425,10 @@ export type SelectSnapchatProfileResponse = ({
      */
     redirect_url?: string;
     account?: {
+        /**
+         * ID of the created SocialAccount
+         */
+        accountId?: string;
         platform?: 'snapchat';
         username?: string;
         displayName?: string;
@@ -3427,6 +3579,28 @@ export type CompleteTelegramConnectError = ({
     error?: string;
 } | unknown);
 
+export type GetFacebookPagesData = {
+    path: {
+        accountId: string;
+    };
+};
+
+export type GetFacebookPagesResponse = ({
+    pages?: Array<{
+        id?: string;
+        name?: string;
+        username?: string;
+        category?: string;
+        fan_count?: number;
+    }>;
+    selectedPageId?: string;
+    cached?: boolean;
+});
+
+export type GetFacebookPagesError = ({
+    error?: string;
+} | unknown);
+
 export type UpdateFacebookPageData = {
     body: {
         selectedPageId: string;
@@ -3709,6 +3883,51 @@ export type UpdatePinterestBoardsError = (unknown | {
     error?: string;
 });
 
+export type GetGmbLocationsData = {
+    path: {
+        accountId: string;
+    };
+};
+
+export type GetGmbLocationsResponse = ({
+    locations?: Array<{
+        id?: string;
+        name?: string;
+        accountId?: string;
+        accountName?: string;
+        address?: string;
+        category?: string;
+        websiteUrl?: string;
+    }>;
+    selectedLocationId?: string;
+    cached?: boolean;
+});
+
+export type GetGmbLocationsError = ({
+    error?: string;
+} | unknown);
+
+export type UpdateGmbLocationData = {
+    body: {
+        selectedLocationId: string;
+    };
+    path: {
+        accountId: string;
+    };
+};
+
+export type UpdateGmbLocationResponse = ({
+    message?: string;
+    selectedLocation?: {
+        id?: string;
+        name?: string;
+    };
+});
+
+export type UpdateGmbLocationError = (unknown | {
+    error?: string;
+});
+
 export type GetRedditSubredditsData = {
     path: {
         accountId: string;
@@ -3949,7 +4168,7 @@ export type CreateWebhookSettingsData = {
         /**
          * Events to subscribe to
          */
-        events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected')>;
+        events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received')>;
         /**
          * Enable or disable webhook delivery
          */
@@ -3993,7 +4212,7 @@ export type UpdateWebhookSettingsData = {
         /**
          * Events to subscribe to
          */
-        events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected')>;
+        events?: Array<('post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received')>;
         /**
          * Enable or disable webhook delivery
          */
@@ -4059,7 +4278,7 @@ export type GetWebhookLogsData = {
         /**
          * Filter by event type
          */
-        event?: 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'webhook.test';
+        event?: 'post.scheduled' | 'post.published' | 'post.failed' | 'post.partial' | 'account.connected' | 'account.disconnected' | 'message.received' | 'webhook.test';
         /**
          * Maximum number of logs to return (max 100)
          */
@@ -4176,4 +4395,733 @@ export type GetPostLogsResponse = ({
 
 export type GetPostLogsError = ({
     error?: string;
+} | unknown);
+
+export type ListInboxConversationsData = {
+    query?: {
+        /**
+         * Filter by specific social account ID
+         */
+        accountId?: string;
+        /**
+         * Pagination cursor for next page
+         */
+        cursor?: string;
+        /**
+         * Maximum number of conversations to return
+         */
+        limit?: number;
+        /**
+         * Filter by platform
+         */
+        platform?: 'facebook' | 'instagram' | 'bluesky' | 'reddit' | 'telegram';
+        /**
+         * Filter by profile ID
+         */
+        profileId?: string;
+        /**
+         * Sort order by updated time
+         */
+        sortOrder?: 'asc' | 'desc';
+        /**
+         * Filter by conversation status
+         */
+        status?: 'active' | 'archived';
+    };
+};
+
+export type ListInboxConversationsResponse = ({
+    data?: Array<{
+        id?: string;
+        platform?: string;
+        accountId?: string;
+        accountUsername?: string;
+        participantId?: string;
+        participantName?: string;
+        participantPicture?: (string) | null;
+        lastMessage?: string;
+        updatedTime?: string;
+        status?: 'active' | 'archived';
+        /**
+         * Number of unread messages
+         */
+        unreadCount?: (number) | null;
+        /**
+         * Direct link to open the conversation on the platform (if available)
+         */
+        url?: (string) | null;
+    }>;
+    pagination?: {
+        hasMore?: boolean;
+        nextCursor?: (string) | null;
+    };
+    meta?: {
+        accountsQueried?: number;
+        accountsFailed?: number;
+        failedAccounts?: Array<{
+            accountId?: string;
+            accountUsername?: (string) | null;
+            platform?: string;
+            error?: string;
+            /**
+             * Error code if available
+             */
+            code?: (string) | null;
+            /**
+             * Seconds to wait before retry (rate limits)
+             */
+            retryAfter?: (number) | null;
+        }>;
+        lastUpdated?: string;
+    };
+});
+
+export type ListInboxConversationsError = ({
+    error?: string;
+} | unknown);
+
+export type GetInboxConversationData = {
+    path: {
+        conversationId: string;
+    };
+    query: {
+        /**
+         * The social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetInboxConversationResponse = ({
+    data?: {
+        id?: string;
+        accountId?: string;
+        accountUsername?: string;
+        platform?: string;
+        status?: 'active' | 'archived';
+        participantName?: string;
+        participantId?: string;
+        lastMessage?: string;
+        lastMessageAt?: string;
+        updatedTime?: string;
+        participants?: Array<{
+            id?: string;
+            name?: string;
+        }>;
+    };
+});
+
+export type GetInboxConversationError = ({
+    error?: string;
+} | unknown);
+
+export type UpdateInboxConversationData = {
+    body: {
+        /**
+         * Social account ID
+         */
+        accountId: string;
+        status: 'active' | 'archived';
+    };
+    path: {
+        conversationId: string;
+    };
+};
+
+export type UpdateInboxConversationResponse = ({
+    success?: boolean;
+    data?: {
+        id?: string;
+        accountId?: string;
+        status?: 'active' | 'archived';
+        platform?: string;
+        updatedAt?: string;
+    };
+});
+
+export type UpdateInboxConversationError = ({
+    error?: string;
+} | unknown);
+
+export type GetInboxConversationMessagesData = {
+    path: {
+        conversationId: string;
+    };
+    query: {
+        /**
+         * Social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetInboxConversationMessagesResponse = ({
+    status?: string;
+    messages?: Array<{
+        id?: string;
+        conversationId?: string;
+        accountId?: string;
+        platform?: string;
+        message?: string;
+        senderId?: string;
+        senderName?: (string) | null;
+        direction?: 'incoming' | 'outgoing';
+        createdAt?: string;
+        attachments?: Array<{
+            id?: string;
+            type?: 'image' | 'video' | 'audio' | 'file' | 'sticker' | 'share';
+            url?: string;
+            filename?: (string) | null;
+            previewUrl?: (string) | null;
+        }>;
+        /**
+         * Reddit message subject
+         */
+        subject?: (string) | null;
+        /**
+         * Instagram story reply
+         */
+        storyReply?: (boolean) | null;
+        /**
+         * Instagram story mention
+         */
+        isStoryMention?: (boolean) | null;
+    }>;
+    lastUpdated?: string;
+});
+
+export type GetInboxConversationMessagesError = ({
+    error?: string;
+} | unknown);
+
+export type SendInboxMessageData = {
+    body: {
+        /**
+         * Social account ID
+         */
+        accountId: string;
+        /**
+         * Message text
+         */
+        message: string;
+    };
+    path: {
+        conversationId: string;
+    };
+};
+
+export type SendInboxMessageResponse = ({
+    success?: boolean;
+    data?: {
+        /**
+         * ID of the sent message (not returned for Reddit)
+         */
+        messageId?: string;
+        /**
+         * Twitter conversation ID
+         */
+        conversationId?: (string) | null;
+        /**
+         * Bluesky sent timestamp
+         */
+        sentAt?: (string) | null;
+        /**
+         * Success message (Reddit only)
+         */
+        message?: (string) | null;
+    };
+});
+
+export type SendInboxMessageError = ({
+    error?: string;
+    code?: 'PLATFORM_LIMITATION';
+} | {
+    error?: string;
+} | unknown);
+
+export type ListInboxCommentsData = {
+    query?: {
+        /**
+         * Filter by specific social account ID
+         */
+        accountId?: string;
+        cursor?: string;
+        limit?: number;
+        /**
+         * Minimum comment count
+         */
+        minComments?: number;
+        /**
+         * Filter by platform
+         */
+        platform?: 'facebook' | 'instagram' | 'youtube' | 'linkedin' | 'reddit' | 'bluesky' | 'tiktok';
+        /**
+         * Filter by profile ID
+         */
+        profileId?: string;
+        /**
+         * Posts created after this date
+         */
+        since?: string;
+        /**
+         * Sort field
+         */
+        sortBy?: 'date' | 'comments';
+        /**
+         * Sort order
+         */
+        sortOrder?: 'asc' | 'desc';
+    };
+};
+
+export type ListInboxCommentsResponse = ({
+    data?: Array<{
+        id?: string;
+        platform?: string;
+        accountId?: string;
+        accountUsername?: string;
+        content?: string;
+        picture?: (string) | null;
+        permalink?: (string) | null;
+        createdTime?: string;
+        commentCount?: number;
+        likeCount?: number;
+        /**
+         * Bluesky content identifier
+         */
+        cid?: (string) | null;
+        /**
+         * Reddit subreddit name
+         */
+        subreddit?: (string) | null;
+    }>;
+    pagination?: {
+        hasMore?: boolean;
+        nextCursor?: (string) | null;
+    };
+    meta?: {
+        accountsQueried?: number;
+        accountsFailed?: number;
+        failedAccounts?: Array<{
+            accountId?: string;
+            accountUsername?: (string) | null;
+            platform?: string;
+            error?: string;
+            /**
+             * Error code if available
+             */
+            code?: (string) | null;
+            /**
+             * Seconds to wait before retry (rate limits)
+             */
+            retryAfter?: (number) | null;
+        }>;
+        lastUpdated?: string;
+    };
+});
+
+export type ListInboxCommentsError = ({
+    error?: string;
+} | unknown);
+
+export type GetInboxPostCommentsData = {
+    path: {
+        postId: string;
+    };
+    query: {
+        accountId: string;
+        /**
+         * (Reddit only) Get replies to a specific comment
+         */
+        commentId?: string;
+        /**
+         * Pagination cursor
+         */
+        cursor?: string;
+        /**
+         * Maximum number of comments to return
+         */
+        limit?: number;
+        /**
+         * (Reddit only) Subreddit name
+         */
+        subreddit?: string;
+    };
+};
+
+export type GetInboxPostCommentsResponse = ({
+    status?: string;
+    comments?: Array<{
+        id?: string;
+        message?: string;
+        createdTime?: string;
+        from?: {
+            id?: string;
+            name?: string;
+            username?: string;
+            picture?: (string) | null;
+            isOwner?: boolean;
+        };
+        likeCount?: number;
+        replyCount?: number;
+        /**
+         * The platform this comment is from
+         */
+        platform?: string;
+        /**
+         * Direct link to the comment on the platform (if available)
+         */
+        url?: (string) | null;
+        replies?: Array<{
+            [key: string]: unknown;
+        }>;
+        canReply?: boolean;
+        canDelete?: boolean;
+        /**
+         * Whether this comment can be hidden (Facebook
+         */
+        canHide?: boolean;
+        /**
+         * Whether this comment can be liked (Facebook
+         */
+        canLike?: boolean;
+        /**
+         * Whether the comment is currently hidden
+         */
+        isHidden?: boolean;
+        /**
+         * Whether the current user has liked this comment
+         */
+        isLiked?: boolean;
+        /**
+         * Bluesky like URI for unliking
+         */
+        likeUri?: (string) | null;
+        /**
+         * Bluesky content identifier
+         */
+        cid?: (string) | null;
+        /**
+         * Parent comment ID for nested replies
+         */
+        parentId?: (string) | null;
+        /**
+         * Bluesky root post URI
+         */
+        rootUri?: (string) | null;
+        /**
+         * Bluesky root post CID
+         */
+        rootCid?: (string) | null;
+    }>;
+    pagination?: {
+        hasMore?: boolean;
+        cursor?: (string) | null;
+    };
+    meta?: {
+        platform?: string;
+        postId?: string;
+        accountId?: string;
+        /**
+         * (Reddit only) Subreddit name
+         */
+        subreddit?: (string) | null;
+        lastUpdated?: string;
+    };
+});
+
+export type GetInboxPostCommentsError = ({
+    error?: string;
+} | unknown);
+
+export type ReplyToInboxPostData = {
+    body: {
+        accountId: string;
+        message: string;
+        /**
+         * Reply to specific comment (optional)
+         */
+        commentId?: string;
+        /**
+         * (Reddit only) Subreddit name for replies
+         */
+        subreddit?: string;
+        /**
+         * (Bluesky only) Parent content identifier
+         */
+        parentCid?: string;
+        /**
+         * (Bluesky only) Root post URI
+         */
+        rootUri?: string;
+        /**
+         * (Bluesky only) Root post CID
+         */
+        rootCid?: string;
+    };
+    path: {
+        postId: string;
+    };
+};
+
+export type ReplyToInboxPostResponse = ({
+    success?: boolean;
+    data?: {
+        commentId?: string;
+        isReply?: boolean;
+        /**
+         * Bluesky CID
+         */
+        cid?: (string) | null;
+    };
+});
+
+export type ReplyToInboxPostError = ({
+    error?: string;
+} | unknown);
+
+export type DeleteInboxCommentData = {
+    path: {
+        postId: string;
+    };
+    query: {
+        accountId: string;
+        commentId: string;
+    };
+};
+
+export type DeleteInboxCommentResponse = ({
+    success?: boolean;
+    data?: {
+        message?: string;
+    };
+});
+
+export type DeleteInboxCommentError = ({
+    error?: string;
+} | unknown);
+
+export type HideInboxCommentData = {
+    body: {
+        /**
+         * The social account ID
+         */
+        accountId: string;
+    };
+    path: {
+        commentId: string;
+        postId: string;
+    };
+};
+
+export type HideInboxCommentResponse = ({
+    status?: string;
+    commentId?: string;
+    hidden?: boolean;
+    platform?: string;
+});
+
+export type HideInboxCommentError = (unknown | {
+    error?: string;
+});
+
+export type UnhideInboxCommentData = {
+    path: {
+        commentId: string;
+        postId: string;
+    };
+    query: {
+        accountId: string;
+    };
+};
+
+export type UnhideInboxCommentResponse = ({
+    status?: string;
+    commentId?: string;
+    hidden?: boolean;
+    platform?: string;
+});
+
+export type UnhideInboxCommentError = (unknown | {
+    error?: string;
+});
+
+export type LikeInboxCommentData = {
+    body: {
+        /**
+         * The social account ID
+         */
+        accountId: string;
+        /**
+         * (Bluesky only) Content identifier for the comment
+         */
+        cid?: string;
+    };
+    path: {
+        commentId: string;
+        postId: string;
+    };
+};
+
+export type LikeInboxCommentResponse = ({
+    status?: string;
+    commentId?: string;
+    liked?: boolean;
+    /**
+     * (Bluesky only) URI to use for unliking
+     */
+    likeUri?: string;
+    platform?: string;
+});
+
+export type LikeInboxCommentError = (unknown | {
+    error?: string;
+});
+
+export type UnlikeInboxCommentData = {
+    path: {
+        commentId: string;
+        postId: string;
+    };
+    query: {
+        accountId: string;
+        /**
+         * (Bluesky only) The like URI returned when liking
+         */
+        likeUri?: string;
+    };
+};
+
+export type UnlikeInboxCommentResponse = ({
+    status?: string;
+    commentId?: string;
+    liked?: boolean;
+    platform?: string;
+});
+
+export type UnlikeInboxCommentError = (unknown | {
+    error?: string;
+});
+
+export type ListInboxReviewsData = {
+    query?: {
+        /**
+         * Filter by specific social account ID
+         */
+        accountId?: string;
+        cursor?: string;
+        /**
+         * Filter by reply status
+         */
+        hasReply?: boolean;
+        limit?: number;
+        maxRating?: number;
+        minRating?: number;
+        platform?: 'facebook' | 'googlebusiness';
+        profileId?: string;
+        sortBy?: 'date' | 'rating';
+        sortOrder?: 'asc' | 'desc';
+    };
+};
+
+export type ListInboxReviewsResponse = ({
+    status?: string;
+    data?: Array<{
+        id?: string;
+        platform?: string;
+        accountId?: string;
+        accountUsername?: string;
+        reviewer?: {
+            id?: (string) | null;
+            name?: string;
+            profileImage?: (string) | null;
+        };
+        rating?: number;
+        text?: string;
+        created?: string;
+        hasReply?: boolean;
+        reply?: {
+            id?: string;
+            text?: string;
+            created?: string;
+        } | null;
+        reviewUrl?: (string) | null;
+    }>;
+    pagination?: {
+        hasMore?: boolean;
+        nextCursor?: (string) | null;
+    };
+    meta?: {
+        accountsQueried?: number;
+        accountsFailed?: number;
+        failedAccounts?: Array<{
+            accountId?: string;
+            accountUsername?: (string) | null;
+            platform?: string;
+            error?: string;
+            /**
+             * Error code if available
+             */
+            code?: (string) | null;
+            /**
+             * Seconds to wait before retry (rate limits)
+             */
+            retryAfter?: (number) | null;
+        }>;
+        lastUpdated?: string;
+    };
+    summary?: {
+        totalReviews?: number;
+        averageRating?: (number) | null;
+    };
+});
+
+export type ListInboxReviewsError = ({
+    error?: string;
+} | unknown);
+
+export type ReplyToInboxReviewData = {
+    body: {
+        accountId: string;
+        message: string;
+    };
+    path: {
+        /**
+         * Review ID (URL-encoded for Google Business)
+         */
+        reviewId: string;
+    };
+};
+
+export type ReplyToInboxReviewResponse = ({
+    status?: string;
+    reply?: {
+        id?: string;
+        text?: string;
+        created?: string;
+    };
+    platform?: string;
+});
+
+export type ReplyToInboxReviewError = ({
+    error?: string;
+} | unknown);
+
+export type DeleteInboxReviewReplyData = {
+    body: {
+        accountId: string;
+    };
+    path: {
+        reviewId: string;
+    };
+};
+
+export type DeleteInboxReviewReplyResponse = ({
+    status?: string;
+    message?: string;
+    platform?: string;
+});
+
+export type DeleteInboxReviewReplyError = ({
+    error?: string;
 } | unknown);