een-api-toolkit 0.3.14 → 0.3.16

package/dist/index.d.ts

@@ -13,6 +13,140 @@ import { StoreDefinition } from 'pinia';
  */
 export declare type ActorType = 'bridge' | 'camera' | 'speaker' | 'account' | 'user' | 'layout' | 'job' | 'measurement' | 'sensor' | 'gateway';
 
+/**
+ * Alert entity from EEN API v3.0.
+ *
+ * @remarks
+ * Represents an alert in the Eagle Eye Networks platform. Alerts are generated
+ * when events match configured rules and can trigger various actions like
+ * notifications.
+ *
+ * For more details on alerts, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listalerts).
+ *
+ * @example
+ * ```typescript
+ * import { listAlerts, type Alert } from 'een-api-toolkit'
+ *
+ * const { data, error } = await listAlerts({
+ *   actorId__in: ['100d4c41'],
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString()
+ * })
+ * if (data) {
+ *   data.results.forEach((alert: Alert) => {
+ *     console.log(`${alert.alertType} at ${alert.timestamp}`)
+ *   })
+ * }
+ * ```
+ *
+ * @category Alerts
+ */
+export declare interface Alert {
+    /** Unique identifier for the alert */
+    id: string;
+    /** ISO 8601 timestamp when the alert was triggered */
+    timestamp: string;
+    /** ISO 8601 timestamp when the alert was created in the system */
+    createTimestamp: string;
+    /** ID of the entity that created the alert */
+    creatorId: string;
+    /** Type of alert (e.g., "een.motionDetectionAlert.v1") */
+    alertType: string;
+    /** Human-readable name of the alert */
+    alertName?: string;
+    /** Category of the alert */
+    category?: string;
+    /** ID of the service rule that triggered this alert */
+    serviceRuleId?: string;
+    /** Event type that triggered this alert */
+    eventType?: string;
+    /** ID of the actor (device/entity) that generated the alert */
+    actorId: string;
+    /** Type of actor that generated the alert */
+    actorType: string;
+    /** Account ID of the actor */
+    actorAccountId: string;
+    /** Human-readable name of the actor */
+    actorName?: string;
+    /** ID of the rule that triggered this alert */
+    ruleId?: string;
+    /** ID of the event that triggered this alert */
+    eventId?: string;
+    /** ID of the location associated with this alert */
+    locationId?: string;
+    /** Human-readable name of the location */
+    locationName?: string;
+    /** Priority level (0-20, where higher is more important) */
+    priority?: number;
+    /** List of data schema types included in this alert */
+    dataSchemas?: string[];
+    /** Alert data objects (varies by alert type) */
+    data?: Record<string, unknown>;
+    /** Actions executed for this alert */
+    actions?: Record<string, AlertAction>;
+    /** Human-readable description of the alert */
+    description?: string;
+}
+
+/**
+ * Action taken for an alert.
+ *
+ * @remarks
+ * Represents an action that was triggered by an alert, such as sending an email
+ * notification or executing a webhook.
+ *
+ * @category Alerts
+ */
+export declare interface AlertAction {
+    /** Name of the action */
+    name: string;
+    /** Type of action (e.g., "email", "webhook", "push") */
+    type: string;
+    /** Whether the action executed successfully */
+    success: boolean;
+    /** ISO 8601 timestamp when the action was executed */
+    timestamp: string;
+    /** Current status of the action */
+    status?: AlertActionStatus;
+}
+
+/**
+ * Status of an alert action.
+ *
+ * @category Alerts
+ */
+export declare type AlertActionStatus = 'fired' | 'success' | 'partialSuccess' | 'silenced' | 'failed' | 'internalError';
+
+/**
+ * Fields that can be included in alert responses.
+ *
+ * @category Alerts
+ */
+export declare type AlertInclude = 'data' | 'actions' | 'dataSchemas' | 'description';
+
+/**
+ * Sort options for alert listing.
+ *
+ * @category Alerts
+ */
+export declare type AlertSort = '+timestamp' | '-timestamp';
+
+/**
+ * Alert type definition from EEN API v3.0.
+ *
+ * @remarks
+ * Describes a type of alert available in the system. Used to understand
+ * what alert types can be filtered for when listing alerts.
+ *
+ * @category Alerts
+ */
+export declare interface AlertType {
+    /** Alert type identifier (e.g., "een.motionDetectionAlert.v1") */
+    type: string;
+    /** Human-readable description of the alert type */
+    description: string;
+}
+
 /**
  * Bridge entity from EEN API v3.0.
  *
@@ -558,6 +692,52 @@ export declare interface EventFieldValues {
     type: string[];
 }
 
+/**
+ * Event metric entity from EEN API v3.0.
+ *
+ * @remarks
+ * Represents a time-series metric for events in the Eagle Eye Networks platform.
+ * Event metrics provide aggregated counts over time, useful for visualizing
+ * event frequency in charts and dashboards.
+ *
+ * For more details on event metrics, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listmetrics).
+ *
+ * @example
+ * ```typescript
+ * import { getEventMetrics, type EventMetric } from 'een-api-toolkit'
+ *
+ * const { data, error } = await getEventMetrics({
+ *   actor: 'camera:100d4c41',
+ *   eventType: 'een.motionDetectionEvent.v1'
+ * })
+ * if (data) {
+ *   data.forEach((metric: EventMetric) => {
+ *     console.log(`${metric.eventType}: ${metric.dataPoints.length} data points`)
+ *     metric.dataPoints.forEach(([timestamp, count]) => {
+ *       console.log(`  ${new Date(timestamp).toISOString()}: ${count}`)
+ *     })
+ *   })
+ * }
+ * ```
+ *
+ * @category Event Metrics
+ */
+export declare interface EventMetric {
+    /** Event type identifier (e.g., "een.motionDetectionEvent.v1") */
+    eventType: string;
+    /** ID of the actor (device/entity) for this metric */
+    actorId: string;
+    /** Type of actor for this metric */
+    actorType: MetricActorType;
+    /** Metric target (typically "count") */
+    target: string;
+    /** Array of [timestamp_ms, value] data points */
+    dataPoints: MetricDataPoint[];
+    /** Additional properties that may be included */
+    [key: string]: unknown;
+}
+
 /**
  * Event type definition from EEN API v3.0.
  *
@@ -688,11 +868,96 @@ export declare type FeedMediaType = 'video' | 'audio' | 'image' | 'halfDuplex' |
  */
 export declare type FeedStreamType = 'main' | 'preview' | 'talkdown';
 
+/**
+ * Convert ISO 8601 timestamp from Z format to +00:00 format.
+ *
+ * @remarks
+ * The EEN API requires timestamps in +00:00 format, not Z format.
+ * This function converts timestamps like `2024-01-01T00:00:00.000Z`
+ * to `2024-01-01T00:00:00.000+00:00`.
+ *
+ * @param timestamp - ISO 8601 timestamp string
+ * @returns Timestamp in +00:00 format
+ *
+ * @example
+ * ```typescript
+ * formatTimestamp('2024-01-01T00:00:00.000Z')
+ * // Returns: '2024-01-01T00:00:00.000+00:00'
+ *
+ * formatTimestamp(new Date().toISOString())
+ * // Returns: timestamp with +00:00 suffix
+ * ```
+ *
+ * @category Utilities
+ */
+export declare function formatTimestamp(timestamp: string): string;
+
 /**
  * Exchange authorization code for access token
  */
 export declare function getAccessToken(code: string): Promise<Result<TokenResponse>>;
 
+/**
+ * Get a specific alert by ID.
+ *
+ * @remarks
+ * Fetches a single alert from `/api/v3.0/alerts/{alertId}`. Use the `include`
+ * parameter to request additional fields.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/getalert).
+ *
+ * @param alertId - The unique identifier of the alert to fetch
+ * @param params - Optional parameters (e.g., include additional fields)
+ * @returns A Result containing the alert or an error
+ *
+ * @example
+ * ```typescript
+ * import { getAlert } from 'een-api-toolkit'
+ *
+ * const { data, error } = await getAlert('alert-123')
+ *
+ * if (error) {
+ *   if (error.code === 'NOT_FOUND') {
+ *     console.log('Alert not found')
+ *   }
+ *   return
+ * }
+ *
+ * console.log(`Alert: ${data.alertType} at ${data.timestamp}`)
+ *
+ * // With additional fields
+ * const { data: alertWithData } = await getAlert('alert-123', {
+ *   include: ['data', 'actions', 'description']
+ * })
+ * ```
+ *
+ * @category Alerts
+ */
+export declare function getAlert(alertId: string, params?: GetAlertParams): Promise<Result<Alert>>;
+
+/**
+ * Parameters for getting a single alert by ID.
+ *
+ * @remarks
+ * Supports including additional fields in the response.
+ *
+ * @example
+ * ```typescript
+ * import { getAlert } from 'een-api-toolkit'
+ *
+ * const { data } = await getAlert('alert-123', {
+ *   include: ['data', 'actions', 'description']
+ * })
+ * ```
+ *
+ * @category Alerts
+ */
+export declare interface GetAlertParams {
+    /** Fields to include in response */
+    include?: AlertInclude[];
+}
+
 /**
  * Generate the OAuth authorization URL
  */
@@ -1005,6 +1270,99 @@ export declare function getCurrentUser(): Promise<Result<UserProfile>>;
  */
 export declare function getEvent(eventId: string, params?: GetEventParams): Promise<Result<Event_2>>;
 
+/**
+ * Get event metrics (time-series data) for a specific actor and event type.
+ *
+ * @remarks
+ * Fetches time-series metric data from `/api/v3.0/eventMetrics`. The `actor` and
+ * `eventType` parameters are required. Returns an array of EventMetric objects
+ * containing data points over time.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listmetrics).
+ *
+ * @param params - Required and optional filtering parameters
+ * @returns A Result containing an array of event metrics or an error
+ *
+ * @example
+ * ```typescript
+ * import { getEventMetrics } from 'een-api-toolkit'
+ *
+ * // Get motion event metrics for a camera (last 7 days by default)
+ * const { data, error } = await getEventMetrics({
+ *   actor: 'camera:100d4c41',
+ *   eventType: 'een.motionDetectionEvent.v1'
+ * })
+ *
+ * if (data) {
+ *   data.forEach(metric => {
+ *     console.log(`${metric.eventType}: ${metric.dataPoints.length} data points`)
+ *     metric.dataPoints.forEach(([timestamp, count]) => {
+ *       console.log(`  ${new Date(timestamp).toISOString()}: ${count}`)
+ *     })
+ *   })
+ * }
+ *
+ * // With custom time range and aggregation
+ * const { data: hourlyData } = await getEventMetrics({
+ *   actor: 'camera:100d4c41',
+ *   eventType: 'een.motionDetectionEvent.v1',
+ *   timestamp__gte: new Date(Date.now() - 86400000).toISOString(),
+ *   timestamp__lte: new Date().toISOString(),
+ *   aggregateByMinutes: 60
+ * })
+ * ```
+ *
+ * @category Event Metrics
+ */
+export declare function getEventMetrics(params: GetEventMetricsParams): Promise<Result<EventMetric[]>>;
+
+/**
+ * Parameters for fetching event metrics.
+ *
+ * @remarks
+ * Supports filtering metrics by actor, event type, and time range. The `actor`
+ * and `eventType` parameters are required. If timestamps are not provided,
+ * defaults to the last 7 days.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listmetrics).
+ *
+ * @example
+ * ```typescript
+ * import { getEventMetrics } from 'een-api-toolkit'
+ *
+ * // Get motion event metrics for a camera over the last 24 hours
+ * const { data } = await getEventMetrics({
+ *   actor: 'camera:100d4c41',
+ *   eventType: 'een.motionDetectionEvent.v1',
+ *   timestamp__gte: new Date(Date.now() - 86400000).toISOString(),
+ *   timestamp__lte: new Date().toISOString(),
+ *   aggregateByMinutes: 60  // Hourly buckets
+ * })
+ *
+ * // With default time range (last 7 days) and aggregation (60 minutes)
+ * const { data: weekData } = await getEventMetrics({
+ *   actor: 'camera:100d4c41',
+ *   eventType: 'een.motionDetectionEvent.v1'
+ * })
+ * ```
+ *
+ * @category Event Metrics
+ */
+export declare interface GetEventMetricsParams {
+    /** Actor to get metrics for (format: "type:id", e.g., "camera:100d4c41") */
+    actor: string;
+    /** Event type to get metrics for (e.g., "een.motionDetectionEvent.v1") */
+    eventType: string;
+    /** ISO 8601 timestamp - metrics starting at or after this time (defaults to 7 days ago) */
+    timestamp__gte?: string;
+    /** ISO 8601 timestamp - metrics ending before this time (defaults to now) */
+    timestamp__lte?: string;
+    /** Aggregation bucket size in minutes (default: 60) */
+    aggregateByMinutes?: number;
+}
+
 /**
  * Parameters for getting a single event by ID.
  *
@@ -1150,6 +1508,39 @@ export declare interface GetLiveImageParams {
  */
 export declare function getMediaSession(): Promise<Result<MediaSessionResponse>>;
 
+/**
+ * Get a specific notification by ID.
+ *
+ * @remarks
+ * Fetches a single notification from `/api/v3.0/notifications/{notificationId}`.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/getnotification).
+ *
+ * @param notificationId - The unique identifier of the notification to fetch
+ * @returns A Result containing the notification or an error
+ *
+ * @example
+ * ```typescript
+ * import { getNotification } from 'een-api-toolkit'
+ *
+ * const { data, error } = await getNotification('notification-123')
+ *
+ * if (error) {
+ *   if (error.code === 'NOT_FOUND') {
+ *     console.log('Notification not found')
+ *   }
+ *   return
+ * }
+ *
+ * console.log(`Notification: ${data.category} - ${data.description}`)
+ * console.log(`Read: ${data.read}`)
+ * ```
+ *
+ * @category Notifications
+ */
+export declare function getNotification(notificationId: string): Promise<Result<Notification_2>>;
+
 /**
  * Get the proxy URL
  */
@@ -1458,6 +1849,196 @@ export declare function initEenToolkit(options?: EenToolkitConfig): void;
  */
 export declare function initMediaSession(): Promise<Result<MediaSessionResult>>;
 
+/**
+ * List alerts with optional filters and pagination.
+ *
+ * @remarks
+ * Fetches a paginated list of alerts from `/api/v3.0/alerts`. Supports various
+ * filters including time range, actor, alert type, priority, and more.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listalerts).
+ *
+ * @param params - Optional filtering and pagination parameters
+ * @returns A Result containing a paginated list of alerts or an error
+ *
+ * @example
+ * ```typescript
+ * import { listAlerts } from 'een-api-toolkit'
+ *
+ * // Get recent alerts from a specific camera
+ * const { data, error } = await listAlerts({
+ *   actorId__in: ['100d4c41'],
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *   pageSize: 50,
+ *   include: ['data', 'actions']
+ * })
+ *
+ * if (data) {
+ *   console.log(`Found ${data.results.length} alerts`)
+ *   data.results.forEach(alert => {
+ *     console.log(`${alert.alertType} at ${alert.timestamp}`)
+ *   })
+ * }
+ *
+ * // Fetch all alerts with pagination
+ * let allAlerts: Alert[] = []
+ * let pageToken: string | undefined
+ * do {
+ *   const { data, error } = await listAlerts({
+ *     timestamp__gte: new Date(Date.now() - 86400000).toISOString(),
+ *     pageSize: 100,
+ *     pageToken
+ *   })
+ *   if (error) break
+ *   allAlerts.push(...data.results)
+ *   pageToken = data.nextPageToken
+ * } while (pageToken)
+ * ```
+ *
+ * @category Alerts
+ */
+export declare function listAlerts(params?: ListAlertsParams): Promise<Result<PaginatedResult<Alert>>>;
+
+/**
+ * Parameters for listing alerts.
+ *
+ * @remarks
+ * Supports filtering alerts by various criteria including time range, actor,
+ * alert type, and more. Supports pagination and sorting.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listalerts).
+ *
+ * @example
+ * ```typescript
+ * import { listAlerts } from 'een-api-toolkit'
+ *
+ * // Get recent alerts from a specific camera
+ * const { data } = await listAlerts({
+ *   actorId__in: ['100d4c41'],
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *   pageSize: 50,
+ *   include: ['data', 'actions'],
+ *   sort: ['-timestamp']
+ * })
+ *
+ * // Fetch next page
+ * if (data?.nextPageToken) {
+ *   const { data: page2 } = await listAlerts({
+ *     actorId__in: ['100d4c41'],
+ *     timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *     pageToken: data.nextPageToken
+ *   })
+ * }
+ * ```
+ *
+ * @category Alerts
+ */
+export declare interface ListAlertsParams {
+    /** Number of results per page (default: 100) */
+    pageSize?: number;
+    /** Token for fetching a specific page */
+    pageToken?: string;
+    /** ISO 8601 timestamp - alerts at or before this time */
+    timestamp__lte?: string;
+    /** ISO 8601 timestamp - alerts at or after this time */
+    timestamp__gte?: string;
+    /** Filter by creator ID */
+    creatorId?: string;
+    /** Filter by alert types (e.g., ["een.motionDetectionAlert.v1"]) */
+    alertType__in?: string[];
+    /** Filter by actor IDs */
+    actorId__in?: string[];
+    /** Filter by actor types */
+    actorType__in?: string[];
+    /** Filter by actor account ID */
+    actorAccountId?: string;
+    /** Filter by rule ID */
+    ruleId?: string;
+    /** Filter by rule IDs */
+    ruleId__in?: string[];
+    /** Filter by event ID */
+    eventId?: string;
+    /** Filter by location IDs */
+    locationId__in?: string[];
+    /** Minimum priority level (inclusive) */
+    priority__gte?: number;
+    /** Maximum priority level (inclusive) */
+    priority__lte?: number;
+    /** Include alerts that are invalid */
+    showInvalidAlerts?: boolean;
+    /** Filter by alert action IDs */
+    alertActionId__in?: string[];
+    /** Filter by alert action statuses */
+    alertActionStatus__in?: AlertActionStatus[];
+    /** Fields to include in response */
+    include?: AlertInclude[];
+    /** Sort order for results */
+    sort?: AlertSort[];
+    /** Language code for localized descriptions */
+    language?: string;
+}
+
+/**
+ * List all available alert types.
+ *
+ * @remarks
+ * Fetches a paginated list of alert types from `/api/v3.0/alertTypes`. Alert types
+ * describe the different kinds of alerts that can be generated in the system.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listalerttypes).
+ *
+ * @param params - Optional pagination parameters
+ * @returns A Result containing a paginated list of alert types or an error
+ *
+ * @example
+ * ```typescript
+ * import { listAlertTypes } from 'een-api-toolkit'
+ *
+ * const { data, error } = await listAlertTypes()
+ * if (data) {
+ *   data.results.forEach(alertType => {
+ *     console.log(`${alertType.type}: ${alertType.description}`)
+ *   })
+ * }
+ *
+ * // With pagination
+ * const { data: pagedTypes } = await listAlertTypes({ pageSize: 20 })
+ * ```
+ *
+ * @category Alerts
+ */
+export declare function listAlertTypes(params?: ListAlertTypesParams): Promise<Result<PaginatedResult<AlertType>>>;
+
+/**
+ * Parameters for listing alert types.
+ *
+ * @remarks
+ * Supports pagination for listing all available alert types.
+ *
+ * @example
+ * ```typescript
+ * import { listAlertTypes } from 'een-api-toolkit'
+ *
+ * const { data } = await listAlertTypes({ pageSize: 50 })
+ * if (data) {
+ *   data.results.forEach(alertType => {
+ *     console.log(`${alertType.type}: ${alertType.description}`)
+ *   })
+ * }
+ * ```
+ *
+ * @category Alerts
+ */
+export declare interface ListAlertTypesParams {
+    /** Number of results per page */
+    pageSize?: number;
+    /** Token for fetching a specific page */
+    pageToken?: string;
+}
+
 /**
  * Parameters for listing bridges.
  *
@@ -2059,6 +2640,137 @@ export declare interface ListMediaParams {
     pageSize?: number;
 }
 
+/**
+ * List notifications with optional filters and pagination.
+ *
+ * @remarks
+ * Fetches a paginated list of notifications from `/api/v3.0/notifications`. Supports
+ * various filters including time range, actor, alert type, category, and more.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listnotifications).
+ *
+ * @param params - Optional filtering and pagination parameters
+ * @returns A Result containing a paginated list of notifications or an error
+ *
+ * @example
+ * ```typescript
+ * import { listNotifications } from 'een-api-toolkit'
+ *
+ * // Get recent notifications for a specific camera
+ * const { data, error } = await listNotifications({
+ *   actorId: '100d4c41',
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *   pageSize: 50
+ * })
+ *
+ * if (data) {
+ *   console.log(`Found ${data.results.length} notifications`)
+ *   data.results.forEach(notification => {
+ *     console.log(`${notification.category}: ${notification.description}`)
+ *   })
+ * }
+ *
+ * // Get unread notifications
+ * const { data: unread } = await listNotifications({
+ *   read: false,
+ *   category: 'video'
+ * })
+ *
+ * // Fetch all notifications with pagination
+ * let allNotifications: Notification[] = []
+ * let pageToken: string | undefined
+ * do {
+ *   const { data, error } = await listNotifications({
+ *     timestamp__gte: new Date(Date.now() - 86400000).toISOString(),
+ *     pageSize: 100,
+ *     pageToken
+ *   })
+ *   if (error) break
+ *   allNotifications.push(...data.results)
+ *   pageToken = data.nextPageToken
+ * } while (pageToken)
+ * ```
+ *
+ * @category Notifications
+ */
+export declare function listNotifications(params?: ListNotificationsParams): Promise<Result<PaginatedResult<Notification_2>>>;
+
+/**
+ * Parameters for listing notifications.
+ *
+ * @remarks
+ * Supports filtering notifications by various criteria including time range,
+ * actor, alert type, category, and more. Supports pagination and sorting.
+ *
+ * For more details, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listnotifications).
+ *
+ * @example
+ * ```typescript
+ * import { listNotifications } from 'een-api-toolkit'
+ *
+ * // Get recent notifications for a specific camera
+ * const { data } = await listNotifications({
+ *   actorId: '100d4c41',
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *   pageSize: 50,
+ *   sort: ['-timestamp']
+ * })
+ *
+ * // Get unread notifications
+ * const { data: unread } = await listNotifications({
+ *   read: false,
+ *   category: 'video'
+ * })
+ *
+ * // Fetch next page
+ * if (data?.nextPageToken) {
+ *   const { data: page2 } = await listNotifications({
+ *     actorId: '100d4c41',
+ *     timestamp__gte: new Date(Date.now() - 3600000).toISOString(),
+ *     pageToken: data.nextPageToken
+ *   })
+ * }
+ * ```
+ *
+ * @category Notifications
+ */
+export declare interface ListNotificationsParams {
+    /** Number of results per page (default: 100) */
+    pageSize?: number;
+    /** Token for fetching a specific page */
+    pageToken?: string;
+    /** ISO 8601 timestamp - notifications at or before this time */
+    timestamp__lte?: string;
+    /** ISO 8601 timestamp - notifications at or after this time */
+    timestamp__gte?: string;
+    /** Filter by alert ID */
+    alertId?: string;
+    /** Filter by alert type */
+    alertType?: string;
+    /** Filter by actor ID */
+    actorId?: string;
+    /** Filter by actor type */
+    actorType?: string;
+    /** Filter by actor account ID */
+    actorAccountId?: string;
+    /** Filter by notification category */
+    category?: NotificationCategory;
+    /** Filter by user ID */
+    userId?: string;
+    /** Filter by read status */
+    read?: boolean;
+    /** Filter by delivery status */
+    status?: NotificationStatus;
+    /** Include legacy v1 notifications */
+    includeV1Notifications?: boolean;
+    /** Sort order for results */
+    sort?: ('+timestamp' | '-timestamp')[];
+    /** Language code for localized descriptions */
+    language?: string;
+}
+
 /**
  * Parameters for listing users.
  *
@@ -2195,6 +2907,119 @@ export declare type MediaStreamType = 'preview' | 'main';
  */
 export declare type MediaType = 'video' | 'image';
 
+/**
+ * Actor types for event metrics in the EEN API v3.0.
+ *
+ * @remarks
+ * Represents the type of entity that generated or is associated with a metric.
+ * Common actor types include cameras, bridges, and users.
+ *
+ * @category Event Metrics
+ */
+export declare type MetricActorType = 'bridge' | 'camera' | 'speaker' | 'account' | 'user' | 'layout' | 'job';
+
+/**
+ * A single metric data point as [timestamp_ms, value].
+ *
+ * @remarks
+ * Event metrics return time-series data as arrays of [timestamp, value] pairs.
+ * The timestamp is in milliseconds since Unix epoch, and the value represents
+ * the count or measurement at that point in time.
+ *
+ * @example
+ * ```typescript
+ * // Data point: January 1, 2024 at midnight with a count of 5
+ * const dataPoint: MetricDataPoint = [1704067200000, 5]
+ * ```
+ *
+ * @category Event Metrics
+ */
+export declare type MetricDataPoint = [number, number];
+
+/**
+ * Notification entity from EEN API v3.0.
+ *
+ * @remarks
+ * Represents a notification in the Eagle Eye Networks platform. Notifications
+ * are sent to users based on alerts and system events through various channels
+ * like email, push notifications, etc.
+ *
+ * For more details on notifications, see the
+ * [EEN API Documentation](https://developer.eagleeyenetworks.com/reference/listnotifications).
+ *
+ * @example
+ * ```typescript
+ * import { listNotifications, type Notification } from 'een-api-toolkit'
+ *
+ * const { data, error } = await listNotifications({
+ *   actorId: '100d4c41',
+ *   timestamp__gte: new Date(Date.now() - 3600000).toISOString()
+ * })
+ * if (data) {
+ *   data.results.forEach((notification: Notification) => {
+ *     console.log(`${notification.category}: ${notification.description}`)
+ *   })
+ * }
+ * ```
+ *
+ * @category Notifications
+ */
+declare interface Notification_2 {
+    /** Unique identifier for the notification */
+    id: string;
+    /** ISO 8601 timestamp of the notification event */
+    timestamp: string;
+    /** ISO 8601 timestamp when the notification was created in the system */
+    createTimestamp: string;
+    /** ISO 8601 timestamp when the notification was sent */
+    sentTimestamp?: string;
+    /** ID of the alert that triggered this notification (null if not alert-based) */
+    alertId?: string | null;
+    /** Type of alert that triggered this notification */
+    alertType?: string;
+    /** ID of the actor (device/entity) associated with this notification */
+    actorId: string;
+    /** Human-readable name of the actor */
+    actorName?: string;
+    /** Type of actor associated with this notification */
+    actorType: string;
+    /** Account ID of the actor */
+    actorAccountId: string;
+    /** ID of the user this notification was sent to */
+    userId: string;
+    /** ID of the account this notification belongs to */
+    accountId: string;
+    /** Whether the notification has been read by the user */
+    read: boolean;
+    /** Current delivery status of the notification */
+    status: NotificationStatus;
+    /** Category of the notification */
+    category: NotificationCategory;
+    /** Human-readable description of the notification */
+    description?: string;
+    /** Actions that were taken for this notification */
+    notificationActions: string[];
+    /** List of data schema types included in this notification */
+    dataSchemas: string[];
+    /** Notification data objects (varies by notification type) */
+    data: Record<string, unknown>;
+}
+export { Notification_2 as Notification }
+
+/**
+ * Categories of notifications in the EEN platform.
+ *
+ * @category Notifications
+ */
+export declare type NotificationCategory = 'health' | 'video' | 'operational' | 'audit' | 'job' | 'security' | 'sharing';
+
+/**
+ * Status of a notification delivery.
+ *
+ * @category Notifications
+ */
+export declare type NotificationStatus = 'pending' | 'bounced' | 'dropped' | 'deferred' | 'delivered' | 'sent' | 'outsideUsersSchedule' | 'notificationsDisabled' | 'noNotificationActions' | 'sendingFailed' | 'throttled' | 'unableToGetSettings';
+
 /**
  * Paginated response from list operations.
  *