@postrun/react 2.13.0 → 2.14.0

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import * as react from 'react';
 import { ReactNode, CSSProperties } from 'react';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient, QueryKey } from '@tanstack/react-query';
-import { PostrunClient, ListProfilesQuery, DiscoverableAccountList, Connection, ConnectionKind, ConnectionStatus, ListMediaQuery, ListPostsQuery, ConnectablePlatform, MediaResource, MediaTarget, Metadata, ComposePostInput, PostValidation, MediaKind, InstagramPostVariant, PostVariant, LinkedInPostVariant, TikTokPostVariant, XPostVariant, XPoll as XPoll$1, TikTokCreatorInfo, TikTokOptionsValue } from '@postrun/js';
+import { PostrunClient, ListProfilesQuery, DiscoverableAccountList, Connection, ConnectionKind, ConnectionStatus, ListMediaQuery, ListPostsQuery, ConnectablePlatform, MediaResource, MediaTarget, Metadata, ComposePostInput, PostValidation, MediaKind, InstagramPostVariant, PostVariant, LinkedInPostVariant, TikTokPostVariant, XPostVariant, PostVariantInput, XPoll as XPoll$1, TikTokCreatorInfo, TikTokOptionsValue } from '@postrun/js';
 export { PostValidation, PostVariant, PostVariantError, TIKTOK_CAPTION_MAX, TikTokCreatorInfo, UploadError, ValidationIssue, captionMaxFor } from '@postrun/js';
 import { TwitterComponents } from 'react-tweet';
 
@@ -5307,8 +5307,9 @@ declare function useTikTokCreatorInfo(connectionId: string | null): _tanstack_re
  * A platform's FETCHED (read) variant — one member of a stored `Post`'s
  * `variants`, as returned by `usePost`/`usePosts`/the calendar. Since the API's
  * read variant is now a typed discriminated union, it carries the SAME typed
- * `settings`/`body`/`post_type`/`media` the write variant does, plus the
- * read-only `id`/`status`/`result`/`error`.
+ * `settings`/`body`/`post_type` the write variant does, plus the read-only
+ * `id`/`status`/`result`/`error` AND the enriched `media[].media` (the full
+ * `MediaResource` inline) — so a fetched post previews with no extra fetch.
  */
 type ReadPostVariant<P extends PostVariant['platform']> = Extract<PostVariant, {
     platform: P;
@@ -5316,147 +5317,152 @@ type ReadPostVariant<P extends PostVariant['platform']> = Extract<PostVariant, {
 /**
  * What a preview's `variant` prop accepts: EITHER the compose-time **write**
  * variant (`XPostVariant`, …) OR the fetched **read** variant. Both expose the
- * typed `settings`, `body`, `post_type`, and `media[].alt_text_override` the cards
- * read — so you can hand a preview a post you just built OR one you fetched from
- * the API, with no transform.
+ * typed `settings`, `body`, `post_type`, and ordered `media` refs the cards read
+ * — so you can hand a preview a post you just built OR one you fetched, with no
+ * transform. A read variant additionally carries each media's full asset inline;
+ * a write/draft variant references media by id (resolve it via the `media` prop).
  */
 type XPreviewVariant = XPostVariant | ReadPostVariant<'x'>;
 type LinkedInPreviewVariant = LinkedInPostVariant | ReadPostVariant<'linkedin'>;
 type TikTokPreviewVariant = TikTokPostVariant | ReadPostVariant<'tiktok'>;
 type InstagramPreviewVariant = InstagramPostVariant | ReadPostVariant<'instagram'>;
 /**
- * Public input types for the post-preview components.
+ * The author a preview header renders. It is DERIVED from the SDK `Connection`
+ * (the system of record for who's posting) — the card reads `avatar_url`,
+ * `username`, and `external_account_name` straight off it, so the header can't
+ * drift from the connection. Pass the whole connection; the card picks what it
+ * needs.
  *
- * Identity that our API DOES store on a `Connection` (`username`, `avatar_url`,
- * `profile_url`) is DERIVED from the SDK `Connection` type — never re-declared —
- * so a preview author can be built straight from a connection and can't drift.
- * Fields the API does NOT store (a verified badge, a display name distinct from
- * the handle, a LinkedIn headline) are presentation extras the customer supplies;
- * those are the documented backend gaps. Media `kind` derives from `MediaKind`;
- * pixels are still a `url`/`File` because a variant references media by id.
+ * The two things our API does NOT store on a connection are presentation extras
+ * a customer may supply via the preview's own props: a `verified` badge and a
+ * LinkedIn `headline`. Everything else comes from the connection.
  */
-/** The identity fields our `Connection` stores — the SDK-driven base every
- * preview author derives from (so the field names + nullability match the API). */
-type ConnectionIdentity = Pick<Connection, 'username' | 'avatar_url'>;
-/**
- * The author identity rendered in an X preview header. `username` (the `@handle`)
- * and `avatar_url` are DERIVED from the SDK `Connection`; `name` (the display
- * name) and `verified` are presentation extras our API doesn't store.
- */
-type XPreviewAuthor = ConnectionIdentity & {
-    /** Display name, e.g. "Acme Studio". NOT on Connection — caller-supplied. */
-    name: string;
-    /** Show the verified badge. NOT on Connection — caller-supplied. */
-    verified?: boolean;
-};
-/**
- * The author identity rendered in a LinkedIn preview header. LinkedIn shows a
- * display `name` + a one-line `headline`. `username`/`avatar_url` are DERIVED
- * from the SDK `Connection`; `name`/`headline`/`verified` are presentation extras
- * our API doesn't store (LinkedIn's `username` is also documented as NULL today).
- */
-type LinkedInPreviewAuthor = ConnectionIdentity & {
-    /** Display name, e.g. "Acme Studio". NOT on Connection — caller-supplied. */
-    name: string;
-    /** One-line headline under the name. NOT on Connection — caller-supplied. */
-    headline?: string;
-    /** Show the verified badge. NOT on Connection — caller-supplied. */
-    verified?: boolean;
-};
-/**
- * The author identity rendered in an Instagram preview header. Instagram shows
- * the `username` (no separate display name) + an optional verified badge.
- *
- * `username` / `avatar_url` are DERIVED from the SDK `Connection` (`string | null`,
- * so build it straight from `useConnections()`). `verified` is a presentation
- * extra — our API does NOT store verified status on a connection (a backend gap),
- * so the customer supplies it (or omit it).
- */
-type InstagramPreviewAuthor = ConnectionIdentity & {
-    /** Verified badge. NOT sourced from our Connection — presentation-only. */
-    verified?: boolean;
-};
+type PreviewConnection = Pick<Connection, 'platform' | 'username' | 'avatar_url' | 'external_account_name'>;
 /** The media kinds a social preview can render (documents are not previewable
  * here) — derived from the SDK's `MediaKind`, never re-listed. */
 type PreviewMediaKind = Extract<MediaKind, 'image' | 'video' | 'gif'>;
 /**
- * One media item to preview. Provide a `url` (e.g. the processed
- * `MediaResource.per_platform.<platform>.url`) OR a `file` (a compose-time blob,
- * before upload) — the component turns a `file` into an object URL and revokes it
- * on unmount. An item with neither is skipped.
+ * One media item resolved for rendering — the shared shape every platform card's
+ * renderer consumes. Produced by `resolveVariantMedia` straight from the SDK
+ * `MediaResource`; pixels come from the per-platform rendition `url`, never a
+ * local `File`.
+ *
+ * `state` is honest: a `ready` item has its `src` (the rendition URL); a
+ * `processing` item has NO `src` (the asset or its rendition isn't ready) and the
+ * card shows the shared "Processing media…" placeholder in its place.
  */
-interface PreviewMedia {
+type ResolvedMedia = {
     kind: PreviewMediaKind;
-    url?: string;
-    file?: File;
-    /** Natural pixel width — improves layout fidelity when known. */
+    state: 'ready';
+    src: string;
     width?: number;
-    /** Natural pixel height — improves layout fidelity when known. */
     height?: number;
-    /** Alt text; falls back to the variant media's `alt_text_override`. */
     alt?: string;
-    /** Poster frame for a video; falls back to `url`/`file`. */
-    posterUrl?: string;
-}
-/** @deprecated Use {@link PreviewMedia}. Kept as an alias for back-compat. */
-type XPreviewMedia = PreviewMedia;
-/** A media item with its pixels already resolved to a single URL by the
- * component (shared by every platform preview's renderer). */
-interface ResolvedMedia {
+} | {
     kind: PreviewMediaKind;
-    src: string;
+    state: 'processing';
+    src?: undefined;
     width?: number;
     height?: number;
     alt?: string;
-    posterSrc?: string;
-}
+};
+/** A resolved item that has pixels — the `ready` member of {@link ResolvedMedia}
+ * (so `src` is guaranteed). Renderers that draw actual media take this; the
+ * card decides up front whether to render pixels or the processing placeholder. */
+type ReadyMedia = Extract<ResolvedMedia, {
+    state: 'ready';
+}>;
+/** Narrow a resolved item to its ready (has-pixels) form. */
+declare function isReadyMedia(item: ResolvedMedia): item is ReadyMedia;
 /**
  * Content for the nested quoted card. Supplied separately because our schema
- * carries only an opaque `quote_tweet_id` (no quoted text/author).
+ * carries only an opaque `quote_tweet_id` (no quoted text/author/media).
  */
 interface XPreviewQuotedTweet {
-    author: XPreviewAuthor;
+    /** The quoted account's display name. */
+    name: string;
+    /** The quoted account's @handle. */
+    username?: string | null;
+    /** The quoted account's avatar URL. */
+    avatar_url?: string | null;
     body?: string;
-    media?: PreviewMedia[];
+    media?: ResolvedMedia[];
 }
 
-declare function toPreviewMedia(items: readonly MediaUploadItem[]): PreviewMedia[];
+/**
+ * The single media resolver every platform preview shares. It turns a variant's
+ * ordered media references into the `ResolvedMedia[]` a card renders — pulling
+ * pixels from the SDK `MediaResource` ONLY (the per-platform rendition `url`),
+ * never a local `File`/object URL.
+ *
+ * A variant references media by id (`media[].media_id`). Two ways the full asset
+ * arrives, and we read whichever is present:
+ *  - **Read / enriched variant:** `media[].media` carries the full `MediaResource`
+ *    inline (the GET /v1/posts shape) — used directly.
+ *  - **Compose / draft variant:** the write variant has only ids, so the host
+ *    passes the uploaded assets as `fallback` (e.g. `useMediaUpload().ready`),
+ *    matched by `media_id`.
+ *
+ * Media STATE is honest, straight off the resource: an asset still uploading /
+ * processing (or whose this-platform rendition isn't ready) resolves with
+ * `state: 'processing'` and no `src` — the card shows the shared "Processing
+ * media…" placeholder; a ready rendition resolves with `state: 'ready'` + its
+ * pixel URL. Documents aren't previewable and are dropped.
+ */
+/** One variant's media reference — the WRITE (compose, id-only) OR the READ
+ * (enriched, carries the full asset inline) shape. Both are derived from the SDK
+ * variant unions, never re-declared. The write member is `media_id`-only; the
+ * read member adds `media`/`position`. */
+type VariantMediaRef = NonNullable<PostVariantInput['media']>[number] | NonNullable<PostVariant['media']>[number];
+/**
+ * Resolve a variant's media to renderable items for ONE platform target.
+ *
+ * @param refs     the variant's `media` array (write or read shape)
+ * @param target   the media render target for this platform (`x`, `linkedin`,
+ *                 `instagram`, `tiktok`, `facebook_page`)
+ * @param fallback uploaded assets to resolve compose-time ids against (the read
+ *                 variant carries its own enriched assets, so this is optional)
+ */
+declare function resolveVariantMedia(refs: readonly VariantMediaRef[] | undefined, target: MediaTarget, fallback?: readonly MediaResource[]): ResolvedMedia[];
 
 interface XPostPreviewProps {
     /** The X variant — either a compose-time write variant or a fetched read
-     * variant (both carry the typed settings/body the card renders). */
+     * variant. A read variant carries its media assets inline; for a compose
+     * variant, pass the uploaded assets via `media`. */
     variant: XPreviewVariant;
-    /** Author identity (not stored on our connection — supplied by you). */
-    author: XPreviewAuthor;
-    /** Resolved media pixels (URLs or compose-time File blobs). */
-    media?: PreviewMedia[];
+    /** The posting account — the SDK `Connection`. The header derives the name,
+     * @handle, and avatar from it. */
+    connection: PreviewConnection;
+    /** Uploaded assets to resolve a compose variant's media ids against (e.g.
+     * `useMediaUpload().ready`). A read variant carries its own assets inline, so
+     * this is only needed for a compose-time draft. */
+    media?: readonly MediaResource[];
+    /** Show the X verified badge — our API doesn't store it, so you supply it. */
+    verified?: boolean;
     /** Content for the quoted card when `settings.quote_tweet_id` is set. */
     quotedTweet?: XPreviewQuotedTweet;
     /** The replied-to account's handle (our schema only stores the parent id). */
     replyToHandle?: string;
-    /** Color scheme. `auto` (default) follows the OS color scheme (light/dark) —
-     * the same resolution every Postrun preview card uses. */
+    /** Color scheme. `auto` (default) follows the OS color scheme. */
     theme?: 'light' | 'dark' | 'auto';
     /** Show the static action row (icons, no counts). Default true. */
     showActions?: boolean;
     /** Class applied to the wrapper — your hook for sizing, shadows, etc. */
     className?: string;
-    /** Inline styles on the wrapper — e.g. react-tweet CSS variables
-     * (`{ ['--tweet-container-margin']: '0' }`). */
+    /** Inline styles on the wrapper — e.g. react-tweet CSS variables. */
     style?: CSSProperties;
     /** Override react-tweet's internal pieces (e.g. `next/image` avatars). */
     components?: TwitterComponents;
 }
 /**
  * A faithful, pixel-accurate preview of how an X post will look once published,
- * rendered straight from a Postrun X variant. Built on `react-tweet` (the same
- * card X itself ships), so you write zero card UI — pass the schema, render the
- * preview. Fully customizable: restyle via `className`/`style` (CSS variables)
- * or swap internals via `components`; theme light/dark/auto.
+ * rendered straight from a Postrun X variant + the posting `Connection`. Built on
+ * `react-tweet` (the same card X ships): pass the schema, render the preview.
+ * Media pixels come from the resolved per-platform renditions — a still-processing
+ * asset shows the shared "Processing media…" tile instead of a fake image.
  */
-declare function XPostPreviewImpl({ variant, author, media, quotedTweet, replyToHandle, theme, showActions, className, style, components: componentsProp, }: XPostPreviewProps): react.JSX.Element;
-/** Memoized: re-renders only when its props change (the resolved-media hook
- * already absorbs unstable media arrays). */
+declare function XPostPreviewImpl({ variant, connection, media, verified, quotedTweet, replyToHandle, theme, showActions, className, style, components: componentsProp, }: XPostPreviewProps): react.JSX.Element;
+/** Memoized: re-renders only when its props change. */
 declare const XPostPreview: react.MemoExoticComponent<typeof XPostPreviewImpl>;
 
 /**
@@ -5484,26 +5490,31 @@ type LinkedInTheme = 'light' | 'dark' | 'auto';
 
 /**
  * A faithful, schema-driven preview of how a LinkedIn post will look in-feed,
- * rendered straight from a Postrun LinkedIn variant. Clean-room components (no
- * dependency to "buy" exists for LinkedIn), mirroring the real feed card: header
- * with headline + audience icon, an entity-highlighted body with the "…more"
- * fold, the 1/2/3/4/+N image mosaic (or a video), and a static action bar.
+ * rendered straight from a Postrun LinkedIn variant + the posting `Connection`.
+ * Clean-room components mirroring the real feed card: header with headline +
+ * audience icon, an entity-highlighted body with the "…more" fold, the
+ * 1/2/3/4/+N image mosaic (or a video), and a static action bar.
  *
  * Renders every `content_kind`: text, single/multi image, video, plus the rich
  * units — article share card, poll, and document — each driven from
- * `settings.{article,poll,document}` (see `renderContent`).
- *
- * Customize via `theme` (light/dark/auto), `className`/`style`, or by overriding
- * the `--pr-li-*` CSS variables the card reads.
+ * `settings.{article,poll,document}`. Media pixels come from the resolved
+ * per-platform renditions; a still-processing asset shows the shared
+ * "Processing media…" tile.
  */
 interface LinkedInPostPreviewProps {
-    /** The LinkedIn variant — either a compose-time write variant or a fetched read
-     * variant (both carry the typed settings/body the card renders). */
+    /** The LinkedIn variant — compose-time write OR fetched read (carries assets
+     * inline). */
     variant: LinkedInPreviewVariant;
-    /** Author identity (LinkedIn stores no avatar/headline on our connection). */
-    author: LinkedInPreviewAuthor;
-    /** Resolved media pixels (URLs or compose-time File blobs). */
-    media?: PreviewMedia[];
+    /** The posting account — the SDK `Connection`. Name/avatar derive from it. */
+    connection: PreviewConnection;
+    /** Uploaded assets to resolve a compose variant's media ids against (e.g.
+     * `useMediaUpload().ready`); a read variant carries its own inline. */
+    media?: readonly MediaResource[];
+    /** One-line headline under the name — our API doesn't store it, so you supply
+     * it. */
+    headline?: string;
+    /** Show the verified badge — our API doesn't store it, so you supply it. */
+    verified?: boolean;
     /** Color scheme. `auto` (default) follows the OS preference. */
     theme?: LinkedInTheme;
     /** Relative time label shown in the header. Default "Now". */
@@ -5515,9 +5526,8 @@ interface LinkedInPostPreviewProps {
     /** Inline styles on the card — including `--pr-li-*` variable overrides. */
     style?: CSSProperties;
 }
-declare function LinkedInPostPreviewImpl({ variant, author, media, theme, time, showActions, className, style, }: LinkedInPostPreviewProps): react.JSX.Element;
-/** Memoized: re-renders only when its props change (the resolved-media hook
- * absorbs unstable media arrays). */
+declare function LinkedInPostPreviewImpl({ variant, connection, media, headline, verified, theme, time, showActions, className, style, }: LinkedInPostPreviewProps): react.JSX.Element;
+/** Memoized: re-renders only when its props change. */
 declare const LinkedInPostPreview: react.MemoExoticComponent<typeof LinkedInPostPreviewImpl>;
 
 /**
@@ -5532,7 +5542,7 @@ type LinkedInArticle = NonNullable<NonNullable<LinkedInPostVariant['settings']>[
 interface ArticleCardProps {
     article: LinkedInArticle;
     /** Resolved thumbnail pixels (from `article.thumbnail_media_id`), if any. */
-    thumbnail?: ResolvedMedia;
+    thumbnail?: ReadyMedia;
 }
 declare function ArticleCard({ article, thumbnail }: ArticleCardProps): react.JSX.Element;
 
@@ -5561,7 +5571,7 @@ type LinkedInDocument = NonNullable<NonNullable<LinkedInPostVariant['settings']>
 interface DocumentCardProps {
     document: LinkedInDocument;
     /** Resolved first-page pixels (from the document asset on media[]), if any. */
-    cover?: ResolvedMedia;
+    cover?: ReadyMedia;
 }
 declare function DocumentCard({ document, cover }: DocumentCardProps): react.JSX.Element;
 
@@ -5579,36 +5589,45 @@ type InstagramTheme = 'light' | 'dark' | 'auto';
 
 /**
  * A faithful, schema-driven preview of how an Instagram post will look, rendered
- * straight from a Postrun Instagram variant. Covers everything the API supports:
- * a **feed** post (single image / carousel) and a **reel** (9:16 video). Identity
- * is SDK-driven (`author` derives from `Connection`); creator details (username,
- * avatar, verified, collaborators) and the audio label come from the variant +
- * author. Feed themes light/dark/`auto`; the reel is always dark.
- *
- * Clean-room (there's no package to "buy" — Instagram's embed only renders
- * already-published posts), referencing the real IG feed + Postiz.
+ * straight from a Postrun Instagram variant + the posting `Connection`. Covers a
+ * **feed** post (single image / carousel) and a **reel** (9:16 video). Identity
+ * (`username`/`avatar_url`) derives from the connection; `verified` is a caller
+ * extra. Media pixels come from the resolved per-platform renditions; a
+ * still-processing asset shows the shared "Processing media…" tile. Feed themes
+ * light/dark/`auto`; the reel is always dark.
  */
 interface InstagramPostPreviewProps {
-    /** The Instagram variant — either a compose-time write variant or a fetched
-     * read variant (both carry the typed settings/body the card renders). */
+    /** The Instagram variant — compose-time write OR fetched read (carries assets
+     * inline). */
     variant: InstagramPreviewVariant;
-    /** Author identity (SDK-driven; `verified` is a presentation extra). */
-    author: InstagramPreviewAuthor;
-    /** Resolved media pixels (processed URLs or compose-time File blobs). */
-    media?: PreviewMedia[];
+    /** The posting account — the SDK `Connection`. Username/avatar derive from it. */
+    connection: PreviewConnection;
+    /** Uploaded assets to resolve a compose variant's media ids against (e.g.
+     * `useMediaUpload().ready`); a read variant carries its own inline. */
+    media?: readonly MediaResource[];
+    /** Show the verified seal — our API doesn't store it, so you supply it. */
+    verified?: boolean;
     /** Color scheme for the feed card. `auto` (default) follows the OS. */
     theme?: InstagramTheme;
     className?: string;
     style?: CSSProperties;
 }
-declare function InstagramPostPreviewImpl({ variant, author, media, theme, className, style, }: InstagramPostPreviewProps): react.JSX.Element;
-/** Memoized: the resolved-media hook absorbs unstable media arrays. */
+declare function InstagramPostPreviewImpl({ variant, connection, media, verified, theme, className, style, }: InstagramPostPreviewProps): react.JSX.Element;
+/** Memoized. */
 declare const InstagramPostPreview: react.MemoExoticComponent<typeof InstagramPostPreviewImpl>;
 
+/** The Instagram header's identity view-model — `username`/`avatar_url` derive
+ * from the connection; `verified` is caller-supplied (not stored on ours). */
+interface InstagramAuthor {
+    username?: string | null;
+    avatar_url?: string | null;
+    verified?: boolean;
+}
+
 interface ReelPreviewProps {
-    author: InstagramPreviewAuthor;
+    author: InstagramAuthor;
     body: string;
-    media: readonly ResolvedMedia[];
+    media: readonly ReadyMedia[];
     /** Media is referenced but its pixels aren't resolved yet (still processing). */
     pending?: boolean;
     /** The reel's audio label (`settings.audio_name`); defaults to "Original audio". */
@@ -5638,10 +5657,12 @@ interface TikTokPostPreviewProps {
     /** The TikTok variant — either a compose-time write variant or a fetched read
      * variant (both carry the typed settings/body the card renders). */
     variant: TikTokPreviewVariant;
-    /** Live creator info (nickname/avatar, audience options, interaction flags). */
+    /** Live creator info (nickname/avatar, audience options, interaction flags) —
+     * TikTok's Required-UX makes this the authoritative creator identity. */
     creatorInfo: TikTokCreatorInfo;
-    /** Resolved media pixels (processed URLs or compose-time File blobs). */
-    media?: PreviewMedia[];
+    /** Uploaded assets to resolve a compose variant's media ids against (e.g.
+     * `useMediaUpload().ready`); a read variant carries its own inline. */
+    media?: readonly MediaResource[];
     /** Class applied to the phone frame — your hook for sizing. */
     className?: string;
     /** Inline styles on the frame. */
@@ -5759,4 +5780,4 @@ declare function Declaration({ brandedContent }: {
     brandedContent: boolean;
 }): react.JSX.Element;
 
-export { ArticleCard, type ArticleCardProps, AudienceSelect, type CalendarFilters, CommercialDisclosure, Connect, type ConnectErrorReason, type ConnectOutcome, type ConnectProps, type ConnectRenderApi, type ConnectState, type ConnectionIdentity, type ConnectionsFilter, Declaration, type DiscoverableAccount, DocumentCard, type DocumentCardProps, type InfiniteList, InstagramPostPreview, type InstagramPostPreviewProps, type InstagramPreviewAuthor, type InstagramPreviewVariant, type InstagramTheme, InteractionToggles, LinkedInPostPreview, type LinkedInPostPreviewProps, type LinkedInPreviewAuthor, type LinkedInPreviewVariant, type LiveOptions, type MediaUploadItem, type MediaUploadOptions, type MediaUploadStatus, Poll, type PollProps, type PostrunContextValue, PostrunProvider, type PostrunProviderProps, type PreviewMedia, type PreviewMediaKind, type ReadPostVariant, ReelPreview, type ReelPreviewProps, type ResolvedMedia, TikTokCaptionField, type TikTokCaptionFieldProps, TikTokPostPreview, type TikTokPostPreviewProps, type TikTokPreviewVariant, TikTokPublishPanel, type TikTokPublishPanelProps, type TikTokTheme, type UseConnectParams, type UseConnectResult, type UseMediaUploadOptions, type UseMediaUploadResult, XPoll, type XPollProps, XPostPreview, type XPostPreviewProps, type XPreviewAuthor, type XPreviewMedia, type XPreviewQuotedTweet, type XPreviewVariant, connectionKeys, mediaKeys, postKeys, profileKeys, tiktokKeys, toPreviewMedia, useCalendar, useConnect, useConnection, useConnections, useCreatePost, useCreateProfile, useDeleteMedia, useDeletePost, useDeleteProfile, useDisconnect, useDiscoverableAccounts, useInfiniteList, useMedia, useMediaInfinite, useMediaList, useMediaUpload, usePost, usePostrun, usePosts, usePostsInfinite, useProfile, useProfiles, useProfilesInfinite, useSelectAccount, useTikTokCreatorInfo, useUpdateMedia, useUpdatePost, useUpdateProfile, useValidatePost };
+export { ArticleCard, type ArticleCardProps, AudienceSelect, type CalendarFilters, CommercialDisclosure, Connect, type ConnectErrorReason, type ConnectOutcome, type ConnectProps, type ConnectRenderApi, type ConnectState, type ConnectionsFilter, Declaration, type DiscoverableAccount, DocumentCard, type DocumentCardProps, type InfiniteList, InstagramPostPreview, type InstagramPostPreviewProps, type InstagramPreviewVariant, type InstagramTheme, InteractionToggles, LinkedInPostPreview, type LinkedInPostPreviewProps, type LinkedInPreviewVariant, type LiveOptions, type MediaUploadItem, type MediaUploadOptions, type MediaUploadStatus, Poll, type PollProps, type PostrunContextValue, PostrunProvider, type PostrunProviderProps, type PreviewConnection, type PreviewMediaKind, type ReadPostVariant, type ReadyMedia, ReelPreview, type ReelPreviewProps, type ResolvedMedia, TikTokCaptionField, type TikTokCaptionFieldProps, TikTokPostPreview, type TikTokPostPreviewProps, type TikTokPreviewVariant, TikTokPublishPanel, type TikTokPublishPanelProps, type TikTokTheme, type UseConnectParams, type UseConnectResult, type UseMediaUploadOptions, type UseMediaUploadResult, XPoll, type XPollProps, XPostPreview, type XPostPreviewProps, type XPreviewQuotedTweet, type XPreviewVariant, connectionKeys, isReadyMedia, mediaKeys, postKeys, profileKeys, resolveVariantMedia, tiktokKeys, useCalendar, useConnect, useConnection, useConnections, useCreatePost, useCreateProfile, useDeleteMedia, useDeletePost, useDeleteProfile, useDisconnect, useDiscoverableAccounts, useInfiniteList, useMedia, useMediaInfinite, useMediaList, useMediaUpload, usePost, usePostrun, usePosts, usePostsInfinite, useProfile, useProfiles, useProfilesInfinite, useSelectAccount, useTikTokCreatorInfo, useUpdateMedia, useUpdatePost, useUpdateProfile, useValidatePost };