@kelvdra/baileys 1.0.4 → 1.0.5

package/lib/Socket/mex.js

@@ -1,5 +1,6 @@
 import { Boom } from '@hapi/boom';
 import { getBinaryNodeChild, S_WHATSAPP_NET } from '../WABinary/index.js';
+
 const wMexQuery = (variables, queryId, query, generateMessageTag) => {
     return query({
         tag: 'iq',
@@ -18,25 +19,62 @@ const wMexQuery = (variables, queryId, query, generateMessageTag) => {
         ]
     });
 };
+
 export const executeWMexQuery = async (variables, queryId, dataPath, query, generateMessageTag) => {
     const result = await wMexQuery(variables, queryId, query, generateMessageTag);
-    const child = getBinaryNodeChild(result, 'result');
+
+    const child =
+        getBinaryNodeChild(result, 'result') ||
+        getBinaryNodeChild(result, 'query') ||
+        (Array.isArray(result?.content)
+            ? result.content.find(item =>
+                Buffer.isBuffer(item?.content) || item?.content instanceof Uint8Array
+            )
+            : undefined);
+
     if (child?.content) {
-        const data = JSON.parse(child.content.toString());
+        const data = JSON.parse(Buffer.from(child.content).toString());
+
         if (data.errors && data.errors.length > 0) {
             const errorMessages = data.errors.map((err) => err.message || 'Unknown error').join(', ');
             const firstError = data.errors[0];
             const errorCode = firstError.extensions?.error_code || 400;
-            throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError });
+            throw new Boom(`GraphQL server error: ${errorMessages}`, {
+                statusCode: errorCode,
+                data: firstError
+            });
         }
-        const response = dataPath ? data?.data?.[dataPath] : data?.data;
+
+        const root = data?.data;
+
+        // normal path
+        const response = dataPath ? root?.[dataPath] : root;
         if (typeof response !== 'undefined') {
             return response;
         }
+
+        if (root && typeof root === 'object') {
+            const keys = Object.keys(root);
+            if (keys.length === 1) {
+                return root[keys[0]];
+            }
+        }
+
+        if (typeof data?.result !== 'undefined') {
+            return data.result;
+		}
+
+        if (root && typeof root === 'object') {
+            return root;
+        }
     }
+
     const action = (dataPath || '').startsWith('xwa2_')
         ? dataPath.substring(5).replace(/_/g, ' ')
         : dataPath?.replace(/_/g, ' ');
-    throw new Boom(`Failed to ${action}, unexpected response structure.`, { statusCode: 400, data: result });
+
+    throw new Boom(`Failed to ${action}, unexpected response structure.`, {
+        statusCode: 400,
+        data: result
+    });
 };
-//# sourceMappingURL=mex.js.map

package/lib/Socket/newsletter.d.ts

@@ -1,29 +1,36 @@
 import type { SocketConfig, WAMediaUpload } from '../Types/index.js';
 import type { NewsletterMetadata, NewsletterUpdate } from '../Types/index.js';
+export declare const extractNewsletterMetadata: (result: any, isCreate?: boolean) => any;
 export declare const makeNewsletterSocket: (config: SocketConfig) => {
-    newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
-    newsletterUpdate: (jid: string, updates: NewsletterUpdate) => Promise<unknown>;
+    newsletterQuery: (jid: string, type: string, content: any[]) => Promise<any>;
+    newsletterWMexQuery: (jid: string | undefined, queryId: string, content?: Record<string, any>, dataPath?: string) => Promise<any>;
+    newsletterCreate: (name: string, description?: string, picture?: WAMediaUpload) => Promise<NewsletterMetadata>;
+    newsletterUpdate: (jid: string, updates: NewsletterUpdate & {
+        settings?: any;
+    }) => Promise<unknown>;
     newsletterSubscribers: (jid: string) => Promise<{
         subscribers: number;
     }>;
-    newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<NewsletterMetadata | null>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: string) => Promise<NewsletterMetadata | null>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<any>;
+    newsletterReactionMode: (jid: string, mode: string) => Promise<unknown>;
     newsletterFollow: (jid: string) => Promise<unknown>;
     newsletterUnfollow: (jid: string) => Promise<unknown>;
     newsletterMute: (jid: string) => Promise<unknown>;
     newsletterUnmute: (jid: string) => Promise<unknown>;
+    newsletterAction: (jid: string, type: string) => Promise<any>;
     newsletterUpdateName: (jid: string, name: string) => Promise<unknown>;
     newsletterUpdateDescription: (jid: string, description: string) => Promise<unknown>;
     newsletterUpdatePicture: (jid: string, content: WAMediaUpload) => Promise<unknown>;
     newsletterRemovePicture: (jid: string) => Promise<unknown>;
-    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
-    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
-    subscribeNewsletterUpdates: (jid: string) => Promise<{
-        duration: string;
-    } | null>;
+    newsletterFetchAllParticipating: () => Promise<never>;
     newsletterAdminCount: (jid: string) => Promise<number>;
     newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
     newsletterDemote: (jid: string, userJid: string) => Promise<void>;
     newsletterDelete: (jid: string) => Promise<void>;
+    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
+    newsletterFetchMessages: (...args: any[]) => Promise<any>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number, since?: number) => Promise<any>;
     groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
@@ -146,4 +153,4 @@ export declare const makeNewsletterSocket: (config: SocketConfig) => {
     }[] | undefined>;
 };
 export type NewsletterSocket = ReturnType<typeof makeNewsletterSocket>;
-//# sourceMappingURL=newsletter.d.ts.map
+//# sourceMappingURL=newsletter.d.ts.map

package/lib/Socket/newsletter.js

@@ -1,27 +1,39 @@
 import { QueryIds, XWAPaths } from '../Types/index.js';
-import { generateProfilePicture } from '../Utils/messages-media.js';
-import { getBinaryNodeChild } from '../WABinary/index.js';
+import { decryptMessageNode, generateMessageID, generateProfilePicture } from '../Utils/index.js';
+import { getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { makeGroupsSocket } from './groups.js';
 import { executeWMexQuery as genericExecuteWMexQuery } from './mex.js';
+
+const encoder = new TextEncoder();
+
 const parseNewsletterCreateResponse = (response) => {
+    const metadata = extractNewsletterMetadataFromGraphQL(response, true);
+    if (metadata) {
+        return metadata;
+    }
     const { id, thread_metadata: thread, viewer_metadata: viewer } = response;
     return {
-        id: id,
+        id,
         owner: undefined,
-        name: thread.name.text,
-        creation_time: parseInt(thread.creation_time, 10),
-        description: thread.description.text,
-        invite: thread.invite,
-        subscribers: parseInt(thread.subscribers_count, 10),
-        verification: thread.verification,
+        name: thread?.name?.text,
+        creation_time: parseInt(thread?.creation_time || '0', 10) || undefined,
+        description: thread?.description?.text,
+        invite: thread?.invite,
+        subscribers: parseInt(thread?.subscribers_count || '0', 10) || undefined,
+        verification: thread?.verification,
         picture: {
-            id: thread.picture.id,
-            directPath: thread.picture.direct_path
+            id: thread?.picture?.id,
+            directPath: thread?.picture?.direct_path
         },
-        mute_state: viewer.mute
+        mute_state: viewer?.mute
     };
 };
+
 const parseNewsletterMetadata = (result) => {
+    const extracted = extractNewsletterMetadataFromGraphQL(result, false);
+    if (extracted) {
+        return extracted;
+    }
     if (typeof result !== 'object' || result === null) {
         return null;
     }
@@ -33,29 +45,182 @@ const parseNewsletterMetadata = (result) => {
     }
     return null;
 };
+
+const extractNewsletterMetadataFromGraphQL = (result, isCreate = false) => {
+    const metadataPath = isCreate
+        ? result
+        : result?.result?.id
+            ? result.result
+            : result;
+
+    if (!metadataPath || typeof metadataPath !== 'object' || !metadataPath.id) {
+        return null;
+    }
+
+    const thread = metadataPath.thread_metadata || {};
+    const viewer = metadataPath.viewer_metadata || {};
+    const settings = thread.settings || {};
+
+    const reactionCodes = Array.isArray(settings.reaction_codes)
+        ? settings.reaction_codes
+        : Array.isArray(settings.reaction_codes?.codes)
+            ? settings.reaction_codes.codes
+            : undefined;
+
+    return {
+        id: metadataPath.id,
+        state: metadataPath?.state?.type,
+        creation_time: thread?.creation_time ? +thread.creation_time : undefined,
+        name: thread?.name?.text,
+        nameTime: thread?.name?.update_time ? +thread.name.update_time : undefined,
+        description: thread?.description?.text,
+        descriptionTime: thread?.description?.update_time ? +thread.description.update_time : undefined,
+        invite: thread?.invite,
+        handle: thread?.handle,
+        picture: {
+            id: thread?.picture?.id,
+            directPath: thread?.picture?.direct_path
+        },
+        preview: thread?.preview?.direct_path
+            ? {
+                directPath: thread.preview.direct_path,
+                id: thread?.preview?.id
+            }
+            : undefined,
+        reaction_codes: reactionCodes,
+        subscribers: thread?.subscribers_count ? +thread.subscribers_count : undefined,
+        verification: thread?.verification,
+        viewer_metadata: viewer,
+        mute_state: viewer?.mute
+    };
+};
+
+export const extractNewsletterMetadata = extractNewsletterMetadataFromGraphQL;
+
 export const makeNewsletterSocket = (config) => {
     const sock = makeGroupsSocket(config);
-    const { query, generateMessageTag } = sock;
+    const { authState, signalRepository, query, generateMessageTag } = sock;
+
     const executeWMexQuery = (variables, queryId, dataPath) => {
         return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
     };
+
+    const newsletterQuery = async (jid, type, content) => {
+        return query({
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                type,
+                xmlns: 'newsletter',
+                to: jid
+            },
+            content
+        });
+    };
+
+    const newsletterWMexQuery = async (jid, queryId, content, dataPath) => {
+        const variables = {
+            ...(jid ? { newsletter_id: jid } : {}),
+            ...(content || {})
+        };
+        return executeWMexQuery(variables, queryId, dataPath);
+    };
+
     const newsletterUpdate = async (jid, updates) => {
         const variables = {
             newsletter_id: jid,
             updates: {
                 ...updates,
-                settings: null
+                settings: updates?.settings === undefined ? null : updates.settings
             }
         };
         return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update');
     };
+
+    const parseFetchedUpdates = async (node, type) => {
+        let child;
+        if (type === 'messages') {
+            child = getBinaryNodeChild(node, 'messages');
+        }
+        else {
+            const parent = getBinaryNodeChild(node, 'message_updates');
+            child = getBinaryNodeChild(parent, 'messages');
+        }
+
+        const messageNodes = child ? getAllBinaryNodeChildren(child) : [];
+        return Promise.all(messageNodes.map(async (messageNode) => {
+            messageNode.attrs.from = child?.attrs?.jid || messageNode.attrs.from;
+
+            const views = parseInt(getBinaryNodeChild(messageNode, 'views_count')?.attrs?.count || '0', 10);
+            const reactionNode = getBinaryNodeChild(messageNode, 'reactions');
+            const reactions = getBinaryNodeChildren(reactionNode, 'reaction')
+                .map(({ attrs }) => ({ count: +(attrs.count || 0), code: attrs.code }));
+
+            const data = {
+                server_id: messageNode.attrs.server_id,
+                views,
+                reactions
+            };
+
+            if (type === 'messages') {
+                const { fullMessage: message, decrypt } = decryptMessageNode(
+                    messageNode,
+                    authState.creds.me.id,
+                    authState.creds.me.lid || '',
+                    signalRepository,
+                    config.logger
+                );
+                await decrypt();
+                data.message = message;
+            }
+
+            return data;
+        }));
+    };
+
+    const resolveActionQueryId = (type) => {
+        const value = QueryIds?.[String(type).toUpperCase()];
+        if (!value) {
+            throw new Error(`Unknown newsletter action: ${type}`);
+        }
+        return value;
+    };
+
     return {
         ...sock,
-        newsletterCreate: async (name, description) => {
+        newsletterQuery,
+        newsletterWMexQuery,
+        newsletterCreate: async (name, description, picture) => {
+            await query({
+                tag: 'iq',
+                attrs: {
+                    to: S_WHATSAPP_NET,
+                    xmlns: 'tos',
+                    id: generateMessageTag(),
+                    type: 'set'
+                },
+                content: [
+                    {
+                        tag: 'notice',
+                        attrs: {
+                            id: '20601218',
+                            stage: '5'
+                        },
+                        content: []
+                    }
+                ]
+            });
+
             const variables = {
                 input: {
                     name,
-                    description: description ?? null
+                    description: description ?? null,
+                    picture: picture ? (await generateProfilePicture(picture)).img.toString('base64') : null,
+                    settings: {
+                        reaction_codes: {
+                            value: 'ALL'
+                        }
+                    }
                 }
             };
             const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.xwa2_newsletter_create);
@@ -65,19 +230,34 @@ export const makeNewsletterSocket = (config) => {
         newsletterSubscribers: async (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers);
         },
-        newsletterMetadata: async (type, key) => {
+        newsletterMetadata: async (type, key, role = 'GUEST') => {
             const variables = {
                 fetch_creation_time: true,
                 fetch_full_image: true,
                 fetch_viewer_metadata: true,
                 input: {
                     key,
-                    type: type.toUpperCase()
+                    type: String(type).toUpperCase(),
+                    view_role: role
                 }
             };
             const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata);
             return parseNewsletterMetadata(result);
         },
+        subscribeNewsletterUpdates: async (jid) => {
+            const result = await newsletterQuery(jid, 'set', [{ tag: 'live_updates', attrs: {}, content: [] }]);
+            const liveUpdatesNode = getBinaryNodeChild(result, 'live_updates');
+            return liveUpdatesNode?.attrs || null;
+        },
+        newsletterReactionMode: async (jid, mode) => {
+            return await newsletterUpdate(jid, {
+                settings: {
+                    reaction_codes: {
+                        value: mode
+                    }
+                }
+            });
+        },
         newsletterFollow: (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow);
         },
@@ -90,6 +270,10 @@ export const makeNewsletterSocket = (config) => {
         newsletterUnmute: (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2);
         },
+        newsletterAction: async (jid, type) => {
+            const queryId = resolveActionQueryId(type);
+            return await newsletterWMexQuery(jid, queryId);
+        },
         newsletterUpdateName: async (jid, name) => {
             return await newsletterUpdate(jid, { name });
         },
@@ -103,6 +287,22 @@ export const makeNewsletterSocket = (config) => {
         newsletterRemovePicture: async (jid) => {
             return await newsletterUpdate(jid, { picture: '' });
         },
+        newsletterFetchAllParticipating: async () => {
+            throw new Error('newsletterFetchAllParticipating is not available in this lib build because the SUBSCRIBED query ID is not present in current Types/Newsletter definitions.');
+        },
+        newsletterAdminCount: async (jid) => {
+            const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count);
+            return response.admin_count;
+        },
+        newsletterChangeOwner: async (jid, newOwnerJid) => {
+            await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner);
+        },
+        newsletterDemote: async (jid, userJid) => {
+            await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote);
+        },
+        newsletterDelete: async (jid) => {
+            await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2);
+        },
         newsletterReactMessage: async (jid, serverId, reaction) => {
             await query({
                 tag: 'message',
@@ -111,7 +311,7 @@ export const makeNewsletterSocket = (config) => {
                     ...(reaction ? {} : { edit: '7' }),
                     type: 'reaction',
                     server_id: serverId,
-                    id: generateMessageTag()
+                    id: generateMessageID()
                 },
                 content: [
                     {
@@ -121,61 +321,50 @@ export const makeNewsletterSocket = (config) => {
                 ]
             });
         },
-        newsletterFetchMessages: async (jid, count, since, after) => {
-            const messageUpdateAttrs = {
-                count: count.toString()
-            };
-            if (typeof since === 'number') {
-                messageUpdateAttrs.since = since.toString();
-            }
-            if (after) {
-                messageUpdateAttrs.after = after.toString();
-            }
-            const result = await query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    type: 'get',
-                    xmlns: 'newsletter',
-                    to: jid
-                },
-                content: [
+        newsletterFetchMessages: async (...args) => {
+            if (typeof args[0] === 'string' && (args[0] === 'invite' || args[0] === 'jid')) {
+                const [type, key, count, after] = args;
+                const result = await newsletterQuery(S_WHATSAPP_NET, 'get', [
                     {
-                        tag: 'message_updates',
-                        attrs: messageUpdateAttrs
+                        tag: 'messages',
+                        attrs: {
+                            type,
+                            ...(type === 'invite' ? { key } : { jid: key }),
+                            count: String(count),
+                            after: after?.toString() || '100'
+                        }
                     }
-                ]
-            });
+                ]);
+                return await parseFetchedUpdates(result, 'messages');
+            }
+
+            const [jid, count, since, after] = args;
+            const messageUpdateAttrs = {
+                count: count.toString(),
+                ...(typeof since === 'number' ? { since: since.toString() } : {}),
+                ...(after !== undefined && after !== null ? { after: after.toString() } : {})
+            };
+            const result = await newsletterQuery(jid, 'get', [
+                {
+                    tag: 'message_updates',
+                    attrs: messageUpdateAttrs
+                }
+            ]);
             return result;
         },
-        subscribeNewsletterUpdates: async (jid) => {
-            const result = await query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    type: 'set',
-                    xmlns: 'newsletter',
-                    to: jid
-                },
-                content: [{ tag: 'live_updates', attrs: {}, content: [] }]
-            });
-            const liveUpdatesNode = getBinaryNodeChild(result, 'live_updates');
-            const duration = liveUpdatesNode?.attrs?.duration;
-            return duration ? { duration: duration } : null;
-        },
-        newsletterAdminCount: async (jid) => {
-            const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count);
-            return response.admin_count;
-        },
-        newsletterChangeOwner: async (jid, newOwnerJid) => {
-            await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner);
-        },
-        newsletterDemote: async (jid, userJid) => {
-            await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote);
-        },
-        newsletterDelete: async (jid) => {
-            await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2);
+        newsletterFetchUpdates: async (jid, count, after, since) => {
+            const result = await newsletterQuery(jid, 'get', [
+                {
+                    tag: 'message_updates',
+                    attrs: {
+                        count: String(count),
+                        after: after?.toString() || '100',
+                        since: since?.toString() || '0'
+                    }
+                }
+            ]);
+            return await parseFetchedUpdates(result, 'updates');
         }
     };
 };
-//# sourceMappingURL=newsletter.js.map
+//# sourceMappingURL=newsletter.js.map

package/lib/Types/Mex.d.ts

@@ -0,0 +1,141 @@
+export declare enum XWAPaths {
+    xwa2_newsletter_create = "xwa2_newsletter_create",
+    xwa2_newsletter_subscribers = "xwa2_newsletter_subscribers",
+    xwa2_newsletter_view = "xwa2_newsletter_view",
+    xwa2_newsletter_metadata = "xwa2_newsletter",
+    xwa2_newsletter_admin_count = "xwa2_newsletter_admin",
+    xwa2_newsletter_mute_v2 = "xwa2_newsletter_mute_v2",
+    xwa2_newsletter_unmute_v2 = "xwa2_newsletter_unmute_v2",
+    xwa2_newsletter_follow = "xwa2_newsletter_follow",
+    xwa2_newsletter_unfollow = "xwa2_newsletter_unfollow",
+    xwa2_newsletter_join_v2 = "xwa2_newsletter_join_v2",
+    xwa2_newsletter_leave_v2 = "xwa2_newsletter_leave_v2",
+    xwa2_newsletter_change_owner = "xwa2_newsletter_change_owner",
+    xwa2_newsletter_demote = "xwa2_newsletter_demote",
+    xwa2_newsletter_delete_v2 = "xwa2_newsletter_delete_v2",
+    xwa2_fetch_account_reachout_timelock = "xwa2_fetch_account_reachout_timelock",
+    xwa2_message_capping_info = "xwa2_message_capping_info"
+}
+export declare enum QueryIds {
+    CREATE = "8823471724422422",
+    UPDATE_METADATA = "24250201037901610",
+    METADATA = "6563316087068696",
+    SUBSCRIBERS = "9783111038412085",
+    FOLLOW = "24404358912487870",
+    UNFOLLOW = "9767147403369991",
+    MUTE = "29766401636284406",
+    UNMUTE = "9864994326891137",
+    ADMIN_COUNT = "7130823597031706",
+    CHANGE_OWNER = "7341777602580933",
+    DEMOTE = "6551828931592903",
+    DELETE = "30062808666639665",
+    REACHOUT_TIMELOCK = "23983697327930364",
+    MESSAGE_CAPPING_INFO = "24503548349331633"
+}
+export type NewsletterUpdate = {
+    name?: string;
+    description?: string;
+    picture?: string;
+};
+export interface NewsletterCreateResponse {
+    id: string;
+    state: {
+        type: string;
+    };
+    thread_metadata: {
+        creation_time: string;
+        description: {
+            id: string;
+            text: string;
+            update_time: string;
+        };
+        handle: string | null;
+        invite: string;
+        name: {
+            id: string;
+            text: string;
+            update_time: string;
+        };
+        picture: {
+            direct_path: string;
+            id: string;
+            type: string;
+        };
+        preview: {
+            direct_path: string;
+            id: string;
+            type: string;
+        };
+        subscribers_count: string;
+        verification: 'VERIFIED' | 'UNVERIFIED';
+    };
+    viewer_metadata: {
+        mute: 'ON' | 'OFF';
+        role: NewsletterViewRole;
+    };
+}
+export interface NewsletterCreateResponse {
+    id: string;
+    state: {
+        type: string;
+    };
+    thread_metadata: {
+        creation_time: string;
+        description: {
+            id: string;
+            text: string;
+            update_time: string;
+        };
+        handle: string | null;
+        invite: string;
+        name: {
+            id: string;
+            text: string;
+            update_time: string;
+        };
+        picture: {
+            direct_path: string;
+            id: string;
+            type: string;
+        };
+        preview: {
+            direct_path: string;
+            id: string;
+            type: string;
+        };
+        subscribers_count: string;
+        verification: 'VERIFIED' | 'UNVERIFIED';
+    };
+    viewer_metadata: {
+        mute: 'ON' | 'OFF';
+        role: NewsletterViewRole;
+    };
+}
+export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER';
+export interface NewsletterMetadata {
+    id: string;
+    owner?: string;
+    name: string;
+    description?: string;
+    invite?: string;
+    creation_time?: number;
+    subscribers?: number;
+    picture?: {
+        url?: string;
+        directPath?: string;
+        mediaKey?: string;
+        id?: string;
+    };
+    verification?: 'VERIFIED' | 'UNVERIFIED';
+    reaction_codes?: {
+        code: string;
+        count: number;
+    }[];
+    mute_state?: 'ON' | 'OFF';
+    thread_metadata?: {
+        creation_time?: number;
+        name?: string;
+        description?: string;
+    };
+}
+//# sourceMappingURL=Mex.d.ts.map