@mantine-vue/whatsapp-inbox 3.2.0

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

@@ -0,0 +1,163 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { ForwardedProps, MessageRenderers, WhatsAppConversationSlots } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppAttachment, WhatsAppAttachmentsAddPayload, WhatsAppConversationData, WhatsAppConversationCapabilities, WhatsAppDraftBehavior, WhatsAppLoadMorePayload, WhatsAppMessageData, WhatsAppMessageReference, WhatsAppOutgoingMessage, WhatsAppPaginationState, WhatsAppRejectedFile, WhatsAppTemplate, WhatsAppUpload } from '../../types';
+import type { WhatsAppComposerProps, WhatsAppComposerStylesNames } from '../WhatsAppComposer';
+import type { WhatsAppConversationHeaderProps, WhatsAppConversationHeaderStylesNames } from '../WhatsAppConversationHeader';
+import type { WhatsAppMessageListProps, WhatsAppMessageListStylesNames } from '../WhatsAppMessageList';
+export type WhatsAppConversationStylesNames = 'conversationRoot' | 'conversationState' | WhatsAppConversationHeaderStylesNames | WhatsAppMessageListStylesNames | WhatsAppComposerStylesNames;
+export interface WhatsAppConversationOwnProps extends StylesApiProps<WhatsAppConversationFactory>, MessageRenderers {
+    /** Conversation to show. Its `capabilities` drive the composer unless overridden. */
+    conversation?: WhatsAppConversationData;
+    /**
+     * Conversation the outgoing payloads are addressed to. Falls back to `conversation.id`, and
+     * is what makes the modal usable with nothing but an id and a message list.
+     */
+    conversationId?: string;
+    /** Overrides the capabilities of `conversation`. */
+    capabilities?: WhatsAppConversationCapabilities;
+    /** Messages of the conversation, in display order. */
+    messages?: WhatsAppMessageData[];
+    /** Whether the initial message load is in flight. */
+    messagesLoading?: boolean;
+    /** Failure of the last message load. */
+    messagesError?: string | null;
+    /** Cursor state of the older-messages pagination. */
+    messagesPagination?: WhatsAppPaginationState;
+    /** Attachments staged in the composer. */
+    uploads?: WhatsAppUpload[];
+    /** Approved templates offered by the composer. */
+    templates?: WhatsAppTemplate[];
+    /** Whether the template list is loading. */
+    templatesLoading?: boolean;
+    /** Failure of the last template load. */
+    templatesError?: string | null;
+    /**
+     * Controlled composer draft for a single conversation. When set it wins over `drafts`, which
+     * is what the modal and drawer use: they only ever show one conversation.
+     */
+    draft?: string;
+    /**
+     * Controlled drafts, keyed by conversation id. This is how an unsent message survives a switch
+     * to another conversation and is restored on return.
+     */
+    drafts?: Record<string, string>;
+    /** Uncontrolled initial drafts, keyed by conversation id. */
+    defaultDrafts?: Record<string, string>;
+    /**
+     * What happens to an unsent draft when the conversation changes.
+     *
+     * `preserve` keeps one draft per conversation and restores it on return. `reset` drops the
+     * draft of the conversation being left. Ignored while `draft` is controlled, since the
+     * consumer owns the value in that case.
+     *
+     * @default 'preserve'
+     */
+    draftBehavior?: WhatsAppDraftBehavior;
+    /** Whether a send is in flight. */
+    sending?: boolean;
+    /** Failure of the last send. */
+    sendError?: string | null;
+    /** Message the draft replies to. */
+    replyTo?: WhatsAppMessageReference | null;
+    /**
+     * Renders the conversation header.
+     * @default true
+     */
+    withHeader?: boolean;
+    /**
+     * Renders the composer.
+     * @default true
+     */
+    withComposer?: boolean;
+    /**
+     * Renders the back control in the header.
+     * @default false
+     */
+    withBack?: boolean;
+    /**
+     * Renders the contact panel toggle in the header.
+     * @default false
+     */
+    withContactToggle?: boolean;
+    /** Whether the contact panel is open, for the header toggle. */
+    contactPanelOpened?: boolean;
+    /**
+     * Moves focus to the composer when the conversation changes, so typing can start immediately
+     * after picking a conversation with the keyboard.
+     * @default true
+     */
+    focusComposerOnChange?: boolean;
+    /** Props passed to the underlying `WhatsAppConversationHeader`. */
+    headerProps?: ForwardedProps<WhatsAppConversationHeaderProps>;
+    /** Props passed to the underlying `WhatsAppMessageList`. */
+    messageListProps?: ForwardedProps<WhatsAppMessageListProps>;
+    /** Props passed to the underlying `WhatsAppComposer`. */
+    composerProps?: ForwardedProps<WhatsAppComposerProps>;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppConversationProps extends Omit<BoxProps, keyof WhatsAppConversationOwnProps>, WhatsAppConversationOwnProps {
+}
+export interface WhatsAppConversationEmits {
+    /** Emitted when the composer draft changes. */
+    'update:draft': [draft: string];
+    /** Emitted with the full draft map whenever a draft changes or is dropped. */
+    'update:drafts': [drafts: Record<string, string>];
+    /** Emitted when the reply target changes. */
+    'update:replyTo': [replyTo: WhatsAppMessageReference | null];
+    /** Emitted whenever the draft changes, for typing indicators. */
+    typing: [value: string];
+    /** Emitted when a message should be sent. */
+    send: [payload: WhatsAppOutgoingMessage];
+    /** Emitted with the files that passed validation, for the consumer to upload. */
+    attachmentsAdd: [payload: WhatsAppAttachmentsAddPayload];
+    /** Emitted when files were refused by the configured constraints. */
+    attachmentsReject: [rejected: WhatsAppRejectedFile[]];
+    /** Emitted when a staged attachment should be dropped. */
+    attachmentRemove: [upload: WhatsAppUpload];
+    /** Emitted when a failed upload should be retried. */
+    attachmentRetry: [upload: WhatsAppUpload];
+    /** Emitted when an in-flight upload should be aborted. */
+    attachmentCancel: [upload: WhatsAppUpload];
+    /** Emitted when the composer refuses to send. */
+    validationError: [message: string];
+    /** Emitted when the retry action of a send error is used. */
+    retrySend: [];
+    /** Emitted when the retry action of a template load error is used. */
+    templatesRetryLoad: [];
+    /** Emitted when older messages should be fetched. */
+    loadOlderMessages: [payload: WhatsAppLoadMorePayload];
+    /** Emitted when the retry action of the message-history error state is used. */
+    retryLoadMessages: [];
+    /** 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 header back control is used. */
+    back: [];
+    /** Emitted when the contact panel toggle is used. */
+    toggleContactPanel: [opened: boolean];
+    /** Emitted when the header contact is activated. */
+    contactClick: [conversation: WhatsAppConversationData];
+    /** Emitted when the user reaches or leaves the bottom of the history. */
+    atBottomChange: [atBottom: boolean];
+}
+export interface WhatsAppConversationExposed {
+    /** Moves focus to the composer input. */
+    focusComposer: () => void;
+    /** Scrolls the history to the newest message. */
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+export type WhatsAppConversationFactory = Factory<{
+    props: Omit<WhatsAppConversationProps, 'rootRef'>;
+    slots: WhatsAppConversationSlots;
+    emits: WhatsAppConversationEmits;
+    exposed: WhatsAppConversationExposed;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppConversationStylesNames;
+}>;

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

@@ -0,0 +1,69 @@
+import type { WhatsAppConversationSlots } from '../../component-props';
+import type { WhatsAppAttachment, WhatsAppMessageData, WhatsAppOutgoingMessage } from '../../types';
+import type { WhatsAppConversationOwnProps } from './WhatsAppConversation.types';
+declare const defaultProps: {
+    readonly draftBehavior: "preserve";
+    readonly withHeader: true;
+    readonly withComposer: true;
+    readonly withBack: false;
+    readonly withContactToggle: false;
+    readonly focusComposerOnChange: true;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppConversationOwnProps, {
+    focusComposer: () => void;
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    send: (payload: WhatsAppOutgoingMessage) => any;
+    validationError: (message: string) => any;
+    loadOlderMessages: (payload: import("../..").WhatsAppLoadMorePayload) => any;
+    retrySend: () => any;
+    typing: (value: string) => any;
+    back: () => any;
+    "update:replyTo": (replyTo: import("../..").WhatsAppMessageReference | null) => any;
+    attachmentsAdd: (payload: import("../..").WhatsAppAttachmentsAddPayload) => any;
+    attachmentsReject: (rejected: import("../..").WhatsAppRejectedFile[]) => any;
+    attachmentRemove: (upload: import("../..").WhatsAppUpload) => any;
+    attachmentRetry: (upload: import("../..").WhatsAppUpload) => any;
+    attachmentCancel: (upload: import("../..").WhatsAppUpload) => any;
+    templatesRetryLoad: () => any;
+    toggleContactPanel: (opened: boolean) => any;
+    contactClick: (conversation: import("../..").WhatsAppConversationData) => any;
+    mediaDownload: (attachment: WhatsAppAttachment, message: WhatsAppMessageData) => any;
+    mediaPreview: (attachment: WhatsAppAttachment, message: WhatsAppMessageData) => any;
+    retryMessage: (message: WhatsAppMessageData) => any;
+    atBottomChange: (atBottom: boolean) => any;
+    "update:draft": (draft: string) => any;
+    "update:drafts": (drafts: Record<string, string>) => any;
+    retryLoadMessages: () => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppConversationOwnProps> & Readonly<{
+    onSend?: ((payload: WhatsAppOutgoingMessage) => any) | undefined;
+    onValidationError?: ((message: string) => any) | undefined;
+    onLoadOlderMessages?: ((payload: import("../..").WhatsAppLoadMorePayload) => any) | undefined;
+    onRetrySend?: (() => any) | undefined;
+    onTyping?: ((value: string) => any) | undefined;
+    onBack?: (() => any) | undefined;
+    "onUpdate:replyTo"?: ((replyTo: import("../..").WhatsAppMessageReference | null) => any) | undefined;
+    onAttachmentsAdd?: ((payload: import("../..").WhatsAppAttachmentsAddPayload) => any) | undefined;
+    onAttachmentsReject?: ((rejected: import("../..").WhatsAppRejectedFile[]) => any) | undefined;
+    onAttachmentRemove?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+    onAttachmentRetry?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+    onAttachmentCancel?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+    onTemplatesRetryLoad?: (() => any) | undefined;
+    onToggleContactPanel?: ((opened: boolean) => any) | undefined;
+    onContactClick?: ((conversation: import("../..").WhatsAppConversationData) => any) | undefined;
+    onMediaDownload?: ((attachment: WhatsAppAttachment, message: WhatsAppMessageData) => any) | undefined;
+    onMediaPreview?: ((attachment: WhatsAppAttachment, message: WhatsAppMessageData) => any) | undefined;
+    onRetryMessage?: ((message: WhatsAppMessageData) => any) | undefined;
+    onAtBottomChange?: ((atBottom: boolean) => any) | undefined;
+    "onUpdate:draft"?: ((draft: string) => any) | undefined;
+    "onUpdate:drafts"?: ((drafts: Record<string, string>) => any) | undefined;
+    onRetryLoadMessages?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppConversationSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/lib/components/WhatsAppConversationHeader/WhatsAppConversationHeader.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppConversationHeader: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppConversationHeader.types").WhatsAppConversationHeaderProps, "rootRef">;
+    slots: import("./WhatsAppConversationHeader.types").WhatsAppConversationHeaderSlots;
+    emits: import("./WhatsAppConversationHeader.types").WhatsAppConversationHeaderEmits;
+    ref: HTMLElement;
+    element: "header";
+    stylesNames: import("./WhatsAppConversationHeader.types").WhatsAppConversationHeaderStylesNames;
+}>;
+export type { WhatsAppConversationHeaderEmits, WhatsAppConversationHeaderFactory, WhatsAppConversationHeaderOwnProps, WhatsAppConversationHeaderProps, WhatsAppConversationHeaderSlots, WhatsAppConversationHeaderStylesNames, } from './WhatsAppConversationHeader.types';

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

@@ -0,0 +1,57 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppConversationSummary } from '../../types';
+export type WhatsAppConversationHeaderStylesNames = 'conversationHeaderRoot' | 'conversationHeaderBack' | 'conversationHeaderAvatar' | 'conversationHeaderBody' | 'conversationHeaderName' | 'conversationHeaderSubtitle' | 'conversationHeaderActions';
+export interface WhatsAppConversationHeaderSlots {
+    /** Replaces the whole header content. */
+    default?: (props: {
+        conversation: WhatsAppConversationSummary | undefined;
+    }) => VNodeChild;
+    /** Rendered at the end of the header, before the contact panel toggle. */
+    headerActions?: (props: {
+        conversation: WhatsAppConversationSummary | undefined;
+    }) => VNodeChild;
+}
+export interface WhatsAppConversationHeaderOwnProps extends StylesApiProps<WhatsAppConversationHeaderFactory> {
+    /** Conversation being shown. */
+    conversation?: WhatsAppConversationSummary;
+    /**
+     * Renders the back control, used by the narrow layout and by the drawer.
+     * @default false
+     */
+    withBack?: boolean;
+    /**
+     * Renders the control that toggles the contact panel.
+     * @default false
+     */
+    withContactToggle?: boolean;
+    /** Whether the contact panel is open, used for the toggle aria-expanded state. */
+    contactPanelOpened?: boolean;
+    /**
+     * Text under the contact name. Falls back to the phone number, which is what makes two
+     * contacts with the same name distinguishable.
+     */
+    subtitle?: string;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppConversationHeaderProps extends Omit<BoxProps, keyof WhatsAppConversationHeaderOwnProps>, WhatsAppConversationHeaderOwnProps {
+}
+export interface WhatsAppConversationHeaderEmits {
+    /** Emitted when the back control is used. */
+    back: [];
+    /** Emitted when the contact panel toggle is used, with the state it should move to. */
+    toggleContactPanel: [opened: boolean];
+    /** Emitted when the contact name or avatar is activated. */
+    contactClick: [conversation: WhatsAppConversationSummary];
+}
+export type WhatsAppConversationHeaderFactory = Factory<{
+    props: Omit<WhatsAppConversationHeaderProps, 'rootRef'>;
+    slots: WhatsAppConversationHeaderSlots;
+    emits: WhatsAppConversationHeaderEmits;
+    ref: HTMLElement;
+    element: 'header';
+    stylesNames: WhatsAppConversationHeaderStylesNames;
+}>;

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

@@ -0,0 +1,23 @@
+import type { WhatsAppConversationHeaderOwnProps, WhatsAppConversationHeaderSlots } from './WhatsAppConversationHeader.types';
+declare const defaultProps: {
+    readonly withBack: false;
+    readonly withContactToggle: false;
+    readonly contactPanelOpened: false;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppConversationHeaderOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    back: () => any;
+    toggleContactPanel: (opened: boolean) => any;
+    contactClick: (conversation: import("../..").WhatsAppConversationSummary) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppConversationHeaderOwnProps> & Readonly<{
+    onBack?: (() => any) | undefined;
+    onToggleContactPanel?: ((opened: boolean) => any) | undefined;
+    onContactClick?: ((conversation: import("../..").WhatsAppConversationSummary) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppConversationHeaderSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/lib/components/WhatsAppConversationList/WhatsAppConversationList.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppConversationList: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppConversationList.types").WhatsAppConversationListProps, "rootRef">;
+    slots: import("../../component-props.js").WhatsAppConversationListSlots;
+    emits: import("./WhatsAppConversationList.types").WhatsAppConversationListEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppConversationList.types").WhatsAppConversationListStylesNames;
+}>;
+export type { WhatsAppConversationListEmits, WhatsAppConversationListFactory, WhatsAppConversationListOwnProps, WhatsAppConversationListProps, WhatsAppConversationListStylesNames, WhatsAppConversationOrder, } from './WhatsAppConversationList.types';

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

@@ -0,0 +1,113 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppConversationListSlots } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppConversationSummary, WhatsAppInboxFilters, WhatsAppInboxFiltersConfig, WhatsAppLoadMorePayload, WhatsAppNewConversationPayload, WhatsAppPaginationState } from '../../types';
+import type { WhatsAppConversationListItemStylesNames } from '../WhatsAppConversationListItem';
+export type WhatsAppConversationListStylesNames = 'conversationListRoot' | 'conversationListHeader' | 'conversationListTitleRow' | 'conversationListTitle' | 'conversationListNewButton' | 'newConversationForm' | 'newConversationActions' | 'conversationListSearch' | 'conversationListFilters' | 'conversationListScrollArea' | 'conversationListItems' | 'conversationListItemWrapper' | 'conversationListState' | 'conversationListLoadMore' | 'conversationListFooter' | WhatsAppConversationListItemStylesNames;
+/**
+ * Order the list renders conversations in.
+ *
+ * `none` keeps the array exactly as supplied, which is the default: a backend that already
+ * sorted by relevance, priority or a custom queue must not be silently reordered by the UI.
+ */
+export type WhatsAppConversationOrder = 'none' | 'activity';
+export interface WhatsAppConversationListOwnProps extends StylesApiProps<WhatsAppConversationListFactory> {
+    /** Conversations to render. */
+    conversations?: WhatsAppConversationSummary[];
+    /** Controlled id of the selected conversation. */
+    selectedConversationId?: string | null;
+    /** Uncontrolled initial selection. */
+    defaultSelectedConversationId?: string | null;
+    /** Controlled filter state. */
+    filters?: WhatsAppInboxFilters;
+    /** Uncontrolled initial filter state. */
+    defaultFilters?: WhatsAppInboxFilters;
+    /**
+     * Which filter controls are rendered. Controls whose options are not supplied stay hidden, so
+     * a backend that cannot answer a filter never shows it.
+     */
+    filtersConfig?: WhatsAppInboxFiltersConfig;
+    /** Whether the initial 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 pagination. */
+    pagination?: WhatsAppPaginationState;
+    /**
+     * Display order of the supplied array.
+     * @default 'none'
+     */
+    order?: WhatsAppConversationOrder;
+    /**
+     * Renders the title and the filter controls.
+     * @default true
+     */
+    withHeader?: boolean;
+    /**
+     * Emits `loadMore` when the user scrolls near the end of the list. Turn it off to rely on the
+     * explicit load-more control alone.
+     * @default true
+     */
+    withInfiniteScroll?: boolean;
+    /**
+     * Distance in pixels from the end at which `loadMore` is emitted.
+     * @default 160
+     */
+    loadMoreThreshold?: number;
+    /** Title rendered above the search field. Falls back to the label. */
+    title?: string;
+    /**
+     * Renders the control that starts a conversation with a number that is not in the list yet.
+     * @default false
+     */
+    withNewConversation?: boolean;
+    /** Controlled opened state of the new-conversation form. */
+    newConversationOpened?: boolean;
+    /** Whether the consumer is still creating or looking up the conversation. */
+    newConversationCreating?: boolean;
+    /**
+     * Failure of the last attempt, rendered inside the form. Use it for backend rules the
+     * frontend cannot check, such as an opt-in that is missing.
+     */
+    newConversationError?: string | null;
+    /**
+     * Validates the phone number before `newConversation` is emitted. Return an error message to
+     * reject it, or `null` to accept.
+     *
+     * Defaults to a permissive digit-count check: the authoritative rules belong to the provider,
+     * and a frontend that guessed at national formats would reject numbers the backend accepts.
+     */
+    validatePhoneNumber?: (phoneNumber: string) => string | null;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppConversationListProps extends Omit<BoxProps, keyof WhatsAppConversationListOwnProps>, WhatsAppConversationListOwnProps {
+}
+export interface WhatsAppConversationListEmits {
+    /** Emitted when the selected conversation changes. */
+    'update:selectedConversationId': [conversationId: string | null];
+    /** Emitted when any filter changes. */
+    'update:filters': [filters: WhatsAppInboxFilters];
+    /** Emitted when a conversation is picked, with the full record. */
+    select: [conversation: WhatsAppConversationSummary];
+    /** Emitted when the next page should be fetched. */
+    loadMore: [payload: WhatsAppLoadMorePayload];
+    /** Emitted when the retry action of the error state is used. */
+    retryLoad: [];
+    /** Emitted when the opened state of the new-conversation form changes. */
+    'update:newConversationOpened': [opened: boolean];
+    /**
+     * Emitted when the user submits a phone number to start a conversation with. Create or look up
+     * the conversation, then select it by updating `selectedConversationId`.
+     */
+    newConversation: [payload: WhatsAppNewConversationPayload];
+}
+export type WhatsAppConversationListFactory = Factory<{
+    props: Omit<WhatsAppConversationListProps, 'rootRef'>;
+    slots: WhatsAppConversationListSlots;
+    emits: WhatsAppConversationListEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppConversationListStylesNames;
+}>;

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

@@ -0,0 +1,35 @@
+import type { WhatsAppConversationListSlots } from '../../component-props';
+import type { WhatsAppConversationSummary, WhatsAppInboxFilters } from '../../types';
+import type { WhatsAppConversationListOwnProps } from './WhatsAppConversationList.types';
+declare const defaultProps: {
+    readonly order: "none";
+    readonly withHeader: true;
+    readonly withInfiniteScroll: true;
+    readonly withNewConversation: false;
+    readonly loadMoreThreshold: 160;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppConversationListOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (conversation: WhatsAppConversationSummary) => any;
+    newConversation: (payload: import("../..").WhatsAppNewConversationPayload) => any;
+    retryLoad: () => any;
+    "update:selectedConversationId": (conversationId: string | null) => any;
+    "update:filters": (filters: WhatsAppInboxFilters) => any;
+    loadMore: (payload: import("../..").WhatsAppLoadMorePayload) => any;
+    "update:newConversationOpened": (opened: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppConversationListOwnProps> & Readonly<{
+    onSelect?: ((conversation: WhatsAppConversationSummary) => any) | undefined;
+    onNewConversation?: ((payload: import("../..").WhatsAppNewConversationPayload) => any) | undefined;
+    onRetryLoad?: (() => any) | undefined;
+    "onUpdate:selectedConversationId"?: ((conversationId: string | null) => any) | undefined;
+    "onUpdate:filters"?: ((filters: WhatsAppInboxFilters) => any) | undefined;
+    onLoadMore?: ((payload: import("../..").WhatsAppLoadMorePayload) => any) | undefined;
+    "onUpdate:newConversationOpened"?: ((opened: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppConversationListSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/lib/components/WhatsAppConversationListItem/WhatsAppConversationListItem.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppConversationListItem: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppConversationListItem.types").WhatsAppConversationListItemProps, "rootRef">;
+    slots: import("./WhatsAppConversationListItem.types").WhatsAppConversationListItemSlots;
+    emits: import("./WhatsAppConversationListItem.types").WhatsAppConversationListItemEmits;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./WhatsAppConversationListItem.types").WhatsAppConversationListItemStylesNames;
+}>;
+export type { WhatsAppConversationListItemEmits, WhatsAppConversationListItemFactory, WhatsAppConversationListItemOwnProps, WhatsAppConversationListItemProps, WhatsAppConversationListItemSlots, WhatsAppConversationListItemStylesNames, } from './WhatsAppConversationListItem.types';

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

@@ -0,0 +1,56 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppConversationItemSlotProps } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppConversationSummary } from '../../types';
+import type { WhatsAppMessageStatusStylesNames } from '../WhatsAppMessageStatus';
+export type WhatsAppConversationListItemStylesNames = 'conversationItemRoot' | 'conversationItemAvatar' | 'conversationItemBody' | 'conversationItemTopRow' | 'conversationItemName' | 'conversationItemTime' | 'conversationItemBottomRow' | 'conversationItemPreview' | 'conversationItemPreviewText' | 'conversationItemIndicators' | 'conversationItemUnread' | 'conversationItemLabels' | 'conversationItemPhone' | WhatsAppMessageStatusStylesNames;
+export interface WhatsAppConversationListItemSlots {
+    /** Replaces the avatar. */
+    conversationAvatar?: (props: WhatsAppConversationItemSlotProps) => VNodeChild;
+    /** Replaces the last-message preview line. */
+    conversationPreview?: (props: WhatsAppConversationItemSlotProps) => VNodeChild;
+}
+export interface WhatsAppConversationListItemOwnProps extends StylesApiProps<WhatsAppConversationListItemFactory> {
+    /** Conversation to render. */
+    conversation: WhatsAppConversationSummary;
+    /** Whether the conversation is the selected one. */
+    selected?: boolean;
+    /**
+     * Renders the unread badge when `unreadCount` is above zero.
+     * @default true
+     */
+    withUnreadBadge?: boolean;
+    /**
+     * Renders the delivery state of the last outbound message before the preview text.
+     * @default true
+     */
+    withStatus?: boolean;
+    /**
+     * Renders the phone number under the contact name.
+     * @default true
+     */
+    withPhoneNumber?: boolean;
+    /**
+     * Renders the conversation labels as badges.
+     * @default true
+     */
+    withLabels?: boolean;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppConversationListItemProps extends Omit<BoxProps, keyof WhatsAppConversationListItemOwnProps>, WhatsAppConversationListItemOwnProps {
+}
+export interface WhatsAppConversationListItemEmits {
+    /** Emitted when the item is activated by click or keyboard. */
+    select: [conversation: WhatsAppConversationSummary];
+}
+export type WhatsAppConversationListItemFactory = Factory<{
+    props: Omit<WhatsAppConversationListItemProps, 'rootRef'>;
+    slots: WhatsAppConversationListItemSlots;
+    emits: WhatsAppConversationListItemEmits;
+    ref: HTMLButtonElement;
+    element: 'button';
+    stylesNames: WhatsAppConversationListItemStylesNames;
+}>;

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

@@ -0,0 +1,21 @@
+import type { WhatsAppConversationListItemOwnProps, WhatsAppConversationListItemSlots } from './WhatsAppConversationListItem.types';
+declare const defaultProps: {
+    readonly selected: false;
+    readonly withUnreadBadge: true;
+    readonly withStatus: true;
+    readonly withPhoneNumber: true;
+    readonly withLabels: true;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppConversationListItemOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (conversation: import("../..").WhatsAppConversationSummary) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppConversationListItemOwnProps> & Readonly<{
+    onSelect?: ((conversation: import("../..").WhatsAppConversationSummary) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppConversationListItemSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/lib/components/WhatsAppEmojiPicker/WhatsAppEmojiPicker.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppEmojiPicker: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppEmojiPicker.types").WhatsAppEmojiPickerProps, "rootRef">;
+    slots: import("./WhatsAppEmojiPicker.types").WhatsAppEmojiPickerSlots;
+    emits: import("./WhatsAppEmojiPicker.types").WhatsAppEmojiPickerEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppEmojiPicker.types").WhatsAppEmojiPickerStylesNames;
+}>;
+export type { WhatsAppEmojiPickerEmits, WhatsAppEmojiPickerFactory, WhatsAppEmojiPickerOwnProps, WhatsAppEmojiPickerProps, WhatsAppEmojiPickerSlots, WhatsAppEmojiPickerStylesNames, } from './WhatsAppEmojiPicker.types';