> ## Documentation Index
> Fetch the complete documentation index at: https://social-b97141fb-feat-user-history-moderation-detail.mintlify.site/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>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.