> ## Documentation Index
> Fetch the complete documentation index at: https://learn.social.plus/llms.txt
> Use this file to discover all available pages before exploring further.

# User Notification Settings

> Read and update account-wide push notification settings for the signed-in user.

User notification settings apply across the signed-in user's devices. Use this scope for global push preferences and module-level choices for chat, social, and video-streaming notifications.

## API surface

| Platform   | Manager                                  | Read            | Enable                     | Disable all                 |
| ---------- | ---------------------------------------- | --------------- | -------------------------- | --------------------------- |
| TypeScript | `Client.notifications().user()`          | `getSettings()` | `enable(modules?)`         | `disableAllNotifications()` |
| iOS        | `client.notificationManager`             | `getSettings()` | `enable(for:)`             | `disableAllNotifications()` |
| Android    | `AmityCoreClient.notifications().user()` | `getSettings()` | `enable(moduleModifiers?)` | `disableAllNotifications()` |
| Flutter    | `AmityCoreClient.notifications().user()` | `getSettings()` | `enable(eventModifiers)`   | `disable()`                 |

## Parameters

| Name              | Platform                          | Type                                          | Required | Description                                                                  |
| ----------------- | --------------------------------- | --------------------------------------------- | -------- | ---------------------------------------------------------------------------- |
| `modules`         | TypeScript                        | `Amity.UserNotificationModule[]`              | No       | Module-level settings to send with `enable`.                                 |
| `modules`         | iOS                               | `[AmityUserNotificationModule]?`              | No       | Module-level settings passed to `enable(for:)`.                              |
| `moduleModifiers` | Android                           | `List<AmityUserNotificationModule.MODIFIER>?` | No       | Module modifiers passed to `enable`.                                         |
| `eventModifiers`  | Flutter                           | `List<UserNotificationModifier>?`             | Nullable | Module modifiers passed to `enable`.                                         |
| `roleFilter`      | TypeScript, iOS, Android, Flutter | Role filter                                   | No       | Optional filter for receiving notifications only from matching sender roles. |

## Modules

| Module value      | TypeScript enum   | iOS case          | Android/Flutter modifier             |
| ----------------- | ----------------- | ----------------- | ------------------------------------ |
| `chat`            | `CHAT`            | `.chat`           | `CHAT` / `Chat`                      |
| `social`          | `SOCIAL`          | `.social`         | `SOCIAL` / `Social`                  |
| `video-streaming` | `VIDEO_STREAMING` | `.videoStreaming` | `VIDEO_STREAMING` / `VideoStreaming` |

## Get user settings

Read account-wide notification settings before rendering global or module-level push controls.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Client, NotificationRolesFilterTypeEnum } from '@amityco/ts-sdk';

  const settings = await Client.notifications()
    .user()
    .getSettings();

  const isEnabled = settings.isEnabled;

  settings.modules.forEach(module => {
    const moduleName = module.moduleName;
    const moduleEnabled = module.isEnabled;

    if (module.rolesFilter?.type === NotificationRolesFilterTypeEnum.ONLY) {
      const roleIds = module.rolesFilter.roleIds;
      updateUI({ moduleName, moduleEnabled, roleIds });
    }
  });
  ```

  ```swift iOS theme={null}
  let notificationManager = client.notificationManager
  let settings = try await notificationManager.getSettings()

  let isEnabled = settings.isEnabled

  for module in settings.modules {
      switch module.moduleType {
      case .chat:
          print("chat enabled: \(module.isEnabled)")
      case .social:
          print("social enabled: \(module.isEnabled)")
      case .videoStreaming:
          print("video streaming enabled: \(module.isEnabled)")
      @unknown default:
          print("unknown module enabled: \(module.isEnabled)")
      }
  }
  ```

  ```kotlin Android theme={null}
  AmityCoreClient.notifications()
      .user()
      .getSettings()
      .doOnSuccess { settings ->
          val isEnabled = settings.isEnabled()

          settings.getModules()?.forEach { module ->
              when (module) {
                  is AmityUserNotificationModule.CHAT -> {
                      val moduleEnabled = module.isEnabled()
                  }
                  is AmityUserNotificationModule.SOCIAL -> {
                      val moduleEnabled = module.isEnabled()
                      val rolesFilter = module.getRolesFilter()
                  }
                  is AmityUserNotificationModule.VIDEO_STREAMING -> {
                      val moduleEnabled = module.isEnabled()
                  }
                  else -> Unit
              }
          }
      }
      .doOnError { error ->
          // Handle error.
      }
      .subscribe()
  ```

  ```dart Flutter theme={null}
  final settings = await AmityCoreClient
      .notifications()
      .user()
      .getSettings();

  final isEnabled = settings.isEnabled;

  settings.events?.forEach((module) {
    final moduleEnabled = module.isEnabled;
    final rolesFilter = module.rolesFilter;
  });
  ```
</CodeGroup>

## Update user settings

Enable, disable, or customize account-wide notification modules after the user changes global push preferences.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import {
    Client,
    NotificationRolesFilterTypeEnum,
    UserNotificationModuleNameEnum,
  } from '@amityco/ts-sdk';

  await Client.notifications()
    .user()
    .enable([
      {
        moduleName: UserNotificationModuleNameEnum.CHAT,
        isEnabled: true,
      },
      {
        moduleName: UserNotificationModuleNameEnum.SOCIAL,
        isEnabled: true,
        rolesFilter: {
          type: NotificationRolesFilterTypeEnum.ONLY,
          roleIds: ['community-moderator'],
        },
      },
      {
        moduleName: UserNotificationModuleNameEnum.VIDEO_STREAMING,
        isEnabled: false,
      },
    ]);

  await Client.notifications()
    .user()
    .disableAllNotifications();
  ```

  ```swift iOS theme={null}
  let notificationManager = client.notificationManager

  try await notificationManager.enable(for: [
      AmityUserNotificationModule(
          moduleType: .chat,
          isEnabled: true,
          roleFilter: nil
      ),
      AmityUserNotificationModule(
          moduleType: .social,
          isEnabled: true,
          roleFilter: AmityRoleFilter.onlyFilter(withRoleIds: ["community-moderator"])
      ),
      AmityUserNotificationModule(
          moduleType: .videoStreaming,
          isEnabled: false,
          roleFilter: nil
      ),
  ])

  try await notificationManager.disableAllNotifications()
  ```

  ```kotlin Android theme={null}
  val rolesFilter = AmityRolesFilter.ONLY(AmityRoles(listOf("community-moderator")))

  val chatModifier = AmityUserNotificationModule.CHAT.enable()
  val socialModifier = AmityUserNotificationModule.SOCIAL.enable(rolesFilter)
  val videoStreamingModifier = AmityUserNotificationModule.VIDEO_STREAMING.disable()

  AmityCoreClient.notifications()
      .user()
      .enable(
          moduleModifiers = listOf(
              chatModifier,
              socialModifier,
              videoStreamingModifier
          )
      )
      .doOnComplete {
          // User notification settings updated.
      }
      .doOnError { error ->
          // Handle error.
      }
      .subscribe()

  AmityCoreClient.notifications()
      .user()
      .disableAllNotifications()
      .subscribe()
  ```

  ```dart Flutter theme={null}
  final rolesFilter = Only(AmityRoles(roles: ['community-moderator']));

  await AmityCoreClient
      .notifications()
      .user()
      .enable([
        Chat.enable(null),
        Social.enable(rolesFilter),
        VideoStreaming.disable(),
      ]);

  await AmityCoreClient
      .notifications()
      .user()
      .disable();
  ```
</CodeGroup>

## Related

<CardGroup cols={2}>
  <Card title="Channel Settings" href="./channel-settings">
    Configure push settings for a chat channel.
  </Card>

  <Card title="Community Settings" href="./community-settings">
    Configure push settings for social community events.
  </Card>
</CardGroup>