@mantine-vue/whatsapp-inbox 3.2.0

package/lib/WhatsAppInbox.context.d.ts

@@ -0,0 +1,70 @@
+import { type WhatsAppInboxLabels, type WhatsAppInboxLabelsOverride } from './labels';
+import type { WhatsAppConversationData, WhatsAppResolvedCapabilities, WhatsAppTimestamp } from './types';
+/**
+ * Date, time and size formatting used across the inbox.
+ *
+ * Every formatter is replaceable for applications that use another date library or timezone.
+ */
+export interface WhatsAppInboxFormatters {
+    /** Time shown under a message bubble. */
+    messageTime: (value: WhatsAppTimestamp, locale: string | undefined) => string;
+    /** Full date and time, used for tooltips and screen-reader text. */
+    fullTimestamp: (value: WhatsAppTimestamp, locale: string | undefined) => string;
+    /** Day divider label in the message list. */
+    dayLabel: (value: WhatsAppTimestamp, locale: string | undefined, labels: WhatsAppInboxLabels) => string;
+    /** Timestamp column of a conversation list item. */
+    conversationTime: (value: WhatsAppTimestamp | undefined, locale: string | undefined, labels: WhatsAppInboxLabels) => string;
+    /** Human readable file size. */
+    fileSize: (bytes: number | undefined) => string;
+}
+/** Built-in `Intl` based formatters. */
+export declare const DEFAULT_WHATSAPP_INBOX_FORMATTERS: WhatsAppInboxFormatters;
+/** Shared configuration published by `WhatsAppInboxProvider`. */
+export interface WhatsAppInboxConfigSource {
+    readonly labels: WhatsAppInboxLabelsOverride | undefined;
+    readonly locale: string | undefined;
+    readonly formatters: Partial<WhatsAppInboxFormatters> | undefined;
+}
+/**
+ * Resolved configuration, as every component consumes it.
+ *
+ * `labels` is already merged, and each formatter is bound to the resolved locale and labels, so
+ * a component calls `config.messageTime(value)` without threading either through.
+ */
+export interface WhatsAppInboxConfig {
+    readonly labels: WhatsAppInboxLabels;
+    readonly locale: string | undefined;
+    messageTime: (value: WhatsAppTimestamp) => string;
+    fullTimestamp: (value: WhatsAppTimestamp) => string;
+    dayLabel: (value: WhatsAppTimestamp) => string;
+    conversationTime: (value: WhatsAppTimestamp | undefined) => string;
+    fileSize: (bytes: number | undefined) => string;
+}
+/** Publishes shared inbox configuration to every component below. */
+export declare function provideWhatsAppInboxConfig(value: WhatsAppInboxConfigSource): void;
+/**
+ * Reads the inbox configuration, merging a component's own `labels` and `locale` over it.
+ *
+ * Components outside a `WhatsAppInboxProvider` use the English defaults.
+ */
+export declare function useWhatsAppInboxConfig(labelsOverride?: () => WhatsAppInboxLabelsOverride | undefined, localeOverride?: () => string | undefined): WhatsAppInboxConfig;
+/**
+ * The conversation the surrounding `WhatsAppConversation` is showing.
+ *
+ * Lets a consumer build a custom layout out of the primitives without re-passing the
+ * conversation and its capabilities to each one. Every consumer of this context still accepts
+ * the same values as props, and props always win.
+ */
+export interface WhatsAppConversationContextValue {
+    readonly conversation: WhatsAppConversationData | undefined;
+    readonly conversationId: string | undefined;
+    readonly capabilities: WhatsAppResolvedCapabilities;
+}
+export declare function provideWhatsAppConversationContext(value: WhatsAppConversationContextValue): void;
+/** Reads the surrounding conversation, or `undefined` outside a `WhatsAppConversation`. */
+export declare function useWhatsAppConversationContext(): WhatsAppConversationContextValue | undefined;
+/**
+ * Resolves the capabilities a component should apply: its own prop when set, the surrounding
+ * conversation's otherwise.
+ */
+export declare function useResolvedCapabilities(ownCapabilities: () => WhatsAppConversationData['capabilities'] | undefined, hasOwnCapabilities?: () => boolean): import("vue").ComputedRef<WhatsAppResolvedCapabilities>;

package/lib/component-props.d.ts

@@ -0,0 +1,138 @@
+import type { VNodeChild } from 'vue';
+import type { EmitsToProps } from '@mantine-vue/core';
+import type { WhatsAppAttachment, WhatsAppContact, WhatsAppConversationSummary, WhatsAppMessageData, WhatsAppTemplate, WhatsAppUpload } from './types';
+/**
+ * Props forwarded to a component the inbox renders internally, plus the `on*` listeners for its
+ * events so a nested object can subscribe to them.
+ *
+ * `rootRef` is dropped because it only makes sense on an element the consumer owns, and because
+ * the factory narrows it to a concrete element type a `Partial<…Props>` cannot satisfy.
+ */
+export type ForwardedProps<Props, Emits = Record<never, never>> = Partial<Omit<Props, 'rootRef'>> & EmitsToProps<Emits>;
+/**
+ * Replaces the rendering of one message.
+ *
+ * The counterpart of the `message` slot. Returning `undefined` uses the built-in renderer.
+ */
+export type RenderMessage = (message: WhatsAppMessageData) => VNodeChild | undefined;
+/** Replaces the content of one message bubble, keeping the bubble, footer and status. */
+export type RenderMessageContent = (message: WhatsAppMessageData) => VNodeChild | undefined;
+/** Scoped slots that mirror the message render props. Slots take precedence over the props. */
+export interface WhatsAppMessageSlots {
+    /** Replaces a message entirely, bubble included. Takes precedence over `renderMessage`. */
+    message?: (props: {
+        message: WhatsAppMessageData;
+    }) => VNodeChild;
+    /** Replaces the content inside a bubble. Takes precedence over `renderMessageContent`. */
+    messageContent?: (props: {
+        message: WhatsAppMessageData;
+    }) => VNodeChild;
+    /** Appended inside the bubble, under the content and before the timestamp row. */
+    messageFooter?: (props: {
+        message: WhatsAppMessageData;
+    }) => VNodeChild;
+    /** Replaces the media renderer of a received attachment. */
+    mediaAttachment?: (props: {
+        attachment: WhatsAppAttachment;
+        message: WhatsAppMessageData;
+    }) => VNodeChild;
+}
+/** The `renderMessage` / `renderMessageContent` pair passed down to each message. */
+export interface MessageRenderers {
+    /**
+     * Replaces the rendering of a message, bubble included. Returning `undefined` falls back to the
+     * built-in renderer. Can also be set with the `message` slot, which takes precedence.
+     */
+    renderMessage?: RenderMessage;
+    /**
+     * Replaces the content inside a message bubble, keeping the bubble, timestamp and delivery
+     * state. Can also be set with the `messageContent` slot, which takes precedence.
+     */
+    renderMessageContent?: RenderMessageContent;
+}
+/**
+ * Folds the message scoped slots into the equivalent render props, so a list forwards one object
+ * to every message instead of re-declaring the slots at each call site.
+ */
+export declare function resolveMessageRenderers(props: MessageRenderers, slots: WhatsAppMessageSlots): MessageRenderers;
+/** Slot props of the conversation list item slots. */
+export interface WhatsAppConversationItemSlotProps {
+    conversation: WhatsAppConversationSummary;
+    selected: boolean;
+}
+/** Slots shared by the conversation list and the full inbox. */
+export interface WhatsAppConversationListSlots {
+    /** Replaces a whole conversation list item. */
+    conversationItem?: (props: WhatsAppConversationItemSlotProps) => VNodeChild;
+    /** Replaces the avatar of a list item. */
+    conversationAvatar?: (props: WhatsAppConversationItemSlotProps) => VNodeChild;
+    /** Replaces the last-message preview of a list item. */
+    conversationPreview?: (props: WhatsAppConversationItemSlotProps) => VNodeChild;
+    /** Rendered above the search field. */
+    listHeader?: () => VNodeChild;
+    /** Rendered under the list, after the load-more control. */
+    listFooter?: () => VNodeChild;
+    /** Replaces the empty state of the list. */
+    emptyInbox?: () => VNodeChild;
+    /** Replaces the loading state of the list. */
+    loadingInbox?: () => VNodeChild;
+    /** Replaces the error state of the list. */
+    errorInbox?: (props: {
+        error: string;
+    }) => VNodeChild;
+    /** Rendered next to the search field, for custom filter controls. */
+    filters?: () => VNodeChild;
+}
+/** Slots of the conversation view, shared with the inbox, modal and drawer. */
+export interface WhatsAppConversationSlots extends WhatsAppMessageSlots {
+    /** Replaces the conversation header. */
+    conversationHeader?: (props: {
+        conversation: WhatsAppConversationSummary | undefined;
+    }) => VNodeChild;
+    /** Rendered at the end of the conversation header, before the contact panel toggle. */
+    headerActions?: (props: {
+        conversation: WhatsAppConversationSummary | undefined;
+    }) => VNodeChild;
+    /** Replaces the empty state shown when the conversation has no messages. */
+    emptyConversation?: () => VNodeChild;
+    /** Replaces the loading state of the message history. */
+    loadingMessages?: () => VNodeChild;
+    /** Replaces the error state of the message history. */
+    errorMessages?: (props: {
+        error: string;
+    }) => VNodeChild;
+    /** Rendered before the composer input, after the attachment control. */
+    composerPrefix?: () => VNodeChild;
+    /** Rendered after the composer input, before the send control. */
+    composerSuffix?: () => VNodeChild;
+    /** Replaces the composer action row. */
+    composerActions?: () => VNodeChild;
+    /** Emoji picker rendered in the composer emoji popover. */
+    emojiPicker?: (props: {
+        insert: (emoji: string) => void;
+        close: () => void;
+    }) => VNodeChild;
+    /** Replaces the preview of one staged attachment. */
+    attachmentPreview?: (props: {
+        upload: WhatsAppUpload;
+    }) => VNodeChild;
+    /** Replaces the preview of a template inside the template selector. */
+    templatePreview?: (props: {
+        template: WhatsAppTemplate;
+    }) => VNodeChild;
+}
+/** Slots of the contact panel. */
+export interface WhatsAppContactPanelSlots {
+    /** Rendered above the built-in contact fields. */
+    contactPanelHeader?: (props: {
+        contact: WhatsAppContact;
+    }) => VNodeChild;
+    /** Replaces the whole contact panel body. */
+    contactPanel?: (props: {
+        contact: WhatsAppContact;
+    }) => VNodeChild;
+    /** Rendered under the built-in contact fields. */
+    contactPanelFooter?: (props: {
+        contact: WhatsAppContact;
+    }) => VNodeChild;
+}

package/lib/components/WhatsAppAttachmentPreview/WhatsAppAttachmentPreview.d.ts

@@ -0,0 +1,8 @@
+export declare const WhatsAppAttachmentPreview: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppAttachmentPreview.types").WhatsAppAttachmentPreviewProps, "rootRef">;
+    emits: import("./WhatsAppAttachmentPreview.types").WhatsAppAttachmentPreviewEmits;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppAttachmentPreview.types").WhatsAppAttachmentPreviewStylesNames;
+}>;
+export type { WhatsAppAttachmentPreviewEmits, WhatsAppAttachmentPreviewFactory, WhatsAppAttachmentPreviewOwnProps, WhatsAppAttachmentPreviewProps, WhatsAppAttachmentPreviewStylesNames, } from './WhatsAppAttachmentPreview.types';

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

@@ -0,0 +1,33 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppUpload } from '../../types';
+export type WhatsAppAttachmentPreviewStylesNames = 'attachmentPreviewRoot' | 'attachmentPreviewThumb' | 'attachmentPreviewThumbImage' | 'attachmentPreviewBody' | 'attachmentPreviewName' | 'attachmentPreviewMeta' | 'attachmentPreviewProgress' | 'attachmentPreviewError' | 'attachmentPreviewActions';
+export interface WhatsAppAttachmentPreviewOwnProps extends StylesApiProps<WhatsAppAttachmentPreviewFactory> {
+    /** Upload to preview. Its `status` decides which actions are offered. */
+    upload: WhatsAppUpload;
+    /**
+     * Renders the remove action.
+     * @default true
+     */
+    withRemove?: boolean;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppAttachmentPreviewProps extends Omit<BoxProps, keyof WhatsAppAttachmentPreviewOwnProps>, WhatsAppAttachmentPreviewOwnProps {
+}
+export interface WhatsAppAttachmentPreviewEmits {
+    /** Emitted when the attachment should be dropped from the composer. */
+    remove: [upload: WhatsAppUpload];
+    /** Emitted when a failed upload should be retried by the consumer. */
+    retry: [upload: WhatsAppUpload];
+    /** Emitted when an in-flight upload should be aborted by the consumer. */
+    cancel: [upload: WhatsAppUpload];
+}
+export type WhatsAppAttachmentPreviewFactory = Factory<{
+    props: Omit<WhatsAppAttachmentPreviewProps, 'rootRef'>;
+    emits: WhatsAppAttachmentPreviewEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppAttachmentPreviewStylesNames;
+}>;

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

@@ -0,0 +1,19 @@
+import type { WhatsAppAttachmentPreviewOwnProps } from './WhatsAppAttachmentPreview.types';
+import type { WhatsAppIconName } from '../../icons';
+import type { WhatsAppMediaType } from '../../types';
+declare const defaultProps: {
+    readonly withRemove: true;
+};
+declare const UPLOAD_ICONS: Record<WhatsAppMediaType, WhatsAppIconName>;
+export { defaultProps, UPLOAD_ICONS };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<WhatsAppAttachmentPreviewOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    remove: (upload: import("../..").WhatsAppUpload) => any;
+    cancel: (upload: import("../..").WhatsAppUpload) => any;
+    retry: (upload: import("../..").WhatsAppUpload) => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppAttachmentPreviewOwnProps> & Readonly<{
+    onRemove?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+    onCancel?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+    onRetry?: ((upload: import("../..").WhatsAppUpload) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

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

package/lib/components/WhatsAppComposer/WhatsAppComposer.d.ts

@@ -0,0 +1,10 @@
+export declare const WhatsAppComposer: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppComposer.types").WhatsAppComposerProps, "rootRef">;
+    slots: import("./WhatsAppComposer.types").WhatsAppComposerSlots;
+    emits: import("./WhatsAppComposer.types").WhatsAppComposerEmits;
+    exposed: import("./WhatsAppComposer.types").WhatsAppComposerExposed;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppComposer.types").WhatsAppComposerStylesNames;
+}>;
+export type { WhatsAppComposerEmits, WhatsAppComposerExposed, WhatsAppComposerFactory, WhatsAppComposerOwnProps, WhatsAppComposerProps, WhatsAppComposerSlots, WhatsAppComposerStylesNames, } from './WhatsAppComposer.types';

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

@@ -0,0 +1,173 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory, ModalProps } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { ForwardedProps } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppAttachmentsAddPayload, WhatsAppConversationCapabilities, WhatsAppMessageReference, WhatsAppOutgoingMessage, WhatsAppRejectedFile, WhatsAppTemplate, WhatsAppUpload } from '../../types';
+import type { WhatsAppAttachmentPreviewStylesNames } from '../WhatsAppAttachmentPreview';
+import type { WhatsAppEmojiPickerProps, WhatsAppEmojiPickerStylesNames } from '../WhatsAppEmojiPicker';
+import type { WhatsAppInteractiveMessageEditorStylesNames } from '../WhatsAppInteractiveMessageEditor';
+import type { WhatsAppMessagingWindowNoticeStylesNames } from '../WhatsAppMessagingWindowNotice';
+import type { WhatsAppTemplateSelectorStylesNames } from '../WhatsAppTemplateSelector';
+export type WhatsAppComposerStylesNames = 'composerRoot' | 'composerNotice' | 'composerReply' | 'composerReplyBody' | 'composerReplyAuthor' | 'composerReplyText' | 'composerAttachments' | 'composerError' | 'composerInputRow' | 'composerInput' | 'composerActions' | 'composerAction' | 'composerSend' | 'composerFooter' | 'composerCount' | WhatsAppAttachmentPreviewStylesNames | WhatsAppEmojiPickerStylesNames | WhatsAppMessagingWindowNoticeStylesNames | WhatsAppTemplateSelectorStylesNames | WhatsAppInteractiveMessageEditorStylesNames;
+export interface WhatsAppComposerSlots {
+    /** Rendered before the text input, after the attachment control. */
+    composerPrefix?: () => VNodeChild;
+    /** Rendered after the text input, before the send control. */
+    composerSuffix?: () => VNodeChild;
+    /** Replaces the whole action row, send control included. */
+    composerActions?: () => VNodeChild;
+    /**
+     * Replaces the built-in emoji picker inside the popover.
+     *
+     * Supplying it takes precedence over `withEmojiPicker`, so a consumer with their own picker –
+     * a fuller catalogue, skin tones, localized names – drops it in without turning anything off.
+     */
+    emojiPicker?: (props: {
+        insert: (emoji: string) => void;
+        close: () => void;
+    }) => VNodeChild;
+    /** Replaces the preview of one staged attachment. */
+    attachmentPreview?: (props: {
+        upload: WhatsAppUpload;
+    }) => VNodeChild;
+    /** Replaces the preview shown inside the template selector. */
+    templatePreview?: (props: {
+        template: WhatsAppTemplate;
+    }) => VNodeChild;
+}
+export interface WhatsAppComposerOwnProps extends StylesApiProps<WhatsAppComposerFactory> {
+    /** Conversation the message is sent to. Included in every outgoing payload. */
+    conversationId?: string;
+    /** Controlled draft text. */
+    modelValue?: string;
+    /** Uncontrolled initial draft text. */
+    defaultValue?: string;
+    /**
+     * What may be sent in this conversation. Falls back to the surrounding
+     * `WhatsAppConversation`, and then to the defaults.
+     */
+    capabilities?: WhatsAppConversationCapabilities;
+    /** Attachments staged in the composer, with the upload state the consumer reports. */
+    uploads?: WhatsAppUpload[];
+    /** Approved templates offered by the template selector. */
+    templates?: WhatsAppTemplate[];
+    /** Whether the template list is loading. */
+    templatesLoading?: boolean;
+    /** Failure of the last template load. */
+    templatesError?: string | null;
+    /** Controlled opened state of the template selector. */
+    templatesOpened?: boolean;
+    /** Controlled opened state of the interactive message editor. */
+    interactiveOpened?: boolean;
+    /** Whether a send is in flight. Disables the send control and shows a loader. */
+    sending?: boolean;
+    /** Disables every control, whatever the capabilities say. */
+    disabled?: boolean;
+    /** Failure of the last send, rendered above the input with a retry action. */
+    error?: string | null;
+    /** Message the draft replies to. Rendered as a quote above the input. */
+    replyTo?: WhatsAppMessageReference | null;
+    /** Overrides the input placeholder. */
+    placeholder?: string;
+    /**
+     * Sends the draft when Enter is pressed. Shift+Enter always inserts a newline.
+     * @default true
+     */
+    sendOnEnter?: boolean;
+    /**
+     * Smallest number of visible rows of the input.
+     * @default 1
+     */
+    minRows?: number;
+    /**
+     * Largest number of visible rows before the input scrolls.
+     * @default 6
+     */
+    maxRows?: number;
+    /** Focuses the input on mount. */
+    autofocus?: boolean;
+    /** Forces the attachment control on or off, overriding the capabilities. */
+    withAttachments?: boolean;
+    /** Forces the template control on or off, overriding the capabilities. */
+    withTemplates?: boolean;
+    /** Forces the emoji control on or off, overriding the capabilities. */
+    withEmoji?: boolean;
+    /**
+     * Renders the built-in `WhatsAppEmojiPicker` inside the emoji popover. Turn it off to supply
+     * your own through the `emojiPicker` slot; with neither, the emoji control stays hidden rather
+     * than opening an empty popover.
+     * @default true
+     */
+    withEmojiPicker?: boolean;
+    /**
+     * Props passed to the built-in picker: category and emoji allow-lists, block-lists, size and
+     * the recently-used list.
+     */
+    emojiPickerProps?: ForwardedProps<WhatsAppEmojiPickerProps>;
+    /** Forces the interactive control on or off, overriding the capabilities. */
+    withInteractive?: boolean;
+    /**
+     * Renders the remaining character count when the capabilities define a maximum length.
+     * @default true
+     */
+    withCharacterCount?: boolean;
+    /** Props passed to the `Modal` that holds the template selector. */
+    templateModalProps?: ForwardedProps<ModalProps>;
+    /** Props passed to the `Modal` that holds the interactive message editor. */
+    interactiveModalProps?: ForwardedProps<ModalProps>;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppComposerProps extends Omit<BoxProps, keyof WhatsAppComposerOwnProps>, WhatsAppComposerOwnProps {
+}
+export interface WhatsAppComposerEmits {
+    /** Emitted whenever the draft text changes. */
+    'update:modelValue': [value: string];
+    /** Emitted whenever the draft text changes, for typing indicators. */
+    typing: [value: string];
+    /** Emitted when the opened state of the template selector changes. */
+    'update:templatesOpened': [opened: boolean];
+    /** Emitted when the opened state of the interactive editor changes. */
+    'update:interactiveOpened': [opened: boolean];
+    /** Emitted when the reply target is cleared. */
+    'update:replyTo': [replyTo: WhatsAppMessageReference | null];
+    /**
+     * Emitted when a message should be sent. The payload is a discriminated union on `kind`, so
+     * the consumer's handler can switch over it exhaustively.
+     */
+    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, with the reason shown to the user. */
+    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: [];
+}
+export interface WhatsAppComposerExposed {
+    /** Moves focus to the text input. */
+    focus: () => void;
+    /** Inserts text at the caret, as the emoji picker does. */
+    insert: (text: string) => void;
+    /** Opens the template selector. */
+    openTemplates: () => void;
+}
+export type WhatsAppComposerFactory = Factory<{
+    props: Omit<WhatsAppComposerProps, 'rootRef'>;
+    slots: WhatsAppComposerSlots;
+    emits: WhatsAppComposerEmits;
+    exposed: WhatsAppComposerExposed;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: WhatsAppComposerStylesNames;
+}>;

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

@@ -0,0 +1,52 @@
+import type { WhatsAppOutgoingMessage, WhatsAppUpload } from '../../types';
+import type { WhatsAppComposerOwnProps, WhatsAppComposerSlots } from './WhatsAppComposer.types';
+declare const defaultProps: {
+    readonly sendOnEnter: true;
+    readonly withEmojiPicker: true;
+    readonly minRows: 1;
+    readonly maxRows: 6;
+    readonly withCharacterCount: true;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppComposerOwnProps, {
+    focus: () => void;
+    insert: (value: string) => void;
+    openTemplates: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    send: (payload: WhatsAppOutgoingMessage) => any;
+    "update:modelValue": (value: string) => any;
+    validationError: (message: string) => any;
+    retrySend: () => any;
+    typing: (value: string) => any;
+    "update:templatesOpened": (opened: boolean) => any;
+    "update:interactiveOpened": (opened: boolean) => any;
+    "update:replyTo": (replyTo: import("../..").WhatsAppMessageReference | null) => any;
+    attachmentsAdd: (payload: import("../..").WhatsAppAttachmentsAddPayload) => any;
+    attachmentsReject: (rejected: import("../..").WhatsAppRejectedFile[]) => any;
+    attachmentRemove: (upload: WhatsAppUpload) => any;
+    attachmentRetry: (upload: WhatsAppUpload) => any;
+    attachmentCancel: (upload: WhatsAppUpload) => any;
+    templatesRetryLoad: () => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppComposerOwnProps> & Readonly<{
+    onSend?: ((payload: WhatsAppOutgoingMessage) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValidationError?: ((message: string) => any) | undefined;
+    onRetrySend?: (() => any) | undefined;
+    onTyping?: ((value: string) => any) | undefined;
+    "onUpdate:templatesOpened"?: ((opened: boolean) => any) | undefined;
+    "onUpdate:interactiveOpened"?: ((opened: boolean) => any) | undefined;
+    "onUpdate:replyTo"?: ((replyTo: import("../..").WhatsAppMessageReference | null) => any) | undefined;
+    onAttachmentsAdd?: ((payload: import("../..").WhatsAppAttachmentsAddPayload) => any) | undefined;
+    onAttachmentsReject?: ((rejected: import("../..").WhatsAppRejectedFile[]) => any) | undefined;
+    onAttachmentRemove?: ((upload: WhatsAppUpload) => any) | undefined;
+    onAttachmentRetry?: ((upload: WhatsAppUpload) => any) | undefined;
+    onAttachmentCancel?: ((upload: WhatsAppUpload) => any) | undefined;
+    onTemplatesRetryLoad?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppComposerSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/lib/components/WhatsAppContactPanel/WhatsAppContactPanel.d.ts

@@ -0,0 +1,9 @@
+export declare const WhatsAppContactPanel: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppContactPanel.types").WhatsAppContactPanelProps, "rootRef">;
+    slots: import("../../component-props.js").WhatsAppContactPanelSlots;
+    emits: import("./WhatsAppContactPanel.types").WhatsAppContactPanelEmits;
+    ref: HTMLElement;
+    element: "aside";
+    stylesNames: import("./WhatsAppContactPanel.types").WhatsAppContactPanelStylesNames;
+}>;
+export type { WhatsAppContactPanelEmits, WhatsAppContactPanelFactory, WhatsAppContactPanelOwnProps, WhatsAppContactPanelProps, WhatsAppContactPanelStylesNames, } from './WhatsAppContactPanel.types';

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

@@ -0,0 +1,40 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { WhatsAppContactPanelSlots } from '../../component-props';
+import type { WhatsAppInboxLabelsOverride } from '../../labels';
+import type { WhatsAppContact, WhatsAppConversationSummary } from '../../types';
+export type WhatsAppContactPanelStylesNames = 'contactPanelRoot' | 'contactPanelHeader' | 'contactPanelTitle' | 'contactPanelBody' | 'contactPanelIdentity' | 'contactPanelName' | 'contactPanelPhone' | 'contactPanelField' | 'contactPanelFieldLabel' | 'contactPanelFieldValue' | 'contactPanelTags' | 'contactPanelFooter' | 'contactPanelEmpty';
+export interface WhatsAppContactPanelOwnProps extends StylesApiProps<WhatsAppContactPanelFactory> {
+    /** Contact to describe. Falls back to the contact of `conversation`. */
+    contact?: WhatsAppContact;
+    /** Conversation the contact belongs to, used for the status and assignee rows. */
+    conversation?: WhatsAppConversationSummary;
+    /**
+     * Renders the close control in the panel header.
+     * @default false
+     */
+    withCloseButton?: boolean;
+    /**
+     * Renders the panel title.
+     * @default true
+     */
+    withHeader?: boolean;
+    /** Overrides the panel title. */
+    title?: string;
+    /** Label overrides. */
+    labels?: WhatsAppInboxLabelsOverride;
+}
+export interface WhatsAppContactPanelProps extends Omit<BoxProps, keyof WhatsAppContactPanelOwnProps>, WhatsAppContactPanelOwnProps {
+}
+export interface WhatsAppContactPanelEmits {
+    /** Emitted when the close control is used. */
+    close: [];
+}
+export type WhatsAppContactPanelFactory = Factory<{
+    props: Omit<WhatsAppContactPanelProps, 'rootRef'>;
+    slots: WhatsAppContactPanelSlots;
+    emits: WhatsAppContactPanelEmits;
+    ref: HTMLElement;
+    element: 'aside';
+    stylesNames: WhatsAppContactPanelStylesNames;
+}>;

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

@@ -0,0 +1,19 @@
+import type { WhatsAppContactPanelSlots } from '../../component-props';
+import type { WhatsAppContactPanelOwnProps } from './WhatsAppContactPanel.types';
+declare const defaultProps: {
+    readonly withCloseButton: false;
+    readonly withHeader: true;
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WhatsAppContactPanelOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<WhatsAppContactPanelOwnProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WhatsAppContactPanelSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

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

@@ -0,0 +1,10 @@
+export declare const WhatsAppConversation: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./WhatsAppConversation.types").WhatsAppConversationProps, "rootRef">;
+    slots: import("../../component-props.js").WhatsAppConversationSlots;
+    emits: import("./WhatsAppConversation.types").WhatsAppConversationEmits;
+    exposed: import("./WhatsAppConversation.types").WhatsAppConversationExposed;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./WhatsAppConversation.types").WhatsAppConversationStylesNames;
+}>;
+export type { WhatsAppConversationEmits, WhatsAppConversationExposed, WhatsAppConversationFactory, WhatsAppConversationOwnProps, WhatsAppConversationProps, WhatsAppConversationStylesNames, } from './WhatsAppConversation.types';