@solostylist/ui-kit 1.0.230 → 2.0.1

package/dist/s-dialog/s-dialog.d.ts

@@ -1,27 +1,49 @@
-import { Breakpoint, DialogProps } from '@mui/material';
+import { DialogProps, DialogSlots } from '@mui/material/Dialog';
+import { DialogActionsProps } from '@mui/material/DialogActions';
+import { DialogContentProps } from '@mui/material/DialogContent';
+import { DialogTitleProps } from '@mui/material/DialogTitle';
+import { IconButtonProps } from '@mui/material/IconButton';
+import { TypographyProps } from '@mui/material/Typography';
+import { OwnerStateSlotProps as MuiOwnerStateSlotProps } from '../utils/slots';
 import * as React from 'react';
-/**
- * Props for the SDialog component.
- */
-export interface SDialogProps extends Omit<DialogProps, 'title' | 'content' | 'onClose' | 'open' | 'maxWidth' | 'children'> {
-    /** Dialog title - can be string or React element */
-    title?: string | React.ReactNode;
-    /** Dialog content - can be string (auto-wrapped in Typography) or React element */
-    content?: string | React.ReactNode;
-    /** Action buttons rendered in the dialog footer */
+export interface SDialogOwnerState {
+    hasActions: boolean;
+    hasTitle: boolean;
+}
+type OwnerStateSlotProps<Props> = MuiOwnerStateSlotProps<Props, SDialogOwnerState>;
+export interface SDialogSlots extends DialogSlots {
+    actions?: React.ElementType;
+    closeButton?: React.ElementType;
+    content?: React.ElementType;
+    title?: React.ElementType;
+    titleContent?: React.ElementType;
+}
+export type SDialogSlotProps = NonNullable<DialogProps['slotProps']> & {
+    actions?: OwnerStateSlotProps<DialogActionsProps>;
+    closeButton?: OwnerStateSlotProps<IconButtonProps>;
+    content?: OwnerStateSlotProps<DialogContentProps>;
+    title?: OwnerStateSlotProps<DialogTitleProps>;
+    titleContent?: OwnerStateSlotProps<TypographyProps>;
+};
+export interface SDialogProps extends Omit<DialogProps, 'children' | 'slots' | 'slotProps' | 'title'> {
+    /** Content rendered in DialogContent. */
+    children?: React.ReactNode;
+    /** Content rendered in DialogActions. */
     actions?: React.ReactNode;
-    /** Callback fired when dialog should close */
-    onClose?: () => void;
-    /** Whether the dialog is open */
-    open?: boolean;
-    /** Maximum width constraint (Material-UI breakpoint) */
-    maxWidth?: Breakpoint;
-    /** Whether to wrap content in a form element */
-    useForm?: boolean;
-    /** Form submit handler (only used if useForm is true) */
-    onSubmit?: () => void;
-    /** Whether to show the close button in the title bar */
-    showClose?: boolean;
+    /** Accessible text for the close button. */
+    closeText?: string;
+    /** Render title strings without the default Typography wrapper. */
+    disableTypography?: boolean;
+    /** Handles explicit close-button activation; Dialog `onClose` remains reserved for MUI close reasons. */
+    onCloseButtonClick?: IconButtonProps['onClick'];
+    /** Controls the optional close button. Defaults to whether `onCloseButtonClick` is provided. */
+    showCloseButton?: boolean;
+    /** Components used for both MUI Dialog slots and structural slots. */
+    slots?: SDialogSlots;
+    /** Props for both MUI Dialog slots and structural slots. */
+    slotProps?: SDialogSlotProps;
+    /** Dialog title content. */
+    title?: React.ReactNode;
 }
 export declare const SDialog: React.ForwardRefExoticComponent<Omit<SDialogProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export default SDialog;

package/dist/s-dialog/s-dialog.js

@@ -1,43 +1,80 @@
-import { t as e } from "../Close-CJu3iF1p.js";
-import * as t from "react";
-import { Fragment as n, jsx as r, jsxs as i } from "react/jsx-runtime";
-import { Dialog as a, DialogActions as o, DialogContent as s, DialogTitle as c, IconButton as l, Stack as u, Typography as d } from "@mui/material";
+import { styled as e, useThemeProps as t } from "@mui/material/styles";
+import n from "@mui/material/IconButton";
+import * as r from "react";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import o from "@mui/material/Typography";
+import { mergeSlotProps as s } from "@mui/material/utils";
+import c from "@mui/utils/appendOwnerState";
+import l from "@mui/icons-material/Close";
+import u from "@mui/material/Stack";
+import d from "@mui/material/Dialog";
+import f from "@mui/material/DialogActions";
+import p from "@mui/material/DialogContent";
+import m from "@mui/material/DialogTitle";
 //#region lib/s-dialog/s-dialog.tsx
-var f = t.forwardRef(({ title: t, content: f, actions: p, onClose: m = () => {}, open: h = !1, maxWidth: g = "sm", useForm: _ = !1, onSubmit: v = () => {}, showClose: y = !0, ...b }, x) => {
-	let S = /* @__PURE__ */ i(n, { children: [f && /* @__PURE__ */ r(s, {
-		ref: x,
-		children: typeof f == "string" ? /* @__PURE__ */ r(d, {
-			variant: "body1",
-			children: f
-		}) : f
-	}), p && /* @__PURE__ */ r(o, { children: p })] });
-	return /* @__PURE__ */ i(a, {
-		fullWidth: !0,
-		maxWidth: g,
-		onClose: m,
-		open: h,
-		...b,
-		children: [t && /* @__PURE__ */ r(c, { children: /* @__PURE__ */ i(u, {
-			direction: "row",
-			spacing: 3,
-			sx: {
-				alignItems: "center",
-				justifyContent: "space-between"
-			},
-			children: [typeof t == "string" ? /* @__PURE__ */ r(d, {
-				variant: "h5",
-				sx: { textTransform: "capitalize" },
-				children: t
-			}) : /* @__PURE__ */ r("div", { children: t }), y && /* @__PURE__ */ r(l, {
-				onClick: m,
-				children: /* @__PURE__ */ r(e, {})
-			})]
-		}) }), _ ? /* @__PURE__ */ r("form", {
-			onSubmit: v,
-			children: S
-		}) : S]
+var h = e(d, {
+	name: "SDialog",
+	slot: "Root"
+})({});
+function g(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+var _ = r.forwardRef(function(e, d) {
+	let _ = t({
+		props: e,
+		name: "SDialog"
+	}), { actions: v, "aria-labelledby": y, children: b, closeText: x = "Close dialog", disableTypography: S = !1, fullWidth: C = !0, maxWidth: w = "sm", onCloseButtonClick: T, open: E, showCloseButton: D, slotProps: O, slots: k, title: A, ...j } = _, M = r.useId(), N = A != null, P = {
+		..._,
+		hasActions: v != null,
+		hasTitle: N
+	}, F = D ?? T != null, { actions: I = f, closeButton: ee = n, content: L = p, title: R = m, titleContent: z = o, ...B } = k ?? {}, { actions: V, closeButton: H, content: U, title: W, titleContent: G, ...K } = O ?? {}, q = c(k?.actions, g(V, P) ?? {}, P), J = c(k?.closeButton, g(H, P) ?? {}, P), Y = c(k?.content, g(U, P) ?? {}, P), X = c(k?.title, g(W, P) ?? {}, P), Z = c(k?.titleContent, g(G, P) ?? {}, P), Q = s(J, { onClick: T }), $ = X.id ?? (N ? M : void 0), te = y ?? $;
+	return /* @__PURE__ */ a(h, {
+		...j,
+		ref: d,
+		"aria-labelledby": te,
+		fullWidth: C,
+		maxWidth: w,
+		onClose: _.onClose,
+		open: E,
+		ownerState: P,
+		slots: B,
+		slotProps: K,
+		children: [
+			(N || F) && /* @__PURE__ */ i(R, {
+				...X,
+				id: $,
+				children: /* @__PURE__ */ a(u, {
+					direction: "row",
+					spacing: 3,
+					sx: {
+						alignItems: "center",
+						justifyContent: N ? "space-between" : "flex-end"
+					},
+					children: [N && typeof A == "string" && !S ? /* @__PURE__ */ i(z, {
+						variant: "h5",
+						...Z,
+						children: A
+					}) : N && /* @__PURE__ */ i("div", { children: A }), F && /* @__PURE__ */ i(ee, {
+						"aria-label": x,
+						...Q,
+						children: /* @__PURE__ */ i(l, {})
+					})]
+				})
+			}),
+			b != null && /* @__PURE__ */ i(L, {
+				...Y,
+				children: typeof b == "string" ? /* @__PURE__ */ i(o, {
+					variant: "body1",
+					children: b
+				}) : b
+			}),
+			v != null && /* @__PURE__ */ i(I, {
+				...q,
+				children: v
+			})
+		]
 	});
 });
-f.displayName = "SDialog";
+_.displayName = "SDialog";
 //#endregion
-export { f as SDialog, f as default };
+export { _ as SDialog, _ as default };

package/dist/s-dialog-confirm/index.d.ts

@@ -1,2 +1,3 @@
 export { default, default as SDialogConfirm, DialogConfirmProvider, useDialogConfirm } from './s-dialog-confirm';
-export type { DialogConfirmContextProps, DialogConfirmOpenOptions, SDialogConfirmProps } from './s-dialog-confirm';
+export type { DialogConfirmContextProps, DialogConfirmOpenOptions, DialogConfirmProviderProps, SDialogConfirmOwnerState, SDialogConfirmProps, SDialogConfirmSlotProps, SDialogConfirmSlots, } from './s-dialog-confirm';
+export type {} from '../theme/component-augmentation';

package/dist/s-dialog-confirm/s-dialog-confirm.d.ts

@@ -1,71 +1,55 @@
-import { Breakpoint } from '@mui/material';
+import { ButtonProps } from '@mui/material/Button';
+import { SDialogProps, SDialogSlotProps, SDialogSlots } from '../s-dialog';
+import { OwnerStateSlotProps as MuiOwnerStateSlotProps } from '../utils/slots';
 import * as React from 'react';
-/**
- * Props interface for SDialogConfirm component
- */
-export interface SDialogConfirmProps {
-    /** Dialog title - can be string or React element */
-    title?: string | React.ReactNode;
-    /** Dialog content - can be string (auto-wrapped in Typography) or React element */
-    content?: string | React.ReactNode;
-    /** Callback fired when user confirms the action */
-    onConfirm?: () => void;
-    /** Callback fired when dialog should close */
-    onClose?: () => void;
-    /** Whether the dialog is open */
-    open?: boolean;
-    /** Maximum width constraint (Material-UI breakpoint) */
-    maxWidth?: Breakpoint;
-    /** Whether to show the close button in the title bar */
-    showClose?: boolean;
-    /** Whether the dialog is in loading state (disables buttons) */
-    loading?: boolean;
-    /** Text for the cancel button */
-    cancelText?: string;
-    /** Text for the confirm button */
-    confirmText?: string;
-    /** Accessible text for the close button */
-    closeText?: string;
+export interface SDialogConfirmOwnerState {
+    loading: boolean;
+}
+type OwnerStateSlotProps<Props> = MuiOwnerStateSlotProps<Props, SDialogConfirmOwnerState>;
+export interface SDialogConfirmSlots extends SDialogSlots {
+    cancelButton?: React.ElementType;
+    confirmButton?: React.ElementType;
 }
-export declare const SDialogConfirm: {
-    ({ title, content, onConfirm, onClose, open, maxWidth, showClose, loading, cancelText, confirmText, closeText, }: SDialogConfirmProps): React.JSX.Element;
-    displayName: string;
+export type SDialogConfirmSlotProps = SDialogSlotProps & {
+    cancelButton?: OwnerStateSlotProps<ButtonProps>;
+    confirmButton?: OwnerStateSlotProps<ButtonProps>;
 };
-export default SDialogConfirm;
-/**
- * Options for opening a confirmation dialog
- */
-export interface DialogConfirmOpenOptions {
-    /** Dialog title */
-    title: string;
-    /** Dialog content/message */
-    content: string;
-    /** Callback executed when user confirms */
-    onConfirm: () => void;
+type DialogConfirmContent = Exclude<React.ReactNode, null | undefined | boolean>;
+type DialogConfirmActionHandler = NonNullable<ButtonProps['onClick']>;
+export interface SDialogConfirmProps extends Omit<SDialogProps, 'actions' | 'children' | 'slotProps' | 'slots' | 'title'> {
+    /** Confirmation content rendered in DialogContent. */
+    children: DialogConfirmContent;
+    /** Text for the cancel button. */
+    cancelText?: React.ReactNode;
+    /** Text for the confirm button. */
+    confirmText?: React.ReactNode;
+    /** Disables actions and activates MUI Button loading state. */
+    loading?: boolean;
+    /** Handles cancel-button activation. */
+    onCancel: DialogConfirmActionHandler;
+    /** Handles confirm-button activation. */
+    onConfirm: DialogConfirmActionHandler;
+    /** Components used for MUI Dialog and confirmation-action slots. */
+    slots?: SDialogConfirmSlots;
+    /** Props or owner-state callbacks for MUI Dialog and confirmation-action slots. */
+    slotProps?: SDialogConfirmSlotProps;
+    /** Accessible dialog title rendered in DialogTitle. */
+    title: DialogConfirmContent;
 }
-/**
- * Context value interface for DialogConfirm system
- */
+export declare const SDialogConfirm: React.ForwardRefExoticComponent<Omit<SDialogConfirmProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export default SDialogConfirm;
+export type DialogConfirmOpenOptions = Omit<SDialogConfirmProps, 'onCancel' | 'open'> & {
+    onCancel?: SDialogConfirmProps['onCancel'];
+};
 export interface DialogConfirmContextProps {
-    /** Function to open a confirmation dialog */
-    handleOpen: (dialogConfirmOptions: DialogConfirmOpenOptions) => void;
-    /** Function to close the dialog */
-    handleClose: () => void;
-    /** Current open state of the dialog */
-    open: boolean;
-    /** Loading state for async operations */
+    closeConfirm: () => void;
     loading: boolean;
-    /** Function to set loading state */
+    open: boolean;
     setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    showConfirm: (options: DialogConfirmOpenOptions) => void;
 }
-export declare const DialogConfirmProvider: ({ children }: {
+export interface DialogConfirmProviderProps {
     children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
-/**
- * Hook to access the confirmation dialog context.
- * Must be used within a DialogConfirmProvider.
- *
- * @returns DialogConfirmContextProps - Context with dialog management functions
- * @throws Error if used outside of DialogConfirmProvider
- */
-export declare const useDialogConfirm: () => DialogConfirmContextProps;
+}
+export declare function DialogConfirmProvider({ children }: DialogConfirmProviderProps): React.JSX.Element;
+export declare function useDialogConfirm(): DialogConfirmContextProps;

package/dist/s-dialog-confirm/s-dialog-confirm.js

@@ -1,90 +1,108 @@
-import { t as e } from "../Typography-CZ_MYa-E.js";
-import { t } from "../Close-CJu3iF1p.js";
-import { useDialog as n } from "../hooks/use-dialog.js";
+import { SDialog as e } from "../s-dialog/s-dialog.js";
+import { styled as t, useThemeProps as n } from "@mui/material/styles";
 import * as r from "react";
 import { Fragment as i, jsx as a, jsxs as o } from "react/jsx-runtime";
-import { Button as s, Dialog as c, DialogActions as l, DialogContent as u, DialogTitle as d, IconButton as f, Stack as p } from "@mui/material";
+import s from "@mui/utils/appendOwnerState";
+import c from "@mui/material/Button";
 //#region lib/s-dialog-confirm/s-dialog-confirm.tsx
-var m = ({ title: n, content: r, onConfirm: m = () => {}, onClose: h = () => {}, open: g = !1, maxWidth: _ = "sm", showClose: v = !0, loading: y = !1, cancelText: b = "Cancel", confirmText: x = "Confirm", closeText: S = "Close" }) => /* @__PURE__ */ o(c, {
-	fullWidth: !0,
-	maxWidth: _,
-	onClose: h,
-	open: g,
-	children: [
-		n && /* @__PURE__ */ a(d, { children: /* @__PURE__ */ o(p, {
-			direction: "row",
-			spacing: 3,
-			sx: {
-				alignItems: "center",
-				justifyContent: "space-between"
-			},
-			children: [typeof n == "string" ? /* @__PURE__ */ a(e, {
-				variant: "h5",
-				children: n
-			}) : /* @__PURE__ */ a("div", { children: n }), v && /* @__PURE__ */ a(f, {
-				"aria-label": S,
-				onClick: h,
-				children: /* @__PURE__ */ a(t, {})
-			})]
-		}) }),
-		r && /* @__PURE__ */ a(u, { children: typeof r == "string" ? /* @__PURE__ */ a(e, {
-			variant: "body1",
-			children: r
-		}) : r }),
-		/* @__PURE__ */ a(l, { children: /* @__PURE__ */ o(i, { children: [/* @__PURE__ */ a(s, {
-			onClick: h,
+var l = t(e, {
+	name: "SDialogConfirm",
+	slot: "Root"
+})({});
+function u(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function d(e, t) {
+	return (n) => {
+		e?.(n), n.defaultPrevented || t(n);
+	};
+}
+function f(e) {
+	return e == null || typeof e == "boolean" ? !1 : typeof e != "string" || e.trim().length > 0;
+}
+function p(e) {
+	return "defaultPrevented" in e && e.defaultPrevented === !0;
+}
+var m = r.forwardRef(function(e, t) {
+	let r = n({
+		props: e,
+		name: "SDialogConfirm"
+	}), { cancelText: p = "Cancel", children: m, confirmText: h = "Confirm", loading: g = !1, onCancel: _, onCloseButtonClick: v, onConfirm: y, showCloseButton: b, slotProps: x, slots: S, title: C, ...w } = r, T = {
+		...r,
+		loading: g
+	}, { cancelButton: E = c, confirmButton: D = c, ...O } = S ?? {}, { cancelButton: k, confirmButton: A, ...j } = x ?? {}, M = u(k, T), N = u(A, T), P = {
+		...M,
+		onClick: d(M?.onClick, _)
+	}, F = {
+		...N,
+		onClick: d(N?.onClick, y)
+	}, I = s(S?.cancelButton, P, T), L = s(S?.confirmButton, F, T), R = g || !!I.disabled, z = g || !!L.disabled, B = g || !!L.loading, V = v ?? _, H = f(C), U = f(m);
+	return /* @__PURE__ */ a(l, {
+		...w,
+		ref: t,
+		actions: /* @__PURE__ */ o(i, { children: [/* @__PURE__ */ a(E, {
 			variant: "outlined",
-			disabled: y,
-			children: b
-		}), /* @__PURE__ */ a(s, {
-			onClick: m,
-			loading: y,
-			children: x
-		})] }) })
-	]
+			...I,
+			disabled: R,
+			children: p
+		}), /* @__PURE__ */ a(D, {
+			...L,
+			disabled: z,
+			loading: B,
+			children: h
+		})] }),
+		onCloseButtonClick: (e) => {
+			e.defaultPrevented || V(e);
+		},
+		ownerState: T,
+		showCloseButton: H ? b : !1,
+		slots: O,
+		slotProps: j,
+		title: H ? C : void 0,
+		children: U ? m : void 0
+	});
 });
 m.displayName = "SDialogConfirm";
-var h = r.createContext(null), g = ({ children: e }) => {
-	let t = n(), [i, s] = r.useState(!1), [c, l] = r.useState({
-		title: "",
-		content: "",
-		onConfirm: () => {}
-	}), u = r.useCallback((e) => {
-		let { title: n, content: r, onConfirm: i } = e;
-		l({
-			title: n,
-			content: r,
-			onConfirm: i
-		}), t.handleOpen();
-	}, [t]), d = r.useMemo(() => ({
-		handleOpen: u,
-		handleClose: t.handleClose,
-		open: t.open,
+var h = r.createContext(null);
+function g({ children: e }) {
+	let [t, n] = r.useState(null), [i, s] = r.useState(!1), c = t != null, l = r.useCallback(() => {
+		n(null), s(!1);
+	}, []), u = r.useCallback((e) => {
+		s(!1), n(e);
+	}, []), d = r.useMemo(() => ({
+		closeConfirm: l,
 		loading: i,
-		setLoading: s
+		open: c,
+		setLoading: s,
+		showConfirm: u
 	}), [
-		t.handleClose,
-		t.open,
-		u,
-		i
+		l,
+		i,
+		c,
+		u
 	]);
 	return /* @__PURE__ */ o(h.Provider, {
 		value: d,
-		children: [/* @__PURE__ */ a(m, {
-			open: t.open,
-			title: c.title,
-			content: c.content,
-			onClose: t.handleClose,
-			onConfirm: () => {
-				c.onConfirm();
+		children: [t && /* @__PURE__ */ a(m, {
+			...t,
+			loading: i || t.loading,
+			open: !0,
+			onCancel: (e) => {
+				t.onCancel?.(e), e.defaultPrevented || l();
+			},
+			onClose: (e, n) => {
+				t.onClose?.(e, n), p(e) || l();
 			},
-			loading: i
+			onCloseButtonClick: (e) => {
+				t.onCloseButtonClick?.(e), e.defaultPrevented || l();
+			}
 		}), e]
 	});
-}, _ = () => {
+}
+function _() {
 	let e = r.useContext(h);
 	if (!e) throw Error("useDialogConfirm must be used within a DialogConfirmProvider");
 	return e;
-};
+}
 //#endregion
 export { g as DialogConfirmProvider, m as SDialogConfirm, m as default, _ as useDialogConfirm };

package/dist/s-dialog-message/index.d.ts

@@ -1,2 +1,3 @@
 export { default, default as SDialogMessage, DialogMessageProvider, useDialogMessage } from './s-dialog-message';
-export type { DialogMessageOpenOptions, DialogMessageContextProps, SDialogMessageProps } from './s-dialog-message';
+export type { DialogMessageContextProps, DialogMessageOpenOptions, DialogMessageProviderProps, SDialogMessageOwnerState, SDialogMessageProps, SDialogMessageSlotProps, SDialogMessageSlots, } from './s-dialog-message';
+export type {} from '../theme/component-augmentation';

package/dist/s-dialog-message/s-dialog-message.d.ts

@@ -1,59 +1,42 @@
-import { Breakpoint } from '@mui/material';
+import { ButtonProps } from '@mui/material/Button';
+import { SDialogProps, SDialogSlotProps, SDialogSlots } from '../s-dialog';
+import { OwnerStateSlotProps } from '../utils/slots';
 import * as React from 'react';
-/**
- * Props interface for SDialogMessage component
- */
-export interface SDialogMessageProps {
-    /** Dialog title - can be string or React element */
-    title?: string | React.ReactNode;
-    /** Dialog content - can be string (auto-wrapped in Typography) or React element */
-    content?: string | React.ReactNode;
-    /** Callback fired when dialog should close */
-    onClose?: () => void;
-    /** Callback fired when user clicks OK button */
-    onOk?: () => void;
-    /** Whether the dialog is open */
-    open?: boolean;
-    /** Maximum width constraint (Material-UI breakpoint) */
-    maxWidth?: Breakpoint;
-    /** Whether to show the close button in the title bar */
-    showClose?: boolean;
+export interface SDialogMessageSlots extends SDialogSlots {
+    okButton?: React.ElementType;
 }
-export declare const SDialogMessage: {
-    ({ title, content, onClose, onOk, open, maxWidth, showClose, }: SDialogMessageProps): React.JSX.Element;
-    displayName: string;
+export interface SDialogMessageOwnerState {
+    okText: React.ReactNode;
+    showCloseButton: boolean;
+}
+export type SDialogMessageSlotProps = SDialogSlotProps & {
+    okButton?: OwnerStateSlotProps<ButtonProps, SDialogMessageOwnerState>;
 };
-export default SDialogMessage;
-/**
- * Options for opening a message dialog
- */
-export interface DialogMessageOpenOptions {
-    /** Dialog title */
-    title?: string;
-    /** Dialog content/message */
-    content?: string;
-    /** Optional callback executed when user clicks OK */
-    onOk?: () => void;
+type DialogMessageActionHandler = NonNullable<ButtonProps['onClick']>;
+export interface SDialogMessageProps extends Omit<SDialogProps, 'actions' | 'children' | 'slotProps' | 'slots'> {
+    /** Message content rendered in DialogContent. */
+    children?: React.ReactNode;
+    /** Content of the acknowledgement button. */
+    okText?: React.ReactNode;
+    /** Handles acknowledgement-button activation. */
+    onOk: DialogMessageActionHandler;
+    /** Components used for MUI Dialog and acknowledgement slots. */
+    slots?: SDialogMessageSlots;
+    /** Props for MUI Dialog and acknowledgement slots. */
+    slotProps?: SDialogMessageSlotProps;
 }
-/**
- * Context value interface for DialogMessage system
- */
+export declare const SDialogMessage: React.ForwardRefExoticComponent<Omit<SDialogMessageProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export default SDialogMessage;
+export type DialogMessageOpenOptions = Omit<SDialogMessageProps, 'onOk' | 'open'> & {
+    onOk?: SDialogMessageProps['onOk'];
+};
 export interface DialogMessageContextProps {
-    /** Function to open a message dialog */
-    handleOpen: (dialogMessageOptions: DialogMessageOpenOptions) => void;
-    /** Function to close the dialog */
-    handleClose: () => void;
-    /** Current open state of the dialog */
+    closeMessage: () => void;
     open: boolean;
+    showMessage: (options: DialogMessageOpenOptions) => void;
 }
-export declare const DialogMessageProvider: ({ children }: {
+export interface DialogMessageProviderProps {
     children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
-/**
- * Hook to access the message dialog context.
- * Must be used within a DialogMessageProvider.
- *
- * @returns DialogMessageContextProps - Context with dialog management functions
- * @throws Error if used outside of DialogMessageProvider
- */
-export declare const useDialogMessage: () => DialogMessageContextProps;
+}
+export declare function DialogMessageProvider({ children }: DialogMessageProviderProps): React.JSX.Element;
+export declare function useDialogMessage(): DialogMessageContextProps;