> For the complete documentation index, see [llms.txt](https://docs.keeper.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.keeper.io/keeperpam/commander-sdk/keeper-commander-sdks/sdk-command-reference/enterprise-management-commands/enterprise-team-commands.md).

# Enterprise Team Commands

Manage an enterprise team(s).

#### Usage <a href="#usage-5" id="usage-5"></a>

```bash
enterprise-team command [--options] OR et command [--option]
```

**Alias:** `et`

#### Commands <a href="#commands-3" id="commands-3"></a>

<table data-search="false"><thead><tr><th>Command</th><th>Description</th><th>Alias</th></tr></thead><tbody><tr><td><a href="#enterprise-team-view"><code>view</code></a></td><td>View enterprise team</td><td><code>v</code></td></tr><tr><td><a href="#enterprise-info-tree"><code>add</code></a></td><td>Create enterprise team(s)</td><td><code>a</code></td></tr><tr><td><a href="#enterprise-info-tree-1"><code>edit</code></a></td><td>Edit enterprise team(s)</td><td><code>e</code></td></tr><tr><td><a href="#enterprise-info-tree-2"><code>delete</code></a></td><td>Delete enterprise team(s)</td><td><code>d</code></td></tr><tr><td><a href="#enterprise-node-invite-email"><code>membership</code></a></td><td>Manage enterprise team membership</td><td><code>m</code></td></tr><tr><td><a href="#enterprise-team-user-update-command"><code>user-update</code></a></td><td>Update user information in team</td><td></td></tr><tr><td><a href="#enterprise-team-approve-command">team-approve</a></td><td>Approve queued teams and users provisioned by SCIM or Active Directory Bridge</td><td>ta</td></tr></tbody></table>

### Enterprise Team View Command

This command is for viewing teams and their permissions.

<details>

<summary>DotNet CLI</summary>

**Command:** `enterprise-team view <team_name> OR et view <team_name>`

**Parameter:**

`team_name` team name (required)

**Options**:

* `-q, --queued` - Include queued team/user information (for list/view)

**Example:**

```
My Vault> enterprise-team view "POD Team"           
      Team Name:  POD Team                       
       Team UID:  qS9qkAme2vl6o5UJggaagA         
  Restrict Edit:  No                             
 Restrict Share:  No                             
  Restrict View:  No                             
          Users:  dhananjay.tayade@metronlabs.com
                  satish.gaddala@metronlabs.com  
   Queued Users:                                 
           Node:  Metron Security 
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `EnterpriseData.Teams`

**Usage:** Enterprise users list can be obtained from EnterpriseData as a dictionary

**Example:**

```csharp
var enterpriseTeam = EnterpriseData.Teams.FirstOrDefault(x =>
                    string.Compare(x.Name, identifier, StringComparison.CurrentCultureIgnoreCase) == 0);
```

</details>

<details>

<summary>PowerCommander</summary>

**Command:**`Get-KeeperEnterpriseTeam`

**Syntax:**

```powershell
Get-KeeperEnterpriseTeam
```

**Aliases:** `ket`

**Parameters:**

* `-Name` - User email.
* `-Filter` - Search filter.
* `-Format` - Output format.
* `-Output` - Output file name.

**Example:**

```powershell
# List all teams
PS> Get-KeeperEnterpriseTeam

# Get specific team
PS> Get-KeeperEnterpriseTeam -Name T1

# Search team
PS> Get-KeeperEnterpriseTeam -Filter T1
```

**Command :** `Get-KeeperEnterpriseTeamUser`

**Parameters:**

`-Team` : Name or Uid to filter users for a team.

**Syntax:**

```powershell
Get-KeeperEnterpriseTeamUser
```

**Example:**

```powershell
# Get all users from a specific team
PS> Get-KeeperEnterpriseTeamUser T

Id             DisplayName  Email                         UserStatus NodeName        
--             -----------  -----                         ---------- --------        
70411693850788 test sso     mimafe5220@docsfy.com         Active     SSO
70411693853106 Test1        mimafe5220@gmail.com          Active     Keeper Security 
```

**Command**: `Get-KeeperAvailableTeam`

**Example**:

```powershell
PS > Get-KeeperAvailableTeam 

TeamUid                Name
-------                ----
eun1B5Cy89qO-sknhz59tg T3
7Xo__xOv62mUmqhXVPSZng Test Role Copy
```

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team view`

**Flag:**

* `-v`, `--verbose` - Print verbose information
* `--format` - Output format: `json`
* `--output` - Output filename
* `team` - Team Name or UID (required)

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
team_id = 'team name or UID'
team = enterprise_data.teams.get_entity(team_id)
if not team:
    ts = [x for x in enterprise_data.teams.get_all_entities() if x.name.lower() == team_id.lower(
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** `listTeams`

```python
export async function listTeams(auth: Auth, options: ListTeamsOptions = {}): Promise<ListTeamRow[]> {
    const columns = resolveColumns(options.columns)
    const includes = includesForColumns(columns)
    const wantsDisplayNames = columns.includes(TeamColumn.Node) || columns.includes(TeamColumn.Roles)
    const enterpriseData = new EnterpriseDataManager(auth)
    const emptyDisplayNames: EnterpriseDisplayNames = {
        nodes: new Map(),
        roles: new Map(),
    }
```

</details>

### Enterprise Team Add Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Create enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**Usage**

```bash
enterprise-team  add [team] [--options] OR et add [team] [--options]
```

**Parameter:**

`team` team name

**Options:**

* `--node <node>` - Node name or ID (for add/update)
* `--restrict-edit <ON|OFF>` - Disable record editing
* `--restrict-share <ON|OFF>` - Disable record re-sharing
* `--restrict-view <ON|OFF>` - Disable password viewing/copying

**Example:**

```bash
# Add team
enterprise-team add "Frontend Team" --node "Engineering"
OR 
et add "Backend Team" --node 12345 --restrict-edit OFF --restrict-share ON
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `CreateTeam`

```csharp
public async Task<EnterpriseTeam> CreateTeam(EnterpriseTeam team)
```

**Example:**

```csharp
team = await enterprise.CreateTeam(new EnterpriseTeam
                            {
                                Name = "Google",
                                RestrictEdit = false,
                                RestrictSharing = true,
                                RestrictView = false,
                            });
```

</details>

<details>

<summary>PowerCommander</summary>

**Command**: `New-KeeperEnterpriseTeam`

**Syntax:**

```powershell
New-KeeperEnterpriseTeam [-TeamName] <string> [[-ParentNode] <long>] [[-RestrictEdit] <bool>] 
    [[-RestrictShare] <bool>] [[-RestrictView] <bool>] [<CommonParameters>]
```

**Parameters:**

* `-TeamName` - Team name (required)
* `-ParentNode` - Parent name or node ID
* `-RestrictEdit` - Restrict editing
* `-RestrictShare` - Restrict sharing
* `-RestrictView` - Restrict viewing passwords

**Examples:**

<pre class="language-powershell"><code class="lang-powershell"><strong>New-KeeperEnterpriseTeam -TeamName "Backend Team"
</strong>New-KeeperEnterpriseTeam -TeamName "Support" -ParentNode 12345 -RestrictView $true
</code></pre>

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team add`

**Parameter**:

`team` - Team Name or Queued Team UID. Can be repeated. (required)

**Team creation flags:**

* `-f`, `--force` - Do not prompt for confirmation
* `--parent` - Parent node name or ID. Defaults to the root node.
* `--restrict-edit` - Disable record edits: `on` or `off`
* `--restrict-share` - Disable record re-shares: `on` or `off`
* `--restrict-view` - Disable view or copy passwords: `on` or `off`

**User operation flags:**

* `-au`, `--add-user` - Add user to team by email. Repeatable.
* `-ru`, `--remove-user` - Remove user from team by email. Repeatable.
* `-hsf`, `--hide-shared-folders` - User does not see shared folders: `on` or `off`. Use with `--add-user` only.

User identifier: enterprise user email, for example `user@company.com`.

**User operation notes:**

* `-hsf on` adds the user with hidden shared folders.
* `-hsf off` adds the user with visible shared folders.
* If the user is already on the team and `-hsf` is omitted, a warning is shown and the user is skipped.
* `-ru @all` is not supported on add. Use enterprise-team membership with `-ru @all`.

**Role operation flags:**

* `-ar`, `--add-role` - Add role to team by name or ID. Repeatable.
* `-rr`, `--remove-role` - Remove role from team by name or ID. Repeatable.

Role identifier: role name or role ID.

**Role operation notes:**

* Admin roles cannot be assigned to teams. They are skipped with a warning.
* If the role is already on the team, it is skipped silently.
* `-rr @all` is not supported on add. Use enterprise-team membership with `-rr @all`.

**Examples:**

```sh
# Create team only
My Vault> enterprise-team add 'Dev Team' --parent 'Engineering'

# Create team + add users
My Vault> enterprise-team add 'Dev Team' -au user1@company.com -au user2@company.com -f

# Create team + add user with hidden shared folders
My Vault> enterprise-team add 'Contractors' -au contractor@company.com -hsf on -f

# Create team + assign roles
My Vault> enterprise-team add 'Dev Team' -ar 'Developers' -ar 'QA Team' -f

# Create team with restrictions + users + roles
My Vault> enterprise-team add 'Secure Team' --restrict-edit on --restrict-share on \
 -au admin@company.com -ar 'Ops Role' -f

# Promote queued team + add users
My Vault> enterprise-team add IQ_queuedTeamUid -au user@company.com -f
```

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)
teams_to_add = [enterprise_management.TeamEdit(
    team_uid=utils.generate_uid(), name=x, node_id=parent_id,
    restrict_edit=restrict_edit, restrict_share=restrict_share, restrict_view=restrict_view)
    for x in team_names]
batch.modify_teams(to_add=teams_to_add)
batch.apply()
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** `addTeams`

```python
export async function addTeams(auth: Auth, input: AddTeamInput): Promise<AddTeamResult> {
    const requestedNames = (input.teams || [])
        .map((value) => (typeof value === 'string' ? value.trim() : ''))
        .filter((value) => value.length > 0)
    if (requestedNames.length === 0) {
        throw new KeeperSdkError('No teams to add.', ResultCodes.NO_TEAMS_TO_ADD)
    }
    for (const name of requestedNames) {
        validateTeamName(name)
    }
```

</details>

### Enterprise Team Edit Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Edit enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**Command:**

`enterprise-team update [team] [--options] OR et update [team] [--options]`

**Parameter:**

`team` team name

**Options:**

* `--node <node>` - Node name or ID (for add/update)
* `--restrict-edit <ON|OFF>` - Disable/Enable record editing
* `--restrict-share <ON|OFF>` - Disable/Enable record re-sharing
* `--restrict-view <ON|OFF>` - Disable/Enable password viewing/copying

**Example:**

```bash
# Update team
enterprise-team update "Developers" --restrict-edit ON
et update TeamUID123 --restrict-share OFF --restrict-view ON
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `UpdateTeam`

```csharp
public async Task<EnterpriseTeam> UpdateTeam(EnterpriseTeam team)
```

**Example:**

```csharp
await context.EnterpriseData.UpdateTeam(team);
```

</details>

<details>

<summary>PowerCommander</summary>

**Command**: `Update-KeeperEnterpriseTeam`

**Syntax:**

```csharp
Update-KeeperEnterpriseTeam [-Team] <string> [[-TeamName] <string>] [[-ParentNode] <string>]
    [[-RestrictView] <ON|OFF>] [[-RestrictEdit] <ON|OFF>] [[-RestrictShare] <ON|OFF>] [<CommonParameters>]
```

**Aliases**: `kete`

**Parameters:**

* `-Team` - Team UID or team name (required)
* `-TeamName` - New team display name
* `-ParentNode` - Parent node name or ID
* `-RestrictView` - Disable or enable password viewing/copying: `ON` or `OFF`
* `-RestrictEdit` - Disable or enable record editing: `ON` or `OFF`
* `-RestrictShare` - Disable or enable record re-sharing: `ON` or `OFF`

**Examples:**

```csharp
Update-KeeperEnterpriseTeam -Team "Developers" -RestrictEdit ON
Update-KeeperEnterpriseTeam -Team "1P7A8XZ9K3J9H" -RestrictShare OFF -RestrictView ON
Update-KeeperEnterpriseTeam -Team "Developers" -TeamName "Engineering" -ParentNode "IT" -RestrictShare OFF
kete "Developers" -RestrictEdit ON

```

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team edit`

**Parameter**:

`team` - Team Name or UID. Can be repeated. (required)

**Team property flags:**

* `-f`, `--force` - Do not prompt for confirmation
* `--name` - Set team display name. Single team only. Returns an error if multiple team values are given.
* `--parent` - Parent node name or ID. If omitted, keeps the first team's current parent node.
* `--restrict-edit` - Disable record edits: `on` or `off`
* `--restrict-share` - Disable record re-shares: `on` or `off`
* `--restrict-view` - Disable view or copy passwords: `on` or `off`

Restriction note: If `--restrict-edit`, `--restrict-share`, or `--restrict-view` are omitted, they are treated as `off` when the edit is applied.

**User operation flags:**

* `-au`, `--add-user` - Add user to team by email. Repeatable.
* `-ru`, `--remove-user` - Remove user from team by email. Repeatable.
* `-hsf`, `--hide-shared-folders` - User does not see shared folders: `on` or `off`. Use with `--add-user` only.

User identifier: enterprise user email, for example `user@company.com`.

**Hide shared folders values:**

| Value   | Effect                                 |
| ------- | -------------------------------------- |
| `on`    | User added with hidden shared folders  |
| `off`   | User added with visible shared folders |
| omitted | Default team user type                 |

**User operation notes:**

* If the user is already on the team, a warning is shown and the user is skipped unless `-hsf` changes the user type.
* `-ru @all` is not supported on edit. Use enterprise-team membership with `-ru @all`.

**Role operation flags:**

* `-ar`, `--add-role` - Add role to team by name or ID. Repeatable.
* `-rr`, `--remove-role` - Remove role from team by name or ID. Repeatable.

Role identifier: role name or role ID.

**Role operation notes:**

* Admin roles cannot be assigned to teams. They are skipped with a warning.
* If the role is already on the team, it is skipped silently.
* `-rr @all` is not supported on edit. Use enterprise-team membership with `-rr @all`.

**Examples:**

```sh
# Rename team
My Vault> enterprise-team edit 'Old Team Name' --name 'New Team Name'

# Move team to parent node
My Vault> enterprise-team edit 'Dev Team' --parent 'Engineering'

# Update restrictions
My Vault> enterprise-team edit 'Dev Team' --restrict-edit on --restrict-share on --restrict-view off

# Add user
My Vault> enterprise-team edit 'Dev Team' -au user@company.com

# Remove user
My Vault> enterprise-team edit 'Dev Team' -ru user@company.com

# Add user with hidden shared folders
My Vault> enterprise-team edit 'Contractors' -au contractor@company.com -hsf on

# Add role
My Vault> enterprise-team edit 'Dev Team' -ar 'Developers'

# Remove role
My Vault> enterprise-team edit 'Dev Team' -rr 'Developers'

# Full update: rename, move, restrictions, users, roles
My Vault> enterprise-team edit 'Dev Team' --name 'Platform Team' --parent 'Engineering' \
 --restrict-edit on -au newuser@company.com -ru olduser@company.com \
 -ar 'Platform Role' -rr 'Legacy Role' -f

# Apply same user to multiple teams
My Vault> enterprise-team edit 'Team A' 'Team B' -au user@company.com

# Bulk remove — use membership instead
My Vault> enterprise-team membership 'Dev Team' -ru @all -rr @all
```

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_edit = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_edit:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())

teams_to_edit = [enterprise_management.TeamEdit(
    team_uid=x.team_uid, name=team_name, node_id=parent_id,
    restrict_edit=restrict_edit, restrict_share=restrict_share, restrict_view=restrict_view)
    for x in team_list]
batch.modify_teams(to_update=teams_to_edit)
batch.apply()
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** `updateTeams`

```python
export async function updateTeams(auth: Auth, input: UpdateTeamInput): Promise<UpdateTeamResult> {
    const requestedIdentifiers = (input.teams || [])
        .map((value) => (typeof value === 'string' ? value.trim() : ''))
        .filter((value) => value.length > 0)
    if (requestedIdentifiers.length === 0) {
        throw new KeeperSdkError('No teams to update.', ResultCodes.NO_TEAMS_TO_UPDATE)
    }

```

</details>

### Enterprise Team Delete Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Delete enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**Command:** `enterpise-team delete teamID`

```bash
enterprise-team delete [team] OR et delete [team]
```

**Parameter:**

`team` team name or team ID

**Example:**

```bash
# Delete team
enterprise-team delete "Old Team"
et delete TeamUID123
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function**: `DeleteTeam`

```csharp
 public async Task DeleteTeam(string teamUid)
```

**Example:**

```csharp
await context.EnterpriseData.DeleteTeam(team.Uid);
```

</details>

<details>

<summary>PowerCommander</summary>

**Command**: `Remove-KeeperEnterpriseTeam`

**Syntax:**

```csharp
Remove-KeeperEnterpriseTeam [-Team] <string> [-Force] [<CommonParameters>]
```

**Aliases**: `ketdel`

**Parameters:**

* `-Team` - Team UID or team name (required)
* `-Force` - Do not prompt for confirmation before deleting the team

**Examples:**

```csharp
Remove-KeeperEnterpriseTeam -Team "Old Team"
Remove-KeeperEnterpriseTeam -Team "1P7A8XZ9K3J9H" -Force
ketdel "Old Team" -Force
```

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team delete`

**Parameter:**

* `team` - Team Name or UID. Can be repeated. (required)

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_remove = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_remove:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())
batch.modify_teams(to_remove=(enterprise_management.TeamEdit(team_uid=x.team_uid) for x in team_list))
batch.apply()
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** `deleteTeams`

```python
export async function deleteTeams(auth: Auth, input: DeleteTeamInput): Promise<DeleteTeamResult> {
    const requestedIdentifiers = (input.teams || [])
        .map((value) => (typeof value === 'string' ? value.trim() : ''))
        .filter((value) => value.length > 0)
    if (requestedIdentifiers.length === 0) {
        throw new KeeperSdkError('No teams to delete.', ResultCodes.NO_TEAMS_TO_DELETE)
    }
```

</details>

### Enterprise Team Membership Command <a href="#enterprise-node-invite-email" id="enterprise-node-invite-email"></a>

Manage enterprise team membership.

<details>

<summary>DotNet CLI</summary>

Not Implemented

</details>

<details>

<summary>DotNet SDK</summary>

**Functions:**

`AddUsersToTeams` - This function is for adding user to given team.

`RemoveUsersFromTeams` - This function is for removing users from team.

**Example:**

```csharp
public async Task AddUsersToTeams(string[] emails, string[] teams, Action<string> warnings = null)
public async Task RemoveUsersFromTeams(string[] emails, string[] teamUids, Action<string> warnings = null)
```

```csharp
await enterprise.AddUsersToTeams(
                            new[] { "username@company.com", "username1@company.com" },
                            new[] { team.Uid }
                            );
 
```

</details>

<details>

<summary>PowerCommander</summary>

**Commands**:

`Add-KeeperEnterpriseTeamMember` - This command is for adding user to given team.

`Remove-KeeperEnterpriseTeamMember` - This command is for removing users from team.

**Syntax:**

```powershell
PS> Add-KeeperEnterpriseTeamMember [-Team] <string> [-Emails] <string[]> [<CommonParameters>]
PS> Remove-KeeperEnterpriseTeamMember [-Team] <string> [-Emails] <string[]> [<CommonParameters>]
```

**Aliases:** `keta`, `ketu`

**Parameters:**

* `-Team` - Team UID or name
* `-Emails`- User email

**Examples:**

```powershell
# Add users to team
PS> Add-KeeperEnterpriseTeamMember -Team "Developers" -Emails"user1@example.com", "user2@example.com"
PS> keta "TeamUID" "user@example.com"

# Remove users from team
PS> Remove-KeeperEnterpriseTeamMember -Team "Developers" -Emails"user@example.com"
PS> ketu "TeamUID" "user1@example.com", "user2@example.com"
```

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team membership`

**Parameter**:

`team` - Team Name or UID. Can be repeated. (required)

**Flag:**

* `-au`, `--add-user` - Add user to team. Can be repeated.
* `-ru`, `--remove-user` - Remove user from team. @all. Can be repeated.
* `-ar`, `--add-role` - Add role to team. Can be repeated.
* `-rr`, `--remove-role` - Remove role from team, @all. Can be repeated.

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['team uids or names']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_remove = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_remove:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())

users_to_add: Optional[List[enterprise_types.User]] = None
roles_to_add: Optional[List[enterprise_types.Role]] = None
users_to_remove: Optional[List[enterprise_types.User]] = None
roles_to_remove: Optional[List[enterprise_types.Role]] = None
has_remove_all_users: bool = False
has_remove_all_roles: bool = False

add_users = ['list of usernames to add']
if isinstance(add_users, list):
    for add_user in add_users:
        user = [user for user in enterprise_data.users.get_all_entities() if user.username.lower() == add_user.lower()]
        users_to_add.append(user)

add_roles = ['list of roles to add']
if isinstance(add_roles, list):
    for role_name in add_roles:
        if isinstance(role_name, int):
            role = enterprise_data.roles.get_entity(role_name)
        elif isinstance(role_name, str):
            if role_name.isnumeric():
                role = enterprise_data.roles.get_entity(int(role_name))
            if not role:
                role = [x for x in enterprise_data.roles.get_all_entities() if x.name.lower() == role_name.lower()]
    roles_to_add.append(role)

remove_users = ['list of usernames to remove']
if isinstance(remove_users, list):
    has_remove_all_users = any((True for x in remove_users if x == '@all'))
    if not has_remove_all_users:
        for remove_user in remove_users:
            user = [user for user in enterprise_data.users.get_all_entities() if user.username.lower() == remove_user.lower()]
            users_to_remove.append(user)

remove_roles = ['list of roles to remove']
if isinstance(remove_roles, list):
    has_remove_all_roles = any((True for x in remove_roles if x == '@all'))
    if not has_remove_all_roles:
        for role_name in remove_roles:
            if isinstance(role_name, int):
                role = enterprise_data.roles.get_entity(role_name)
            elif isinstance(role_name, str):
                if role_name.isnumeric():
                    role = enterprise_data.roles.get_entity(int(role_name))
                if not role:
                    role = [x for x in enterprise_data.roles.get_all_entities() if x.name.lower() == role_name.lower()]
        roles_to_remove.append(role)

for team in team_list:
    existing_users = {x.enterprise_user_id for x in enterprise_data.team_users.get_links_by_subject(team.team_uid)}
    existing_roles = {x.role_id for x in enterprise_data.role_teams.get_links_by_object(team.team_uid)}
    if users_to_add:
        users_to_add = [x for x in users_to_add if x.enterprise_user_id not in existing_users]
        if users_to_add:
            batch.modify_team_users(to_add=[enterprise_management.TeamUserEdit(
                team_uid=team.team_uid, enterprise_user_id=x.enterprise_user_id) for x in users_to_add])
    if roles_to_add:
        roles_to_add = [x for x in roles_to_add if x.role_id not in existing_roles]
        if roles_to_add:
            batch.modify_role_teams(to_add=[enterprise_management.RoleTeamEdit(
                role_id=x.role_id, team_uid=team.team_uid) for x in roles_to_add])
    if has_remove_all_users:
        batch.modify_team_users(to_remove=[enterprise_management.TeamUserEdit(
            team_uid=team.team_uid, enterprise_user_id=x) for x in existing_users])
    elif users_to_remove:
        batch.modify_team_users(to_remove=[enterprise_management.TeamUserEdit(
            team_uid=team.team_uid, enterprise_user_id=x.enterprise_user_id) for x in users_to_remove])
    if has_remove_all_roles:
        batch.modify_role_teams(to_remove=[enterprise_management.RoleTeamEdit(
            role_id=x, team_uid=team.team_uid) for x in existing_roles])
    elif roles_to_remove:
        batch.modify_role_teams(to_remove=[enterprise_management.RoleTeamEdit(
            role_id=x.role_id, team_uid=team.team_uid) for x in roles_to_remove])

batch.apply()
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** comming soon

```python
```

</details>

### Enterprise Team User Update Command

This command/function is used to update the usertype in a team

<details>

<summary>DotNet CLI</summary>

**Command:** `enterprise-user <action> username --team=<team_name> --user-type=<user_type>`

**Parameter:**

`email` - User email or ID.

`team` - Team name or ID

`user-type` - 0=user, 1=admin, 2=admin\_only (means he wont see the shared folders but can add users to the team)

**Examples:**

```sh
My Vault> eu team-user-update "nelelex252@hudisk.com" --team="T2" --user-type=0
```

</details>

<details>

<summary>DotNet SDK</summary>

**Enterprise Team User Update:**

**Function:** `TeamEnterpriseUserUpdate`

**Usage:**

```csharp
 public async Task TeamEnterpriseUserUpdate(EnterpriseTeam enterpriseTeam, EnterpriseUser enterpriseUser, int userType)
```

**Parameters:**

<table><thead><tr><th width="227.4921875"></th><th>Description</th></tr></thead><tbody><tr><td><code>enterpriseTeam</code></td><td>EnterpriseTeam object representing the team</td></tr><tr><td><code>enterpriseUser</code></td><td>EnterpriseUser object representing the user</td></tr><tr><td><code>userType</code></td><td>0=user, 1=admin, 2=admin_only (means he wont see the shared folders but can add users to the team)</td></tr></tbody></table>

**Example:**

{% code overflow="wrap" %}

```csharp
await EnterpriseManagementExamples.EnterpriseUserExamples.UserExamples.TeamEnterpriseUserUpdateExample("jTiPyIP4NmPiyAVv2oKFpw", "nebilem641@nctime.com", 0);
```

{% endcode %}

</details>

<details>

<summary>PowerCommander</summary>

**Command:** `Update-KeeperEnterpriseTeamUser`

**Flags:**

<table><thead><tr><th width="150.9345703125">Parameter</th><th>Description</th></tr></thead><tbody><tr><td><code>User</code></td><td>Updates enterprise user information.</td></tr><tr><td><code>Team</code></td><td>Team name or UID</td></tr><tr><td><code>UserType</code></td><td>User type: 0, 1, or 2<br>0 - User (Normal User)<br>1 - Administrator<br>2 - Administrator Only</td></tr></tbody></table>

**Example:**

```powershell
PS > Update-KeeperEnterpriseTeamUser -Team PCTTeam -User tofam63308@ixospace.com -UserType 1                     
Team user tofam63308@ixospace.com updated
```

</details>

<details>

<summary>Python CLI</summary>

Comming Soon

</details>

<details>

<summary>Python SDK</summary>

Comming Soon

</details>

### Enterprise Team Approve Command

<details>

<summary>DotNet CLI</summary>

**Command:** `team-approve` or `ta`

**Parameter:**

`--team` Approve queued teams only.

`--email` Approve queued team users only.

`--restrict-edit <on|off>` Restrict or allow record editing for approved teams.

`--restrict-share <on|off>` Restrict or allow record sharing for approved teams.

`--restrict-view <on|off>` Restrict or allow viewing or copying passwords for approved teams.

`--dry-run` Display planned approvals without executing them.

`--format <table|csv|json>` Output format for dry-run results.

`--output <file_name>` Output file for CSV or JSON dry-run results.

`--force` Reload enterprise and queued-team data before approval.

By default, both queued teams and queued users are approved.

**Examples:**

```sh
team-approve
team-approve --team
team-approve --email
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `ApproveQueuedTeams`

**Usage:**

```csharp
public async Task<TeamApproveResult> ApproveQueuedTeams( IQueuedTeamData queuedTeamData,TeamApproveOptions options = null)
```

**Parameters:**

<table><thead><tr><th width="227.4921875"></th><th>Description</th></tr></thead><tbody><tr><td><code>ApproveTeams</code></td><td>Approve queued teams</td></tr><tr><td><code>ApproveUsers</code></td><td>Approve queued team users.</td></tr><tr><td><code>RestrictEdit</code></td><td>Restrict record editing for approved teams.</td></tr><tr><td><code>RestrictShare</code></td><td>Restrict record sharing for approved teams.</td></tr><tr><td><code>RestrictView</code></td><td>Restrict viewing or copying passwords for approved teams.</td></tr><tr><td><code>DryRun</code></td><td>Return planned approvals without executing them.</td></tr></tbody></table>

**Example:**

{% code overflow="wrap" %}

```csharp
var result = await enterpriseData.ApproveQueuedTeams(
    queuedTeamData,
    new TeamApproveOptions
    {
        ApproveTeams = true,
        ApproveUsers = true,
        RestrictEdit = true
    });
```

{% endcode %}

</details>

<details>

<summary>PowerCommander</summary>

**Command:** `Invoke-KeeperTeamApprove`

**Alias:** `kta`

**Flags:**

<table data-search="false"><thead><tr><th width="150.9345703125">Parameter</th><th>Description</th></tr></thead><tbody><tr><td><code>-TeamsOnly</code></td><td>Approve queued teams only.</td></tr><tr><td><code>-UsersOnly</code></td><td>Approve queued team users only</td></tr><tr><td><code>-RestrictEdit</code></td><td>Restrict record editing for approved teams.</td></tr><tr><td><code>-RestrictShare</code></td><td>Restrict record sharing for approved teams.</td></tr><tr><td><code>-RestrictView</code></td><td>Restrict viewing or copying passwords for approved teams.</td></tr><tr><td><code>-Force</code></td><td>Reload enterprise and queued-team data before approval.</td></tr><tr><td><code>-DryRun</code></td><td>Display planned approvals without executing them.</td></tr></tbody></table>

**Example:**

```powershell
# Approve queued teams and users
PS> Invoke-KeeperTeamApprove

# Approve queued teams only
PS> kta -TeamsOnly

# Approve queued users only
PS> kta -UsersOnly
```

</details>

<details>

<summary>JavaScript SDK</summary>

**Function:** comming soon

```python
```

</details>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.keeper.io/keeperpam/commander-sdk/keeper-commander-sdks/sdk-command-reference/enterprise-management-commands/enterprise-team-commands.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.