@nizam-os/customer-sdk 2.7.0 → 4.0.0

package/dist/api/resources/files/client/Client.d.ts

@@ -41,6 +41,7 @@ export declare class FilesClient {
      * @throws {@link NizamCustomer.BadRequestError}
      * @throws {@link NizamCustomer.UnauthorizedError}
      * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.ConflictError}
      * @throws {@link NizamCustomer.ContentTooLargeError}
      * @throws {@link NizamCustomer.UnprocessableEntityError}
      * @throws {@link NizamCustomer.TooManyRequestsError}
@@ -48,6 +49,7 @@ export declare class FilesClient {
      *
      * @example
      *     await client.files.initiateFileUpload({
+     *         "Idempotency-Key": "9f1e6d2a-7c3b-4e5f-8a91-0b2c3d4e5f60",
      *         kind: "profile_picture",
      *         subject_type: "task_attempt",
      *         subject_id: "b3c4d5e6-7f8a-9b0c-1d2e-3f4a5b6c7d8e",

package/dist/api/resources/files/client/Client.js

@@ -134,6 +134,7 @@ class FilesClient {
      * @throws {@link NizamCustomer.BadRequestError}
      * @throws {@link NizamCustomer.UnauthorizedError}
      * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.ConflictError}
      * @throws {@link NizamCustomer.ContentTooLargeError}
      * @throws {@link NizamCustomer.UnprocessableEntityError}
      * @throws {@link NizamCustomer.TooManyRequestsError}
@@ -141,6 +142,7 @@ class FilesClient {
      *
      * @example
      *     await client.files.initiateFileUpload({
+     *         "Idempotency-Key": "9f1e6d2a-7c3b-4e5f-8a91-0b2c3d4e5f60",
      *         kind: "profile_picture",
      *         subject_type: "task_attempt",
      *         subject_id: "b3c4d5e6-7f8a-9b0c-1d2e-3f4a5b6c7d8e",
@@ -154,8 +156,9 @@ class FilesClient {
         return core.HttpResponsePromise.fromPromise(this.__initiateFileUpload(request, requestOptions));
     }
     async __initiateFileUpload(request, requestOptions) {
+        const { "Idempotency-Key": idempotencyKey, ..._body } = request;
         const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "Idempotency-Key": idempotencyKey }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
@@ -165,7 +168,7 @@ class FilesClient {
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: request,
+            body: _body,
             timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
             maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
             abortSignal: requestOptions?.abortSignal,
@@ -183,6 +186,8 @@ class FilesClient {
                     throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NizamCustomer.ConflictError(_response.error.body, _response.rawResponse);
                 case 413:
                     throw new NizamCustomer.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:

package/dist/api/resources/files/client/requests/InitiateFileUploadRequest.d.ts

@@ -1,6 +1,7 @@
 /**
  * @example
  *     {
+ *         "Idempotency-Key": "9f1e6d2a-7c3b-4e5f-8a91-0b2c3d4e5f60",
  *         kind: "profile_picture",
  *         subject_type: "task_attempt",
  *         subject_id: "b3c4d5e6-7f8a-9b0c-1d2e-3f4a5b6c7d8e",
@@ -11,6 +12,8 @@
  *     }
  */
 export interface InitiateFileUploadRequest {
+    /** Optional. Supply a UUID (canonical 8-4-4-4-12 form; lowercase v4 recommended) to make this operation idempotent: the same key on a retry replays the original outcome instead of creating a second resource. 2xx successes and deliberate 4xx domain rejections are cached and replayed for 24h when the request body matches; transient 5xx responses are never cached, so a retry with the same key re-executes. A malformed key is rejected with 400 `idempotency.invalid_key`; reusing a key with a different request body is 409 `idempotency.key_conflict`; a key still in flight is 409 `idempotency.in_progress`. Omit the header and the operation behaves like any other write. */
+    "Idempotency-Key"?: string;
     /** What the bytes are for the platform — fixes the policy applied to them. */
     kind: InitiateFileUploadRequest.Kind;
     /** Type of the business entity this file documents (optional at upload time; can also be attached later). */

package/dist/api/resources/notifications/client/Client.d.ts

@@ -14,7 +14,7 @@ export declare class NotificationsClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<NotificationsClient.Options>;
     constructor(options: NotificationsClient.Options);
     /**
-     * The caller's own notifications ordered by `created_at` descending (pass `sort=created_at` for ascending). `unread=true` restricts to unread; `since=` (RFC 3339) returns only items at/after the instant for incremental catch-up after a reconnect. Pagination is bidirectional (`starting_after` / `ending_before`); cursors are bound to the sort direction that minted them.
+     * The caller's own notifications ordered by `created_at` descending (pass `sort=created_at` for ascending). `status` selects the segment — `all` (default; the active inbox, non-archived), `unread`, `read`, or `archived`. `category` and `kind` accept comma-separated values and AND on top of the segment; `q` matches the notification title/body. `since=` (RFC 3339) returns only items at/after the instant for incremental catch-up after a reconnect. Pagination is bidirectional (`starting_after` / `ending_before`); cursors are bound to the sort direction that minted them.
      *
      * @param {NizamCustomer.ListNotificationsRequest} request
      * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -27,6 +27,8 @@ export declare class NotificationsClient {
      *
      * @example
      *     await client.notifications.listNotifications({
+     *         status: "<string>",
+     *         q: "<string>",
      *         since: "2026-05-20T14:00:00Z",
      *         starting_after: "Y3Vyc29yX25leHRfMDFKNVE=",
      *         ending_before: "Y3Vyc29yX25leHRfMDFKNVE="
@@ -34,6 +36,38 @@ export declare class NotificationsClient {
      */
     listNotifications(request?: NizamCustomer.ListNotificationsRequest, requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.ListResponseNotification>;
     private __listNotifications;
+    /**
+     * Archives every active notification of the caller in one operation. Returns the number archived (zero when the active inbox was already empty).
+     *
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.BadRequestError}
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.archiveAllNotifications()
+     */
+    archiveAllNotifications(requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.NotificationsArchived>;
+    private __archiveAllNotifications;
+    /**
+     * The segment-badge roll-up for the active organization: total + unread (active, non-archived), archived, and per-category active total/unread. Computed server-side in one pass so segment badges stay accurate across cursor pages (never inferred from the loaded page). Excludes dismissed (soft-deleted) notifications.
+     *
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.BadRequestError}
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.getNotificationCounts()
+     */
+    getNotificationCounts(requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.NotificationCounts>;
+    private __getNotificationCounts;
     /**
      * Flips every unread notification of the caller to read in one operation. Returns the number of notifications that were flipped (zero when the inbox was already clear).
      *
@@ -51,7 +85,7 @@ export declare class NotificationsClient {
     markAllNotificationsRead(requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.NotificationsMarkedRead>;
     private __markAllNotificationsRead;
     /**
-     * The unread badge count for the active organization. Excludes dismissed (soft-deleted) notifications.
+     * The unread badge count for the active organization. Counts active (non-archived) unread notifications; excludes dismissed (soft-deleted) and archived ones.
      *
      * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
      *
@@ -66,6 +100,25 @@ export declare class NotificationsClient {
      */
     getUnreadNotificationCount(requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.NotificationUnreadCount>;
     private __getUnreadNotificationCount;
+    /**
+     * Moves a single notification to the archive ("Done") — reversible, not a delete: it leaves the active inbox but stays listable under `status=archived`. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.ArchiveNotificationRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.archiveNotification({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    archiveNotification(request: NizamCustomer.ArchiveNotificationRequest, requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.Notification>;
+    private __archiveNotification;
     /**
      * Flips a single notification to read. Idempotent — a second call is a no-op that preserves the original read timestamp. 404 if the notification is not the caller's.
      *
@@ -85,4 +138,42 @@ export declare class NotificationsClient {
      */
     markNotificationRead(request: NizamCustomer.MarkNotificationReadRequest, requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.Notification>;
     private __markNotificationRead;
+    /**
+     * Restores an archived notification to the active inbox — the inverse of archive. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.UnarchiveNotificationRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.unarchiveNotification({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    unarchiveNotification(request: NizamCustomer.UnarchiveNotificationRequest, requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.Notification>;
+    private __unarchiveNotification;
+    /**
+     * Flips a single notification back to unread — the inverse of mark-read. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.MarkNotificationUnreadRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.markNotificationUnread({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    markNotificationUnread(request: NizamCustomer.MarkNotificationUnreadRequest, requestOptions?: NotificationsClient.RequestOptions): core.HttpResponsePromise<NizamCustomer.Notification>;
+    private __markNotificationUnread;
 }

package/dist/api/resources/notifications/client/Client.js

@@ -50,7 +50,7 @@ class NotificationsClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * The caller's own notifications ordered by `created_at` descending (pass `sort=created_at` for ascending). `unread=true` restricts to unread; `since=` (RFC 3339) returns only items at/after the instant for incremental catch-up after a reconnect. Pagination is bidirectional (`starting_after` / `ending_before`); cursors are bound to the sort direction that minted them.
+     * The caller's own notifications ordered by `created_at` descending (pass `sort=created_at` for ascending). `status` selects the segment — `all` (default; the active inbox, non-archived), `unread`, `read`, or `archived`. `category` and `kind` accept comma-separated values and AND on top of the segment; `q` matches the notification title/body. `since=` (RFC 3339) returns only items at/after the instant for incremental catch-up after a reconnect. Pagination is bidirectional (`starting_after` / `ending_before`); cursors are bound to the sort direction that minted them.
      *
      * @param {NizamCustomer.ListNotificationsRequest} request
      * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -63,6 +63,8 @@ class NotificationsClient {
      *
      * @example
      *     await client.notifications.listNotifications({
+     *         status: "<string>",
+     *         q: "<string>",
      *         since: "2026-05-20T14:00:00Z",
      *         starting_after: "Y3Vyc29yX25leHRfMDFKNVE=",
      *         ending_before: "Y3Vyc29yX25leHRfMDFKNVE="
@@ -72,9 +74,12 @@ class NotificationsClient {
         return core.HttpResponsePromise.fromPromise(this.__listNotifications(request, requestOptions));
     }
     async __listNotifications(request = {}, requestOptions) {
-        const { unread, since, sort, limit, starting_after: startingAfter, ending_before: endingBefore } = request;
+        const { status, category, kind, q, since, sort, limit, starting_after: startingAfter, ending_before: endingBefore, } = request;
         const _queryParams = {
-            unread,
+            status,
+            category,
+            kind,
+            q,
             since: since != null ? since : undefined,
             sort,
             limit,
@@ -128,6 +133,122 @@ class NotificationsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v1/notifications");
     }
+    /**
+     * Archives every active notification of the caller in one operation. Returns the number archived (zero when the active inbox was already empty).
+     *
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.BadRequestError}
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.archiveAllNotifications()
+     */
+    archiveAllNotifications(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__archiveAllNotifications(requestOptions));
+    }
+    async __archiveAllNotifications(requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.NizamCustomerEnvironment.Production, "v1/notifications/archive_all"),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NizamCustomer.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NizamCustomer.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NizamCustomer.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NizamCustomerError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/archive_all");
+    }
+    /**
+     * The segment-badge roll-up for the active organization: total + unread (active, non-archived), archived, and per-category active total/unread. Computed server-side in one pass so segment badges stay accurate across cursor pages (never inferred from the loaded page). Excludes dismissed (soft-deleted) notifications.
+     *
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.BadRequestError}
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.getNotificationCounts()
+     */
+    getNotificationCounts(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getNotificationCounts(requestOptions));
+    }
+    async __getNotificationCounts(requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.NizamCustomerEnvironment.Production, "v1/notifications/counts"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NizamCustomer.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NizamCustomer.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NizamCustomer.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NizamCustomerError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v1/notifications/counts");
+    }
     /**
      * Flips every unread notification of the caller to read in one operation. Returns the number of notifications that were flipped (zero when the inbox was already clear).
      *
@@ -190,7 +311,7 @@ class NotificationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/read_all");
     }
     /**
-     * The unread badge count for the active organization. Excludes dismissed (soft-deleted) notifications.
+     * The unread badge count for the active organization. Counts active (non-archived) unread notifications; excludes dismissed (soft-deleted) and archived ones.
      *
      * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
      *
@@ -250,6 +371,68 @@ class NotificationsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v1/notifications/unread_count");
     }
+    /**
+     * Moves a single notification to the archive ("Done") — reversible, not a delete: it leaves the active inbox but stays listable under `status=archived`. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.ArchiveNotificationRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.archiveNotification({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    archiveNotification(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__archiveNotification(request, requestOptions));
+    }
+    async __archiveNotification(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.NizamCustomerEnvironment.Production, `v1/notifications/${core.url.encodePathParam(id)}/archive`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NizamCustomer.NotFoundError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NizamCustomer.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NizamCustomer.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NizamCustomerError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/{id}/archive");
+    }
     /**
      * Flips a single notification to read. Idempotent — a second call is a no-op that preserves the original read timestamp. 404 if the notification is not the caller's.
      *
@@ -312,5 +495,129 @@ class NotificationsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/{id}/read");
     }
+    /**
+     * Restores an archived notification to the active inbox — the inverse of archive. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.UnarchiveNotificationRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.unarchiveNotification({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    unarchiveNotification(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__unarchiveNotification(request, requestOptions));
+    }
+    async __unarchiveNotification(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.NizamCustomerEnvironment.Production, `v1/notifications/${core.url.encodePathParam(id)}/unarchive`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NizamCustomer.NotFoundError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NizamCustomer.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NizamCustomer.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NizamCustomerError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/{id}/unarchive");
+    }
+    /**
+     * Flips a single notification back to unread — the inverse of mark-read. Idempotent. 404 if the notification is not the caller's.
+     *
+     * @param {NizamCustomer.MarkNotificationUnreadRequest} request
+     * @param {NotificationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NizamCustomer.UnauthorizedError}
+     * @throws {@link NizamCustomer.ForbiddenError}
+     * @throws {@link NizamCustomer.NotFoundError}
+     * @throws {@link NizamCustomer.TooManyRequestsError}
+     * @throws {@link NizamCustomer.InternalServerError}
+     *
+     * @example
+     *     await client.notifications.markNotificationUnread({
+     *         id: "00000000-0000-0000-0000-000000000000"
+     *     })
+     */
+    markNotificationUnread(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__markNotificationUnread(request, requestOptions));
+    }
+    async __markNotificationUnread(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.NizamCustomerEnvironment.Production, `v1/notifications/${core.url.encodePathParam(id)}/unread`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new NizamCustomer.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NizamCustomer.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NizamCustomer.NotFoundError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NizamCustomer.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NizamCustomer.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NizamCustomerError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/notifications/{id}/unread");
+    }
 }
 exports.NotificationsClient = NotificationsClient;

package/dist/api/resources/notifications/client/requests/ArchiveNotificationRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @example
+ *     {
+ *         id: "00000000-0000-0000-0000-000000000000"
+ *     }
+ */
+export interface ArchiveNotificationRequest {
+    id: string;
+}

package/dist/api/resources/notifications/client/requests/ArchiveNotificationRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/resources/notifications/client/requests/ListNotificationsRequest.d.ts

@@ -1,14 +1,22 @@
 /**
  * @example
  *     {
+ *         status: "<string>",
+ *         q: "<string>",
  *         since: "2026-05-20T14:00:00Z",
  *         starting_after: "Y3Vyc29yX25leHRfMDFKNVE=",
  *         ending_before: "Y3Vyc29yX25leHRfMDFKNVE="
  *     }
  */
 export interface ListNotificationsRequest {
-    /** Restrict to unread notifications. */
-    unread?: boolean;
+    /** Inbox segment. One of: `all` (default — active, non-archived), `unread`, `read`, `archived`. */
+    status?: string;
+    /** Filter by category. Comma-separated; values: `transactional`, `operational`, `alert`, `marketing`, `security`, `system`. */
+    category?: string | string[];
+    /** Filter by notification kind (wire key). Comma-separated; e.g. `membership.joined`. */
+    kind?: string | string[];
+    /** Free-text search over the notification title/body (max 200 chars). */
+    q?: string;
     /** Only notifications created at/after this RFC 3339 instant. */
     since?: string;
     /** Sort order. Allowed fields: `created_at`. Prefix a field with `-` for descending (e.g. `-created_at`); unknown fields are rejected with `400 validation_failed`. */

package/dist/api/resources/notifications/client/requests/MarkNotificationUnreadRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @example
+ *     {
+ *         id: "00000000-0000-0000-0000-000000000000"
+ *     }
+ */
+export interface MarkNotificationUnreadRequest {
+    id: string;
+}

package/dist/api/resources/notifications/client/requests/MarkNotificationUnreadRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/resources/notifications/client/requests/UnarchiveNotificationRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @example
+ *     {
+ *         id: "00000000-0000-0000-0000-000000000000"
+ *     }
+ */
+export interface UnarchiveNotificationRequest {
+    id: string;
+}

package/dist/api/resources/notifications/client/requests/UnarchiveNotificationRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/resources/notifications/client/requests/index.d.ts

@@ -1,2 +1,5 @@
+export type { ArchiveNotificationRequest } from "./ArchiveNotificationRequest.js";
 export type { ListNotificationsRequest } from "./ListNotificationsRequest.js";
 export type { MarkNotificationReadRequest } from "./MarkNotificationReadRequest.js";
+export type { MarkNotificationUnreadRequest } from "./MarkNotificationUnreadRequest.js";
+export type { UnarchiveNotificationRequest } from "./UnarchiveNotificationRequest.js";

package/dist/api/types/Device.d.ts

@@ -5,9 +5,9 @@ export interface Device {
     /** Device id. */
     id?: string | undefined;
     /** Push transport. */
-    platform?: string | undefined;
+    platform?: Device.Platform | undefined;
     /** Registration lifecycle. */
-    status?: string | undefined;
+    status?: Device.Status | undefined;
     /** When the device was first registered. */
     registered_at?: string | undefined;
     /** When the registration was last refreshed (last seen). */
@@ -16,6 +16,21 @@ export interface Device {
     object?: Device.Object_ | undefined;
 }
 export declare namespace Device {
+    /** Push transport. */
+    const Platform: {
+        readonly Ios: "ios";
+        readonly Android: "android";
+        readonly Web: "web";
+    };
+    type Platform = (typeof Platform)[keyof typeof Platform];
+    /** Registration lifecycle. */
+    const Status: {
+        readonly Active: "active";
+        readonly Suspended: "suspended";
+        readonly Inactive: "inactive";
+        readonly Expired: "expired";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
     /** Object type discriminator. */
     const Object_: {
         readonly Device: "device";

package/dist/api/types/Device.js

@@ -4,6 +4,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
 var Device;
 (function (Device) {
+    /** Push transport. */
+    Device.Platform = {
+        Ios: "ios",
+        Android: "android",
+        Web: "web",
+    };
+    /** Registration lifecycle. */
+    Device.Status = {
+        Active: "active",
+        Suspended: "suspended",
+        Inactive: "inactive",
+        Expired: "expired",
+    };
     /** Object type discriminator. */
     Device.Object_ = {
         Device: "device",

package/dist/api/types/Notification.d.ts

@@ -18,6 +18,10 @@ export interface Notification {
     read?: boolean | undefined;
     /** When it was read (RFC 3339); null while unread. */
     read_at?: string | undefined;
+    /** Whether the recipient has archived ("Done") it. */
+    archived?: boolean | undefined;
+    /** When it was archived (RFC 3339); null while in the active inbox. */
+    archived_at?: string | undefined;
     /** When it was raised (RFC 3339). */
     created_at?: string | undefined;
 }

package/dist/api/types/NotificationCategoryCount.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Active total/unread for one category.
+ */
+export interface NotificationCategoryCount {
+    /** Category. */
+    category?: NotificationCategoryCount.Category | undefined;
+    /** Active notifications in this category. */
+    total?: number | undefined;
+    /** Active unread notifications in this category. */
+    unread?: number | undefined;
+}
+export declare namespace NotificationCategoryCount {
+    /** Category. */
+    const Category: {
+        readonly Transactional: "transactional";
+        readonly Operational: "operational";
+        readonly Alert: "alert";
+        readonly Marketing: "marketing";
+        readonly Security: "security";
+        readonly System: "system";
+    };
+    type Category = (typeof Category)[keyof typeof Category];
+}

package/dist/api/types/NotificationCategoryCount.js

@@ -0,0 +1,16 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationCategoryCount = void 0;
+var NotificationCategoryCount;
+(function (NotificationCategoryCount) {
+    /** Category. */
+    NotificationCategoryCount.Category = {
+        Transactional: "transactional",
+        Operational: "operational",
+        Alert: "alert",
+        Marketing: "marketing",
+        Security: "security",
+        System: "system",
+    };
+})(NotificationCategoryCount || (exports.NotificationCategoryCount = NotificationCategoryCount = {}));

package/dist/api/types/NotificationCounts.d.ts

@@ -0,0 +1,23 @@
+import type * as NizamCustomer from "../index.js";
+/**
+ * Inbox segment-badge counts (server-derived).
+ */
+export interface NotificationCounts {
+    /** Active (non-archived) notifications. */
+    total?: number | undefined;
+    /** Active unread notifications. */
+    unread?: number | undefined;
+    /** Archived ("Done") notifications. */
+    archived?: number | undefined;
+    /** Per-category active counts; categories with no active row are omitted. */
+    categories?: NizamCustomer.NotificationCategoryCount[] | undefined;
+    /** Object type discriminator. */
+    object?: NotificationCounts.Object_ | undefined;
+}
+export declare namespace NotificationCounts {
+    /** Object type discriminator. */
+    const Object_: {
+        readonly NotificationCounts: "notification_counts";
+    };
+    type Object_ = (typeof Object_)[keyof typeof Object_];
+}

package/dist/api/types/NotificationCounts.js

@@ -0,0 +1,11 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationCounts = void 0;
+var NotificationCounts;
+(function (NotificationCounts) {
+    /** Object type discriminator. */
+    NotificationCounts.Object_ = {
+        NotificationCounts: "notification_counts",
+    };
+})(NotificationCounts || (exports.NotificationCounts = NotificationCounts = {}));

package/dist/api/types/NotificationsArchived.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Result of an archive-all operation.
+ */
+export interface NotificationsArchived {
+    /** Number of notifications archived. */
+    archived?: number | undefined;
+    /** Object type discriminator. */
+    object?: NotificationsArchived.Object_ | undefined;
+}
+export declare namespace NotificationsArchived {
+    /** Object type discriminator. */
+    const Object_: {
+        readonly NotificationsArchived: "notifications_archived";
+    };
+    type Object_ = (typeof Object_)[keyof typeof Object_];
+}

package/dist/api/types/NotificationsArchived.js

@@ -0,0 +1,11 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsArchived = void 0;
+var NotificationsArchived;
+(function (NotificationsArchived) {
+    /** Object type discriminator. */
+    NotificationsArchived.Object_ = {
+        NotificationsArchived: "notifications_archived",
+    };
+})(NotificationsArchived || (exports.NotificationsArchived = NotificationsArchived = {}));

package/dist/api/types/NotificationsMarkedRead.d.ts

@@ -1,5 +1,5 @@
 /**
- * Result of a mark-all-read operation.
+ * Result of a mark-read operation.
  */
 export interface NotificationsMarkedRead {
     /** Number of notifications flipped to read. */

package/dist/api/types/index.d.ts

@@ -57,10 +57,13 @@ export * from "./MembershipChoice.js";
 export * from "./MembershipDriftResponse.js";
 export * from "./MqttToken.js";
 export * from "./Notification.js";
+export * from "./NotificationCategoryCount.js";
+export * from "./NotificationCounts.js";
 export * from "./NotificationDeadLetter.js";
 export * from "./NotificationPreference.js";
 export * from "./NotificationPreferenceItem.js";
 export * from "./NotificationPreferences.js";
+export * from "./NotificationsArchived.js";
 export * from "./NotificationsMarkedRead.js";
 export * from "./NotificationUnreadCount.js";
 export * from "./OpenAssignmentRequest.js";

package/dist/api/types/index.js

@@ -73,10 +73,13 @@ __exportStar(require("./MembershipChoice.js"), exports);
 __exportStar(require("./MembershipDriftResponse.js"), exports);
 __exportStar(require("./MqttToken.js"), exports);
 __exportStar(require("./Notification.js"), exports);
+__exportStar(require("./NotificationCategoryCount.js"), exports);
+__exportStar(require("./NotificationCounts.js"), exports);
 __exportStar(require("./NotificationDeadLetter.js"), exports);
 __exportStar(require("./NotificationPreference.js"), exports);
 __exportStar(require("./NotificationPreferenceItem.js"), exports);
 __exportStar(require("./NotificationPreferences.js"), exports);
+__exportStar(require("./NotificationsArchived.js"), exports);
 __exportStar(require("./NotificationsMarkedRead.js"), exports);
 __exportStar(require("./NotificationUnreadCount.js"), exports);
 __exportStar(require("./OpenAssignmentRequest.js"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nizam-os/customer-sdk",
-  "version": "2.7.0",
+  "version": "4.0.0",
   "description": "Nizam Customer API SDK for TypeScript / JavaScript.",
   "license": "MIT",
   "private": false,