import { Attachment } from 'stream-chat';
import { Channel } from 'stream-chat';
import { ChannelFilters } from 'stream-chat';
import { ChannelMemberResponse } from 'stream-chat';
import { ChannelPreviewUIComponentProps } from 'stream-chat-react';
import { ChannelSort } from 'stream-chat';
import { ComponentType } from 'react';
import { default as default_2 } from 'react';
import { Dispatch } from 'react';
import { EmptyStateIndicatorProps } from 'stream-chat-react';
import { Event as Event_2 } from 'stream-chat';
import { FC } from 'react';
import { InfiniteScrollProps } from 'stream-chat-react';
import { JSX as JSX_2 } from 'react/jsx-runtime';
import { LocalMessage } from 'stream-chat';
import { Logger } from '@linktr.ee/messaging-core';
import { MessageCustomType } from '@linktr.ee/messaging-taxonomy';
import { MessagingUser } from '@linktr.ee/messaging-core';
import { OfficialCtaActionKind } from '@linktr.ee/messaging-taxonomy';
import { OfficialCtaActionPayload } from '@linktr.ee/messaging-taxonomy';
import { Provider } from 'react';
import { RichCardImagePresentation } from '@linktr.ee/messaging-taxonomy';
import { SendMessageAPIResponse } from 'stream-chat';
import { SetStateAction } from 'react';
import { StreamChat } from 'stream-chat';
import { StreamChatService } from '@linktr.ee/messaging-core';
import { StreamChatServiceConfig } from '@linktr.ee/messaging-core';

export declare const ActionButton: ({ variant, className, children, ...rest }: ActionButtonProps) => JSX_2.Element;

export declare interface ActionButtonProps extends default_2.ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: 'default' | 'danger';
}

export declare type AttachmentSourceType = 'image' | 'audio' | 'video' | 'document';

declare interface AudioAttachmentSharedProps extends MessageAttachmentBaseProps {
    /** Audio source URL (`mp3`, `aac`, `wav`, …). */
    src?: string;
    /** MIME type hint — typed onto the inline `<source>` element. */
    mimeType?: string;
    /**
     * Filename — used as the download default name (consumed by the
     * native player's kebab menu). The HTML `<audio>` element doesn't
     * expose a built-in title slot, so we don't render the filename
     * inside the bubble itself.
     */
    filename?: string;
    /**
     * Stacked audio. Takes precedence over `src` when set. Each item
     * renders its own native `<audio controls>` player, vertically
     * stacked inside the same bubble with an 8px gap between players.
     * Sent + Received only — the composer surface accepts a single
     * attachment at a time.
     */
    items?: MessageAttachmentAudioItem[];
    /**
     * `<audio preload>` hint applied to every player on the bubble.
     * When omitted, the default depends on the rendered shape:
     *
     *   - Single audio (no `items`, or `items.length === 1`) →
     *     `'metadata'` so the native player surfaces duration
     *     immediately.
     *   - Stacked audio (`items.length > 1`) → `'none'` so a thread
     *     of voice memos doesn't fan out N parallel metadata requests
     *     on first paint.
     *
     * Per-track overrides live on `AudioItem.preload`.
     */
    preload?: MediaPreloadMode;
}

/**
 * Avatar component that displays a user image or colored initial fallback
 */
export declare const Avatar: ({ id, image, size, className, starred, shape, dmAgentEnabled, }: AvatarProps) => JSX_2.Element;

export declare interface AvatarProps {
    id: string;
    name: string;
    image?: string;
    size?: number;
    className?: string;
    starred?: boolean;
    shape?: 'squircle' | 'circle';
    dmAgentEnabled?: boolean;
}

/**
 * Build the meta line shown under the title in compact document / file
 * attachments — `EXT · SIZE` (`PDF · 379.5 KB`). Either part is dropped
 * when not available so audio / generic files still get a useful label.
 */
export declare function buildCompactMetaLabel(mimeType?: string, filename?: string, fileSize?: number): string | undefined;

/**
 * Empty state component shown when a channel has no messages
 * Returns null to show nothing - the LoadingIndicator handles the loading state
 */
export declare const ChannelEmptyState: default_2.FC;

/**
 * Channel list component with customizable header and actions
 */
export declare const ChannelList: default_2.NamedExoticComponent<ChannelListProps>;

/**
 * ChannelList component props
 */
export declare interface ChannelListProps {
    onChannelSelect: (channel: Channel) => void;
    selectedChannel?: Channel;
    className?: string;
    filters: ChannelFilters;
    /**
     * Controls whether new-message events can promote channels that are not
     * already present in the current list.
     *
     * Defaults to `false` for backward compatibility with existing filtered
     * ChannelList consumers.
     */
    allowNewMessagesFromUnfilteredChannels?: boolean;
    /**
     * Client-side filter applied before rendering the channel list.
     * Websocket events can add channels to the list that bypass server-side
     * query filters. Use this to enforce visibility rules that can't be
     * automatically derived from the filters prop (e.g. $or conditions).
     *
     * @example
     * // Hide channels where the visitor hasn't sent a message yet,
     * // but keep legacy channels that predate the has_visitor_message field
     * channelRenderFilterFn={(channels) =>
     *   channels.filter(ch => ch.data?.has_visitor_message !== false)
     * }
     */
    channelRenderFilterFn?: (channels: Channel[]) => Channel[];
    /**
     * Sort order for the channel list query.
     * Defaults to `{ last_message_at: -1 }` (most recent first).
     */
    sort?: ChannelSort;
    customEmptyStateIndicator?: React.ComponentType<EmptyStateIndicatorProps>;
    /**
     * Custom paginator for the channel list. The default is Stream's
     * `InfiniteScroll`; hosts that render multiple ChannelLists in one stacked
     * layout can provide a paginator that listens to the host-owned scroll
     * container or renders an explicit load-more control.
     */
    channelListPaginator?: ComponentType<InfiniteScrollProps>;
    /**
     * Custom component rendered for each channel row in the conversation list.
     * Receives Stream's channel preview props plus this package's selection
     * state and `onChannelSelect` handler.
     */
    channelPreview?: ComponentType<ChannelPreviewProps>;
    renderMessagePreview?: (message: LocalMessage | undefined, defaultPreview?: string) => React.ReactNode;
    /**
     * Language code used to pick translated message text from Stream Chat i18n.
     * Falls back to message.text when no matching translation exists.
     */
    viewerLanguage?: string;
    /**
     * Lock the visible channel order so live events don't promote a channel to
     * the top. Forwarded to Stream's `<ChannelList>`. Note `lockChannelOrder`
     * alone doesn't cover `notification.message_new` or `channel.visible`; pair it
     * with the event handlers below to fully neutralize promotion.
     */
    lockChannelOrder?: boolean;
    /**
     * Live channel-list event handlers forwarded verbatim to Stream's
     * `<ChannelList>`. Left undefined, Stream applies its default "move the
     * changed channel to the top" behaviour.
     *
     * Hosts that order by a custom channel field (`last_conversation_at` for the
     * inbox, `priority_score` for Spotlight) use these to neutralize promotion on
     * new-message / visibility events and re-sort on `channel.updated` instead.
     * Each receives Stream's `setChannels` dispatcher and the triggering event.
     * See MES-1214 / MES-1219.
     */
    onMessageNewHandler?: ChannelListReorderHandler;
    onMessageNew?: ChannelListReorderHandler;
    onChannelVisible?: ChannelListReorderHandler;
    onAddedToChannel?: ChannelListReorderHandler;
    onChannelUpdated?: ChannelListReorderHandler;
}

/**
 * Signature of Stream's `<ChannelList>` live-event handlers: mutate the loaded
 * channel array via `setChannels` in response to a websocket `event`.
 */
export declare type ChannelListReorderHandler = (setChannels: Dispatch<SetStateAction<Channel[]>>, event: Event_2) => void;

declare type ChannelMember = ChannelMembers[string];

declare type ChannelMembers = NonNullable<Channel['state']>['members'];

export declare type ChannelPreviewProps = ChannelPreviewUIComponentProps & {
    selectedChannel?: Channel | null;
    onChannelSelect: (channel: Channel) => void;
    viewerLanguage?: string;
};

/**
 * Channel view component with message list and input
 */
export declare const ChannelView: default_2.NamedExoticComponent<ChannelViewProps>;

/**
 * Props that MessagingShell passes through to ChannelView.
 * ChannelViewProps is the source of truth for these props.
 */
declare type ChannelViewPassthroughProps = Pick<ChannelViewProps, 'renderMessageInputActions' | 'renderConversationFooter' | 'CustomChannelEmptyState' | 'onBlockParticipantClick' | 'onReportParticipantClick' | 'dmAgentEnabled' | 'onMessageSent' | 'viewerLanguage' | 'renderChannelBanner' | 'customChannelActions' | 'renderChannelActions' | 'onParticipantNameClick' | 'renderMessage' | 'onMessageLinkClick' | 'onOutboundClick' | 'resolveOutbound' | 'showChannelInfo' | 'composerInput' | 'attachmentPreviewList'>;

/**
 * ChannelView component props
 */
export declare interface ChannelViewProps {
    channel: Channel;
    onBack?: () => void;
    showBackButton?: boolean;
    renderMessageInputActions?: (channel: Channel) => React.ReactNode;
    renderMessageInputFooter?: (channel: Channel) => React.ReactNode;
    renderConversationFooter?: (channel: Channel) => React.ReactNode;
    onLeaveConversation?: (channel: Channel) => void;
    onBlockParticipant?: (participantId?: string) => void;
    className?: string;
    CustomChannelEmptyState?: React.ComponentType;
    /**
     * Show the "Delete Conversation" button in channel info dialog.
     * Defaults to true for backward compatibility.
     */
    showDeleteConversation?: boolean;
    /**
     * Analytics callback fired when "Delete Conversation" is clicked.
     */
    onDeleteConversationClick?: () => void;
    /**
     * Analytics callback fired when "Block" or "Unblock" is clicked.
     */
    onBlockParticipantClick?: () => void;
    /**
     * Analytics callback fired when "Report" is clicked.
     */
    onReportParticipantClick?: () => void;
    /**
     * Show the "Block"/"Unblock" action in the channel info dialog.
     * Defaults to true. Set false for restricted surfaces such as the
     * Linktree official channel, where blocking is not offered.
     */
    showBlockParticipant?: boolean;
    /**
     * Show the "Report" action in the channel info dialog.
     * Defaults to true. Set false for restricted surfaces such as the
     * Linktree official channel, where reporting is not offered.
     */
    showReportParticipant?: boolean;
    /**
     * @deprecated Not currently rendered. The channel info sidebar was removed
     * in favour of the actions popover; this prop is retained for API
     * compatibility and will be wired up again when the replacement profile
     * surface lands. Previously toggled the subscription/follower-status label
     * in the channel info dialog profile card.
     */
    showFollowerStatus?: boolean;
    /**
     * Replace the message composer with a non-interactive locked panel showing
     * `composerDisabledReason`. Defaults to false. Used by the Linktree official
     * channel, where the linker cannot message Linktree from the inbox (they
     * message Linktree from its public profile instead).
     *
     * Distinct from the channel's `frozen` flag, which keeps the composer
     * rendered but read-only/dimmed.
     */
    composerDisabled?: boolean;
    /**
     * Explanatory text shown inside the locked panel. Only rendered when
     * `composerDisabled` is true.
     */
    composerDisabledReason?: string;
    /**
     * When true and DM agent is active on the channel (not paused),
     * messages will be sent with skip_push and silent flags to suppress
     * notifications to the creator until the agent responds.
     * The library reads chatbot_paused from channel.data internally.
     *
     * In header UI, this treatment is shown only for visitor view.
     */
    dmAgentEnabled?: boolean;
    /**
     * Custom metadata to attach to all outgoing messages.
     * Used for paid messaging flows where messages need custom_type and listing_id.
     *
     * @example
     * messageMetadata={{ custom_type: 'MESSAGE_PAID', listing_id: '...' }}
     */
    messageMetadata?: Partial<MessageMetadata>;
    /**
     * Callback fired after a message is successfully sent.
     * Receives the full API response including message.id.
     * Useful for triggering payment flows with the message ID.
     *
     * @example
     * onMessageSent={(response) => {
     *   openPaymentModal(response.message.id)
     * }}
     */
    onMessageSent?: (response: SendMessageAPIResponse) => void;
    /**
     * Show the star/pin button in channel header.
     * Defaults to false. Only useful when users can view multiple channels
     * and filter by starred/pinned status.
     */
    showStarButton?: boolean;
    /**
     * @deprecated No longer rendered. The redesigned header shows built-in paid
     * and starred badges instead. Kept temporarily so existing call sites type-check.
     */
    renderHeaderTitleBadges?: (context: {
        channel: Channel;
        participant?: ChannelMemberResponse;
    }) => React.ReactNode;
    /**
     * Show the channel actions menu (the `...` popover) in the header, which
     * exposes the block/report/delete moderation actions. Defaults to true.
     * Set false for surfaces that should not expose those actions — e.g.
     * anonymous visitor chat, where the visitor has no authenticated identity
     * to act on.
     *
     * Note: the channel info sidebar was removed in favour of the actions
     * popover, so this no longer mounts a profile dialog or renders a clickable
     * participant name; it now solely gates the actions menu.
     */
    showChannelInfo?: boolean;
    /**
     * Language code used to pick translated message text from Stream Chat i18n.
     * Falls back to message.text when no matching translation exists.
     */
    viewerLanguage?: string;
    /**
     * Custom render function for a banner/card component that renders
     * between the channel header and message list.
     * Useful for showing summaries, alerts, or contextual information.
     */
    renderChannelBanner?: () => React.ReactNode;
    /**
     * @deprecated Not currently rendered. The channel info sidebar was removed
     * in favour of the actions popover; this prop is retained for API
     * compatibility and will be wired up again when the replacement profile
     * surface lands. Previously rendered custom content (badges, metadata)
     * below the participant name in the channel info dialog profile card.
     */
    customProfileContent?: React.ReactNode;
    /**
     * Custom actions rendered at the bottom of the channel actions popover
     * (below Delete Conversation, Block/Unblock, Report).
     * Pass one or more <li> elements so they match the list styling.
     * Use the exported ActionButton for consistent styling.
     */
    customChannelActions?: React.ReactNode;
    /**
     * Override the entire channel-header actions slot. When provided, this
     * replaces the default `(...)` overflow menu (Delete/Block/Report +
     * `customChannelActions`) — use it to render a host-owned trigger that does
     * something other than open the popover.
     *
     * @example
     * renderChannelActions={<button onClick={openMyDialog}>…</button>}
     */
    renderChannelActions?: React.ReactNode;
    /**
     * Custom render function for decorating each message in the message list.
     * Receives the default message node and the message object.
     *
     * @example
     * renderMessage={(messageNode, message) => (
     *   <MessageDecorator isStarred={Boolean(message.pinned)}>
     *     {messageNode}
     *   </MessageDecorator>
     * )}
     */
    renderMessage?: (messageNode: React.ReactElement, message: LocalMessage) => React.ReactNode;
    /**
     * Fired when a user clicks any link inside the channel view (message
     * bubbles, attachment cards, etc.). Receives the clicked URL. Fires
     * alongside the native navigation, not in place of it.
     *
     * @example
     * onMessageLinkClick={(url) => trackChannelLinkClicked(url)}
     */
    onMessageLinkClick?: MessageLinkClickHandler;
    /**
     * Fired when an outbound source label is clicked on an outgoing message.
     * Hosts own navigation so this shared package never assumes an admin URL.
     */
    onOutboundClick?: OutboundClickHandler;
    /**
     * Resolves `metadata.outbound_id` (an outbound record id) to the current
     * automation id and name. The host must provide a new resolver reference
     * when a returned outbound changes so ChannelView re-renders and publishes
     * the new value to memoized rows. Missing records stay unresolved and render
     * no label.
     */
    resolveOutbound?: OutboundResolver;
    /**
     * Passed to Stream `Channel` as `SendButton`. Required for hosts that replace
     * the send control: `Channel` merges this into `ComponentContext` and an
     * explicit `SendButton: undefined` would otherwise override outer
     * `WithComponents` overrides.
     *
     * @example
     * sendButton={MediaSendButton}
     */
    sendButton?: ComponentType<any>;
    /**
     * Custom component rendered inside the message composer bubble (above the
     * textarea). Passed to Stream `Channel` as `AttachmentPreviewList`.
     * Use this to render staged paid or media attachments inside the input.
     */
    attachmentPreviewList?: ComponentType;
    /**
     * Replace the entire inner composer — the textarea + send arrangement — with
     * a host-owned component. Passed to Stream's `<MessageInput>` as the `Input`
     * component, so it runs inside the message-input context and reuses the
     * library's send pipeline (`doSendMessageRequest`, message metadata, DM-agent
     * suppression), attachments, and previews via the Stream hooks
     * (`useMessageInputContext`, `useMessageComposerHasSendableData`,
     * `TextareaComposer`, …). Use it when a surface needs a different composer
     * layout (e.g. a full-width textarea above a toolbar row) than the default.
     *
     * The outer wrapper — frozen handling and the `renderMessageInputActions` /
     * `renderMessageInputFooter` slots — is unchanged. Read the exported
     * `useComposerLocked()` hook to honour the frozen state. Defaults to the
     * built-in composer when omitted.
     */
    composerInput?: ComponentType;
    /**
     * Fired when the participant identity in the channel header is clicked. When
     * provided, the avatar + name pill render as a button with a trailing caret;
     * when omitted, they render as non-interactive chrome.
     *
     * @example
     * onParticipantNameClick={() => openThreadContentDialog()}
     */
    onParticipantNameClick?: () => void;
}

/** Shared props for the `Composer` state of every attachment type. */
declare interface ComposerExtras {
    /** Renders a dismiss `×` button overlaid on the attachment. */
    onDismiss?: () => void;
}

export declare const CustomMessageProvider: Provider<Partial<CustomMessageRegistry>>;

export declare interface CustomMessageRegistry {
    LockedAttachment: LockedAttachmentContextValue;
}

declare type DraftProps = MediaCardDraftProps & {
    /** Drafting is always the sender — doesn't apply here. */
    isMine?: never;
    /**
     * "text" renders as a chat bubble showing the real draft `text` instead of
     * a media thumbnail card. Media-only fields below are ignored in text mode.
     * Defaults to `"media"`.
     */
    contentType?: 'text' | 'media';
    /** The message's own text, shown as-is (not redacted yet). Only used when `contentType` is `"text"`. */
    renderedText?: default_2.ReactNode;
};

export declare interface Faq {
    id: string;
    question: string;
    answer: string;
    enabled: boolean;
    order?: number | null;
}

export declare const FaqList: default_2.FC<FaqListProps>;

export declare const FaqListItem: default_2.FC<FaqListItemProps>;

export declare interface FaqListItemProps {
    question: string;
    onClick: () => void;
    loading?: boolean;
    className?: string;
}

export declare interface FaqListProps {
    faqs: Faq[];
    onFaqClick: (faqId: string) => void;
    loadingFaqId?: string | null;
    headerText?: string;
    className?: string;
    avatarImage?: string;
    avatarName?: string;
}

/** Fetches the underlying source; `void` return means none available. */
declare type FetchSourceHandler = () => Promise<LockedAttachmentSource | void>;

declare interface FileAttachmentSharedProps extends MessageAttachmentBaseProps {
    /** Source URL of the file (used as the download target). */
    src?: string;
    /** Filename — drives the title + the meta line + the download default name. */
    filename?: string;
    fileSize?: number;
    /** MIME type — drives the type icon. Defaults to `application/octet-stream`. */
    mimeType?: string;
    /**
     * Override displayed title (defaults to `filename`). Useful when a
     * sender renames the attachment before sending.
     */
    title?: string;
    /**
     * Stacked files. Takes precedence over `src` when set. Each item
     * renders as its own row inside the bubble; clicking a row downloads
     * that file. Sent + Received only — the composer surface accepts a
     * single attachment at a time.
     */
    items?: MessageAttachmentFileItem[];
    /**
     * Forwarded to the row trigger. When omitted the click still
     * downloads the file. Supply this for analytics, or return `false`
     * to fully intercept the download (e.g. show a confirmation modal,
     * route to a custom preview, throttle large files). Any other
     * return value — including `void`/`undefined` — lets the built-in
     * download proceed. For stacked attachments the `index` argument
     * identifies the row.
     */
    onClick?: (index: number) => boolean | void;
}

/**
 * Format a byte count as a short human-readable string (`'379.5 KB'`).
 * Mirrors the meta line shown next to file attachments in the mobile chat
 * design — `EXT · SIZE`, e.g. `PDF · 379.5 KB`.
 */
export declare function formatFileSize(bytes: number): string;

/**
 * Format a date - shows time for today, relative time for older messages
 * (e.g., "Just now", "2:08 PM" for today, "Yesterday" for yesterday,
 * "Mon" for 2-6 days ago, "Jul 14" for older dates this year,
 * "Jul 14, 2025" for previous years)
 */
export declare const formatRelativeTime: (date: Date) => string;

/**
 * Returns the short uppercase extension label shown in the meta line of
 * compact document / file attachments. Prefers the filename extension
 * when present (matches the mobile design which trusts the filename),
 * and falls back to a label derived from the MIME type.
 */
export declare function getFileExtensionLabel(mimeType?: string, filename?: string): string | undefined;

export declare function getMessageDisplayText({ message, viewerLanguage, }: {
    message?: MessageWithI18n | null;
    viewerLanguage?: string;
}): string | undefined;

declare interface ImageAttachmentSharedProps extends MessageAttachmentBaseProps {
    /** Single image — convenience for the most common case. */
    src?: string;
    alt?: string;
    /** Filename used as the viewer dialog's accessible name. */
    filename?: string;
    /**
     * Stacked images. Takes precedence over `src` when set. Renders a
     * 1 / 2 / 3 / 4-tile grid (5+ collapse into a `+N` overflow tile).
     * Sent + Received only — the composer surface intentionally accepts
     * a single attachment at a time.
     */
    items?: MessageAttachmentImageItem[];
    /**
     * Native lazy-load hint forwarded to every `<img>` rendered on the
     * bubble surface (Composer thumbnail, single + stacked tiles, and
     * the `+N` overflow tile). Defaults to `'lazy'` — chat surfaces
     * usually scroll a long history, and lazy loading prevents every
     * historical image from being fetched on mount. Set `'eager'` for
     * above-the-fold hero attachments. Per-tile overrides live on
     * `ImageItem.loading`. The opened `ImageViewer` always eager-loads
     * the active image regardless of this value.
     */
    loading?: ImageLoadingMode;
    /**
     * Forwarded to the Image viewer trigger. When omitted the click
     * still opens the built-in viewer — supply this for analytics, or
     * return `false` to intercept the open (e.g. switch to a route-
     * based gallery / confirmation modal). Any other return value
     * (including `void`/`undefined`) lets the built-in viewer open.
     * For stacked attachments the `index` argument identifies the tile.
     */
    onClick?: (index: number) => boolean | void;
}

/** Loading hint forwarded to the underlying `<img>` element. */
declare type ImageLoadingMode = 'lazy' | 'eager';

/**
 * True when an attachment is a link preview (OG card) rather than media:
 * either Stream's native `link` type, or a non-empty (trimmed) `og_scrape_url`
 * with no `asset_url`. A whitespace-only `og_scrape_url` is not a link.
 */
export declare function isLinkAttachment(a: Attachment): boolean;

/** Check if a message is a tip based on metadata */
export declare const isTipMessage: (message: LocalMessage) => boolean;

export declare function isUuidLike(value: string): boolean;

/**
 * Link previews (1P / 3P Link Apps) shown in the chat thread. Mirrors
 * the `LockedAttachment` API — render `LinkAttachment.Composer` while
 * drafting, `LinkAttachment.Sent` after posting, and
 * `LinkAttachment.Received` in the recipient's thread. Maps to the
 * "LinkApps" section of the messaging design system.
 *
 * Two visual layouts via the `layout` prop:
 *   - **Featured** (default) — a hero thumbnail filling the card above the
 *     chin, inside a fixed 290x250 box. Used by hero-image LinkApps
 *     (Spotify with cover art, TikTok with a frame, etc.) and by link
 *     previews carrying OG imagery.
 *   - **Classic** — compact card with no hero thumbnail; title /
 *     description / URL / CTA only, sized to its content. Used for LinkApp
 *     embeds without artwork (FAQ, Form) and any link preview that lacks
 *     OG imagery.
 *
 * Pass `accentColor` (a hex extracted from the thumbnail) to paint the card
 * and its bubble tail; the card derives its own WCAG AA text colour.
 *
 * For chat **document / image / video / audio attachments**, reach for
 * `MessageAttachment.{Image,Video,Audio,Pdf,File}` instead — those
 * render as bubbles with built-in viewers (zoom-capable image
 * lightbox, native PDF viewer, video / audio with download) and a
 * caption slot for accompanying text.
 */
export declare const LinkAttachment: {
    Composer: FC<LinkAttachmentComposerCardProps>;
    Sent: FC<LinkAttachmentSentCardProps>;
    Received: FC<LinkAttachmentReceivedCardProps>;
};

/**
 * Shared props for the three `LinkAttachment.*` variants (Composer, Sent,
 * Received). Maps to the "Attachments" + "LinkApps" sections of the messaging
 * design system in Figma — a 290px-wide, 250px-tall card whose hero thumbnail
 * absorbs whatever height the chin doesn't use, a title (optionally prefixed
 * with a brand badge for Link Apps), a description, and either a URL footer
 * or a CTA button.
 */
export declare interface LinkAttachmentBaseProps {
    title?: string;
    /** Placeholder shown in the title slot before one is configured (dark variants only). */
    placeholderTitle?: string;
    /** Secondary description rendered below the title. */
    description?: string;
    /**
     * Max lines the description renders before truncating with an ellipsis.
     * Defaults to `1` (single-line truncate — the link-preview default). Set
     * higher for cards whose body is prose (e.g. official messages) so it wraps
     * across multiple lines like the mobile card.
     */
    descriptionLines?: number;
    /**
     * Optional URL displayed at the bottom of the card (e.g. `tr.ee/briemix`).
     * Ignored when `cta` is provided. Also used as the navigation target for
     * the Received card when no `cta` is set.
     */
    url?: string;
    /** MIME type of the hero thumbnail — drives the type icon for empty states. */
    mimeType?: string;
    /** Hero thumbnail shown above the title block; fills the card above the chin. */
    thumbnailUrl?: string;
    /**
     * Source URL for playable media in the hero region. When provided
     * alongside a video / audio `mimeType`, the hero renders an inline
     * native player (used by media-rich link previews that embed a
     * preview clip). For chat document / file attachments, reach for
     * `MessageAttachment.{Pdf,File}` instead.
     */
    sourceUrl?: string;
    /**
     * Visual layout — `'featured'` keeps the 180px hero thumbnail above the
     * body, `'classic'` drops the hero entirely for a compact text-only
     * card. Defaults to `'featured'`.
     */
    layout?: LinkAttachmentLayout;
    /**
     * Optional 16x16 brand badge rendered before the title (used by Link Apps:
     * Spotify, TikTok, FAQ, Form, etc.). Consumers render whatever they want
     * — typically a colored 4px-rounded square containing a glyph or `<img>`.
     */
    appIcon?: default_2.ReactNode;
    /**
     * Optional call-to-action rendered below the description. When set,
     * replaces the URL footer (e.g. FAQ "View FAQs", Form "Complete form").
     */
    cta?: LinkAttachmentCta;
    /**
     * Dominant colour extracted from `thumbnailUrl`, as a hex string
     * (`#RRGGBB` or `#RGB`). Paints the card and — when the card is the last
     * bubble in a same-author run — its tail. Its hue is kept while the lightness
     * is swapped to a fixed per-side stop (`oklch(from …)` in `styles.css`); the
     * stops clear WCAG AA at every hue by construction, so callers never pass a
     * text colour.
     *
     * Only painted while the hero image it was extracted from is actually on
     * screen. Omitted, unparseable, `layout: 'classic'`, no `thumbnailUrl`,
     * `status` other than `'ready'`, a playable-audio `mimeType` + `sourceUrl`
     * (whose hero is the native player rather than an image), or a hero that fails
     * to load => the card keeps the plain bubble fill. Browsers without
     * relative-colour-syntax support also keep that fill (progressive enhancement).
     */
    accentColor?: string;
    /**
     * Render state. `'loading'` shows a neutral pulsing hero plus two skeleton
     * text bars and ignores `accentColor` (there is no image yet). `'failed'`
     * renders the fallback chin with whatever text is available. Defaults to
     * `'ready'`.
     *
     * `'loading'` outranks the hero shape that `mimeType` + `sourceUrl` would
     * otherwise select: a card mid-scrape does not yet know what the asset is, so
     * it renders the skeleton rather than a live `<audio>` / `<video>` player
     * beside the skeleton's own text bars.
     */
    status?: LinkAttachmentStatus;
}

export declare interface LinkAttachmentComposerCardProps extends LinkAttachmentBaseProps {
    /**
     * When provided, renders a dismiss X in the thumbnail corner. Called when
     * the composer clicks it to remove the attachment.
     */
    onDismiss?: () => void;
    /**
     * When provided, renders a pencil button to the right of the description
     * that the composer can use to edit the attachment metadata.
     */
    onEditClick?: () => void;
    /**
     * Accessible name for the dismiss button. Defaults to English because the
     * toolkit has no i18n layer; consumers that do (frontyard passes
     * `ComposerLinkPreviewList.closeLinkPreview`) should supply their own.
     */
    dismissLabel?: string;
}

export declare interface LinkAttachmentCta {
    label: string;
    /** When set, the CTA renders as an `<a>` opening in a new tab. */
    href?: string;
    /** When set, called on click (in addition to `href` navigation if provided). */
    onClick?: () => void;
    /**
     * Visual emphasis of the CTA button. Defaults to `'primary'` (the filled
     * dark button), so existing callers are unaffected. `'secondary'` renders
     * the subtle/grey button. Orthogonal to the card's sent/received `variant`
     * (which controls bubble side, not button emphasis).
     *
     * NOTE: this is the presentational half only. The wire-format value should
     * ride the shared interactive-surfaces action contract (the `InteractiveAction`
     * shape), not be re-invented per surface.
     */
    variant?: 'primary' | 'secondary';
}

/**
 * Visual layout for a `LinkAttachment.*` card.
 *
 * - `featured` — full card with a 180px hero thumbnail above the body.
 *   The default; matches the hero-image "LinkApps" frames in Figma
 *   (Spotify with cover art, TikTok with a frame, etc.).
 * - `classic` — compact card without a hero thumbnail. Title /
 *   description / URL / CTA only. Used for Link App embeds that don't
 *   carry artwork (and for plain link previews without OG imagery).
 *
 * For document / image / video / audio chat attachments, reach for
 * `MessageAttachment.{Image,Video,Audio,Pdf,File}` instead — those
 * render as bubbles with built-in viewers and download support and
 * carry a `text` slot for accompanying captions.
 */
export declare type LinkAttachmentLayout = 'featured' | 'classic';

export declare interface LinkAttachmentReceivedCardProps extends LinkAttachmentBaseProps {
    /**
     * Fired when the recipient activates the card. Behavior depends on how
     * the card is configured:
     *   - **Link app with a CTA** (FAQ / Form): the CTA owns navigation;
     *     `onClick` fires when the recipient taps the CTA itself, alongside
     *     `cta.onClick` (use for analytics).
     *   - **Link app with a URL** (Spotify / TikTok / generic link): the card
     *     chrome is an `<a target="_blank">` opening `url` — `onClick` fires
     *     alongside the navigation (use for analytics).
     *   - **Hero-image only card**: the card has no URL, so it renders as
     *     a button. `onClick` is the consumer's hook for opening a preview.
     *   - **Video / audio link previews**: the shell stays non-interactive
     *     so the native media controls remain operable — `onClick` is
     *     ignored in this configuration.
     */
    onClick?: () => void;
    /**
     * Position of this card inside its same-author run. `'single'` / `'end'`
     * paint the accent-coloured tail, mirrored to the card's left edge;
     * `'first'` / `'middle'` omit it because a later bubble in the run owns it.
     * Defaults to `'single'`.
     */
    groupPosition?: MessageAttachmentGroupPosition;
}

export declare interface LinkAttachmentSentCardProps extends LinkAttachmentBaseProps {
    /**
     * Fired when the sender activates their own posted card. Mirrors the
     * `Received` variant so analytics fires symmetrically on both sides
     * of the conversation. Behavior depends on configuration:
     *   - **Link app with a URL**: the card chrome is an `<a target="_blank">`
     *     opening `url`; `onClick` fires alongside the navigation.
     *   - **Link app with a CTA**: the CTA owns navigation; `onClick` is
     *     ignored (the CTA's own `onClick` is the analytics hook).
     *   - **Video / audio link previews**: the shell stays non-interactive
     *     so the native media controls remain operable; `onClick` is ignored.
     */
    onClick?: () => void;
    /**
     * Position of this card inside its same-author run. `'single'` / `'end'`
     * paint the accent-coloured tail; `'first'` / `'middle'` omit it because a
     * later bubble in the run owns it. Defaults to `'single'`.
     */
    groupPosition?: MessageAttachmentGroupPosition;
}

/**
 * Render state of a link card. Mirrors Stream's `LinkPreviewStatus` 1:1
 * (`LOADING` -> `'loading'`, `LOADED` -> `'ready'`, `FAILED` -> `'failed'`)
 * so a composer can forward its preview state without inventing a parallel
 * vocabulary.
 */
export declare type LinkAttachmentStatus = 'loading' | 'ready' | 'failed';

export declare const LockedAttachment: default_2.FC<LockedAttachmentProps>;

export declare interface LockedAttachmentContextValue {
    /** Whether the given message is mid-checkout. */
    isUnlocking: (id: string) => boolean;
    /** Opens the checkout flow for a message. */
    onUnlockClick?: (message: LocalMessage, channel: Channel) => void;
    /** Handles a Download click for a message. */
    onDownloadClick?: (message: LocalMessage, channel: Channel) => void;
    /** Reveals the locked media's source. Unused for text — payment writes `message.text` directly. */
    onFetchSource?: (message: LocalMessage, channel: Channel) => Promise<LockedAttachmentSource | void>;
}

export declare interface LockedAttachmentGalleryItem {
    /** Drives the per-item play/lock affordance. */
    mimeType: string;
    /** Poster image, locked or unlocked. */
    thumbnailUrl?: string;
    /** Media source, shown only when unlocked. */
    sourceUrl?: string;
}

/**
 * The card for a paid attachment — a still-drafting `isDraft` card, a static
 * receiver-facing `isPreview` mockup, or a sent text/media card discriminated
 * by `isMine` + `contentType`. Internally lazy-loads only the one underlying
 * implementation the resolved branch needs.
 */
export declare type LockedAttachmentProps = DraftProps | PreviewProps | SentTextOwnProps | SentTextOtherProps | SentMediaOwnProps | SentMediaOtherProps;

export declare interface LockedAttachmentSource {
    /** Proxied URL for in-app playback. */
    sourceUrl: string;
    /** Opened when the visitor clicks Download. */
    redeemUrl?: string;
    /** Overrides the metadata thumbnail when present. */
    thumbnailUrl?: string;
}

export { Logger }

declare interface MediaCardBaseProps {
    /** Attachment title. */
    title?: string;
    /** Fallback shown when `title` is unset. */
    placeholderTitle?: string;
    /** Drives icon/thumbnail rendering. */
    mimeType?: string;
    /** Poster image, locked or unlocked. */
    thumbnailUrl?: string;
    /** Secondary description text. */
    detail?: string;
    /** Amount label. */
    amountText?: string;
    /** 2+ items renders as a carousel instead of a single thumbnail. */
    gallery?: LockedAttachmentGalleryItem[];
}

declare interface MediaCardDraftProps extends MediaCardBaseProps {
    /** True while composing — shows the real (unredacted) thumbnail. */
    isDraft: true;
    isPreview?: false;
    /** Fallback amount before a price is set. */
    placeholderAmountText?: string;
    /** Lazily fetches the source on first tap; cached and reused after. */
    onFetchSource?: FetchSourceHandler;
    /** Fired on first tap to preview. */
    onPreviewClick?: () => void;
    /** Removes the draft attachment. */
    onDismiss?: () => void;
    /** Renders a pencil button to edit the attachment metadata. */
    onEditClick?: () => void;
}

declare type MediaCardOtherProps = MediaCardSentBaseProps & {
    /** Recipient's view. */
    isMine: false;
    /** Opens checkout on click. Omit to hide the button. */
    onUnlockClick?: () => void;
    /** Omit to hide the Download button. */
    onDownloadClick?: () => void;
    /** Spinner on Unlock while checkout runs. */
    isUnlocking?: boolean;
};

declare type MediaCardOwnProps = MediaCardSentBaseProps & {
    /** Sender's own view. */
    isMine: true;
    /** Fired on first tap to preview own attachment. */
    onPreviewClick?: () => void;
};

declare interface MediaCardPreviewProps extends MediaCardBaseProps {
    /** True to render exactly as the recipient will see it before purchase — always locked/blurred. */
    isDraft?: false;
    isPreview: true;
    /** Fallback amount before a price is set. */
    placeholderAmountText?: string;
}

declare interface MediaCardSentBaseProps extends MediaCardBaseProps {
    /** False once sent. */
    isDraft?: false;
    isPreview?: false;
    /** Drives the lock/skeleton/badge state. */
    paymentStatus?: PaymentStatus;
    onFetchSource?: FetchSourceHandler;
}

/** Preload hint forwarded to the underlying `<video>` / `<audio>` element. */
declare type MediaPreloadMode = 'none' | 'metadata' | 'auto';

/**
 * Per-MIME chat attachment cards used inside the messaging stream.
 *
 * Each subnamespace (`Image`, `Video`, `Audio`, `Pdf`, `File`) exposes
 * three states (`Composer`, `Sent`, `Received`) that map to the
 * sender / recipient sides of a chat:
 *
 *   - `Composer` — sender draft state with a dismiss `×` affordance.
 *   - `Sent`     — sender-side state shown after posting.
 *   - `Received` — recipient-side state.
 *
 * Sent / Received variants accept an optional `text` prop that renders
 * inside the same bubble as the attachment — mirroring the mobile chat
 * where a sender can pair a caption with an attachment ('Here is the
 * file', 'Here is the image'). Composer prop types intentionally omit
 * `text` (and `items` / `groupPosition`) so the type system enforces
 * the same contract: captions live in the message-input textarea, not
 * inside the draft attachment preview.
 *
 * Stacked attachments — every type except `Composer` accepts an
 * `items={[…]}` prop on Sent / Received that takes precedence over
 * the singular `src`/`filename`/etc. inputs:
 *
 *   - Image / Video render a 1 / 2 / 3 / 4-tile grid (5+ collapse
 *     into a `+N` overflow tile). Activating any tile opens the
 *     built-in `ImageViewer` / `VideoViewer` at that index; when
 *     `items.length > 1` the lightbox becomes a carousel (prev / next
 *     chrome, ArrowLeft / ArrowRight, current / total counter) so the
 *     user can browse siblings without closing the modal.
 *   - Pdf / Audio / File render their compact rows / players in a
 *     vertical stack with an 8px gap between rows. Each row keeps
 *     its own activation target — Pdf opens the carousel-aware
 *     `PdfViewer` at that index, Audio gets its own native player,
 *     and File downloads the asset for that row.
 *
 * The Composer surface accepts only a single attachment at a time,
 * so its props omit `items` / `text`.
 *
 * Image / Video Composer renders bare — just the media with rounded
 * corners and a dismiss overlay, no surrounding bubble — so the draft
 * preview reads as an in-progress attachment instead of a sent
 * message. Sent / Received wrap the media in the shared bubble chrome.
 *
 * Image / Video / Pdf are interactive in every state (Composer, Sent,
 * Received) — clicks open the corresponding native lightbox `<dialog>`,
 * which centers the media at reasonable max dimensions (Escape and
 * backdrop click also dismiss). The Image viewer adds an explicit
 * download button to the chrome; the Video viewer relies on the
 * native `<video controls>` download menu, and the Pdf viewer
 * inherits the browser's built-in PDF download. Sibling-row Download
 * buttons on Pdf / File and the native `<audio>` controls expose
 * downloads outside the viewer too. The lightbox chrome is styled
 * with plain CSS (`.mes-media-viewer*`) so the package's shipped
 * stylesheet is enough to render the viewer correctly without a
 * Tailwind dependency in the consumer.
 *
 * # Lazy-loading defaults
 *
 * Media attachments bake in network-friendly defaults for long chat
 * histories and expose explicit escape hatches when a caller knows
 * better (e.g. a hero attachment that's already on-screen):
 *
 *   - **Image** — every `<img>` rendered on the bubble surface
 *     (Composer thumbnail, single + stacked tiles, `+N` overflow)
 *     ships with `loading="lazy" decoding="async"`. Override via the
 *     attachment's `loading` prop (or `ImageItem.loading` for per-tile
 *     control). The opened `ImageViewer` always eager-loads the
 *     active image so it appears immediately.
 *   - **Video** — the `<video>` rendered inside the `VideoViewer`
 *     defaults to `preload="none"`, so no video bytes are fetched
 *     until the user opens the viewer. Poster `<img>` thumbnails on
 *     the bubble surface are `loading="lazy" decoding="async"`.
 *     Override via the attachment's `preload` prop (or
 *     `VideoItem.preload` per item). Once the viewer is open the
 *     active item bumps to `preload="metadata"` so duration / the
 *     first frame appear immediately.
 *   - **Audio** — a single audio bubble defaults to
 *     `preload="metadata"` so the native player surfaces duration
 *     immediately. A stacked audio bubble (`items.length > 1`)
 *     defaults to `preload="none"` for every player so a thread of
 *     voice memos doesn't fan out N parallel metadata requests on
 *     first paint. Override via the attachment's `preload` prop
 *     (or `AudioItem.preload` per track).
 *   - **Pdf** / **File** — no inline media element to throttle; the
 *     bubble renders compact rows that download / open lazily on
 *     activation. No `loading` / `preload` props on these surfaces.
 */
export declare const MessageAttachment: {
    Image: {
        Composer: FC<MessageAttachmentImageComposerProps>;
        Sent: FC<ImageAttachmentSharedProps>;
        Received: FC<ImageAttachmentSharedProps>;
    };
    Video: {
        Composer: FC<MessageAttachmentVideoComposerProps>;
        Sent: FC<VideoAttachmentSharedProps>;
        Received: FC<VideoAttachmentSharedProps>;
    };
    Audio: {
        Composer: FC<MessageAttachmentAudioComposerProps>;
        Sent: FC<AudioAttachmentSharedProps>;
        Received: FC<AudioAttachmentSharedProps>;
    };
    Pdf: {
        Composer: FC<MessageAttachmentPdfComposerProps>;
        Sent: FC<PdfAttachmentSharedProps>;
        Received: FC<PdfAttachmentSharedProps>;
    };
    File: {
        Composer: FC<MessageAttachmentFileComposerProps>;
        Sent: FC<FileAttachmentSharedProps>;
        Received: FC<FileAttachmentSharedProps>;
    };
};

/**
 * Composer-only props. Single audio (`src`) only — the composer
 * surface accepts a single attachment at a time, so `items` is not
 * supported. Captions (`text`) and `groupPosition` are also dropped:
 * the composer renders a standalone draft, not part of a same-author
 * run, and captions live in the message-input textarea, not inside
 * the draft attachment preview.
 */
export declare interface MessageAttachmentAudioComposerProps extends ComposerExtras {
    src?: string;
    mimeType?: string;
    filename?: string;
    /** See `AudioAttachmentSharedProps.preload`. */
    preload?: MediaPreloadMode;
}

/** A single audio file inside an Audio attachment (single or stacked). */
export declare interface MessageAttachmentAudioItem {
    src: string;
    /** MIME type hint — typed onto the inline `<source>` element. */
    mimeType?: string;
    /**
     * Filename — used as the download default name (consumed by the
     * native player's kebab menu).
     */
    filename?: string;
    /**
     * Per-track override for the `<audio preload>` hint. Defaults to
     * the parent attachment's `preload` value, which itself defaults
     * to `'metadata'` for a single audio (so the native player can
     * surface duration immediately) and `'none'` for a stacked thread
     * (so a fan-out of metadata requests doesn't happen on first paint).
     */
    preload?: MediaPreloadMode;
}

export declare type MessageAttachmentAudioReceivedProps = AudioAttachmentSharedProps;

export declare type MessageAttachmentAudioSentProps = AudioAttachmentSharedProps;

/** Shared props every `MessageAttachment.*.{Composer|Sent|Received}` accepts. */
export declare interface MessageAttachmentBaseProps {
    /**
     * Optional text rendered below the attachment inside the same bubble.
     * Mirrors the chat behavior in the mobile screenshots — `'Here is the
     * file'`, `'Here is the image'`, etc.
     */
    text?: default_2.ReactNode;
    /**
     * Position of this attachment inside a same-author message run —
     * mirrors the corner-flattening stream-chat-react applies to text
     * bubbles in a clustered conversation. Defaults to `'single'`, so
     * standalone usage keeps every corner rounded. Pass the value
     * derived from `bubbleGroupPositionFromStream({ firstOfGroup,
     * endOfGroup, groupedByUser })` when rendering inside a real
     * `CustomMessage` thread to make the attachment visually merge
     * with adjacent bubbles. Image / Video Composer ignore this — the
     * draft preview renders bare without the surrounding bubble.
     */
    groupPosition?: MessageAttachmentGroupPosition;
}

/**
 * Composer-only props. Single file (`src`) only — the composer surface
 * accepts a single attachment at a time, so `items` is not supported.
 * Captions (`text`) and `groupPosition` are also dropped: the composer
 * renders a standalone draft, not part of a same-author run, and
 * captions live in the message-input textarea, not inside the draft
 * attachment preview.
 */
export declare interface MessageAttachmentFileComposerProps extends ComposerExtras {
    src?: string;
    filename?: string;
    fileSize?: number;
    mimeType?: string;
    title?: string;
    onClick?: (index: number) => boolean | void;
}

/** A single generic file inside a File attachment (single or stacked). */
export declare interface MessageAttachmentFileItem {
    src: string;
    /** Filename — drives the title + the meta line + the download default name. */
    filename?: string;
    /** File size in bytes — formatted into the `EXT · SIZE` meta line. */
    fileSize?: number;
    /** MIME type — drives the type icon. Defaults to `application/octet-stream`. */
    mimeType?: string;
    /** Override displayed title. Defaults to `filename`. */
    title?: string;
}

export declare type MessageAttachmentFileReceivedProps = FileAttachmentSharedProps;

export declare type MessageAttachmentFileSentProps = FileAttachmentSharedProps;

/**
 * Position of a bubble inside a same-author run, mirroring the grouping
 * stream-chat-react applies to consecutive messages from the same user:
 *
 *   - `'single'` — standalone message, every corner fully rounded.
 *   - `'first'`  — first in a 2+ message run; the corner facing the
 *                  next bubble in the run is flattened.
 *   - `'middle'` — both the corner facing the previous bubble and the
 *                  corner facing the next bubble are flattened.
 *   - `'end'`    — last in a 2+ message run; the corner facing the
 *                  previous bubble is flattened (this is also the
 *                  bubble the avatar attaches to on the receiver side).
 *
 * "Facing" is determined by the bubble's side: sender-aligned bubbles
 * cluster against their right edge, receiver-aligned bubbles against
 * their left edge.
 */
export declare type MessageAttachmentGroupPosition = 'single' | 'first' | 'middle' | 'end';

/**
 * Convenience adapter that derives the `BubbleGroupPosition` from the
 * three booleans `stream-chat-react` forwards into the `Message` HOC.
 * Drop-in for `useMessageContext()` consumers:
 *
 * ```tsx
 * const { firstOfGroup, endOfGroup, groupedByUser } = useMessageContext()
 * <MessageAttachment.Image.Sent
 *   {...props}
 *   groupPosition={bubbleGroupPositionFromStream({
 *     firstOfGroup, endOfGroup, groupedByUser,
 *   })}
 * />
 * ```
 *
 * @deprecated Unadopted convenience adapter, slated for removal in a future
 * release. No consumer uses it. Derive `groupPosition` (a `BubbleGroupPosition`)
 * inline from stream-chat-react's `firstOfGroup` / `endOfGroup` /
 * `groupedByUser` booleans instead.
 */
export declare const messageAttachmentGroupPositionFromStream: ({ firstOfGroup, endOfGroup, groupedByUser, }: {
    firstOfGroup?: boolean;
    endOfGroup?: boolean;
    groupedByUser?: boolean;
}) => MessageAttachmentGroupPosition;

/**
 * Composer-only props. Single image (`src`) is required; stacked
 * `items` and `text` captions are not supported in the composer state.
 */
export declare interface MessageAttachmentImageComposerProps {
    src: string;
    alt?: string;
    filename?: string;
    /**
     * Native lazy-load hint forwarded to the composer thumbnail `<img>`.
     * Defaults to `'lazy'`. See `ImageAttachmentSharedProps.loading` for
     * the rationale.
     */
    loading?: ImageLoadingMode;
    onClick?: (index: number) => boolean | void;
    onDismiss?: () => void;
}

/** A single image inside an Image attachment (single or stacked). */
export declare interface MessageAttachmentImageItem {
    src: string;
    alt?: string;
    /** Optional width/height hint — preserved aspect on cover-fit. */
    width?: number;
    height?: number;
    /**
     * Per-tile native lazy-load override. Defaults to the parent
     * attachment's `loading` value (which itself defaults to `'lazy'`).
     * Pass `'eager'` for above-the-fold hero tiles.
     */
    loading?: ImageLoadingMode;
}

export declare type MessageAttachmentImageReceivedProps = ImageAttachmentSharedProps;

export declare type MessageAttachmentImageSentProps = ImageAttachmentSharedProps;

/**
 * Composer-only props. Single PDF (`src`) only — the composer surface
 * accepts a single attachment at a time, so `items` is not supported.
 * Captions (`text`) and `groupPosition` are also dropped: the composer
 * renders a standalone draft, not part of a same-author run, and
 * captions live in the message-input textarea, not inside the draft
 * attachment preview.
 */
export declare interface MessageAttachmentPdfComposerProps extends ComposerExtras {
    src?: string;
    filename?: string;
    fileSize?: number;
    title?: string;
    onClick?: (index: number) => boolean | void;
}

/** A single PDF inside a Pdf attachment (single or stacked). */
export declare interface MessageAttachmentPdfItem {
    src: string;
    /** Filename — drives the row title + the meta line + the viewer dialog's accessible name. */
    filename?: string;
    /** File size in bytes — formatted into the `EXT · SIZE` meta line. */
    fileSize?: number;
    /** Override displayed title. Defaults to `filename`. */
    title?: string;
}

export declare type MessageAttachmentPdfReceivedProps = PdfAttachmentSharedProps;

export declare type MessageAttachmentPdfSentProps = PdfAttachmentSharedProps;

/**
 * Three messaging states a `MessageAttachment.*` card can render in,
 * mirroring the LinkAttachment / LockedAttachment families.
 */
export declare type MessageAttachmentState = 'composer' | 'sent' | 'received';

/**
 * Composer-only props. Single video (`src`) is required; stacked
 * `items` and `text` captions are not supported in the composer state.
 */
export declare interface MessageAttachmentVideoComposerProps {
    src: string;
    poster?: string;
    mimeType?: string;
    filename?: string;
    /**
     * `<video preload>` hint forwarded into the viewer. Defaults to
     * `'none'`. See `VideoAttachmentSharedProps.preload`.
     */
    preload?: MediaPreloadMode;
    onClick?: (index: number) => boolean | void;
    onDismiss?: () => void;
}

/** A single video inside a Video attachment (single or stacked). */
export declare interface MessageAttachmentVideoItem {
    src: string;
    /** Poster / thumbnail rendered before playback starts. */
    poster?: string;
    /**
     * Width ÷ height of the source clip, when the sender recorded it on the
     * attachment (Stream's `original_width` / `original_height`). Preferred over
     * measuring the poster, because it is known before any image loads and works
     * for a clip that has no poster at all — the case that otherwise leaves a
     * portrait video in a square or landscape box. Absent on anything sent
     * before the composer began writing it (MES-1353).
     */
    naturalAspectRatio?: number;
    /** Optional MIME type (e.g. `video/mp4`). */
    mimeType?: string;
    /**
     * Per-item override for the `<video preload>` hint. Defaults to the
     * parent attachment's `preload` value (which itself defaults to
     * `'none'` so the poster carries the visual weight and no video
     * bytes are fetched until playback).
     */
    preload?: MediaPreloadMode;
}

export declare type MessageAttachmentVideoReceivedProps = VideoAttachmentSharedProps;

export declare type MessageAttachmentVideoSentProps = VideoAttachmentSharedProps;

/**
 * A dumb, context-free chat message bubble for rendering a single message row
 * *outside* a live channel — previews, digests, confirmation dialogs, the
 * Stacks "responded" summary, etc. Unlike `ChannelView`, it needs no Stream
 * client or provider.
 *
 * Render `MessageBubble.Sent` for the sender's own treatment (dark, right
 * tail) and `MessageBubble.Received` for the recipient's (light, left tail,
 * optional header). Surface colours, radius, typography, and the tail
 * silhouette are shared with the in-channel bubble drawn by `CustomMessage`,
 * so previews stay pixel-identical and re-theme from one source of truth.
 *
 * The variant is a **visual treatment, not an authorship claim**: to preview
 * an outgoing message as the recipient will see it, render
 * `MessageBubble.Received` with your own text.
 */
export declare const MessageBubble: {
    Sent: FC<SentBubbleProps>;
    Received: FC<ReceivedBubbleProps>;
};

export declare interface MessageBubbleBaseProps {
    /**
     * Message body. Rendered verbatim with `whitespace-pre-wrap` (newlines
     * preserved); this is a dumb component, so no markdown / link parsing.
     */
    text: string;
    /**
     * Draw the bubble tail at the bottom corner. `sent` tails point
     * bottom-right, `received` bottom-left. Defaults to `true`.
     */
    tail?: boolean;
    /**
     * Extra classes on the outer bubble. Width is caller-controlled: pass
     * `w-fit` to hug the text (chat/preview) or `w-full` to fill the container
     * (card-like list rows). With no width class the bubble fills its
     * container. Also where you'd set `max-w-[…]`.
     */
    className?: string;
}

/**
 * Which visual treatment the bubble paints. This is decoupled from message
 * *authorship*: it selects a side + colour, not who wrote the text. To preview
 * an outgoing message as the recipient will see it (e.g. a bulk-reply
 * confirmation), render the `received` treatment with your own text.
 */
export declare type MessageBubbleVariant = 'sent' | 'received';

/**
 * Callback invoked when a user clicks a link inside the channel view.
 * Receives the clicked URL and, when resolvable, the message the link
 * was rendered in (so consumers can filter on sender or metadata).
 * `message` is `undefined` when the click happens on a link outside a
 * resolvable message wrapper. Fires alongside the native navigation,
 * not in place of it.
 */
export declare type MessageLinkClickHandler = (url: string, message: LocalMessage | undefined) => void;

export declare interface MessageMetadata {
    custom_type?: MessageCustomType;
    listing_id?: string;
    amount_text?: string;
    payment_status?: PaymentStatus;
    attachment_title?: string;
    attachment_content_type?: 'text' | 'media';
    attachment_mime_type?: string;
    attachment_thumbnail?: string;
    attachment_detail?: string;
    /**
     * The client surface a linker send was composed from, when it needs to be
     * distinguished server-side. A plain reply carries no `sent_from`; a single
     * reply composed inside stack-detail channel mode sets `'stack_detail'` so the
     * backend can leave stack removal confirm-gated (client-owned) instead of
     * silently removing the conversation from its stack. Composes with
     * `custom_type` — it identifies the send context, not the message kind. (MES-1266)
     */
    sent_from?: 'stack_detail';
    /**
     * Opaque outbound record id on automation messages. The Stream wire field is
     * `outbound_id`; resolver APIs name this value `outboundRecordId` explicitly.
     */
    outbound_id?: string;
}

declare type MessageWithI18n = Pick<LocalMessage, 'text'> & {
    i18n?: Record<string, string> | null;
};

/**
 * Messaging capabilities configuration
 */
export declare interface MessagingCapabilities {
    /**
     * Show the "Delete Conversation" button in channel info dialog.
     * Defaults to true for backward compatibility.
     */
    showDeleteConversation?: boolean;
}

/**
 * Context value for messaging state and service
 */
declare interface MessagingContextValue {
    service: StreamChatService | null;
    client: StreamChat | null;
    isConnected: boolean;
    isLoading: boolean;
    error: string | null;
    capabilities: MessagingCapabilities;
    refreshConnection: () => Promise<void>;
    debug: boolean;
}

/**
 * Provides the resolved logger sink to the messaging subtree. Rendered by
 * `MessagingProvider`; usable standalone in tests or in a subtree that needs a
 * different sink.
 */
export declare const MessagingLoggerProvider: default_2.FC<{
    logger?: Logger;
    children: default_2.ReactNode;
}>;

/**
 * Provider component that wraps messaging-core with React state management
 */
export declare const MessagingProvider: default_2.FC<MessagingProviderProps>;

/**
 * apiKey mode: the provider builds its own Stream client from `apiKey` and owns
 * the connect/disconnect lifecycle. Both fields are required so a non-injected
 * consumer cannot compile a provider that never connects.
 */
declare interface MessagingProviderApiKeyProps extends MessagingProviderBaseProps {
    client?: undefined;
    apiKey: string;
    serviceConfig: Omit<StreamChatServiceConfig, 'apiKey'>;
}

declare interface MessagingProviderBaseProps {
    children: React.ReactNode;
    user: MessagingUser | null;
    capabilities?: MessagingCapabilities;
    debug?: boolean;
    /**
     * Optional sink for the package's own log output. Levels left undefined fall
     * back to console, which is also the default when the prop is omitted. In
     * apiKey mode it is forwarded to the underlying StreamChatService unless
     * `serviceConfig.logger` is set, which wins.
     */
    logger?: Logger;
}

/**
 * Injected-client mode: the provider renders `<Chat>` against an
 * already-constructed Stream client and does NOT create a StreamChatService or
 * call `connectUser` — the caller owns the client's connection lifecycle. This
 * is the seam for offline/dev (`createMockMessagingClient` from
 * `@linktr.ee/messaging-react/testing`) and for tests, so consumers render the
 * real UI instead of forking it. `apiKey`/`serviceConfig` are not used here.
 */
declare interface MessagingProviderInjectedClientProps extends MessagingProviderBaseProps {
    client: StreamChat;
    apiKey?: never;
    serviceConfig?: never;
}

/**
 * MessagingProvider component props. Either an injected `client` (caller owns
 * the lifecycle) or an `apiKey` + `serviceConfig` (provider owns it) — never
 * neither.
 */
export declare type MessagingProviderProps = MessagingProviderInjectedClientProps | MessagingProviderApiKeyProps;

/**
 * Direct-conversation surface for one specific participant.
 *
 * Renders a single ChannelView for the channel between the connected user and
 * `initialParticipantFilter`. If no channel exists yet and
 * `initialParticipantData` is supplied, the configured StreamChatService
 * channel creator is invoked to create one.
 */
export declare const MessagingShell: default_2.FC<MessagingShellProps>;

/**
 * Main MessagingShell component props.
 *
 * MessagingShell renders a single direct conversation between the connected
 * user and `initialParticipantFilter`. It does not show a channel list — for
 * inbox-style surfaces, compose `<ChannelList>` and `<ChannelView>` directly.
 */
export declare interface MessagingShellProps extends ChannelViewPassthroughProps {
    capabilities?: MessagingCapabilities;
    onChannelSelect?: (channel: Channel) => void;
    /**
     * Fired when the user leaves the conversation or blocks the participant.
     * The consumer is responsible for what happens next — typically
     * unmounting MessagingShell, navigating away, or re-rendering with new
     * participant data. When omitted, the shell renders a "Conversation
     * ended" state rather than an indefinite spinner.
     */
    onExitConversation?: () => void;
    /**
     * UUID of the other participant for the direct conversation to render.
     *
     * If a channel with this participant already exists, it is auto-selected.
     * If no channel exists, supply `initialParticipantData` to auto-create one
     * via the configured StreamChatService channel creator.
     */
    initialParticipantFilter: string;
    /**
     * Participant data for auto-creating a channel when no channel exists yet
     * for `initialParticipantFilter`. When omitted, the shell renders an error
     * state ("No conversation found with this account") if the channel is
     * missing.
     *
     * This reuses the existing ChannelCreator from StreamChatServiceConfig.
     */
    initialParticipantData?: Participant;
}

export declare function normalizeLanguageCode(language?: string): string | undefined;

export { OfficialCtaActionKind }

export { OfficialCtaActionPayload }

/**
 * Structured attachment shape for server-authored Linktree official CTA cards.
 * The `action` payload type is owned by the taxonomy; the `Attachment &` shape
 * stays here because this package is the SDK-aware (stream-chat) layer.
 */
export declare type OfficialCtaAttachment = Attachment & {
    action?: OfficialCtaActionPayload;
    type: 'linktree_official_cta';
};

export declare function optimizeMessagingAttachmentUrl(url: string | undefined | null): string | undefined;

export declare type OutboundClickHandler = (outbound: ResolvedOutbound) => void;

export declare type OutboundResolver = (outboundRecordId: string) => ResolvedOutbound | undefined;

/**
 * Generic participant interface for different host environments
 */
export declare interface Participant {
    id: string;
    name: string;
    image?: string;
    username?: string;
    phone?: string;
    metadata?: Record<string, unknown>;
}

export declare type ParticipantDisplayUser = {
    id?: string;
    name?: string | null;
    username?: string | null;
};

/**
 * Message metadata for paid messaging and chatbot flows.
 * Used to identify message types and payment status.
 */
declare type PaymentStatus = 'pending' | 'paid' | 'failed' | 'refunded';

declare interface PdfAttachmentSharedProps extends MessageAttachmentBaseProps {
    /** Single PDF — convenience for the most common case. */
    src?: string;
    /** Filename — drives the row title + the meta line + the viewer dialog's accessible name. */
    filename?: string;
    /** File size in bytes — formatted into the `EXT · SIZE` meta line. */
    fileSize?: number;
    /**
     * Override displayed title (defaults to `filename`). Useful when a
     * sender re-titles a generated PDF before sending.
     */
    title?: string;
    /**
     * Stacked PDFs. Takes precedence over `src` when set. Each item
     * renders as its own row inside the bubble; clicking a row opens
     * that PDF in the viewer. Sent + Received only — the composer
     * surface accepts a single attachment at a time.
     */
    items?: MessageAttachmentPdfItem[];
    /**
     * Forwarded to the viewer trigger. When omitted the click still
     * opens the built-in `PdfViewer`. Supply this to fire analytics, or
     * return `false` to intercept the open (e.g. swap to a route-based
     * viewer / confirmation modal). Any other return value (including
     * `void`/`undefined`) lets the built-in viewer open. For stacked
     * attachments the `index` argument identifies the row.
     */
    onClick?: (index: number) => boolean | void;
}

declare type PreviewProps = MediaCardPreviewProps & {
    /** Drafting is always the sender — doesn't apply here. */
    isMine?: never;
    /**
     * "text" renders as a chat bubble instead of a media thumbnail card.
     * Media-only fields below are ignored in text mode. Defaults to `"media"`.
     */
    contentType?: 'text' | 'media';
};

export declare interface ReceivedBubbleProps extends MessageBubbleBaseProps {
    /**
     * Optional header rendered above the text inside the bubble — used by the
     * Stacks message list to show the sender's name. Omit for a plain bubble.
     */
    header?: default_2.ReactNode;
}

/**
 * Resolves the member to display as the conversation's "other party".
 *
 * For a normal 1:1 channel this is the member that isn't the current user. The
 * official channel is special: its display identity is always the official
 * sender ("Linktree"), regardless of who is viewing. That matters because an
 * unverified sensitive linker reads the official channel as a guest whose
 * random Stream id isn't a member, so the "not me" heuristic would otherwise
 * fall back to the linker's own member and show their name instead of Linktree.
 */
export declare function resolveConversationParticipant(members: ChannelMembers | undefined, currentUserId: string | undefined, channelType: string | undefined): ChannelMember | undefined;

export declare type ResolvedOutbound = {
    /** Automation id referenced by the outbound record. */
    id: string;
    name?: string;
};

/**
 * Resolves a human-readable participant label from Stream user fields.
 * Never falls back to user.id. UUID-like names are treated as missing.
 */
export declare function resolveParticipantDisplayName(user?: ParticipantDisplayUser | null): string;

/**
 * The generic rich message card (`linktree_rich_card`) — the shared render
 * primitive for rich message surfaces. Render `RichCard.Sent` for the sender's
 * own copy (dark chrome) and `RichCard.Received` in the recipient's thread
 * (light chrome). The official welcome card and broadcast link/collection cards
 * are all this one card at different knobs:
 *
 *   - `hero` + `primary` action → the official welcome card (stacked button)
 *   - `hero` + `secondary` action → a single-link broadcast (inline button)
 *   - `fan` + `secondary` action → a collection broadcast
 *
 * A standalone renderer, not tied to Stream's `Attachment`: the dispatching
 * consumer narrows an attachment with the taxonomy's `isRichCard`, then maps
 * the taxonomy `RichCard` fields onto these props (resolving each action's
 * `kind` to an `href` / `onClick`).
 */
export declare const RichCard: {
    Sent: default_2.FC<RichCardBaseProps>;
    Received: default_2.FC<RichCardBaseProps>;
};

/**
 * A single footer action button — the **presentational** half of a taxonomy
 * `RichCardAction`. The dispatching consumer resolves the action's `kind` to a
 * behaviour before handing it here: `open_external_url` → `href`; a `launch_*`
 * / `post_to_socials` kind → an `onClick` that opens its client surface. A kind
 * the consumer does not recognise is dropped (no button) rather than mapped, so
 * the card stands on its own image/title/subtitle — exactly the taxonomy's
 * unknown-kind rule.
 */
export declare interface RichCardActionButton {
    label: string;
    /** Renders the button as an `<a target="_blank">` (for `open_external_url`). */
    href?: string;
    /** Called on activation (in addition to `href` navigation when both are set). */
    onClick?: () => void;
    /**
     * Button emphasis. The **first** action's variant drives the footer layout:
     * `primary` → a stacked full-width button below the copy; `secondary` → a row
     * in the chin with the copy on the left and the action pinned right. Defaults
     * to `primary`.
     */
    variant?: 'primary' | 'secondary';
}

/**
 * Shared props for the `RichCard.*` variants (Sent, Received). The generic
 * rich message card: a `hero` or `fan` image region, a title + subtitle, and a
 * `variant`-driven footer of action buttons. The official welcome card and
 * broadcast link/collection cards are all this one card at different knobs.
 */
export declare interface RichCardBaseProps {
    title?: string;
    /** Subtitle / body copy — the base attachment's `text`. */
    subtitle?: string;
    /**
     * Max lines the subtitle wraps before clamping. Defaults to `3` — rich cards
     * carry prose, unlike the single-line link-preview default.
     */
    subtitleLines?: number;
    /** SAFE public thumbnail URLs. `hero` shows the first; `fan` shows up to 3. */
    images?: string[];
    /**
     * Image layout. Defaults from {@link images} length (≤1 → `hero`, ≥2 →
     * `fan`) via the taxonomy's `resolveRichCardImagePresentation`.
     */
    imagePresentation?: RichCardImagePresentation;
    /**
     * Footer actions. Empty / absent → no footer. Clients pass one today; the
     * shape is future-proof for several.
     */
    actions?: RichCardActionButton[];
    /** Optional 16×16 brand badge rendered before the title. */
    appIcon?: default_2.ReactNode;
    /**
     * Dominant colour of the hero image (`#RRGGBB` or bare hex), painted as the
     * card + tail surface. Only applied for a single on-screen `hero` image (a
     * `fan` card keeps the plain fill) — the same gate LinkAttachment uses.
     */
    accentColor?: string;
    /**
     * Position of this card inside its same-author run. `'single'` / `'end'`
     * paint the accent-coloured bubble tail; `'first'` / `'middle'` omit it.
     * Defaults to `'single'`.
     */
    groupPosition?: MessageAttachmentGroupPosition;
}

export { RichCardImagePresentation }

export declare type RichCardReceivedCardProps = RichCardBaseProps;

/** Props for `RichCard.Sent` / `RichCard.Received`. */
export declare type RichCardSentCardProps = RichCardBaseProps;

export declare interface SentBubbleProps extends MessageBubbleBaseProps {
}

declare type SentMediaOtherProps = MediaCardOtherProps & {
    contentType?: 'media';
};

declare type SentMediaOwnProps = MediaCardOwnProps & {
    contentType?: 'media';
    /** Sender's view has no unlock/download flow — doesn't apply here. */
    onUnlockClick?: never;
    isUnlocking?: never;
    onDownloadClick?: never;
};

declare type SentTextOtherProps = TextCardOtherProps & {
    contentType: 'text';
};

declare type SentTextOwnProps = TextCardOwnProps & {
    contentType: 'text';
    /** Sender's view has no unlock flow — doesn't apply here. */
    onUnlockClick?: never;
    isUnlocking?: never;
};

declare interface TextCardBaseProps {
    /** Amount label. */
    amountText?: string;
}

declare type TextCardOtherProps = TextCardSentBaseProps & {
    /** Recipient's view. */
    isMine: false;
    /** Spinner on Unlock while checkout runs. */
    isUnlocking?: boolean;
    /** Opens checkout on click. Omit to hide the button. */
    onUnlockClick?: () => void;
};

declare type TextCardOwnProps = TextCardSentBaseProps & {
    /** Sender's own view. */
    isMine: true;
};

declare interface TextCardSentBaseProps extends TextCardBaseProps {
    /** False once sent. */
    isDraft?: false;
    isPreview?: false;
    /** Revealed content once paid. */
    renderedText?: default_2.ReactNode;
    /** Drives the lock/skeleton/badge state. */
    paymentStatus?: PaymentStatus;
}

/** Tip pill — the gift-emoji bubble a tip message attaches, with or without accompanying text */
export declare const TipMessage: ({ message }: {
    message: LocalMessage;
}) => JSX_2.Element | null;

/**
 * Read the composer's locked (frozen-channel) state from inside a custom
 * composer supplied via `composerInput`. Returns true when the channel is
 * frozen; mirror the default composer by rendering the textarea read-only and
 * disabling the send control.
 */
export declare const useComposerLocked: () => boolean;

export declare function useCustomMessage<K extends keyof CustomMessageRegistry>(key: K): CustomMessageRegistry[K];

/**
 * Hook to access messaging service and state
 */
export declare const useMessaging: () => MessagingContextValue;

/**
 * The logger sink for the current subtree. Falls back to console when no
 * provider (or no `logger` prop) is present, so call sites never branch.
 */
export declare const useMessagingLogger: () => Required<Logger>;

declare interface VideoAttachmentSharedProps extends MessageAttachmentBaseProps {
    /** Single video — convenience for the most common case. */
    src?: string;
    /** Poster image — preview shown before playback starts. */
    poster?: string;
    /**
     * Width ÷ height of the source clip. See `VideoItem.naturalAspectRatio` —
     * this is the single-`src` convenience form of the same thing, and is what
     * lets a posterless portrait clip size itself correctly (MES-1353).
     */
    naturalAspectRatio?: number;
    /** MIME type hint — typed onto the inline `<source>` element. */
    mimeType?: string;
    /** Filename used as the viewer dialog's accessible name. */
    filename?: string;
    /**
     * Stacked videos. Takes precedence over `src` when set. Renders a
     * 1 / 2 / 3 / 4-tile grid (5+ collapse into a `+N` overflow tile).
     * Sent + Received only — the composer surface intentionally accepts
     * a single attachment at a time.
     */
    items?: MessageAttachmentVideoItem[];
    /**
     * `<video preload>` hint forwarded into the viewer. Defaults to
     * `'none'` — the poster `<img>` carries the visual weight on the
     * bubble surface, and we shouldn't fetch any video bytes until the
     * user actually opens the viewer. Per-item overrides live on
     * `VideoItem.preload`. The opened `VideoViewer` always preloads
     * metadata for the active item (so duration / first-frame appear
     * immediately) regardless of this value.
     */
    preload?: MediaPreloadMode;
    /**
     * Forwarded to the viewer trigger. When omitted the click still
     * opens the built-in `VideoViewer` — supply this for analytics, or
     * return `false` to intercept the open (e.g. switch to a route-
     * based player / confirmation modal). Any other return value
     * (including `void`/`undefined`) lets the built-in viewer open.
     * For stacked attachments the `index` argument identifies the tile.
     */
    onClick?: (index: number) => boolean | void;
}

export { }


declare module 'stream-chat' {
    interface CustomAttachmentData extends LinktreeAttachmentData {
        /**
         * Dominant colour of the attachment's image, `#RRGGBB`, resolved by the
         * sender at stage time and persisted on the attachment so every viewer —
         * and every later render of the same message — paints an identical chin
         * without re-extracting. Absent on messages sent before MES-1349.
         */
        accent_color?: string;
    }
    interface CustomChannelData extends LinktreeChannelData {
        /**
         * Whether DM agent auto-replies are paused for this channel. Writer-only
         * field not read by other clients, so it stays local rather than in the
         * shared {@link LinktreeChannelData} contract.
         */
        chatbot_paused?: boolean;
    }
    interface CustomMemberData {
        /**
         * Whether this member follows the channel's linker account.
         */
        is_follower?: boolean;
    }
    interface CustomMessageData extends LinktreeMessageData {
        /**
         * Message metadata from backend.
         * Contains type and payment information.
         */
        metadata?: MessageMetadata;
        /**
         * DM Agent-specific system message type.
         * Used as a fallback when metadata.custom_type is not available.
         */
        dm_agent_system_type?: DmAgentSystemType;
    }
}