@mantine-vue/whatsapp-inbox 3.2.0

package/lib/components/WhatsAppInteractiveMessageEditor/WhatsAppInteractiveMessageEditor.types.d.ts

@@ -0,0 +1,49 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppInteractiveContent, WhatsAppInteractiveType } from '../../types';
+export type WhatsAppInteractiveMessageEditorStylesNames = 'interactiveEditorRoot' | 'interactiveEditorSection' | 'interactiveEditorSectionTitle' | 'interactiveEditorRow' | 'interactiveEditorItem' | 'interactiveEditorFooter';
+export interface WhatsAppInteractiveMessageEditorOwnProps extends StylesApiProps<WhatsAppInteractiveMessageEditorFactory> {
+    /** Controlled draft. Always a well-formed `WhatsAppInteractiveContent`. */
+    modelValue?: WhatsAppInteractiveContent;
+    /** Uncontrolled initial draft. */
+    defaultValue?: WhatsAppInteractiveContent;
+    /**
+     * Interactive types the provider supports, from the conversation capabilities. The type
+     * selector is hidden when only one is available, and the editor renders nothing when the
+     * list is empty.
+     * @default ['button']
+     */
+    interactiveTypes?: WhatsAppInteractiveType[];
+    /**
+     * Largest number of reply buttons a message may carry.
+     * @default 3
+     */
+    maxButtons?: number;
+    /**
+     * Largest number of rows a list section may carry.
+     * @default 10
+     */
+    maxRowsPerSection?: number;
+    /** Disables every control. */
+    disabled?: boolean;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppInteractiveMessageEditorProps extends Omit<BoxProps, keyof WhatsAppInteractiveMessageEditorOwnProps>, WhatsAppInteractiveMessageEditorOwnProps {
+}
+export interface WhatsAppInteractiveMessageEditorEmits {
+    /** Emitted whenever the draft changes. */
+    'update:modelValue': [value: WhatsAppInteractiveContent];
+    /** Emitted when the draft passes validation and should be sent. */
+    submit: [value: WhatsAppInteractiveContent];
+    /** Emitted when the cancel action is used. */
+    cancel: [];
+}
+export type WhatsAppInteractiveMessageEditorFactory = Factory<{
+    props: Omit<WhatsAppInteractiveMessageEditorProps, 'rootRef'>;
+    emits: WhatsAppInteractiveMessageEditorEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppInteractiveMessageEditorStylesNames;
+}>;

package/lib/components/WhatsAppInteractiveMessageEditor/WhatsAppInteractiveMessageEditor.vue.d.ts

@@ -0,0 +1,27 @@
+import type { WhatsAppInteractiveMessageEditorOwnProps } from './WhatsAppInteractiveMessageEditor.types';
+import type { WhatsAppInteractiveContent, WhatsAppInteractiveType } from '../../types';
+declare const defaultProps: {
+    readonly maxButtons: 3;
+    readonly maxRowsPerSection: 10;
+    readonly disabled: false;
+};
+/**
+ * A fresh, well-formed draft of the given type.
+ *
+ * The draft is always a valid `WhatsAppInteractiveContent`, never a loose bag of fields: the
+ * `v-model` a consumer binds is the same discriminated union the message would be sent with, so
+ * there is nothing to translate on submit.
+ */
+declare function createInteractiveDraft(type: WhatsAppInteractiveType, previous?: WhatsAppInteractiveContent): WhatsAppInteractiveContent;
+export { createInteractiveDraft, defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<WhatsAppInteractiveMessageEditorOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    submit: (value: WhatsAppInteractiveContent) => any;
+    "update:modelValue": (value: WhatsAppInteractiveContent) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppInteractiveMessageEditorOwnProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onSubmit?: ((value: WhatsAppInteractiveContent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: WhatsAppInteractiveContent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/lib/components/WhatsAppInteractiveMessageEditor/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppInteractiveMessageEditor';

package/lib/components/WhatsAppMediaAttachment/WhatsAppMediaAttachment.d.ts

@@ -0,0 +1,8 @@
+export declare const WhatsAppMediaAttachment: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMediaAttachment.types").WhatsAppMediaAttachmentProps, "rootRef">;
+    emits: import("./WhatsAppMediaAttachment.types").WhatsAppMediaAttachmentEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppMediaAttachment.types").WhatsAppMediaAttachmentStylesNames;
+}>;
+export type { WhatsAppMediaAttachmentEmits, WhatsAppMediaAttachmentFactory, WhatsAppMediaAttachmentOwnProps, WhatsAppMediaAttachmentProps, WhatsAppMediaAttachmentStylesNames, } from './WhatsAppMediaAttachment.types';

package/lib/components/WhatsAppMediaAttachment/WhatsAppMediaAttachment.types.d.ts

@@ -0,0 +1,41 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppAttachment, WhatsAppMessageDirection } from '../../types';
+export type WhatsAppMediaAttachmentStylesNames = 'mediaRoot' | 'mediaImage' | 'mediaVideo' | 'mediaAudio' | 'mediaImageControl' | 'mediaDocument' | 'mediaDocumentIcon' | 'mediaDocumentBody' | 'mediaDocumentName' | 'mediaDocumentMeta' | 'mediaAction' | 'mediaFallback';
+export interface WhatsAppMediaAttachmentOwnProps extends StylesApiProps<WhatsAppMediaAttachmentFactory> {
+    /** Attachment to render. `mediaType` picks the renderer. */
+    attachment: WhatsAppAttachment;
+    /** Direction of the message the attachment belongs to, used for the document styling. */
+    direction?: WhatsAppMessageDirection;
+    /**
+     * Whether the download action is rendered for documents and media.
+     * @default true
+     */
+    withDownload?: boolean;
+    /**
+     * Whether images and videos render their own player or preview.
+     * Turn this off to render a compact document-style row for every media type.
+     * @default true
+     */
+    withPreview?: boolean;
+    /** Largest width of an image or video, any valid CSS length. */
+    maxWidth?: string | number;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppMediaAttachmentProps extends Omit<BoxProps, keyof WhatsAppMediaAttachmentOwnProps>, WhatsAppMediaAttachmentOwnProps {
+}
+export interface WhatsAppMediaAttachmentEmits {
+    /** Emitted when the download action is used. The default link behaviour still runs. */
+    download: [attachment: WhatsAppAttachment];
+    /** Emitted when an image or a sticker is activated, for consumers with a lightbox. */
+    preview: [attachment: WhatsAppAttachment];
+}
+export type WhatsAppMediaAttachmentFactory = Factory<{
+    props: Omit<WhatsAppMediaAttachmentProps, 'rootRef'>;
+    emits: WhatsAppMediaAttachmentEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppMediaAttachmentStylesNames;
+}>;

package/lib/components/WhatsAppMediaAttachment/WhatsAppMediaAttachment.vue.d.ts

@@ -0,0 +1,19 @@
+import type { WhatsAppMediaAttachmentOwnProps } from './WhatsAppMediaAttachment.types';
+import type { WhatsAppIconName } from '../../icons';
+import type { WhatsAppMediaType } from '../../types';
+declare const defaultProps: {
+    readonly withDownload: true;
+    readonly withPreview: true;
+};
+declare const MEDIA_ICONS: Record<WhatsAppMediaType, WhatsAppIconName>;
+declare const varsResolver: (theme: import("@mantine-vue/core").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+export { defaultProps, MEDIA_ICONS, varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<WhatsAppMediaAttachmentOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    preview: (attachment: import("../..").WhatsAppAttachment) => any;
+    download: (attachment: import("../..").WhatsAppAttachment) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppMediaAttachmentOwnProps> & Readonly<{
+    onPreview?: ((attachment: import("../..").WhatsAppAttachment) => any) | undefined;
+    onDownload?: ((attachment: import("../..").WhatsAppAttachment) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/lib/components/WhatsAppMediaAttachment/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppMediaAttachment';

package/lib/components/WhatsAppMessage/WhatsAppMessage.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppMessage: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMessage.types").WhatsAppMessageProps, "rootRef">;
+    slots: import("../../component-props.js").WhatsAppMessageSlots;
+    emits: import("./WhatsAppMessage.types").WhatsAppMessageEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppMessage.types").WhatsAppMessageStylesNames;
+}>;
+export type { WhatsAppMessageEmits, WhatsAppMessageFactory, WhatsAppMessageOwnProps, WhatsAppMessageProps, WhatsAppMessageStylesNames, } from './WhatsAppMessage.types';

package/lib/components/WhatsAppMessage/WhatsAppMessage.types.d.ts

@@ -0,0 +1,46 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { MessageRenderers, WhatsAppMessageSlots } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppAttachment, WhatsAppMessageData } from '../../types';
+import type { WhatsAppMediaAttachmentStylesNames } from '../WhatsAppMediaAttachment';
+import type { WhatsAppMessageBubbleStylesNames } from '../WhatsAppMessageBubble';
+import type { WhatsAppTemplatePreviewStylesNames } from '../WhatsAppTemplatePreview';
+export type WhatsAppMessageStylesNames = 'messageRoot' | 'messageInteractive' | 'messageInteractiveBody' | 'messageInteractiveFooter' | 'messageInteractiveButtons' | 'messageInteractiveButton' | 'messageInteractiveReply' | 'messageCaption' | 'messageLocation' | 'messageLocationName' | 'messageLocationAddress' | 'messageContactCard' | 'messageContactName' | 'messageContactDetail' | 'messageUnsupported' | WhatsAppMessageBubbleStylesNames | WhatsAppMediaAttachmentStylesNames | WhatsAppTemplatePreviewStylesNames;
+export interface WhatsAppMessageOwnProps extends StylesApiProps<WhatsAppMessageFactory>, MessageRenderers {
+    /** Message to render. Its `type` picks the content renderer. */
+    message: WhatsAppMessageData;
+    /**
+     * Whether a failed message offers a retry action. Comes from the conversation capabilities
+     * when the message is rendered inside a `WhatsAppConversation`.
+     * @default true
+     */
+    withRetry?: boolean;
+    /**
+     * Draws the bubble tail. Turned off for the middle of a run of messages from the same side.
+     * @default true
+     */
+    withTail?: boolean;
+    /** Largest width of the bubble, any valid CSS length. */
+    maxWidth?: string | number;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppMessageProps extends Omit<BoxProps, keyof WhatsAppMessageOwnProps>, WhatsAppMessageOwnProps {
+}
+export interface WhatsAppMessageEmits {
+    /** Emitted when the retry action of a failed message is used. */
+    retry: [message: WhatsAppMessageData];
+    /** Emitted when the download action of an attachment is used. */
+    mediaDownload: [attachment: WhatsAppAttachment, message: WhatsAppMessageData];
+    /** Emitted when an image or sticker is activated, for consumers with a lightbox. */
+    mediaPreview: [attachment: WhatsAppAttachment, message: WhatsAppMessageData];
+}
+export type WhatsAppMessageFactory = Factory<{
+    props: Omit<WhatsAppMessageProps, 'rootRef'>;
+    slots: WhatsAppMessageSlots;
+    emits: WhatsAppMessageEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppMessageStylesNames;
+}>;

package/lib/components/WhatsAppMessage/WhatsAppMessage.vue.d.ts

@@ -0,0 +1,25 @@
+import type { WhatsAppMessageSlots } from '../../component-props';
+import type { WhatsAppAttachment } from '../../types';
+import type { WhatsAppMessageOwnProps } from './WhatsAppMessage.types';
+declare const defaultProps: {
+    readonly withRetry: true;
+    readonly withTail: true;
+};
+declare const MEDIA_TYPES: readonly ["image", "video", "audio", "document", "sticker"];
+export { defaultProps, MEDIA_TYPES };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppMessageOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: (message: import("../..").WhatsAppMessageData) => any;
+    mediaDownload: (attachment: WhatsAppAttachment, message: import("../..").WhatsAppMessageData) => any;
+    mediaPreview: (attachment: WhatsAppAttachment, message: import("../..").WhatsAppMessageData) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppMessageOwnProps> & Readonly<{
+    onRetry?: ((message: import("../..").WhatsAppMessageData) => any) | undefined;
+    onMediaDownload?: ((attachment: WhatsAppAttachment, message: import("../..").WhatsAppMessageData) => any) | undefined;
+    onMediaPreview?: ((attachment: WhatsAppAttachment, message: import("../..").WhatsAppMessageData) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppMessageSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/WhatsAppMessage/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppMessage';

package/lib/components/WhatsAppMessageBubble/WhatsAppMessageBubble.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppMessageBubble: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMessageBubble.types").WhatsAppMessageBubbleProps, "rootRef">;
+    slots: import("./WhatsAppMessageBubble.types").WhatsAppMessageBubbleSlots;
+    emits: import("./WhatsAppMessageBubble.types").WhatsAppMessageBubbleEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppMessageBubble.types").WhatsAppMessageBubbleStylesNames;
+}>;
+export type { WhatsAppMessageBubbleEmits, WhatsAppMessageBubbleFactory, WhatsAppMessageBubbleOwnProps, WhatsAppMessageBubbleProps, WhatsAppMessageBubbleSlots, WhatsAppMessageBubbleStylesNames, WhatsAppMessageBubbleVariant, } from './WhatsAppMessageBubble.types';

package/lib/components/WhatsAppMessageBubble/WhatsAppMessageBubble.types.d.ts

@@ -0,0 +1,77 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory, MantineRadius } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppMessageAuthor, WhatsAppMessageDirection, WhatsAppMessageError, WhatsAppMessageReference, WhatsAppDeliveryStatus, WhatsAppReaction, WhatsAppTimestamp } from '../../types';
+export type WhatsAppMessageBubbleStylesNames = 'bubbleRoot' | 'bubble' | 'bubbleAuthor' | 'bubbleQuote' | 'bubbleQuoteAuthor' | 'bubbleQuoteText' | 'bubbleForwarded' | 'bubbleContent' | 'bubbleFooter' | 'bubbleTime' | 'bubbleStatus' | 'bubbleError' | 'bubbleErrorText' | 'bubbleRetry' | 'bubbleReactions' | 'bubbleReaction' | 'systemMessage';
+/** How the bubble is laid out. `system` renders centred text without a bubble. */
+export type WhatsAppMessageBubbleVariant = 'bubble' | 'system';
+export interface WhatsAppMessageBubbleOwnProps extends StylesApiProps<WhatsAppMessageBubbleFactory> {
+    /** Side the bubble is aligned to and colour it uses. */
+    direction: WhatsAppMessageDirection;
+    /**
+     * Layout of the bubble.
+     * @default 'bubble'
+     */
+    variant?: WhatsAppMessageBubbleVariant;
+    /** Delivery state rendered in the footer. */
+    status?: WhatsAppDeliveryStatus;
+    /** Time rendered in the footer. */
+    timestamp?: WhatsAppTimestamp;
+    /** Agent who sent the message, rendered above the content in shared inboxes. */
+    author?: WhatsAppMessageAuthor;
+    /** Quoted message rendered above the content. */
+    replyTo?: WhatsAppMessageReference;
+    /** Renders the forwarded marker. */
+    forwarded?: boolean;
+    /** Failure details rendered under the bubble, with a retry action when retryable. */
+    error?: WhatsAppMessageError;
+    /**
+     * Whether the retry action may be rendered at all. Comes from the conversation capabilities.
+     * @default true
+     */
+    withRetry?: boolean;
+    /** Reactions rendered under the bubble. */
+    reactions?: WhatsAppReaction[];
+    /**
+     * Draws the small tail on the first bubble of a run.
+     * @default true
+     */
+    withTail?: boolean;
+    /**
+     * Key of `theme.radius` or any valid CSS value to set `border-radius`.
+     * @default 'lg'
+     */
+    radius?: MantineRadius;
+    /**
+     * Largest width of the bubble, any valid CSS length.
+     * @default '75%'
+     */
+    maxWidth?: string | number;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppMessageBubbleProps extends Omit<BoxProps, keyof WhatsAppMessageBubbleOwnProps>, WhatsAppMessageBubbleOwnProps {
+}
+export interface WhatsAppMessageBubbleSlots {
+    /** Content of the bubble. */
+    default?: () => VNodeChild;
+    /** Rendered inside the bubble, between the content and the timestamp row. */
+    footer?: () => VNodeChild;
+    /** Replaces the quoted message block. */
+    quote?: (props: {
+        replyTo: WhatsAppMessageReference;
+    }) => VNodeChild;
+}
+export interface WhatsAppMessageBubbleEmits {
+    /** Emitted when the retry action of a failed message is used. */
+    retry: [];
+}
+export type WhatsAppMessageBubbleFactory = Factory<{
+    props: Omit<WhatsAppMessageBubbleProps, 'rootRef'>;
+    slots: WhatsAppMessageBubbleSlots;
+    emits: WhatsAppMessageBubbleEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppMessageBubbleStylesNames;
+}>;

package/lib/components/WhatsAppMessageBubble/WhatsAppMessageBubble.vue.d.ts

@@ -0,0 +1,22 @@
+import type { WhatsAppMessageBubbleOwnProps, WhatsAppMessageBubbleSlots } from './WhatsAppMessageBubble.types';
+declare const defaultProps: {
+    readonly variant: "bubble";
+    readonly withTail: true;
+    readonly withRetry: true;
+    readonly radius: "lg";
+    readonly maxWidth: "75%";
+};
+declare const varsResolver: (theme: import("@mantine-vue/core").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+export { defaultProps, varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppMessageBubbleOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppMessageBubbleOwnProps> & Readonly<{
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppMessageBubbleSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/WhatsAppMessageBubble/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppMessageBubble';

package/lib/components/WhatsAppMessageList/WhatsAppMessageList.d.ts

@@ -0,0 +1,10 @@
+export declare const WhatsAppMessageList: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMessageList.types").WhatsAppMessageListProps, "rootRef">;
+    slots: import("./WhatsAppMessageList.types").WhatsAppMessageListSlots;
+    emits: import("./WhatsAppMessageList.types").WhatsAppMessageListEmits;
+    exposed: import("./WhatsAppMessageList.types").WhatsAppMessageListExposed;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppMessageList.types").WhatsAppMessageListStylesNames;
+}>;
+export type { WhatsAppMessageListEmits, WhatsAppMessageListExposed, WhatsAppMessageListFactory, WhatsAppMessageListOwnProps, WhatsAppMessageListProps, WhatsAppMessageListSlots, WhatsAppMessageListStylesNames, } from './WhatsAppMessageList.types';

package/lib/components/WhatsAppMessageList/WhatsAppMessageList.types.d.ts

@@ -0,0 +1,94 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { MessageRenderers, WhatsAppMessageSlots } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppAttachment, WhatsAppLoadMorePayload, WhatsAppMessageData, WhatsAppPaginationState } from '../../types';
+import type { WhatsAppMessageStylesNames } from '../WhatsAppMessage';
+export type WhatsAppMessageListStylesNames = 'messageListRoot' | 'messageListScrollArea' | 'messageListContent' | 'messageListItems' | 'messageListGroup' | 'messageListGroupItems' | 'messageListItem' | 'messageListDayDivider' | 'messageListDayLabel' | 'messageListLoadOlder' | 'messageListState' | 'messageListScrollToBottom' | WhatsAppMessageStylesNames;
+export interface WhatsAppMessageListSlots extends WhatsAppMessageSlots {
+    /** Replaces the empty state. */
+    emptyConversation?: () => import('vue').VNodeChild;
+    /** Replaces the initial loading state. */
+    loadingMessages?: () => import('vue').VNodeChild;
+    /** Replaces the error state. */
+    errorMessages?: (props: {
+        error: string;
+    }) => import('vue').VNodeChild;
+}
+export interface WhatsAppMessageListOwnProps extends StylesApiProps<WhatsAppMessageListFactory>, MessageRenderers {
+    /** Messages to render, in display order. The list never reorders them. */
+    messages?: WhatsAppMessageData[];
+    /**
+     * Conversation the messages belong to. Changing it resets the scroll position and the
+     * pending-messages counter, which is what makes switching conversations feel instant.
+     */
+    conversationId?: string;
+    /** Whether the initial message load is in flight. */
+    loading?: boolean;
+    /** Failure of the last load. Renders the error state with a retry action. */
+    error?: string | null;
+    /** Cursor state of the older-messages pagination. */
+    pagination?: WhatsAppPaginationState;
+    /**
+     * Whether failed messages offer a retry action. Falls back to the conversation capabilities.
+     */
+    withRetry?: boolean;
+    /**
+     * Renders a date divider before the first message of each day.
+     * @default true
+     */
+    withDayDividers?: boolean;
+    /**
+     * Scrolls to the newest message when one arrives, but only while the user is already at the
+     * bottom. Reading older messages is never interrupted.
+     * @default true
+     */
+    autoScroll?: boolean;
+    /**
+     * Distance in pixels from the bottom that still counts as "at the bottom".
+     * @default 80
+     */
+    autoScrollThreshold?: number;
+    /**
+     * Distance in pixels from the top at which `loadOlder` is emitted.
+     * @default 120
+     */
+    loadOlderThreshold?: number;
+    /** Largest width of a message bubble, any valid CSS length. */
+    bubbleMaxWidth?: string | number;
+    /** Props passed to the viewport element of the underlying `ScrollArea`. */
+    viewportProps?: Record<string, any>;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppMessageListProps extends Omit<BoxProps, keyof WhatsAppMessageListOwnProps>, WhatsAppMessageListOwnProps {
+}
+export interface WhatsAppMessageListEmits {
+    /** Emitted when the user scrolls near the top and older messages should be fetched. */
+    loadOlder: [payload: WhatsAppLoadMorePayload];
+    /** Emitted when the retry action of the error state is used. */
+    retryLoad: [];
+    /** Emitted when the retry action of a failed message is used. */
+    retryMessage: [message: WhatsAppMessageData];
+    /** Emitted when the download action of an attachment is used. */
+    mediaDownload: [attachment: WhatsAppAttachment, message: WhatsAppMessageData];
+    /** Emitted when an image or sticker is activated. */
+    mediaPreview: [attachment: WhatsAppAttachment, message: WhatsAppMessageData];
+    /** Emitted when the user reaches or leaves the bottom of the history. */
+    atBottomChange: [atBottom: boolean];
+}
+export interface WhatsAppMessageListExposed {
+    /** Scrolls the history to the newest message. */
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+    /** The scrollable viewport, for consumers that plug in their own virtualization. */
+    getViewport: () => HTMLElement | null;
+}
+export type WhatsAppMessageListFactory = Factory<{
+    props: Omit<WhatsAppMessageListProps, 'rootRef'>;
+    slots: WhatsAppMessageListSlots;
+    emits: WhatsAppMessageListEmits;
+    exposed: WhatsAppMessageListExposed;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppMessageListStylesNames;
+}>;

package/lib/components/WhatsAppMessageList/WhatsAppMessageList.vue.d.ts

@@ -0,0 +1,39 @@
+import type { WhatsAppMessageData } from '../../types';
+import type { WhatsAppMessageListOwnProps, WhatsAppMessageListSlots } from './WhatsAppMessageList.types';
+declare const defaultProps: {
+    readonly withDayDividers: true;
+    readonly autoScroll: true;
+    readonly autoScrollThreshold: 80;
+    readonly loadOlderThreshold: 120;
+};
+/**
+ * Marks the `ScrollArea` viewport so the list can find it again without depending on Mantine
+ * static classes, which a consumer can turn off.
+ */
+declare const VIEWPORT_ATTRIBUTE = "data-whatsapp-message-viewport";
+export { defaultProps, VIEWPORT_ATTRIBUTE };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppMessageListOwnProps, {
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+    getViewport: () => HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retryLoad: () => any;
+    mediaDownload: (attachment: import("../..").WhatsAppAttachment, message: WhatsAppMessageData) => any;
+    mediaPreview: (attachment: import("../..").WhatsAppAttachment, message: WhatsAppMessageData) => any;
+    loadOlder: (payload: import("../..").WhatsAppLoadMorePayload) => any;
+    retryMessage: (message: WhatsAppMessageData) => any;
+    atBottomChange: (atBottom: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppMessageListOwnProps> & Readonly<{
+    onRetryLoad?: (() => any) | undefined;
+    onMediaDownload?: ((attachment: import("../..").WhatsAppAttachment, message: WhatsAppMessageData) => any) | undefined;
+    onMediaPreview?: ((attachment: import("../..").WhatsAppAttachment, message: WhatsAppMessageData) => any) | undefined;
+    onLoadOlder?: ((payload: import("../..").WhatsAppLoadMorePayload) => any) | undefined;
+    onRetryMessage?: ((message: WhatsAppMessageData) => any) | undefined;
+    onAtBottomChange?: ((atBottom: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppMessageListSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/WhatsAppMessageList/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppMessageList';

package/lib/components/WhatsAppMessageStatus/WhatsAppMessageStatus.d.ts

@@ -0,0 +1,7 @@
+export declare const WhatsAppMessageStatus: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMessageStatus.types").WhatsAppMessageStatusProps, "rootRef">;
+    ref: HTMLSpanElement;
+    element: "span";
+    stylesNames: import("./WhatsAppMessageStatus.types").WhatsAppMessageStatusStylesNames;
+}>;
+export type { WhatsAppMessageStatusFactory, WhatsAppMessageStatusOwnProps, WhatsAppMessageStatusProps, WhatsAppMessageStatusStylesNames, } from './WhatsAppMessageStatus.types';

package/lib/components/WhatsAppMessageStatus/WhatsAppMessageStatus.types.d.ts

@@ -0,0 +1,30 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppDeliveryStatus as WhatsAppMessageStatusValue } from '../../types';
+export type WhatsAppMessageStatusStylesNames = 'statusRoot' | 'statusIcon' | 'statusLabel';
+export interface WhatsAppMessageStatusOwnProps extends StylesApiProps<WhatsAppMessageStatusFactory> {
+    /** Delivery state to render. Nothing is rendered when it is not set. */
+    status?: WhatsAppMessageStatusValue;
+    /**
+     * Also renders the state as text next to the icon. The text is always available to screen
+     * readers, so this only controls whether it is visible.
+     * @default false
+     */
+    withLabel?: boolean;
+    /**
+     * Icon size, any valid CSS length.
+     * @default '1em'
+     */
+    size?: string | number;
+    /** Label overrides, used for the state names. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppMessageStatusProps extends Omit<BoxProps, keyof WhatsAppMessageStatusOwnProps>, WhatsAppMessageStatusOwnProps {
+}
+export type WhatsAppMessageStatusFactory = Factory<{
+    props: Omit<WhatsAppMessageStatusProps, 'rootRef'>;
+    ref: HTMLSpanElement;
+    element: 'span';
+    stylesNames: WhatsAppMessageStatusStylesNames;
+}>;

package/lib/components/WhatsAppMessageStatus/WhatsAppMessageStatus.vue.d.ts

@@ -0,0 +1,24 @@
+import type { WhatsAppMessageStatusOwnProps } from './WhatsAppMessageStatus.types';
+import type { WhatsAppIconName } from '../../icons';
+import type { WhatsAppDeliveryStatus as WhatsAppMessageStatusValue } from '../../types';
+declare const defaultProps: {
+    readonly withLabel: false;
+    readonly size: "1em";
+};
+/**
+ * Each state gets its own glyph, not only its own colour: WhatsApp's own single/double tick
+ * distinction is the accessible part of the indicator, and the blue of `read` is decoration on
+ * top of it.
+ */
+declare const STATUS_ICONS: Record<WhatsAppMessageStatusValue, WhatsAppIconName>;
+declare const STATUS_LABEL_KEYS: {
+    readonly pending: "statusPending";
+    readonly sent: "statusSent";
+    readonly delivered: "statusDelivered";
+    readonly read: "statusRead";
+    readonly failed: "statusFailed";
+};
+export { defaultProps, STATUS_ICONS, STATUS_LABEL_KEYS };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<WhatsAppMessageStatusOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WhatsAppMessageStatusOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/lib/components/WhatsAppMessageStatus/index.d.ts

@@ -0,0 +1 @@
+export * from './WhatsAppMessageStatus';

package/lib/components/WhatsAppMessagingWindowNotice/WhatsAppMessagingWindowNotice.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppMessagingWindowNotice: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppMessagingWindowNotice.types").WhatsAppMessagingWindowNoticeProps, "rootRef">;
+    slots: import("./WhatsAppMessagingWindowNotice.types").WhatsAppMessagingWindowNoticeSlots;
+    emits: import("./WhatsAppMessagingWindowNotice.types").WhatsAppMessagingWindowNoticeEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppMessagingWindowNotice.types").WhatsAppMessagingWindowNoticeStylesNames;
+}>;
+export type { WhatsAppMessagingWindowNoticeEmits, WhatsAppMessagingWindowNoticeFactory, WhatsAppMessagingWindowNoticeOwnProps, WhatsAppMessagingWindowNoticeProps, WhatsAppMessagingWindowNoticeSlots, WhatsAppMessagingWindowNoticeStylesNames, } from './WhatsAppMessagingWindowNotice.types';