@opencoredev/social-sdk 0.2.1 → 0.4.0

package/dist/platforms/tiktok.d.ts

@@ -8,6 +8,10 @@ export interface TikTokOptions {
     readonly verifiedMediaOrigins: readonly string[];
     readonly fetch?: typeof globalThis.fetch;
     readonly clock?: () => Date;
+    /** App client secret that TikTok uses to sign webhook deliveries (`TikTok-Signature`). */
+    readonly webhookSecret?: string;
+    /** Accepted age of a signed webhook timestamp, in seconds. Defaults to 300. */
+    readonly webhookToleranceSeconds?: number;
 }
 export interface TikTokNative {
     readonly creatorInfo: (account: ConnectedAccountRef, context: AdapterOperationContext) => Promise<JsonObject>;

package/dist/platforms/tiktok.js

@@ -1,9 +1,12 @@
-/* oxlint-disable anti-slop/no-unknown-parameters -- validated external boundary or fixture contract. */
 import { defineAdapter } from "../core/adapter.js";
+import { definedFields } from "../core/fields.js";
 import { SocialError } from "../core/errors.js";
-import { managedHttp, publicFields } from "../cloud/common.js";
-import { array, object, optionalNumber, optionalString, string } from "../transport/validation.js";
+import { managedHttp, optionsObject, publicFields } from "../cloud/common.js";
+import { parseJson } from "../transport/json.js";
+import { array, isBoolean, isFiniteNumber, isJsonArray, isJsonObject, isString, object, optionalNumber, optionalString, string, } from "../transport/validation.js";
 import { httpsUrl } from "../transport/upload.js";
+import { verifyTikTokWebhook } from "../server/webhooks.js";
+import { directWebhooks, webhookCapability } from "./webhook-adapter.js";
 const videoFields = [
     "id",
     "create_time",
@@ -19,34 +22,37 @@ const videoFields = [
     "share_count",
     "view_count",
 ];
+/**
+ * TikTok reports some rejections as 4xx responses with a structured `error.code`.
+ * Pass those through as 200 so `data()` can map the provider code.
+ */
+function withTikTokErrorBodies(fetch) {
+    return async (input, init) => {
+        const response = await fetch(input, init);
+        if (response.status < 400 || response.status >= 500)
+            return response;
+        const body = await response.clone().text();
+        try {
+            const errorObject = object(object(parseJson(body))["error"]);
+            if (errorObject["code"] !== undefined)
+                return new Response(body, {
+                    status: 200,
+                    headers: response.headers,
+                });
+        }
+        catch {
+            // Preserve ordinary HTTP error handling for non-JSON responses.
+        }
+        return response;
+    };
+}
 export function tiktok(options) {
+    const userFetch = options.fetch;
     const request = managedHttp("https://open.tiktokapis.com", {
         apiKey: options.auth.accessToken,
-        // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-        ...(options.fetch
-            ? {
-                fetch: async (input, init) => {
-                    const response = await options.fetch(input, init);
-                    if (response.status < 400 || response.status >= 500)
-                        return response;
-                    const body = await response.clone().text();
-                    try {
-                        const parsed = JSON.parse(body);
-                        const parsedObject = object(parsed);
-                        const errorObject = object(parsedObject["error"]);
-                        if (errorObject["code"] !== undefined)
-                            return new Response(body, {
-                                status: 200,
-                                headers: response.headers,
-                            });
-                    }
-                    catch {
-                        // Preserve ordinary HTTP error handling for non-JSON responses.
-                    }
-                    return response;
-                },
-            }
-            : {}),
+        ...definedFields({
+            fetch: userFetch === undefined ? undefined : withTikTokErrorBodies(userFetch),
+        }),
     });
     const origins = new Set(options.verifiedMediaOrigins.map((value) => httpsUrl(value).origin));
     const now = () => (options.clock?.() ?? new Date()).toISOString();
@@ -60,14 +66,6 @@ export function tiktok(options) {
                 message: "Account reference does not belong to this TikTok authorization.",
             });
     };
-    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- validated boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- validated boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- provider payload is validated at this adapter boundary.
-    // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- validated external boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- validated external boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- validated external boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- validated external boundary or fixture contract.
-    // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- validated external boundary or fixture contract.
     const data = (value) => {
         const response = object(value);
         const error = object(response["error"]);
@@ -106,7 +104,7 @@ export function tiktok(options) {
         const fail = (code, message) => issues.push({ code, message, severity: "error", targetIndex: target.targetIndex });
         if (target.account.platform !== "tiktok" || target.account.accountId !== options.auth.openId)
             fail("tiktok.account", "Select the configured TikTok creator.");
-        const config = target.options === undefined ? {} : object(target.options);
+        const config = optionsObject(target);
         const draft = config["draft"] === true;
         if (config["consentGiven"] !== true)
             fail("tiktok.consent", "The creator must preview the content and explicitly consent before transfer.");
@@ -119,18 +117,19 @@ export function tiktok(options) {
             "aiGenerated",
             "draft",
         ])
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-            if (typeof config[key] !== "boolean")
+            if (!isBoolean(config[key]))
                 fail(`tiktok.${key}`, `Explicit ${key} choice is required.`);
-        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-        if (!draft && (!config["creatorInfo"] || typeof config["creatorInfo"] !== "object"))
+        const creatorInfoValue = config["creatorInfo"];
+        if (!draft && !isJsonObject(creatorInfoValue) && !isJsonArray(creatorInfoValue))
             fail("tiktok.creator_info", "Query creator information explicitly and render its choices before preparation.");
         else if (!draft) {
-            const creator = object(config["creatorInfo"]);
+            const creator = object(creatorInfoValue);
             if (creator["accountId"] !== target.account.accountId ||
                 creator["backend"] !== target.account.backend)
                 fail("tiktok.creator_mismatch", "Creator information belongs to a different account or backend.");
-            if (!array(creator["privacyLevels"]).includes(config["privacy"]))
+            const privacyLevels = array(creator["privacyLevels"]);
+            const privacy = config["privacy"];
+            if (privacy === undefined || !privacyLevels.includes(privacy))
                 fail("tiktok.privacy", "Choose a privacy level returned by this creator's information.");
         }
         const media = target.content.media ?? [];
@@ -140,19 +139,17 @@ export function tiktok(options) {
             fail("tiktok.media", "Choose one video or 1 to 35 photos; formats cannot be mixed.");
         if ((target.content.text?.length ?? 0) > (video ? 2200 : 4000))
             fail("tiktok.caption", "Caption exceeds TikTok's UTF-16 limit for this format.");
-        if (!video &&
-            config["title"] !== undefined &&
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-            (typeof config["title"] !== "string" || config["title"].length > 90))
+        const title = config["title"];
+        if (!video && title !== undefined && (!isString(title) || title.length > 90))
             fail("tiktok.title", "Photo titles are limited to 90 UTF-16 code units.");
-        if (video && config["title"] !== undefined)
+        if (video && title !== undefined)
             fail("tiktok.title", "Video captions use content.text; title is a photo-only option.");
+        const photoCoverIndex = config["photoCoverIndex"];
         if (!video &&
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-            (typeof config["photoCoverIndex"] !== "number" ||
-                !Number.isInteger(config["photoCoverIndex"]) ||
-                config["photoCoverIndex"] < 0 ||
-                config["photoCoverIndex"] >= media.length))
+            (!isFiniteNumber(photoCoverIndex) ||
+                !Number.isInteger(photoCoverIndex) ||
+                photoCoverIndex < 0 ||
+                photoCoverIndex >= media.length))
             fail("tiktok.cover", "Select a photo cover index within the attached images.");
         for (const item of media) {
             if (item.source.kind !== "https-url") {
@@ -188,6 +185,7 @@ export function tiktok(options) {
             apiRevision: "Content Posting API v2",
             runtime: ["node22", "node24", "bun"],
             capabilities: [
+                webhookCapability("tiktok", "Verifies TikTok-Signature (HMAC-SHA256 over timestamp and raw body) with the client secret and a 300 second default timestamp window, then decodes the event."),
                 {
                     platform: "tiktok",
                     operation: "posts.publish",
@@ -196,6 +194,12 @@ export function tiktok(options) {
                     requiredScopes: ["video.publish"],
                     notes: "Verified URL source; explicit creator choices/consent. Public posting requires app audit. Draft mode uses video.upload.",
                 },
+                {
+                    platform: "tiktok",
+                    operation: "posts.schedule",
+                    availability: "unsupported-by-platform",
+                    notes: "Content Posting API post_info has no publish-time field.",
+                },
                 { platform: "tiktok", operation: "posts.status", availability: "available" },
                 {
                     platform: "tiktok",
@@ -216,6 +220,13 @@ export function tiktok(options) {
                     requiredScopes: ["video.upload"],
                 },
                 { platform: "tiktok", operation: "posts.status.poll", availability: "available" },
+                // Source, accessed 2026-09-24: https://developers.tiktok.com/doc/content-posting-api-get-started
+                {
+                    platform: "tiktok",
+                    operation: "posts.update",
+                    availability: "unsupported-by-platform",
+                    notes: "The Content Posting API sets caption and privacy only when a post is initialized. It has no endpoint to edit a published post.",
+                },
                 {
                     platform: "tiktok",
                     operation: "comments.read",
@@ -227,6 +238,12 @@ export function tiktok(options) {
                     operation: "messages.read",
                     availability: "unsupported-by-platform",
                 },
+                {
+                    platform: "tiktok",
+                    operation: "notifications.read",
+                    availability: "unsupported-by-platform",
+                    notes: "TikTok for Developers APIs do not expose a user notification inbox.",
+                },
                 {
                     platform: "tiktok",
                     operation: "accounts.read",
@@ -245,8 +262,20 @@ export function tiktok(options) {
                     availability: "available",
                     requiredScopes: ["video.list"],
                 },
+                {
+                    platform: "tiktok",
+                    operation: "profile.update",
+                    availability: "unsupported-by-platform",
+                    notes: "The Display API reads user info only. TikTok has no profile write endpoint.",
+                },
             ],
         },
+        webhooks: directWebhooks("tiktok", (input) => verifyTikTokWebhook({
+            ...input,
+            secret: options.webhookSecret ?? "",
+            now: () => options.clock?.() ?? new Date(),
+            ...definedFields({ toleranceSeconds: options.webhookToleranceSeconds }),
+        }), now),
         accounts: {
             async list(_input, context) {
                 const response = data(await request("/v2/user/info/", context, undefined, { fields: "open_id,display_name" }));
@@ -325,27 +354,28 @@ export function tiktok(options) {
                 const result = data(await request("/v2/video/list/", context, { cursor, max_count: limit }, {
                     fields: "id,create_time,cover_image_url,share_url,title,video_description,duration,height,width,like_count,comment_count,share_count,view_count",
                 }));
+                const nextOffset = result["cursor"];
+                const nextCursor = result["has_more"] === true &&
+                    isFiniteNumber(nextOffset) &&
+                    Number.isSafeInteger(nextOffset) &&
+                    nextOffset >= 0
+                    ? String(nextOffset)
+                    : undefined;
                 return {
                     items: array(result["videos"]).map((row) => publicFields(row, videoFields)),
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(result["has_more"] === true &&
-                        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                        typeof result["cursor"] === "number" &&
-                        Number.isSafeInteger(result["cursor"]) &&
-                        result["cursor"] >= 0
-                        ? { nextCursor: String(result["cursor"]) }
-                        : {}),
+                    ...definedFields({ nextCursor }),
                 };
             },
             prepareTarget: prepare,
             async publishTarget(target, context) {
                 authorize(target.account, context);
-                const config = object(target.options);
+                const config = optionsObject(target);
                 const draft = config["draft"] === true;
                 const latest = draft ? undefined : await creatorInfo(target.account, context);
                 const media = target.content.media ?? [];
                 const first = media[0];
-                if (latest && !array(latest["privacyLevels"]).includes(config["privacy"]))
+                const privacy = config["privacy"];
+                if (latest && (privacy === undefined || !array(latest["privacyLevels"]).includes(privacy)))
                     throw new SocialError({
                         code: "invalid_input",
                         operation: "posts.publish",
@@ -373,12 +403,10 @@ export function tiktok(options) {
                         operation: "posts.publish",
                         message: "Verified media URL required.",
                     });
+                const maxDuration = latest?.["maxVideoDurationSeconds"];
                 if (first.kind === "video" &&
-                    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                    latest &&
-                    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                    typeof latest["maxVideoDurationSeconds"] === "number" &&
-                    (first.durationSeconds ?? Infinity) > latest["maxVideoDurationSeconds"])
+                    isFiniteNumber(maxDuration) &&
+                    (first.durationSeconds ?? Infinity) > maxDuration)
                     throw new SocialError({
                         code: "invalid_input",
                         operation: "posts.publish",
@@ -391,37 +419,32 @@ export function tiktok(options) {
                     brand_content_toggle: config["brandedContent"] === true,
                     brand_organic_toggle: config["ownBrand"] === true,
                 };
-                // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- validated boundary or fixture contract.
                 let result;
                 if (first.kind === "video")
                     result = data(await request(draft ? "/v2/post/publish/inbox/video/init/" : "/v2/post/publish/video/init/", context, {
-                        // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                        ...(draft
-                            ? {}
-                            : {
-                                post_info: {
+                        ...definedFields({
+                            post_info: draft
+                                ? undefined
+                                : {
                                     ...postInfo,
                                     disable_duet: config["disableDuet"] === true,
                                     disable_stitch: config["disableStitch"] === true,
                                     is_aigc: config["aiGenerated"] === true,
                                 },
-                            }),
+                        }),
                         source_info: { source: "PULL_FROM_URL", video_url: first.source.url },
                     }));
                 else
                     result = data(await request("/v2/post/publish/content/init/", context, {
                         post_info: {
                             ...postInfo,
-                            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                            title: typeof config["title"] === "string" ? config["title"] : "",
+                            title: optionalString(config["title"]) ?? "",
                             description: target.content.text ?? "",
                             auto_add_music: false,
                         },
                         source_info: {
                             source: "PULL_FROM_URL",
-                            photo_cover_index: 
-                            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                            typeof config["photoCoverIndex"] === "number" ? config["photoCoverIndex"] : 0,
+                            photo_cover_index: optionalNumber(config["photoCoverIndex"]) ?? 0,
                             photo_images: media.map((item) => item.source.kind === "https-url" ? item.source.url : ""),
                         },
                         post_mode: draft ? "MEDIA_UPLOAD" : "DIRECT_POST",
@@ -478,14 +501,11 @@ export function tiktok(options) {
                 if (state === "PUBLISH_COMPLETE") {
                     const ids = result["publicaly_available_post_id"];
                     const id = Array.isArray(ids) && ids.length === 1 ? ids[0] : undefined;
-                    const nativeId = 
-                    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                    typeof id === "string"
+                    const nativeId = isString(id)
                         ? id
-                        : // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                            typeof id === "number" && Number.isSafeInteger(id)
-                                ? String(id)
-                                : undefined;
+                        : isFiniteNumber(id) && Number.isSafeInteger(id)
+                            ? String(id)
+                            : undefined;
                     if (nativeId)
                         return {
                             ...base,
@@ -520,22 +540,22 @@ export function tiktok(options) {
                 if (!row)
                     return [];
                 const fetchedAt = now();
-                return ["like_count", "comment_count", "share_count", "view_count"].flatMap((field) => 
-                // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                typeof row[field] === "number" && Number.isFinite(row[field])
-                    ? [
-                        {
-                            name: field,
-                            // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
-                            value: row[field],
-                            unit: "count",
-                            period: "lifetime",
-                            fetchedAt,
-                            freshness: "unknown",
-                            source: "tiktok:video.query",
-                        },
-                    ]
-                    : []);
+                return ["like_count", "comment_count", "share_count", "view_count"].flatMap((field) => {
+                    const value = row[field];
+                    return isFiniteNumber(value)
+                        ? [
+                            {
+                                name: field,
+                                value,
+                                unit: "count",
+                                period: "lifetime",
+                                fetchedAt,
+                                freshness: "unknown",
+                                source: "tiktok:video.query",
+                            },
+                        ]
+                        : [];
+                });
             },
             async getAccountMetrics(account, context) {
                 // https://developers.tiktok.com/doc/tiktok-api-v2-user-info/
@@ -551,41 +571,37 @@ export function tiktok(options) {
                         message: "TikTok creator identity mismatch.",
                     });
                 const fetchedAt = now();
-                return ["follower_count", "following_count", "likes_count", "video_count"].flatMap((field) => 
-                // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                typeof user[field] === "number" && Number.isFinite(user[field])
-                    ? [
-                        {
-                            name: field,
-                            // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
-                            value: user[field],
-                            unit: "count",
-                            period: "lifetime",
-                            fetchedAt,
-                            freshness: "unknown",
-                            source: "tiktok:user.info.stats",
-                        },
-                    ]
-                    : []);
+                return ["follower_count", "following_count", "likes_count", "video_count"].flatMap((field) => {
+                    const value = user[field];
+                    return isFiniteNumber(value)
+                        ? [
+                            {
+                                name: field,
+                                value,
+                                unit: "count",
+                                period: "lifetime",
+                                fetchedAt,
+                                freshness: "unknown",
+                                source: "tiktok:user.info.stats",
+                            },
+                        ]
+                        : [];
+                });
             },
         },
         native: {
             creatorInfo,
             async uploadDraft({ account, video, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return data(await request("/v2/post/publish/inbox/video/init/", context, video));
             },
             async listVideos({ account, cursor, maxCount, context }) {
                 authorize(account, context);
                 const parsedCursor = cursor === undefined ? 0 : Number(cursor);
-                const result = data(await request("/v2/video/list/", context, { cursor: parsedCursor, max_count: maxCount ?? 20 }, { fields: videoFields.join(",") }));
-                // SAFETY: data() validates the provider response as a JSON object.
-                return result;
+                return data(await request("/v2/video/list/", context, { cursor: parsedCursor, max_count: maxCount ?? 20 }, { fields: videoFields.join(",") }));
             },
             async publishStatus({ account, publishId, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return data(await request("/v2/post/publish/status/fetch/", context, { publish_id: publishId }));
             },
         },

package/dist/platforms/webhook-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { WebhooksAdapter } from "../core/adapter.js";
+import type { CapabilityDeclaration } from "../core/types.js";
+import { type DirectWebhookPlatform, type VerifiedWebhook } from "../server/webhooks.js";
+/** Shared adapter wiring for direct-platform webhook verification and decoding. */
+export declare function directWebhooks(platform: DirectWebhookPlatform, verify: (input: {
+    readonly headers: Headers;
+    readonly body: Uint8Array;
+}) => Promise<VerifiedWebhook>, now: () => string): WebhooksAdapter;
+export declare function webhookCapability(platform: DirectWebhookPlatform, notes: string): CapabilityDeclaration;

package/dist/platforms/webhook-adapter.js

@@ -0,0 +1,24 @@
+import { decodePlatformWebhook, } from "../server/webhooks.js";
+/** Shared adapter wiring for direct-platform webhook verification and decoding. */
+export function directWebhooks(platform, verify, now) {
+    return {
+        async verify(input) {
+            // Throws `unauthorized` on any failure, matching the managed adapters.
+            await verify(input);
+            return { valid: true, method: "hmac" };
+        },
+        async decode(input, context) {
+            return {
+                ...(await decodePlatformWebhook({
+                    platform,
+                    backend: context.backendInstance,
+                    body: input.body,
+                    receivedAt: now(),
+                })),
+            };
+        },
+    };
+}
+export function webhookCapability(platform, notes) {
+    return { platform, operation: "webhooks.verify", availability: "available", notes };
+}

package/dist/platforms/x-engagement.js

@@ -1,5 +1,7 @@
 import { SocialError } from "../core/errors.js";
 import { managedHttp } from "../cloud/common.js";
+import { definedFields } from "../core/fields.js";
+import { isBoolean, isJsonObject } from "../transport/validation.js";
 async function mutate(action, tweetId, account, options, context) {
     if (account.kind !== "connected-account" ||
         account.version !== 1 ||
@@ -19,26 +21,19 @@ async function mutate(action, tweetId, account, options, context) {
         });
     const request = managedHttp("https://api.x.com", {
         apiKey: options.accessToken,
-        // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-        ...(options.fetch ? { fetch: options.fetch } : {}),
+        ...definedFields({ fetch: options.fetch }),
     });
     const result = await request(`/2/users/${encodeURIComponent(options.userId)}/likes${action === "unlike" ? `/${tweetId}` : ""}`, context, action === "like" ? { tweet_id: tweetId } : undefined, {}, action === "like" ? "POST" : "DELETE");
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-    const data = result && typeof result === "object" && "data" in result ? result.data : undefined;
-    if (!data ||
-        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-        typeof data !== "object" ||
-        !("liked" in data) ||
-        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-        typeof data.liked !== "boolean" ||
-        data.liked !== (action === "like"))
+    const data = isJsonObject(result) ? result["data"] : undefined;
+    const liked = isJsonObject(data) ? data["liked"] : undefined;
+    if (!isBoolean(liked) || liked !== (action === "like"))
         throw new SocialError({
             code: "ambiguous_outcome",
             operation: `x.${action}`,
             message: "X did not confirm the requested reaction state. Reconcile before retrying.",
             retryDisposition: { kind: "reconcile-first" },
         });
-    return { liked: data.liked, tweetId, userId: options.userId };
+    return { liked, tweetId, userId: options.userId };
 }
 /** Requires like.write, tweet.read, users.read and the app's current API access. Never retries writes. */
 export function xLike(tweetId, account, options, context) {

package/dist/platforms/x-stream.d.ts

@@ -0,0 +1,83 @@
+import type { AdapterOperationContext, JsonObject, JsonValue } from "../core/types.js";
+import type { XMediaField, XTweetExpansion, XTweetField, XUserField } from "./x.js";
+/** X sends a `\r\n` keep-alive at least every 20 seconds and recommends a 20-second read timeout. */
+export declare const xStreamDefaultStallTimeoutMs = 20000;
+/** A filtered-stream rule as stored by X. */
+export interface XStreamRule {
+    readonly id: string;
+    readonly value: string;
+    readonly tag?: string;
+}
+/** A rule to add. X limits values to 1,024 characters on pay-per-use and 2,048 on Enterprise. */
+export interface XStreamRuleInput {
+    readonly value: string;
+    readonly tag?: string;
+}
+/** Result of one rule mutation. `errors` holds per-rule rejections that X returned with HTTP 200. */
+export interface XStreamRulesUpdate {
+    readonly dryRun: boolean;
+    readonly rules: readonly XStreamRule[];
+    readonly summary?: JsonObject;
+    readonly errors: readonly JsonObject[];
+}
+export interface XMatchingRule {
+    readonly id: string;
+    readonly tag?: string;
+}
+/**
+ * One message from the filtered stream. `post` carries a matched Post. `error` carries an
+ * error-only message such as `operational-disconnect`; X usually closes the connection after it.
+ * `other` preserves message types this adapter does not recognize yet.
+ */
+export type XStreamEvent = {
+    readonly kind: "post";
+    readonly post: JsonObject;
+    readonly matchingRules: readonly XMatchingRule[];
+    readonly includes?: JsonObject;
+    readonly errors?: readonly JsonObject[];
+} | {
+    readonly kind: "error";
+    readonly errors: readonly JsonObject[];
+} | {
+    readonly kind: "other";
+    readonly message: JsonObject;
+};
+export interface XStreamOptions {
+    readonly tweetFields?: readonly XTweetField[];
+    readonly expansions?: readonly XTweetExpansion[];
+    readonly userFields?: readonly XUserField[];
+    readonly mediaFields?: readonly XMediaField[];
+    /**
+     * Minutes (1-5) of Posts to replay after a short disconnection. Enterprise access only.
+     * `0` or omitted means no backfill; the SDK then leaves `backfill_minutes` off the request.
+     */
+    readonly backfillMinutes?: number;
+    /** Recovery window start (ISO 8601, within the last 24 hours). Enterprise access only. */
+    readonly startTime?: string;
+    /** Recovery window end (ISO 8601). X closes the connection after the window is replayed. */
+    readonly endTime?: string;
+    /** Fail with `timeout` when neither data nor a keep-alive arrives within this window. */
+    readonly stallTimeoutMs?: number;
+}
+interface StreamConfig {
+    readonly bearerToken: string;
+    readonly fetch?: typeof globalThis.fetch | undefined;
+}
+/** Parse one rule object from X, rejecting malformed identifiers. */
+export declare function parseStreamRule(value: JsonValue | undefined, operation: string): XStreamRule;
+/** Parse the rule-mutation response while keeping per-rule errors. */
+export declare function parseRulesUpdate(value: JsonValue, dryRun: boolean): XStreamRulesUpdate;
+/** Validate one rule for local bounds. X enforces the tier-specific limit. */
+export declare function validateRuleInput(rule: XStreamRuleInput): void;
+export declare function validateRuleIds(ids: readonly string[], operation: string, max: number): void;
+/** Classify one newline-delimited message. */
+export declare function parseStreamMessage(line: string): XStreamEvent;
+/** Validate caller options and build the connection URL. Performs no I/O. */
+export declare function streamUrl(options: XStreamOptions): URL;
+/**
+ * Open one filtered-stream connection and yield its messages. The connection is made when
+ * iteration starts and closes when the caller stops iterating, the context signal aborts, the
+ * stall timeout elapses, or X ends the response. This function never reconnects.
+ */
+export declare function readFilteredStream(config: StreamConfig, options: XStreamOptions, context: AdapterOperationContext): AsyncGenerator<XStreamEvent, void, undefined>;
+export {};