@openfin/cloud-notification-core-api 0.0.1-alpha.80d41e7 → 0.0.1-alpha.80effad

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +2 -2
  2. package/bundle.d.ts +604 -242
  3. package/index.cjs +468 -111
  4. package/index.mjs +466 -112
  5. package/package.json +1 -1
package/bundle.d.ts CHANGED
@@ -1,288 +1,650 @@
1
- import z from 'zod';
1
+ import { z } from 'zod';
2
2
 
3
3
  export declare class AuthorizationError extends CloudNotificationAPIError {
4
4
  constructor(message?: string, code?: string);
5
5
  }
6
6
 
7
- export declare type BaseNotificationReceivedEvent = {
8
- action: 'new' | 'update';
9
- notificationId: string;
10
- correlationId?: string;
11
- target: string;
12
- targetName?: string;
13
- targetType: string;
14
- payload: unknown;
15
- };
16
-
17
7
  /**
18
- * Represents a single connection to the Cloud Notification service
19
- *
8
+ * Represents common properties for all notification events
20
9
  */
21
- export declare class CloudNotificationAPI {
22
- #private;
23
- constructor(cloudNotificationSettings: CloudNotificationSettings);
24
- /**
25
- * Connects and creates a session on the Cloud Notifications service
26
- *
27
- * @param {ConnectParameters} parameters - The parameters to use to connect
28
- * @returns {*} {Promise<void>}
29
- * @memberof CloudNotificationAPI
30
- * @throws {CloudNotificationAPIError} - If an error occurs during connection
31
- * @throws {AuthorizationError} - If the connection is unauthorized
32
- */
33
- connect(parameters: ConnectParameters): Promise<ConnectionResult>;
34
- /**
35
- * Disconnects from the Cloud Notification service
36
- *
37
- * @returns {*} {Promise<void>}
38
- * @memberof CloudNotificationAPI
39
- * @throws {CloudNotificationAPIError} - If an error occurs during disconnection
40
- */
41
- disconnect(): Promise<void>;
42
- postNotificationEvent(notificationId: string, event: {
43
- category: string;
44
- type: string;
45
- payload?: unknown;
46
- }): Promise<void>;
10
+ export declare type BaseNotificationReceivedEvent = {
47
11
  /**
48
- * Raises a notification to the Cloud Notification service
49
- *
50
- * @param {NotificationOptions} options - The options for the notification
51
- * @param {unknown} payload - The payload of the notification
52
- * @returns {*} {Promise<NotificationRaiseResult>}
53
- * @memberof CloudNotificationAPI
54
- * @throws {SessionNotConnectedError} - If the session is not connected
55
- * @throws {PublishError} - If an error occurs during publishing
12
+ * The action that was performed on the notification
56
13
  */
57
- raiseNotification(options: NotificationOptions_2, payload: unknown): Promise<NotificationRaiseResult>;
58
- updateNotification(): Promise<void>;
59
- deleteNotification(): Promise<void>;
60
- addEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
61
- removeEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
62
- once<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
63
- }
64
-
65
- export declare class CloudNotificationAPIError extends Error {
66
- code: string;
67
- constructor(message?: string, code?: string, cause?: unknown);
68
- }
69
-
70
- /**
71
- * Represents a logging function to be used by the cloud notification client
72
- */
73
- export declare type CloudNotificationLogger = (level: LogLevel, message: string) => void;
74
-
75
- export declare type CloudNotificationSettings = {
14
+ action: 'new' | 'update' | 'delete';
76
15
  /**
77
- * The URL of the notification server to connect to
16
+ * The unique identifier for the notification
78
17
  */
79
- url: string;
80
- };
81
-
82
- /**
83
- * Repesents the result of a successful connection to the server
84
- */
85
- export declare type ConnectionResult = {
18
+ notificationId: string;
86
19
  /**
87
- * The unique identifier for the session
20
+ * The correlation identifier for the notification
88
21
  */
89
- sessionId: string;
22
+ correlationId?: string;
90
23
  /**
91
- * The platform identifier
24
+ * The identifier of the target of the notification
92
25
  */
93
- platformId: string;
26
+ target: string;
94
27
  /**
95
- * The source identifier
28
+ * The name of the target i.e, the group or user that the notification was sent to
96
29
  */
97
- sourceId: string;
30
+ targetName?: string;
98
31
  /**
99
- * The user identifier
32
+ * The type of the target i.e, 'groups' or 'users'
100
33
  */
101
- userId: string;
34
+ targetType: TARGET_TYPE;
102
35
  /**
103
- * A collection of groups that the user is either a direct or indirect member of
36
+ * The payload of the notification.
37
+ * See the documentation for the notification center events for more information on the payload
104
38
  */
105
- groups: {
106
- uuid: string;
107
- name: string;
108
- }[];
39
+ payload: unknown;
109
40
  };
110
41
 
111
42
  /**
112
- * Represents the parameters to use to connect to an notification server
43
+ * Represents a single connection to the Cloud Notification service
44
+ *
113
45
  */
114
- export declare type ConnectParameters = {
115
- /**
116
- * ID for a group of shared applications.
117
- * This acts as a namespace for the notification messages that allows separation of messages between different groups of applications for the same user
118
- */
119
- platformId: string;
120
- /**
121
- * A value that distinguishes the host the application is running in. For example this could be the hostname of the current machine
122
- */
123
- sourceId: string;
124
- /**
125
- * The maximum number of times to retry connecting to the cloud notification service when the connection is dropped
126
- * defaults to 30
127
- */
128
- reconnectRetryLimit?: number;
129
- /**
130
- * Specifies how often keep alive messages should be sent to the cloud notification service in seconds
131
- * defaults to 30
132
- */
133
- keepAliveIntervalSeconds?: number;
134
- /**
135
- * Calculates the time offset between the local machine and the notification server
136
- * defaults to true
137
- */
138
- syncTime?: boolean;
46
+ export declare class CloudNotificationAPI {
47
+ #private;
139
48
  /**
140
- * Optional function to call with any logging messages to allow integration with the host application's logging
49
+ * Constructs a new instance of the CloudNotificationAPI
141
50
  *
142
- * defaults to console.log
51
+ * @param cloudNotificationSettings - The settings for the Cloud Notification API.
143
52
  */
144
- logger?: CloudNotificationLogger;
53
+ constructor(cloudNotificationSettings: CloudNotificationSettings);
145
54
  /**
146
- * Determines the type of authentication to use with the service gateway
147
- * defaults to 'none'
55
+ * Connects and creates a session on the Cloud Notifications service.
148
56
  *
149
- * 'jwt' - Use JWT authentication, in this case jwtAuthenticationParameters must also be provided
150
- * 'basic' - Use basic authentication, in this case basicAuthenticationParameters must also be provided
151
- * 'default' - Authentication will be inherited from the current session
152
- */
153
- authenticationType?: 'jwt' | 'basic' | 'default';
154
- /**
155
- * Optional parameters for basic authentication
156
- */
157
- basicAuthenticationParameters?: {
158
- /**
159
- * The username to use for basic authentication
160
- */
161
- username: string;
162
- /**
163
- * The password to use for basic authentication
164
- */
165
- password: string;
166
- };
167
- /**
168
- * Optional parameters for JWT authentication
169
- */
170
- jwtAuthenticationParameters?: {
171
- /**
172
- * When JWT authentication is being used, this will be invoked just whenever a JWT token is required for a request
173
- */
174
- jwtRequestCallback: () => string | object;
175
- /**
176
- * The id of the service gateway JWT authentication definition to use
177
- *
178
- * Note: Contact Here support to to get your organization's authentication id
179
- */
180
- authenticationId: string;
181
- };
182
- };
57
+ * @example
58
+ * ```typescript
59
+ * const notificationApi = new CloudNotificationAPI({
60
+ * url: process.env.NOTIFICATION_SERVER_HOST
61
+ * });
62
+ *
63
+ * let connectionResult: ConnectionResult;
64
+ * try {
65
+ * connectionResult = await notificationApi.connect(connectSettings);
66
+ * } catch (errorConnect) {
67
+ * terminal.write(chalk.red(`\nError connecting to notification server: ${errorConnect}\n`));
68
+ * process.exit(1);
69
+ * }
70
+ * ```
71
+ *
72
+ * @param parameters - The parameters to use to connect.
73
+ * @returns A promise that resolves when the connection is established.
74
+ * @throws {@link CloudNotificationAPIError} If an error occurs during connection.
75
+ * @throws {@link AuthorizationError} If the connection is unauthorized.
76
+ */
77
+ connect(parameters: ConnectParameters): Promise<ConnectionResult>;
78
+ /**
79
+ * Disconnects from the Cloud Notification service.
80
+ *
81
+ * @returns A promise that resolves when disconnected.
82
+ * @throws {@link CloudNotificationAPIError} If an error occurs during disconnection.
83
+ */
84
+ disconnect(): Promise<void>;
85
+ /**
86
+ * Posts a notification event to the Cloud Notification service.
87
+ *
88
+ * @param notificationId - The ID of the notification or an array of notification IDs.
89
+ * @param event - The event details, including category, type, and optional payload.
90
+ * @returns A promise that resolves when the event is posted.
91
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
92
+ * @throws {@link PublishError} If an error occurs during publishing.
93
+ */
94
+ postNotificationEvent(notificationId: string | string[], event: {
95
+ category: string;
96
+ type: string;
97
+ payload?: unknown;
98
+ }, options?: NotificationEventOptions): Promise<void>;
99
+ /**
100
+ * Removes a notification from the notification center for a given set of users or user groups.
101
+ *
102
+ * @param notificationId - The ID of the notification to remove.
103
+ * @param targets - The targets to remove the notification from.
104
+ * @returns A promise that resolves when the notification is removed.
105
+ */
106
+ removeFromNotificationCenter(notificationId: string, targets: NotificationTargets): Promise<void>;
107
+ /**
108
+ * Post a notification-reminder-created event to the Cloud Notification service.
109
+ *
110
+ * @param notificationId - The ID of the notification or an array of notification IDs to mark as a reminder.
111
+ * @param payload - The payload of the reminder.
112
+ * @returns A promise that resolves when the notification-reminder-created event is posted.
113
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
114
+ */
115
+ setReminder<T extends {
116
+ reminderDate: Date;
117
+ }>(notificationId: string | string[], payload: T, targets: NotificationTargets): Promise<void>;
118
+ /**
119
+ * Post a notification-reminder-removed event to the Cloud Notification service.
120
+ *
121
+ * @param notificationId - The ID of the notification or an array of notification IDs to cancel the reminder for.
122
+ * @returns A promise that resolves when the notification-reminder-removed event is posted.
123
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
124
+ */
125
+ cancelReminder(notificationId: string | string[], targets: NotificationTargets): Promise<void>;
126
+ /**
127
+ * Raises a notification to the Cloud Notification service.
128
+ *
129
+ * @param options - The options for the notification.
130
+ * @param payload - The payload of the notification which should generally conform to the notification center schema
131
+ * @returns A promise that resolves with the notification raise result.
132
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
133
+ * @throws {@link PublishError} If an error occurs during publishing.
134
+ */
135
+ raiseNotification(options: NotificationOptions_2, payload: unknown): Promise<NotificationRaiseResult>;
136
+ /**
137
+ * Raises a notification update to the Cloud Notification service.
138
+ *
139
+ * @param notificationId - The ID of the notification to update.
140
+ * @param options - The options for the notification update.
141
+ * @param payload - The new payload of the notification which should generally conform to the notification center update schema
142
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
143
+ * @throws {@link PublishError} If an error occurs during publishing of the update.
144
+ */
145
+ updateNotification(notificationId: string, options: NotificationUpdateOptions, payload: unknown): Promise<void>;
146
+ /**
147
+ * Marks a notification as deleted in the Cloud Notification service.
148
+ *
149
+ * This in turn causes notification events to be raised for the notification
150
+ *
151
+ * @param notificationId - The ID of the notification to delete.
152
+ * @returns A promise that resolves when the notification is deleted.
153
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
154
+ */
155
+ deleteNotification(notificationId: string | string[]): Promise<void>;
156
+ /**
157
+ * Replays notifications from the Cloud Notification service.
158
+ *
159
+ * This is called at platform startup to populate the notification center with notifications that were missed since the last time the platform was started.
160
+ *
161
+ * @param pageItemLimit - The maximum number of items per page.
162
+ * @param pageStartCursor - The cursor to start the page from. This is retrieved from the pageInfo property.
163
+ * @returns A promise that resolves with the notifications replay details.
164
+ * @throws {@link SessionNotConnectedError} If the session is not connected.
165
+ * @throws {@link NotificationRetrievalError} If an error occurs during retrieval.
166
+ */
167
+ replayNotifications(pageItemLimit: number | undefined, pageStartCursor: string | undefined): Promise<NotificationsReplayDetails>;
168
+ /**
169
+ * Adds an event listener for a specific event type.
170
+ *
171
+ * @param type - The event type.
172
+ * @param callback - The callback function to invoke when the event occurs.
173
+ */
174
+ addEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
175
+ /**
176
+ * Removes an event listener for a specific event type.
177
+ *
178
+ * @param type - The event type.
179
+ * @param callback - The callback function to remove.
180
+ */
181
+ removeEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
182
+ /**
183
+ * Adds a one-time event listener for a specific event type.
184
+ *
185
+ * @param type - The event type.
186
+ * @param callback - The callback function to invoke once when the event occurs.
187
+ */
188
+ once<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
189
+ }
183
190
 
184
- export declare type EventListenersMap = Map<keyof EventMap, Array<(...args: Parameters<EventMap[keyof EventMap]>) => void>>;
191
+ export declare class CloudNotificationAPIError extends Error {
192
+ code: string;
193
+ constructor(message?: string, code?: string, cause?: unknown);
194
+ }
185
195
 
186
- export declare type EventMap = {
187
- reconnected: () => void;
188
- disconnected: () => void;
189
- reconnecting: (attemptNo: number) => void;
190
- error: (error: Error) => void;
191
- 'session-expired': () => void;
192
- 'session-extended': () => void;
193
- 'new-notification': (event: NewNotificationEvent) => void;
194
- 'update-notification': (event: UpdateNotificationEvent) => void;
195
- 'notification-event': (event: NotificationEvent) => void;
196
- };
196
+ /**
197
+ * Represents a logging function to be used by the cloud notification client
198
+ */
199
+ export declare type CloudNotificationLogger = (level: LogLevel, message: string) => void;
197
200
 
198
- export declare class EventRetrievalError extends CloudNotificationAPIError {
199
- constructor(message?: string, code?: string, cause?: unknown);
200
- }
201
+ export declare type CloudNotificationSettings = {
202
+ /**
203
+ * The URL of the notification server to connect to
204
+ *
205
+ * @example 'https://the-environment.example.com/notifications'
206
+ */
207
+ url: string;
208
+ /**
209
+ * The maximum number of times to retry connecting to the cloud notification service when the connection is dropped
210
+ * defaults to 30
211
+ */
212
+ reconnectRetryLimit?: number;
213
+ /**
214
+ * Specifies how often keep alive messages should be sent to the cloud notification service in seconds
215
+ * defaults to 30
216
+ */
217
+ keepAliveIntervalSeconds?: number;
218
+ /**
219
+ * Optional function to call with any logging messages to allow integration with the host application's logging
220
+ *
221
+ * Defaults to console.log
222
+ */
223
+ logger?: CloudNotificationLogger;
224
+ /**
225
+ * The time used to deduplicate notifications
226
+ */
227
+ deduplicationTTLms?: number;
228
+ /**
229
+ * Will cause the api to calculate the time offset between the local machine and the notification server
230
+ * defaults to true
231
+ */
232
+ syncTime?: boolean;
233
+ };
201
234
 
202
- export declare class InvalidMessageFormatError extends CloudNotificationAPIError {
203
- constructor(zodParseResult: z.SafeParseReturnType<unknown, unknown>);
204
- }
235
+ /**
236
+ * Represents the result of a successful connection to the server
237
+ */
238
+ export declare type ConnectionResult = {
239
+ /**
240
+ * The unique identifier for the session
241
+ */
242
+ sessionId: string;
243
+ /**
244
+ * The platform identifier
245
+ */
246
+ platformId: string;
247
+ /**
248
+ * The source identifier
249
+ */
250
+ sourceId: string;
251
+ /**
252
+ * The user identifier
253
+ */
254
+ userId: string;
255
+ /**
256
+ * A collection of groups that the user is either a direct or indirect member of
257
+ */
258
+ groups: {
259
+ uuid: string;
260
+ name: string;
261
+ }[];
262
+ };
205
263
 
206
- export declare type LogLevel = 'log' | 'debug' | 'info' | 'warn' | 'error';
264
+ /**
265
+ * Represents the parameters to use to connect to an notification server
266
+ */
267
+ export declare type ConnectParameters = {
268
+ /**
269
+ * ID for a group of shared applications.
270
+ *
271
+ * This acts as a namespace for the notification messages that allows separation of messages between different groups of applications for the same user
272
+ *
273
+ * This, in general, should be the uuid of the platform that you are communicating
274
+ */
275
+ platformId: string;
276
+ /**
277
+ * A value that distinguishes the host the application is running in. For example this could be the hostname of the current machine
278
+ */
279
+ sourceId: string;
280
+ /**
281
+ * Determines the type of authentication to use with the service gateway
282
+ *
283
+ * - 'jwt' - Use JWT authentication, in this case jwtAuthenticationParameters must also be provided
284
+ * - 'basic' - Use basic authentication, in this case basicAuthenticationParameters must also be provided
285
+ * - 'default' - Authentication will be inherited from the current session
286
+ */
287
+ authenticationType?: 'jwt' | 'basic' | 'default';
288
+ /**
289
+ * Optional parameters for basic authentication
290
+ */
291
+ basicAuthenticationParameters?: {
292
+ /**
293
+ * The username to use for basic authentication
294
+ */
295
+ username: string;
296
+ /**
297
+ * The password to use for basic authentication
298
+ */
299
+ password: string;
300
+ };
301
+ /**
302
+ * Optional parameters for JWT authentication
303
+ */
304
+ jwtAuthenticationParameters?: {
305
+ /**
306
+ * When JWT authentication is being used, this will be invoked just whenever a JWT token is required for a request
307
+ *
308
+ * This token should be conform to the configuration set within your environment. Contact Here support for more details
309
+ *
310
+ * @example
311
+ * ```typescript
312
+ * const jwtRequestCallback = () => {
313
+ * return 'your-jwt-token';
314
+ * };
315
+ * ```
316
+ */
317
+ jwtRequestCallback: () => string | object;
318
+ /**
319
+ * The id of the service gateway JWT authentication definition to use
320
+ *
321
+ * Note: Contact Here support to to get your organization's authentication id
322
+ */
323
+ authenticationId: string;
324
+ };
325
+ };
207
326
 
208
- export declare type NewNotificationEvent = BaseNotificationReceivedEvent & {
209
- action: 'new';
210
- };
327
+ export declare type DeleteNotificationEvent = BaseNotificationReceivedEvent & {
328
+ action: 'delete';
329
+ };
211
330
 
212
- export declare type NotificationEvent = {
213
- notificationId: string;
214
- correlationId?: string;
215
- category: string;
216
- type: string;
217
- payload?: unknown;
218
- };
331
+ export declare type EventMap = {
332
+ /**
333
+ * Emitted when the connection has been re-established
334
+ * @returns void
335
+ */
336
+ reconnected: () => void;
337
+ /**
338
+ * Emitted when the connection has been disconnected
339
+ * @returns void
340
+ */
341
+ reconnecting: (attemptNo: number) => void;
342
+ /**
343
+ * Emitted when the connection has been disconnected
344
+ * @returns void
345
+ */
346
+ disconnected: () => void;
347
+ /**
348
+ * Emitted when an error occurs
349
+ * @returns void
350
+ */
351
+ error: (error: Error) => void;
352
+ /**
353
+ * Emitted when the session has expired
354
+ * @returns void
355
+ */
356
+ 'session-expired': () => void;
357
+ /**
358
+ * Emitted when the session has been extended
359
+ * @returns void
360
+ */
361
+ 'session-extended': () => void;
362
+ /**
363
+ * Emitted when a new notification is received
364
+ * @returns void
365
+ */
366
+ 'new-notification': (event: NewNotificationEvent) => void;
367
+ /**
368
+ * Emitted when an update to a notification is received
369
+ * @returns void
370
+ */
371
+ 'update-notification': (event: UpdateNotificationEvent) => void;
372
+ /**
373
+ * Emitted when a notification is deleted
374
+ * @returns void
375
+ */
376
+ 'delete-notification': (event: DeleteNotificationEvent) => void;
377
+ /**
378
+ * Emitted when a notification event is received for this specific session
379
+ * @returns void
380
+ */
381
+ 'notification-event': (event: NotificationEvent) => void;
382
+ /**
383
+ * Emitted when a notification event is received for all sessions
384
+ * @returns void
385
+ */
386
+ 'global-notification-event': (event: NotificationEvent) => void;
387
+ };
219
388
 
220
- /**
221
- * Represents the options for a notification publish
222
- */
223
- declare type NotificationOptions_2 = {
224
- /**
225
- * A caller specified identifier for the notification
226
- * This is used to identify the notification in the system when events and responses are received
227
- */
228
- correlationId?: string;
229
- /**
230
- * The targets to send the notification to
231
- * This is a set of groups and users that the notification will be sent to
232
- */
233
- targets: NotificationTargets;
234
- };
235
- export { NotificationOptions_2 as NotificationOptions }
389
+ export declare class EventPublishError extends CloudNotificationAPIError {
390
+ constructor(message?: string, code?: string, cause?: unknown);
391
+ }
236
392
 
237
- /**
238
- * Represents the response from raising a notification
239
- */
240
- export declare type NotificationRaiseResult = {
241
- /**
242
- * The unique identifier for the notification
243
- */
244
- notificationId: string;
245
- /**
246
- * The correlation ID that was provided when raising the notification
247
- */
248
- correlationId?: string;
249
- };
393
+ export declare class EventRetrievalError extends CloudNotificationAPIError {
394
+ constructor(message?: string, code?: string, cause?: unknown);
395
+ }
250
396
 
251
- /**
252
- * Represents a set of targets for a notification publish
253
- */
254
- export declare type NotificationTargets = {
255
- /**
256
- * The groups to send the notification to
257
- */
258
- groups: string[];
259
- /**
260
- * The users to send the notification to
261
- */
262
- users: string[];
263
- };
397
+ export declare class InvalidMessageFormatError extends CloudNotificationAPIError {
398
+ constructor(zodParseResult: z.SafeParseReturnType<unknown, unknown>);
399
+ }
264
400
 
265
- export declare class PublishError extends CloudNotificationAPIError {
266
- constructor(message?: string, code?: string, cause?: unknown);
267
- }
401
+ export declare type LogLevel = 'log' | 'debug' | 'info' | 'warn' | 'error';
268
402
 
269
- export declare type PublishResult = {
270
- notificationId: string;
271
- correlationId: string | undefined;
272
- };
403
+ export declare type NewNotificationEvent = BaseNotificationReceivedEvent & {
404
+ action: 'new';
405
+ };
273
406
 
274
- export declare class SessionNotConnectedError extends CloudNotificationAPIError {
275
- constructor(message?: string, code?: string);
276
- }
407
+ /**
408
+ * Represents a notification event
409
+ */
410
+ export declare type NotificationEvent = {
411
+ /**
412
+ * The unique identifier for the notification
413
+ */
414
+ notificationId: string;
415
+ /**
416
+ * The correlation identifier for the notification
417
+ */
418
+ correlationId?: string;
419
+ /**
420
+ * The source identifier
421
+ */
422
+ sourceId: string;
423
+ /**
424
+ * The originating session identifier
425
+ */
426
+ originatingSessionId: string;
427
+ /**
428
+ * The platform identifier
429
+ */
430
+ platformId: string;
431
+ /**
432
+ * The unique platform identifier for the user
433
+ */
434
+ userId: string;
435
+ /**
436
+ * The resolved username of the user
437
+ */
438
+ userName?: string;
439
+ /**
440
+ * The category of the notification.
441
+ * For notification center events this will be 'notification-center-event'
442
+ */
443
+ category: string;
444
+ /**
445
+ * The type of the notification.
446
+ * For example 'notification-close' when a user closes a notification in the notification center
447
+ */
448
+ type: string;
449
+ /**
450
+ * The payload of the notification.
451
+ * See the documentation for the notification center events for more information on the payload
452
+ */
453
+ payload?: unknown;
454
+ };
277
455
 
278
- export declare type UpdateNotificationEvent = BaseNotificationReceivedEvent & {
279
- action: 'update';
280
- };
456
+ /**
457
+ * Represents the options for a notification event publish
458
+ */
459
+ export declare type NotificationEventOptions = {
460
+ /**
461
+ * The targets to send the event to
462
+ *
463
+ * This is a set of groups and users that the notification event will direct to. You may use to explicitly remove the notification
464
+ * from a subset of the original targets that received it.
465
+ *
466
+ * For example you send a notification to *all-users* and then want to remove the notification from a specific group. You can do this by
467
+ * specifying the group name in the targets.
468
+ *
469
+ * @example
470
+ * ```typescript
471
+ * const notificationEventOptions: NotificationEventOptions = {
472
+ * targets: {
473
+ * groups: ['all-users'],
474
+ * users: ['someuser@company.com']
475
+ * }
476
+ * };
477
+ * ```
478
+ */
479
+ targets: NotificationTargets;
480
+ };
281
481
 
282
- export declare type UserGroupWithTopic = {
283
- uuid: string;
284
- name: string;
285
- topic?: string;
286
- };
482
+ /**
483
+ * Represents the options for a notification publish
484
+ */
485
+ declare type NotificationOptions_2 = {
486
+ /**
487
+ * A caller specified identifier for the notification
488
+ *
489
+ * This is used to identify the notification in the system when events and responses are received
490
+ */
491
+ correlationId?: string;
492
+ /**
493
+ * The targets to send the notification to
494
+ *
495
+ * This is a set of groups and users that the notification will be sent to
496
+ *
497
+ * @example
498
+ * ```typescript
499
+ * const notificationOptions: NotificationOptions = {
500
+ * targets: {
501
+ * groups: ['all-users'],
502
+ * users: ['someuser@company.com']
503
+ * }
504
+ * };
505
+ * ```
506
+ */
507
+ targets: NotificationTargets;
508
+ /**
509
+ * Optional number of seconds to keep the notification alive
510
+ *
511
+ * After this time the notification will be expired and a delete update will be raised
512
+ */
513
+ ttlSeconds?: number;
514
+ };
515
+ export { NotificationOptions_2 as NotificationOptions }
516
+
517
+ /**
518
+ * Represents the response from raising a notification
519
+ */
520
+ export declare type NotificationRaiseResult = {
521
+ /**
522
+ * The unique identifier for the notification
523
+ */
524
+ notificationId: string;
525
+ /**
526
+ * The correlation ID that was provided when raising the notification
527
+ */
528
+ correlationId?: string;
529
+ };
530
+
531
+ export declare class NotificationRetrievalError extends CloudNotificationAPIError {
532
+ constructor(message?: string, code?: string, cause?: unknown);
533
+ }
534
+
535
+ /**
536
+ * Represents a single notification replay detail.
537
+ */
538
+ export declare type NotificationsReplayDetail = {
539
+ /**
540
+ * The cursor of the notification.
541
+ */
542
+ cursor: string;
543
+ /**
544
+ * The session ID of the notification.
545
+ */
546
+ sessionId: string;
547
+ /**
548
+ * The notification ID.
549
+ */
550
+ notificationId: string;
551
+ /**
552
+ * The version of the notification.
553
+ */
554
+ version: number;
555
+ /**
556
+ * The type of notification record.
557
+ */
558
+ action: 'new' | 'update' | 'delete';
559
+ /**
560
+ * The payload of the notification.
561
+ */
562
+ payload?: unknown;
563
+ /**
564
+ * The original correlation ID of the notification if specified.
565
+ */
566
+ correlationId?: string | null;
567
+ /**
568
+ * The timestamp of the notification.
569
+ */
570
+ timestamp: Date;
571
+ /**
572
+ * The payload of the latest reminder event for the notification.
573
+ */
574
+ latestReminderPayload?: unknown;
575
+ };
576
+
577
+ /**
578
+ * Represents the results of a notifications replay request.
579
+ */
580
+ export declare type NotificationsReplayDetails = {
581
+ /**
582
+ * The list of notifications replay details.
583
+ */
584
+ data: NotificationsReplayDetail[];
585
+ /**
586
+ * The pagination information for the notifications replay request.
587
+ */
588
+ pageInfo: {
589
+ /**
590
+ * The cursor of the first notification in the page.
591
+ */
592
+ pageStart?: string;
593
+ /**
594
+ * The cursor of the next page.
595
+ */
596
+ nextPage?: string;
597
+ /**
598
+ * Whether there is a next page of notifications.
599
+ */
600
+ hasNextPage: boolean;
601
+ };
602
+ };
603
+
604
+ /**
605
+ * Represents a set of targets for a notification publish
606
+ */
607
+ export declare type NotificationTargets = {
608
+ /**
609
+ * The optional groups to send the notification to
610
+ *
611
+ * This can be a collection of either group names e.g. all-users which can be retrieved from the admin console or the
612
+ * UUID of the group itself
613
+ */
614
+ groups: string[];
615
+ /**
616
+ * The optional specific users to send the notification to
617
+ *
618
+ * This can be the username e.g. someuser\@company.com or the UUID of the user itself
619
+ */
620
+ users: string[];
621
+ };
622
+
623
+ /**
624
+ * Represents the options for a notification update
625
+ */
626
+ export declare type NotificationUpdateOptions = {
627
+ /**
628
+ * Optional number of seconds to keep the notification alive
629
+ * After this time the notification will be expired and a delete update will be raised
630
+ */
631
+ ttlSeconds?: number;
632
+ };
633
+
634
+ export declare class PublishError extends CloudNotificationAPIError {
635
+ constructor(message?: string, code?: string, cause?: unknown);
636
+ }
637
+
638
+ export declare class SessionNotConnectedError extends CloudNotificationAPIError {
639
+ constructor(message?: string, code?: string);
640
+ }
641
+
642
+ export declare type TARGET_TYPE = z.infer<typeof targetTypeSchema>;
643
+
644
+ export declare const targetTypeSchema: z.ZodEnum<["users", "groups"]>;
645
+
646
+ export declare type UpdateNotificationEvent = BaseNotificationReceivedEvent & {
647
+ action: 'update';
648
+ };
287
649
 
288
- export { }
650
+ export { }