/** Represents the severity level of a notification */
export type NotificationSeverity = 'error' | 'warning' | 'info' | 'success' | (string & {});
/** Represents an action button for a notification */
export type NotificationAction = {
    /** Text label for the action button */
    label: string;
    /** Handler function called when action button is clicked */
    handler: () => void;
    /** Optional metadata for styling or other custom properties */
    metadata?: Record<string, unknown>;
};
export type NotificationOrigin = {
    emitter: string;
    context?: Record<string, unknown>;
};
/** Represents a single notification message */
export type Notification = {
    /** Unique identifier for the notification */
    id: string;
    /** The notification message text */
    message: string;
    /** Timestamp when notification was created */
    createdAt: number;
    /**
     * Identifier of the notification emitter.
     * The identifier then can be recognized by notification consumers to act upon specific origin values.
     */
    origin: NotificationOrigin;
    /** Array of action buttons for the notification */
    actions?: NotificationAction[];
    /** The severity level of the notification. Defaults to undefined unless explicitly provided. */
    severity?: NotificationSeverity;
    /**
     * Optional code that can be used to group the notifications of the same type, e.g. attachment-upload-blocked.
     * Format: domain:entity:operation:result
     *   domain: where the error occurred (api, validation, permission, etc)
     *   entity: what was being operated on (poll, attachment, message, etc)
     *   operation: what was being attempted (create, upload, validate, etc)
     *   result: what happened (failed, blocked, invalid, etc)
     *
     *   Poll related errors
     *   'api:poll:create:failed'           // API call to create poll failed
     *   'validation:poll:create:invalid'   // Poll creation validation failed
     *
     *   Attachment related errors
     *   'validation:attachment:file:missing'     // Required file is missing
     *   'permission:attachment:upload:blocked'   // Upload blocked due to permissions
     *   'api:attachment:upload:failed'          // API upload call failed
     *   'validation:attachment:type:unsupported' // Unsupported file type
     *   'validation:attachment:size:exceeded'    // File size too large
     *   'validation:attachment:count:exceeded'   // Too many attachments
     *
     *   Message related errors
     *   'api:message:send:failed'          // Message send failed
     *   'validation:message:content:empty' // Message content validation failed
     *
     *   Channel related errors
     *   'api:channel:join:failed'          // Channel join failed
     *   'permission:channel:access:denied' // Channel access denied
     *
     *   Authentication related errors
     *   'auth:token:expired'               // Auth token expired
     *   'auth:token:invalid'               // Invalid auth token
     *
     *   Network related errors
     *   'network:request:timeout'          // Request timed out
     *   'network:request:failed'           // Network request failed
     *
     *    Rate limiting
     *   'rate:limit:exceeded'              // Rate limit exceeded
     *
     *   System errors
     *   'system:internal:error'            // Internal system error
     *   'system:resource:unavailable';     // System resource unavailable
     */
    type?: string;
    /** Optional auto-dismiss duration in milliseconds. The timeout starts when NotificationManager.startTimeout() is called. */
    duration?: number;
    /** Optional metadata to attach to the notification */
    metadata?: Record<string, unknown>;
    /** Optional tags that can be used for routing or grouping notifications (e.g. `target:channel`). */
    tags?: string[];
    /** In case of error notification the instance of the originally thrown error */
    originalError?: Error;
};
/** Configuration options when creating a notification */
export type NotificationOptions = Partial<Pick<Notification, 'type' | 'severity' | 'actions' | 'metadata' | 'tags' | 'originalError'>> & {
    /**
     * How long a notification should be displayed in milliseconds.
     * Use `0` for persistent (no auto-dismiss); call `client.notifications.remove(id)` to dismiss.
     */
    duration?: number;
};
/**
 * State shape for the notification store
 * @deprcated use NotificationManagerState
 */
export type NotificationState = {
    /** Array of current notification objects */
    notifications: Notification[];
};
/** State shape for the notification store */
export type NotificationManagerState = NotificationState;
export type NotificationSortComparator = (a: Notification, b: Notification) => number;
export type NotificationManagerConfig = {
    durations: Partial<Record<NotificationSeverity, number>>;
    sortComparator?: NotificationSortComparator;
};
export type AddNotificationPayload = Pick<Notification, 'message' | 'origin'> & {
    options?: NotificationOptions;
};