# Enterprise Team Commands

#### 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>

| Command                                               | Description                       | Alias |
| ----------------------------------------------------- | --------------------------------- | ----- |
| [`view`](#enterprise-team-view)                       | View enterprise team              | `v`   |
| [`add`](#enterprise-info-tree)                        | Create enterprise team(s)         | `a`   |
| [`edit`](#enterprise-info-tree-1)                     | Edit enterprise team(s)           | `e`   |
| [`delete`](#enterprise-info-tree-2)                   | Delete enterprise team(s)         | `d`   |
| [`membership`](#enterprise-node-invite-email)         | Manage enterprise team membership | `m`   |
| [`user-update`](#enterprise-team-user-update-command) | Update user information in team   |       |

### 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>

### 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)

**Flag:**

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

</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>

### 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>

Not Implemented

</details>

<details>

<summary>Python CLI</summary>

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

**Parameter**:

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

**Flag:**

* `-f`, `--force` - Do not prompt for confirmation
* `--name`, `--displayname` - Set team display name
* `--parent` - Parent node name or ID
* `--restrict-edit` - Disable record edits: `on` or `off`
* `--restrict-share` - Disable record re-shares: `on` or `off`
* `--restrict-view` - Disable view/copy passwords: `on` or `off`

</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>

### 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>

Not Implemented

</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>

### 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>

### 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>


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

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

The question should be specific, self-contained, and written in natural language.
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.