@servicetitan/anvil2 1.44.2 → 1.45.0

package/dist/components/TextField/TextField.d.ts

@@ -1,7 +1,6 @@
-import { TextFieldProps as CoreTextFieldProps } from '@servicetitan/hammer-react';
-import { DistributiveOmit } from '../../types';
-import { DataTrackingId } from '../../types/DataTrackingId';
-export type TextFieldProps = DistributiveOmit<CoreTextFieldProps, "prefix"> & DataTrackingId & {
+import { TextFieldProps as CoreTextFieldProps } from './internal/TextField';
+import { MaxLengthCounterProps } from '../../types';
+export type TextFieldProps = Omit<CoreTextFieldProps, "prefix"> & {
     prefix?: string;
-};
+} & MaxLengthCounterProps;
 export declare const TextField: import('react').ForwardRefExoticComponent<TextFieldProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/TextField/internal/TextField.d.ts

@@ -0,0 +1,20 @@
+import { ComponentPropsWithoutRef, ReactElement, ReactNode } from 'react';
+import { DataTrackingId, LayoutUtilProps, Size, MaxLengthCounterProps } from '../../../types';
+import { HelperProps } from '../../../internal/components';
+import { FieldLabelProps } from '../../FieldLabel';
+export type TextFieldProps = Omit<ComponentPropsWithoutRef<"input">, "size" | "prefix"> & LayoutUtilProps & {
+    error?: ReactElement | string | boolean;
+    label?: FieldLabelProps["children"];
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+    size?: Extract<Size, "small" | "medium" | "large">;
+    type?: "text" | "email" | "tel" | "url" | "password" | "number";
+    description?: HelperProps["description"];
+    errorAriaLive?: HelperProps["errorAriaLive"];
+    hint?: HelperProps["hint"];
+    loading?: boolean;
+    disabled?: boolean;
+    labelProps?: FieldLabelProps;
+    moreInfo?: ReactNode;
+} & MaxLengthCounterProps & DataTrackingId;
+export declare const TextField: import('react').ForwardRefExoticComponent<TextFieldProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/Textarea/Textarea.d.ts

@@ -1,25 +1,58 @@
-import { TextareaProps as CoreTextareaProps } from '@servicetitan/hammer-react';
-import { DataTrackingId } from '../../types/DataTrackingId';
+import { ChangeEvent, ComponentPropsWithoutRef, ReactElement } from 'react';
+import { DataTrackingId, LayoutUtilProps, MaxLengthCounterProps } from '../../types';
+import { FieldLabelProps } from '../FieldLabel';
+import { HelperProps } from '../../internal/components';
+import { TextareaAutosizeConditionalProps, TextareaState } from './types';
 /**
  * Props for the Textarea component
- * @property {HelperProps["errorMessage"] | boolean} [error] - Sets error style on textarea. If string or ReactElement provided, places it under the label and sets error style
- * @property {HelperProps["errorAriaLive"] | boolean} [errorAriaLive] - ARIA live region setting for error announcements
- * @property {ReactElement | string} [hint] - Hint text displayed below the textarea
- * @property {ReactElement | string} [description] - Description text displayed below the textarea
- * @property {string | ReactElement} [label] - Label for textarea (required for accessibility)
- * @property {boolean} [disableResize] - Sets textarea's element no user-controllable method for resizing
- * @property {(e?: ChangeEvent<HTMLTextAreaElement>, state?: TextareaState) => void} [onChange] - Fires on each change of textarea's value
- * @property {boolean} [showCounter] - Show character counter
- * @property {number} [maxLength] - Maximum number of characters allowed
- * @property {boolean} [autoHeight] - Auto height mode on typing
- * @property {number} [maxRows] - Maximum number of rows when auto-height is enabled
- * @property {number} [minRows] - Minimum number of rows when auto-height is enabled
- * @extends Omit<ComponentPropsWithoutRef<"textarea">, "onChange" | "required">
- * @extends LayoutUtilProps
- * @extends FieldLabelProps
- * @extends DataTrackingId
  */
-export type TextareaProps = CoreTextareaProps & DataTrackingId;
+export type TextareaProps = Omit<ComponentPropsWithoutRef<"textarea">, "onChange"> & LayoutUtilProps & DataTrackingId & MaxLengthCounterProps & TextareaAutosizeConditionalProps & Pick<FieldLabelProps, "moreInfo" | "openMoreInfo"> & {
+    /**
+     * Sets error style on textarea.
+     * If string or ReactElement provided, places it under the label and sets error style.
+     * Note: error string replaces helpText over, if both present.
+     */
+    error?: HelperProps["errorMessage"] | boolean;
+    /**
+     * Hint text displayed below the textarea
+     */
+    hint?: ReactElement | string;
+    /**
+     * Description text displayed below the textarea
+     */
+    description?: ReactElement | string;
+    /**
+     * Label for textarea is required
+     * @accessibility This should either be a string or have text content inside for accessibility
+     */
+    label?: string | ReactElement;
+    /**
+     * Sets textarea's element no user-controllable method for resizing
+     * @default false
+     */
+    disableResize?: boolean;
+    /**
+     * Fires on each change of textarea's value
+     * @param e The change event
+     * @param state Object containing the current value
+     */
+    onChange?: (e?: ChangeEvent<HTMLTextAreaElement>, state?: TextareaState) => void;
+    /**
+     * Props passed to the internal label component.
+     */
+    labelProps?: FieldLabelProps;
+} & ({
+    /**
+     * ARIA live region setting for error announcements
+     */
+    errorAriaLive?: HelperProps["errorAriaLive"];
+} | {
+    /**
+     * ARIA live region setting for error announcements
+     * @deprecated Boolean value is no longer supported. Use `"off" | "assertive" | "polite"` instead
+     */
+    errorAriaLive?: boolean;
+});
 /**
  * Textarea component for multi-line text input with advanced features.
  *

package/dist/components/Textarea/index.d.ts

@@ -1,2 +1 @@
-export * from './Textarea';
-export { Textarea as default } from './Textarea';
+export { Textarea as default, type TextareaProps, Textarea } from './Textarea';

package/dist/components/Textarea/types.d.ts

@@ -0,0 +1,35 @@
+import { TextareaAutosizeProps } from 'react-textarea-autosize';
+/**
+ * Conditional props for auto-height functionality
+ */
+export type TextareaAutosizeConditionalProps = {
+    /**
+     * Auto height mode on typing
+     */
+    autoHeight: true;
+    /**
+     * Maximum number of rows when auto-height is enabled
+     */
+    maxRows?: TextareaAutosizeProps["maxRows"];
+    /**
+     * Minimum number of rows when auto-height is enabled
+     */
+    minRows?: TextareaAutosizeProps["minRows"];
+} | {
+    /**
+     * Auto height mode on typing
+     * @default false
+     */
+    autoHeight?: false;
+    maxRows?: never;
+    minRows?: never;
+};
+/**
+ * State object passed to onChange callback
+ */
+export type TextareaState = {
+    /**
+     * Current value of the textarea
+     */
+    value?: string | number | readonly string[];
+};

package/dist/components/TimeField/TimeField.d.ts

@@ -1,23 +1,60 @@
-import { TimeFieldProps as CoreTimeFieldProps, TimeFieldChange } from '@servicetitan/hammer-react';
-import { DataTrackingId } from '../../types/DataTrackingId';
+import { DataTrackingId } from '../../types';
+import { TextFieldProps } from '../TextField';
+import { TimeFieldChangeHandler, TimeFormat } from './internal/types';
 /**
- * Props for the TimeField component
- * @property {string | null} [value] - The current value of the time field
- * @property {string | null} [defaultValue] - The default value for uncontrolled mode
- * @property {TimeFieldChangeHandler} [onChange] - Callback when the time value changes
- * @property {TimeFormat} [format] - Time format to use
- * @property {number} [step] - Time increment in minutes
- * @property {string | null} [min] - Minimum allowed time
- * @property {string | null} [max] - Maximum allowed time
- * @property {boolean} [autoround] - Whether to automatically round to the nearest step
- * @property {boolean} [disableSuggestions] - Whether to disable the dropdown suggestions
- * @extends DataTrackingId
+ * Props for the TimeField component.
+ * @extends Omit<TextFieldProps, "onChange" | "value" | "defaultValue" | "type" | "min" | "max" | "step" | "maxLength" | "showCounter">
  */
-export type TimeFieldProps = CoreTimeFieldProps & DataTrackingId;
-/**
- * Change event data for TimeField onChange callback.
- */
-export type { TimeFieldChange };
+export type TimeFieldProps = Omit<TextFieldProps, "onChange" | "value" | "defaultValue" | "type" | "min" | "max" | "step" | "maxLength" | "showCounter" | "prefix"> & {
+    /**
+     * The current value of the time field.
+     * @example "14:30" or "02:30 PM"
+     */
+    value?: string | null;
+    /**
+     * The default value for uncontrolled mode.
+     * @example "14:30" or "02:30 PM"
+     */
+    defaultValue?: string | null;
+    /**
+     * Callback when the time value changes.
+     */
+    onChange?: TimeFieldChangeHandler;
+    /**
+     * Time format to use.
+     * @default 12
+     */
+    format?: TimeFormat;
+    /**
+     * Time increment in minutes.
+     * @default 30
+     */
+    step?: number;
+    /**
+     * Whether to automatically round to the nearest step.
+     * @default false
+     */
+    autoround?: boolean;
+    /**
+     * Whether to disable the dropdown suggestions.
+     * @default false
+     */
+    disableSuggestions?: boolean;
+} & ({
+    /**
+     * Minimum allowed time constraint.
+     * @example "09:00 AM" or "09:00"
+     */
+    min: string;
+    /**
+     * Maximum allowed time constraint.
+     * @example "05:00 PM" or "17:00"
+     */
+    max: string;
+} | {
+    min?: never;
+    max?: never;
+}) & DataTrackingId;
 /**
  * TimeField component for entering time values with auto-rounding and suggestions.
  *

package/dist/components/TimeField/index.d.ts

@@ -1 +1,3 @@
 export * from './TimeField';
+export { TimeField as default, type TimeFieldProps } from './TimeField';
+export { type TimeFieldChange } from './internal/types';

package/dist/components/TimeField/internal/MaskedTimeInput.d.ts

@@ -0,0 +1,87 @@
+import { TimeFormat } from './types';
+import { TextFieldProps } from '../../TextField/internal/TextField';
+/**
+ * Change event data for MaskedTimeInput onInputChange callback.
+ */
+export type MaskedTimeInputChange = {
+    /**
+     * The original input change event.
+     */
+    event: React.ChangeEvent<HTMLInputElement>;
+    /**
+     * The parsed time as a string if valid, otherwise null.
+     */
+    time: string | null;
+    /**
+     * True if the input matches the mask and is not empty.
+     */
+    isInputValid: boolean;
+    /**
+     * True if the input is empty.
+     */
+    isInputEmpty: boolean;
+};
+/**
+ * Props for the MaskedTimeInput component.
+ * @extends Omit<TextFieldProps, "onChange" | "value" | "ref" | "showCounter" | "prefix" | "type" | "maxLength" | "hint">
+ */
+export interface MaskedTimeInputProps extends Omit<TextFieldProps, "onChange" | "value" | "ref" | "showCounter" | "prefix" | "type" | "maxLength" | "hint"> {
+    /**
+     * External time selection from dropdown
+     */
+    selectedTime?: string | null;
+    /**
+     * The time format (12 or 24 hour).
+     */
+    format: TimeFormat;
+    /**
+     * The placeholder string for the input.
+     */
+    placeholder: string;
+    /**
+     * Minimum allowed time constraint.
+     */
+    min?: string;
+    /**
+     * Maximum allowed time constraint.
+     */
+    max?: string;
+    /**
+     * Callback fired when the input value changes.
+     */
+    onInputChange?: (change: MaskedTimeInputChange) => void;
+    /**
+     * Callback fired when a key is pressed.
+     */
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /**
+     * Callback fired when the input receives focus.
+     */
+    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /**
+     * Data attribute indicating if the current input is valid.
+     */
+    "data-input-valid"?: boolean;
+}
+/**
+ * A masked time input component for entering time in 12/24 hour format.
+ *
+ * Features:
+ * - Input masking and placeholder using Maskito
+ * - Smart validation and parsing
+ * - Hard-coded clock icon prefix
+ * - Controlled or uncontrolled usage
+ * - Automatic time format conversion
+ * - Placeholder handling and cleanup
+ *
+ * @example
+ * <MaskedTimeInput
+ *   selectedTime="14:30"
+ *   format={24}
+ *   placeholder="––:––"
+ *   onInputChange={(change) => {
+ *     console.log('Input changed:', change.time);
+ *   }}
+ * />
+ */
+export declare const MaskedTimeInput: import('react').ForwardRefExoticComponent<MaskedTimeInputProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/TimeField/internal/constants.d.ts

@@ -0,0 +1,25 @@
+import { TimeFormat } from './types';
+export declare const TIME_CONSTANTS: {
+    /** Minutes in a full day (24 hours * 60 minutes) */
+    readonly MINUTES_IN_DAY: 1440;
+    /** Maximum hour in 24-hour format */
+    readonly MAX_HOUR_24: 23;
+    /** Maximum minute value */
+    readonly MAX_MINUTE: 59;
+    /** Timeout in milliseconds for input debouncing */
+    readonly INPUT_DEBOUNCE_TIMEOUT: 100;
+};
+export declare const FORMAT_CONSTANTS: {
+    /** 12-hour time format */
+    readonly TWELVE_HOUR: 12;
+    /** 24-hour time format */
+    readonly TWENTY_FOUR_HOUR: 24;
+};
+/**
+ * Placeholder strings for different time formats.
+ */
+export declare const TIME_FORMAT_PLACEHOLDERS: Record<TimeFormat, string>;
+/**
+ * Clock icon used as prefix in the time input field.
+ */
+export declare const CLOCK_ICON: import('react').FC<import('react').SVGProps<SVGSVGElement>>;

package/dist/components/TimeField/internal/maskito/timePlaceholderMask.d.ts

@@ -0,0 +1,28 @@
+import { TimeFormat } from '../types';
+/**
+ * Creates Maskito options for time input with placeholder support.
+ *
+ * Features:
+ * - Time-specific masking for 12/24 hour formats
+ * - Placeholder character support
+ * - Filtered preprocessors to avoid conflicts
+ * - Combined plugins and postprocessors
+ *
+ * @param format - The time format (12 or 24 hour)
+ * @param placeholder - The placeholder string to use
+ * @returns Object containing Maskito options and removePlaceholder function
+ */
+declare const timePlaceholderMask: ({ format, placeholder, }: {
+    format: TimeFormat;
+    placeholder: string;
+}) => {
+    options: {
+        plugins: import('@maskito/core').MaskitoPlugin[];
+        preprocessors: import('@maskito/core').MaskitoPreprocessor[];
+        postprocessors: import('@maskito/core').MaskitoPostprocessor[];
+        mask: import('@maskito/core').MaskitoMask;
+        overwriteMode: "replace" | "shift" | ((elementState: import('@maskito/core/src/lib/types').ElementState) => "replace" | "shift");
+    };
+    removePlaceholder: (value: string) => string;
+};
+export default timePlaceholderMask;

package/dist/components/TimeField/internal/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Time format options for the TimeField component.
+ */
+export type TimeFormat = 12 | 24;
+/**
+ * Change event data for TimeField onChange callback.
+ */
+export interface TimeFieldChange {
+    /**
+     * The time in HH:mm format (24-hour) or hh:mm a format (12-hour).
+     * @example "14:30" or "02:30 PM"
+     */
+    time: string | null;
+    /**
+     * Whether the input is valid. That is, it matches the format and is not empty.
+     * This does not mean that the time is valid according to the constraints.
+     */
+    isInputValid: boolean;
+    /**
+     * Whether the input is empty.
+     */
+    isInputEmpty: boolean;
+}
+/**
+ * Callback function type for TimeField onChange events.
+ */
+export type TimeFieldChangeHandler = (change: TimeFieldChange) => void;

package/dist/components/TimeField/internal/utils/timeFormatting.d.ts

@@ -0,0 +1,10 @@
+import { TimeFormat } from '../types';
+/**
+ * Converts hours and minutes to a formatted time string.
+ *
+ * @param hours - Hours (0-23)
+ * @param minutes - Minutes (0-59)
+ * @param format - Target format (12 or 24 hour)
+ * @returns Formatted time string
+ */
+export declare function formatTimeString(hours: number, minutes: number, format: TimeFormat): string;

package/dist/components/TimeField/internal/utils/timeOptions.d.ts

@@ -0,0 +1,24 @@
+import { TimeFormat } from '../types';
+/**
+ * Generates time options for the dropdown based on step, min/max constraints, and format.
+ *
+ * @param step - Time increment in minutes (default 30)
+ * @param min - Minimum allowed time as string
+ * @param max - Maximum allowed time as string
+ * @param format - Time format (12 or 24 hour)
+ * @returns Array of time options formatted as strings
+ */
+export declare function generateTimeOptions({ step, min, max, format, }: {
+    step?: number;
+    min?: string;
+    max?: string;
+    format: TimeFormat;
+}): string[];
+/**
+ * Filters time options based on user input.
+ *
+ * @param options - Array of available time options
+ * @param userInput - The current user input (after Maskito processing)
+ * @returns Filtered array of matching options
+ */
+export declare function filterTimeOptions(options: string[], userInput: string): string[];

package/dist/components/TimeField/internal/utils/timeParsing.d.ts

@@ -0,0 +1,43 @@
+import { TimeFormat } from '../types';
+/**
+ * Maximum hour value for 24-hour format.
+ */
+export declare const MAX_HOUR: 23;
+/**
+ * Maximum minute value.
+ */
+export declare const MAX_MINUTE: 59;
+/**
+ * Converts a time string to total minutes since midnight.
+ *
+ * @param timeStr - Time string in HH:mm format (24-hour)
+ * @returns Total minutes since midnight
+ */
+export declare const timeToMinutes: (timeStr: string) => number;
+/**
+ * Converts a time string between 12-hour and 24-hour formats.
+ *
+ * @param time - Time string to convert
+ * @param targetFormat - Target format (12 or 24)
+ * @returns Converted time string
+ */
+export declare function convertTimeFormat(time: string, targetFormat: TimeFormat): string;
+/**
+ * Parses input value and converts it to a time string with validation.
+ *
+ * @param value - The raw input value (may contain placeholders)
+ * @param format - The time format (12 or 24 hour)
+ * @param removePlaceholder - Function to remove placeholder characters
+ * @param min - Minimum allowed time constraint
+ * @param max - Maximum allowed time constraint
+ * @returns Object containing parsed time string, validation state, and empty state
+ */
+export declare function parseInputValue(value: string, format: TimeFormat, removePlaceholder: (value: string) => string, min?: string, max?: string): {
+    time: null;
+    isInputValid: boolean;
+    isInputEmpty: boolean;
+} | {
+    time: string;
+    isInputValid: boolean;
+    isInputEmpty: boolean;
+};

package/dist/components/TimeField/internal/utils/timeRounding.d.ts

@@ -0,0 +1,58 @@
+import { TimeFormat } from '../types';
+/**
+ * Options for auto-rounding functionality.
+ */
+export interface AutoRoundingOptions {
+    /** Whether auto-rounding is enabled. */
+    autoround: boolean;
+    /** Time increment in minutes. */
+    step?: number;
+    /** Time format (12 or 24 hour). */
+    format: TimeFormat;
+}
+/**
+ * Gets the next future step for a given time based on the step increment.
+ *
+ * @param time - The current time string
+ * @param step - The step increment in minutes
+ * @param format - The time format (12 or 24 hour)
+ * @returns The next step time string
+ */
+export declare function getNextFutureStep(time: string, step: number, format: TimeFormat): string;
+/**
+ * Handles auto-rounding of time values based on step intervals.
+ *
+ * @param time - The time to potentially auto-round
+ * @param options - Auto-rounding configuration options
+ * @returns The rounded time or the original time if no rounding is needed
+ */
+export declare function handleAutoRounding(time: string | null, options: AutoRoundingOptions): string | null;
+/**
+ * Generates AM/PM variants for 12-hour format auto-rounding when user hasn't specified AM/PM.
+ *
+ * @param currentTime - The current time string
+ * @param step - Step increment in minutes
+ * @param inputValue - Original user input to check for AM/PM specification
+ * @returns Array of time options (AM only, PM only, or both)
+ */
+export declare function generateAmPmVariants(currentTime: string, step: number, inputValue: string): string[];
+/**
+ * Tries to generate PM interpretation options for ambiguous input.
+ *
+ * @param currentTime - The current time string
+ * @param step - Step increment in minutes
+ * @param inputValue - Original user input
+ * @returns Array of PM time options or empty array
+ */
+export declare function generatePmInterpretation(currentTime: string, step: number, inputValue: string): string[];
+/**
+ * Gets auto-rounding options for dropdown suggestions when no matches are found.
+ *
+ * @param currentTime - The current parsed time
+ * @param step - Step increment in minutes
+ * @param format - Time format (12 or 24 hour)
+ * @param inputValue - Original user input
+ * @param min - Minimum time constraint
+ * @returns Array of auto-rounded time options
+ */
+export declare function getAutoRoundingOptions(currentTime: string | null, step: number, format: TimeFormat, inputValue: string, min?: string): string[];

package/dist/components/TimeField/internal/utils/timeValidation.d.ts

@@ -0,0 +1,28 @@
+import { TimeFormat } from '../types';
+/**
+ * Checks if a time aligns with a given step interval.
+ *
+ * @param time - The time to check
+ * @param step - The step increment in minutes
+ * @returns True if the time aligns with the step
+ */
+export declare function isTimeOnStep(time: string, step: number): boolean;
+/**
+ * Checks if a time is valid (exists and can be parsed).
+ *
+ * @param time - The time to check
+ * @returns True if the time is valid
+ */
+export declare function isValidTime(time: string | null): boolean;
+/**
+ * Checks if a partial input might become valid as the user continues typing.
+ * For example, "1" in a 10-11 AM range could become "10:00 AM" or "11:00 AM".
+ * Or "2" in a 20:00-23:00 range could become "20:00", "21:00", etc.
+ *
+ * @param inputValue - The current input value (may include mask characters)
+ * @param format - The time format (12 or 24 hour)
+ * @param min - Minimum allowed time constraint
+ * @param max - Maximum allowed time constraint
+ * @returns True if the partial input could potentially become valid
+ */
+export declare function isPartialInputPotentiallyValid(inputValue: string, format: TimeFormat, min?: string, max?: string): boolean;

package/dist/components/Toast/Toaster.d.ts

@@ -1,4 +1,4 @@
-import { ToasterProps as HammerToasterProps, ToastEventType } from '@servicetitan/hammer-react';
+import { ToasterProps as BaseToasterProps, ToastEventType } from './internal/Toaster';
 /**
  * Props for the Toaster component
  * @property {number | false} [duration] - Timeout, in ms, before toasts auto-closes. If set to false, toasts will not auto-close
@@ -7,9 +7,9 @@ import { ToasterProps as HammerToasterProps, ToastEventType } from '@servicetita
  * @property {number | false} [duration] - Duration of the toast in milliseconds. If set to false, the toast will not auto-dismiss
  * @property {string} [focusKey] - How a screen-reader will announce the hotkey used to set focus on the first toast
  * @property {number} [toastsBeforeStack] - How many toasts to display before they start stacking
- * @extends Omit<HammerToasterProps, "disableEvents" | "duration">
+ * @extends Omit<BaseToasterProps, "disableEvents" | "duration">
  */
-export type ToasterProps = Omit<HammerToasterProps, "disableEvents" | "duration"> & {
+export type ToasterProps = Omit<BaseToasterProps, "disableEvents" | "duration"> & {
     /**
      * Timeout, in ms, before toasts auto-closes. If set to false, toasts will not auto-close.
      * @deprecated The monolith toaster controls the duration of toasts. This prop should not be used in other cases.
@@ -50,7 +50,7 @@ export type ToasterProps = Omit<HammerToasterProps, "disableEvents" | "duration"
  *   focusKey="t"
  * />
  */
-export declare const Toaster: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & Omit<import('@servicetitan/hammer-react/dist/components/Toast/ToastStack').ToastStackProps, "toasts"> & {
+export declare const Toaster: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & Omit<import('./internal/ToastStack').ToastStackProps, "toasts"> & {
     disableEvents?: boolean;
     forceRender?: boolean;
     id: string;