@classytic/social 0.1.0

package/dist/providers/twitter.mjs

@@ -0,0 +1,628 @@
+import { t as PlatformProvider } from "../base-Bw7e52V8.mjs";
+import { t as SocialError } from "../errors-Cm6LeKf7.mjs";
+import { t as httpRequest } from "../http-DpcLSR1M.mjs";
+import { n as generateCodeChallenge, r as generateCodeVerifier, t as PkceStore } from "../pkce-jq5II68b.mjs";
+import { t as TwitterCredentialsSchema } from "../twitter-BC22zfuc.mjs";
+import { t as TWITTER_ERROR_HINTS } from "../types-Dp5Z9VBr.mjs";
+
+//#region src/providers/twitter/index.ts
+/**
+* Twitter/X Provider
+* ==================
+* Full Twitter API v2 integration with OAuth 2.0 + PKCE.
+*
+* Supports:
+* - OAuth 2.0 with PKCE (authorization code flow)
+* - Tweet CRUD (create, delete, search, get)
+* - Reply and quote tweets
+* - Like / unlike / retweet / unretweet
+* - User lookup (by ID, username, or authenticated user)
+* - Direct messages (send)
+* - Followers / following lists
+* - Bookmarks
+* - Media upload (via v1.1 chunked upload)
+*
+* @see https://developer.x.com/en/docs/x-api
+*/
+const API_BASE = "https://api.twitter.com/2";
+const AUTH_URL = "https://x.com/i/oauth2/authorize";
+const TOKEN_URL = "https://api.twitter.com/2/oauth2/token";
+const REVOKE_URL = "https://api.twitter.com/2/oauth2/revoke";
+const DEFAULT_SCOPES = [
+	"tweet.read",
+	"tweet.write",
+	"tweet.moderate.write",
+	"users.read",
+	"follows.read",
+	"follows.write",
+	"offline.access",
+	"like.read",
+	"like.write",
+	"dm.write",
+	"dm.read",
+	"list.read",
+	"list.write",
+	"bookmark.read",
+	"bookmark.write",
+	"block.read",
+	"mute.read",
+	"media.write"
+];
+const SCOPE_DESCRIPTIONS = {
+	"tweet.read": "Read tweets on your behalf",
+	"tweet.write": "Create, delete, and manage tweets",
+	"tweet.moderate.write": "Hide/unhide replies to your tweets",
+	"users.read": "Read user profile information",
+	"follows.read": "View followers and following lists",
+	"follows.write": "Follow and unfollow users",
+	"offline.access": "Stay connected (refresh tokens)",
+	"like.read": "View liked tweets",
+	"like.write": "Like and unlike tweets",
+	"dm.write": "Send direct messages",
+	"dm.read": "Read direct messages",
+	"list.read": "Read lists",
+	"list.write": "Create and manage lists",
+	"bookmark.read": "View bookmarks",
+	"bookmark.write": "Create and manage bookmarks",
+	"block.read": "View blocked accounts",
+	"mute.read": "View muted accounts"
+};
+const pkceVerifiers = new PkceStore(600 * 1e3);
+var TwitterProvider = class extends PlatformProvider {
+	constructor(config = {}) {
+		super(config);
+		this.name = "twitter";
+		this.displayName = "Twitter / X";
+		this.authType = "oauth2";
+	}
+	getAuthUrl(state, credData, options) {
+		const clientId = credData?.clientId;
+		if (!clientId) throw new SocialError("twitter", "Client ID is required", { statusCode: 400 });
+		const redirectUri = credData?.redirectUri || this.config.redirectUri || `http://localhost:${this.config.port || 8060}/api/oauth/twitter/callback`;
+		const codeVerifier = generateCodeVerifier();
+		pkceVerifiers.set(state, codeVerifier);
+		return `${AUTH_URL}?${new URLSearchParams({
+			response_type: "code",
+			client_id: clientId,
+			redirect_uri: redirectUri,
+			scope: DEFAULT_SCOPES.join(" "),
+			state,
+			code_challenge: codeVerifier,
+			code_challenge_method: "plain"
+		}).toString()}`;
+	}
+	/**
+	* Async auth URL generation with proper S256 PKCE challenge.
+	* Prefer this over getAuthUrl() when async is acceptable.
+	*/
+	async getAuthUrlAsync(state, credData) {
+		const clientId = credData?.clientId;
+		if (!clientId) throw new SocialError("twitter", "Client ID is required", { statusCode: 400 });
+		const redirectUri = credData?.redirectUri || this.config.redirectUri || `http://localhost:${this.config.port || 8060}/api/oauth/twitter/callback`;
+		const codeVerifier = generateCodeVerifier();
+		pkceVerifiers.set(state, codeVerifier);
+		const codeChallenge = await generateCodeChallenge(codeVerifier);
+		return `${AUTH_URL}?${new URLSearchParams({
+			response_type: "code",
+			client_id: clientId,
+			redirect_uri: redirectUri,
+			scope: DEFAULT_SCOPES.join(" "),
+			state,
+			code_challenge: codeChallenge,
+			code_challenge_method: "S256"
+		}).toString()}`;
+	}
+	async exchangeCode(code, credData, state) {
+		const clientId = credData?.clientId;
+		const clientSecret = credData?.clientSecret;
+		if (!clientId) throw new SocialError("twitter", "Client ID is required for token exchange", { statusCode: 400 });
+		const redirectUri = credData?.redirectUri || this.config.redirectUri || `http://localhost:${this.config.port || 8060}/api/oauth/twitter/callback`;
+		const codeVerifier = state ? pkceVerifiers.take(state) : void 0;
+		const body = new URLSearchParams({
+			grant_type: "authorization_code",
+			code,
+			redirect_uri: redirectUri,
+			client_id: clientId,
+			...codeVerifier ? { code_verifier: codeVerifier } : {}
+		});
+		const headers = { "Content-Type": "application/x-www-form-urlencoded" };
+		if (clientSecret) headers["Authorization"] = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
+		const response = await fetch(TOKEN_URL, {
+			method: "POST",
+			headers,
+			body: body.toString()
+		});
+		const data = await response.json();
+		if (!response.ok) throw new SocialError("twitter", `Token exchange failed: ${data.error_description || data.error || response.statusText}`, {
+			statusCode: response.status,
+			errorCode: data.error,
+			hint: "Ensure your Client ID, Client Secret, and redirect URI are correct.",
+			originalError: new Error(JSON.stringify(data))
+		});
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			token_type: data.token_type,
+			scope: data.scope
+		};
+	}
+	async refreshToken(refreshToken, credData) {
+		const clientId = credData?.clientId;
+		const clientSecret = credData?.clientSecret;
+		if (!clientId) throw new SocialError("twitter", "Client ID is required for token refresh", { statusCode: 400 });
+		const body = new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: clientId
+		});
+		const headers = { "Content-Type": "application/x-www-form-urlencoded" };
+		if (clientSecret) headers["Authorization"] = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
+		const response = await fetch(TOKEN_URL, {
+			method: "POST",
+			headers,
+			body: body.toString()
+		});
+		const data = await response.json();
+		if (!response.ok) throw new SocialError("twitter", `Token refresh failed: ${data.error_description || data.error || response.statusText}`, {
+			statusCode: response.status,
+			errorCode: data.error,
+			hint: "The refresh token may have been revoked. Re-authenticate."
+		});
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			token_type: data.token_type,
+			scope: data.scope
+		};
+	}
+	async revokeToken(accessToken, credData) {
+		const clientId = credData?.clientId;
+		if (!clientId) return;
+		const body = new URLSearchParams({
+			token: accessToken,
+			token_type_hint: "access_token",
+			client_id: clientId
+		});
+		await fetch(REVOKE_URL, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: body.toString()
+		}).catch(() => {});
+	}
+	async getAccountInfo(accessToken) {
+		const user = (await this._api("GET", "/users/me?user.fields=id,name,username,description,profile_image_url,public_metrics,verified,verified_type,created_at,location,url", accessToken)).data;
+		return {
+			id: user.id,
+			name: user.name,
+			username: user.username,
+			profileImage: user.profile_image_url ?? null,
+			description: user.description,
+			location: user.location,
+			url: user.url,
+			verified: user.verified,
+			verifiedType: user.verified_type,
+			followersCount: user.public_metrics?.followers_count,
+			followingCount: user.public_metrics?.following_count,
+			tweetCount: user.public_metrics?.tweet_count,
+			listedCount: user.public_metrics?.listed_count,
+			createdAt: user.created_at
+		};
+	}
+	async testCredential(credentialData) {
+		try {
+			const tokenData = typeof credentialData.oauthTokenData === "string" ? JSON.parse(credentialData.oauthTokenData) : credentialData.oauthTokenData;
+			if (!tokenData?.access_token) return {
+				status: "Error",
+				message: "No access token found. Complete OAuth authorization first."
+			};
+			const info = await this.getAccountInfo(tokenData.access_token);
+			return {
+				status: "OK",
+				message: `Connected as @${info.username} (${info.name})`,
+				data: {
+					id: info.id,
+					username: info.username,
+					name: info.name
+				}
+			};
+		} catch (err) {
+			return {
+				status: "Error",
+				message: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	/**
+	* Create a tweet (or reply / quote tweet).
+	*/
+	async createTweet(accessToken, params) {
+		const body = { text: params.text };
+		if (params.replyTo) body.reply = { in_reply_to_tweet_id: params.replyTo };
+		if (params.quoteTweetId) body.quote_tweet_id = params.quoteTweetId;
+		if (params.mediaIds?.length) body.media = { media_ids: params.mediaIds };
+		if (params.poll) body.poll = {
+			options: params.poll.options,
+			duration_minutes: params.poll.durationMinutes
+		};
+		if (params.replySettings) body.reply_settings = params.replySettings;
+		const result = await this._api("POST", "/tweets", accessToken, body);
+		return {
+			id: result.data.id,
+			text: result.data.text,
+			editHistoryTweetIds: result.data.edit_history_tweet_ids
+		};
+	}
+	/**
+	* Delete a tweet by ID.
+	*/
+	async deleteTweet(accessToken, tweetId) {
+		return { deleted: (await this._api("DELETE", `/tweets/${tweetId}`, accessToken)).data?.deleted ?? true };
+	}
+	/**
+	* Get a single tweet by ID.
+	*/
+	async getTweet(accessToken, tweetId, fields) {
+		const tweetFields = fields?.join(",") || "id,text,author_id,created_at,public_metrics,entities,conversation_id,reply_settings,source,lang";
+		const data = await this._api("GET", `/tweets/${tweetId}?tweet.fields=${tweetFields}`, accessToken);
+		if (!data.data) throw new SocialError("twitter", `Tweet ${tweetId} not found`, {
+			statusCode: 404,
+			errorCode: "TWEET_NOT_FOUND",
+			hint: TWITTER_ERROR_HINTS["TWEET_NOT_FOUND"]
+		});
+		return this._parseTweet(data.data);
+	}
+	/**
+	* Search recent tweets (last 7 days on Basic tier).
+	*/
+	async searchTweets(accessToken, params) {
+		const qs = new URLSearchParams({ query: params.query });
+		if (params.maxResults) qs.set("max_results", String(params.maxResults));
+		if (params.nextToken) qs.set("next_token", params.nextToken);
+		if (params.startTime) qs.set("start_time", params.startTime);
+		if (params.endTime) qs.set("end_time", params.endTime);
+		if (params.sortOrder) qs.set("sort_order", params.sortOrder);
+		if (params.tweetFields?.length) qs.set("tweet.fields", params.tweetFields.join(","));
+		if (params.userFields?.length) qs.set("user.fields", params.userFields.join(","));
+		if (params.expansions?.length) qs.set("expansions", params.expansions.join(","));
+		if (!params.tweetFields?.length) qs.set("tweet.fields", "id,text,author_id,created_at,public_metrics,entities,source,lang");
+		const result = await this._api("GET", `/tweets/search/recent?${qs.toString()}`, accessToken);
+		return {
+			tweets: (result.data || []).map((t) => this._parseTweet(t)),
+			meta: {
+				newestId: result.meta?.newest_id,
+				oldestId: result.meta?.oldest_id,
+				resultCount: result.meta?.result_count || 0,
+				nextToken: result.meta?.next_token
+			},
+			includes: result.includes
+		};
+	}
+	/**
+	* Like a tweet.
+	*/
+	async likeTweet(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { liked: (await this._api("POST", `/users/${me}/likes`, accessToken, { tweet_id: tweetId })).data?.liked ?? true };
+	}
+	/**
+	* Unlike a tweet.
+	*/
+	async unlikeTweet(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { liked: (await this._api("DELETE", `/users/${me}/likes/${tweetId}`, accessToken)).data?.liked ?? false };
+	}
+	/**
+	* Retweet a tweet.
+	*/
+	async retweet(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { retweeted: (await this._api("POST", `/users/${me}/retweets`, accessToken, { tweet_id: tweetId })).data?.retweeted ?? true };
+	}
+	/**
+	* Remove a retweet.
+	*/
+	async unretweet(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { retweeted: (await this._api("DELETE", `/users/${me}/retweets/${tweetId}`, accessToken)).data?.retweeted ?? false };
+	}
+	/**
+	* Bookmark a tweet.
+	*/
+	async bookmarkTweet(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { bookmarked: (await this._api("POST", `/users/${me}/bookmarks`, accessToken, { tweet_id: tweetId })).data?.bookmarked ?? true };
+	}
+	/**
+	* Remove a bookmark.
+	*/
+	async removeBookmark(accessToken, tweetId) {
+		const me = await this._getMyId(accessToken);
+		return { bookmarked: (await this._api("DELETE", `/users/${me}/bookmarks/${tweetId}`, accessToken)).data?.bookmarked ?? false };
+	}
+	/**
+	* Follow a user.
+	*/
+	async followUser(accessToken, targetUserId) {
+		const me = await this._getMyId(accessToken);
+		const result = await this._api("POST", `/users/${me}/following`, accessToken, { target_user_id: targetUserId });
+		return {
+			following: result.data?.following ?? true,
+			pendingFollow: result.data?.pending_follow ?? false
+		};
+	}
+	/**
+	* Unfollow a user.
+	*/
+	async unfollowUser(accessToken, targetUserId) {
+		const me = await this._getMyId(accessToken);
+		return { following: (await this._api("DELETE", `/users/${me}/following/${targetUserId}`, accessToken)).data?.following ?? false };
+	}
+	/**
+	* Get followers of a user.
+	*/
+	async getFollowers(accessToken, userId, opts = {}) {
+		const qs = new URLSearchParams();
+		if (opts.maxResults) qs.set("max_results", String(opts.maxResults));
+		if (opts.paginationToken) qs.set("pagination_token", opts.paginationToken);
+		qs.set("user.fields", (opts.userFields || [
+			"id",
+			"name",
+			"username",
+			"profile_image_url",
+			"public_metrics",
+			"verified"
+		]).join(","));
+		const result = await this._api("GET", `/users/${userId}/followers?${qs.toString()}`, accessToken);
+		return {
+			users: (result.data || []).map((u) => this._parseUser(u)),
+			nextToken: result.meta?.next_token
+		};
+	}
+	/**
+	* Get users that a user is following.
+	*/
+	async getFollowing(accessToken, userId, opts = {}) {
+		const qs = new URLSearchParams();
+		if (opts.maxResults) qs.set("max_results", String(opts.maxResults));
+		if (opts.paginationToken) qs.set("pagination_token", opts.paginationToken);
+		qs.set("user.fields", (opts.userFields || [
+			"id",
+			"name",
+			"username",
+			"profile_image_url",
+			"public_metrics",
+			"verified"
+		]).join(","));
+		const result = await this._api("GET", `/users/${userId}/following?${qs.toString()}`, accessToken);
+		return {
+			users: (result.data || []).map((u) => this._parseUser(u)),
+			nextToken: result.meta?.next_token
+		};
+	}
+	/**
+	* Get a user by username.
+	*/
+	async getUserByUsername(accessToken, username, fields) {
+		const clean = username.replace(/^@/, "");
+		const userFields = fields?.join(",") || "id,name,username,description,profile_image_url,public_metrics,verified,verified_type,created_at,location,url";
+		const data = await this._api("GET", `/users/by/username/${clean}?user.fields=${userFields}`, accessToken);
+		if (!data.data) throw new SocialError("twitter", `User @${clean} not found`, {
+			statusCode: 404,
+			errorCode: "USER_NOT_FOUND",
+			hint: TWITTER_ERROR_HINTS["USER_NOT_FOUND"]
+		});
+		return this._parseUser(data.data);
+	}
+	/**
+	* Get a user by ID.
+	*/
+	async getUserById(accessToken, userId, fields) {
+		const userFields = fields?.join(",") || "id,name,username,description,profile_image_url,public_metrics,verified,verified_type,created_at,location,url";
+		const data = await this._api("GET", `/users/${userId}?user.fields=${userFields}`, accessToken);
+		if (!data.data) throw new SocialError("twitter", `User ${userId} not found`, {
+			statusCode: 404,
+			errorCode: "USER_NOT_FOUND",
+			hint: TWITTER_ERROR_HINTS["USER_NOT_FOUND"]
+		});
+		return this._parseUser(data.data);
+	}
+	/**
+	* Send a direct message to a user.
+	*/
+	async sendDirectMessage(accessToken, params) {
+		const body = { text: params.text };
+		if (params.mediaId) body.attachments = [{ media_id: params.mediaId }];
+		const result = await this._api("POST", `/dm_conversations/with/${params.participantId}/messages`, accessToken, body);
+		return {
+			dmConversationId: result.data?.dm_conversation_id ?? "",
+			dmEventId: result.data?.dm_event_id ?? ""
+		};
+	}
+	/**
+	* Mute a user.
+	*/
+	async muteUser(accessToken, targetUserId) {
+		const me = await this._getMyId(accessToken);
+		return { muting: (await this._api("POST", `/users/${me}/muting`, accessToken, { target_user_id: targetUserId })).data?.muting ?? true };
+	}
+	/**
+	* Unmute a user.
+	*/
+	async unmuteUser(accessToken, targetUserId) {
+		const me = await this._getMyId(accessToken);
+		return { muting: (await this._api("DELETE", `/users/${me}/muting/${targetUserId}`, accessToken)).data?.muting ?? false };
+	}
+	async uploadPhoto(params) {
+		const { tokens, caption, title } = params;
+		const text = caption || title || "";
+		if (!text) throw new SocialError("twitter", "Tweet text or caption is required", { statusCode: 400 });
+		const result = await this.createTweet(tokens.access_token, { text });
+		return {
+			platformPostId: result.id,
+			platformUrl: `https://x.com/i/status/${result.id}`,
+			status: "published",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async deletePost(accessToken, tweetId) {
+		return this.deleteTweet(accessToken, tweetId);
+	}
+	async sendMessage(accessToken, participantId, text) {
+		return this.sendDirectMessage(accessToken, {
+			participantId,
+			text
+		});
+	}
+	getCredentialZodSchema() {
+		return TwitterCredentialsSchema;
+	}
+	getCredentialSchema() {
+		return [{
+			name: "clientId",
+			displayName: "Client ID",
+			type: "text",
+			required: true,
+			description: "OAuth 2.0 Client ID from the Twitter Developer Portal",
+			placeholder: "abc123..."
+		}, {
+			name: "clientSecret",
+			displayName: "Client Secret",
+			type: "password",
+			required: true,
+			description: "OAuth 2.0 Client Secret (for confidential clients)",
+			placeholder: "secret..."
+		}];
+	}
+	getMetadata() {
+		return {
+			name: this.name,
+			displayName: this.displayName,
+			authType: this.authType,
+			icon: "twitter",
+			brandColor: "#000000",
+			description: "Post tweets, reply, search, and manage your X/Twitter account",
+			scopes: DEFAULT_SCOPES,
+			scopeDescriptions: SCOPE_DESCRIPTIONS,
+			setupGuide: [
+				{
+					step: 1,
+					title: "Create a Developer App",
+					description: "Go to developer.x.com → Projects & Apps → Create a new app. Select \"Web App\" as the app type."
+				},
+				{
+					step: 2,
+					title: "Set up OAuth 2.0",
+					description: "Under \"User authentication settings\", enable OAuth 2.0. Set the callback URL to your redirect URI. Select \"Web App\" type."
+				},
+				{
+					step: 3,
+					title: "Copy credentials",
+					description: "Copy the Client ID and Client Secret from the \"Keys and tokens\" tab."
+				},
+				{
+					step: 4,
+					title: "API Access Level",
+					description: "Ensure your app has at least Basic API access (Free tier is very limited). Apply for Pro if you need search and analytics."
+				}
+			],
+			supportsScheduling: false,
+			supportsEnvironment: false,
+			redirectUriPattern: "/api/oauth/twitter/callback",
+			credentialSchema: this.getCredentialSchema()
+		};
+	}
+	/** Cached user ID for the authenticated user (per-request) */
+	_myIdCache = /* @__PURE__ */ new Map();
+	async _getMyId(accessToken) {
+		const cached = this._myIdCache.get(accessToken);
+		if (cached) return cached;
+		const id = (await this._api("GET", "/users/me", accessToken)).data.id;
+		this._myIdCache.set(accessToken, id);
+		return id;
+	}
+	/**
+	* Core API request helper.
+	*/
+	async _api(method, endpoint, accessToken, body) {
+		const url = endpoint.startsWith("http") ? endpoint : `${API_BASE}${endpoint}`;
+		const result = await httpRequest("twitter", {
+			method: method.toUpperCase(),
+			url,
+			bearer: accessToken,
+			headers: { "User-Agent": "web:com.classytic.social:v0.1.0" },
+			json: body,
+			timeout: 3e4,
+			retry: { attempts: 2 },
+			parseError: (raw, status) => {
+				if (raw && typeof raw === "object") {
+					const r = raw;
+					const errors = r.errors;
+					const detail = errors?.[0]?.detail || r.detail || r.error_description || r.error;
+					const errorTitle = errors?.[0]?.title || r.title || "API_ERROR";
+					const hintKey = errorTitle.toUpperCase().replace(/ /g, "_");
+					return {
+						message: `Twitter API error (${status}): ${detail || "Unknown"}`,
+						errorCode: errorTitle,
+						hint: TWITTER_ERROR_HINTS[hintKey] || TWITTER_ERROR_HINTS[String(status)] || null
+					};
+				}
+				return null;
+			}
+		});
+		if (result.status === 204) return { data: { deleted: true } };
+		return result.data;
+	}
+	_parseTweet(raw) {
+		return {
+			id: raw.id,
+			text: raw.text,
+			authorId: raw.author_id,
+			createdAt: raw.created_at,
+			conversationId: raw.conversation_id,
+			inReplyToUserId: raw.in_reply_to_user_id,
+			publicMetrics: raw.public_metrics ? {
+				retweetCount: raw.public_metrics.retweet_count ?? 0,
+				replyCount: raw.public_metrics.reply_count ?? 0,
+				likeCount: raw.public_metrics.like_count ?? 0,
+				quoteCount: raw.public_metrics.quote_count ?? 0,
+				bookmarkCount: raw.public_metrics.bookmark_count,
+				impressionCount: raw.public_metrics.impression_count
+			} : void 0,
+			entities: raw.entities,
+			attachments: raw.attachments,
+			source: raw.source,
+			lang: raw.lang,
+			replySettings: raw.reply_settings,
+			editHistoryTweetIds: raw.edit_history_tweet_ids
+		};
+	}
+	_parseUser(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			username: raw.username,
+			createdAt: raw.created_at,
+			description: raw.description,
+			location: raw.location,
+			profileImageUrl: raw.profile_image_url,
+			protected: raw.protected,
+			publicMetrics: raw.public_metrics ? {
+				followersCount: raw.public_metrics.followers_count ?? 0,
+				followingCount: raw.public_metrics.following_count ?? 0,
+				tweetCount: raw.public_metrics.tweet_count ?? 0,
+				listedCount: raw.public_metrics.listed_count ?? 0,
+				likeCount: raw.public_metrics.like_count
+			} : void 0,
+			url: raw.url,
+			verified: raw.verified,
+			verifiedType: raw.verified_type,
+			pinnedTweetId: raw.pinned_tweet_id
+		};
+	}
+};
+
+//#endregion
+export { TwitterProvider };
+//# sourceMappingURL=twitter.mjs.map