`dropbox.team` – Team

class dropbox.team.ActiveWebSession(session_id=None, user_agent=None, os=None, browser=None, ip_address=None, country=None, created=None, updated=None, expires=None)

Bases: DeviceSession

Information on active web sessions.

Variables:

team.ActiveWebSession.user_agent – Information on the hosting device.
team.ActiveWebSession.os – Information on the hosting operating system.
team.ActiveWebSession.browser – Information on the browser used for this web session.
team.ActiveWebSession.expires – The time this session expires.

__init__(session_id=None, user_agent=None, os=None, browser=None, ip_address=None, country=None, created=None, updated=None, expires=None)

browser

expires

os

user_agent

class dropbox.team.AddSecondaryEmailResult(tag, value=None)

Bases: Union

Result of trying to add a secondary email to a user. ‘success’ is the only value indicating that a secondary email was successfully added to a user. The other values explain the type of error that occurred, and include the email for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.AddSecondaryEmailResult.success (secondary_emails.SecondaryEmail) – Describes a secondary email that was successfully added to a user.
team.AddSecondaryEmailResult.unavailable (str) – Secondary email is not available to be claimed by the user.
team.AddSecondaryEmailResult.already_pending (str) – Secondary email is already a pending email for the user.
team.AddSecondaryEmailResult.already_owned_by_user (str) – Secondary email is already a verified email for the user.
team.AddSecondaryEmailResult.reached_limit (str) – User already has the maximum number of secondary emails allowed.
team.AddSecondaryEmailResult.transient_error (str) – A transient error occurred. Please try again later.
team.AddSecondaryEmailResult.too_many_updates (str) – An error occurred due to conflicting updates. Please try again later.
team.AddSecondaryEmailResult.unknown_error (str) – An unknown error occurred.
team.AddSecondaryEmailResult.rate_limited (str) – Too many emails are being sent to this email address. Please try again later.

classmethod already_owned_by_user(val)

Create an instance of this class set to the already_owned_by_user tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod already_pending(val)

Create an instance of this class set to the already_pending tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

get_already_owned_by_user()

Secondary email is already a verified email for the user.

Only call this if is_already_owned_by_user() is true.

Return type:: str

get_already_pending()

Secondary email is already a pending email for the user.

Only call this if is_already_pending() is true.

Return type:: str

get_rate_limited()

Too many emails are being sent to this email address. Please try again later.

Only call this if is_rate_limited() is true.

Return type:: str

get_reached_limit()

User already has the maximum number of secondary emails allowed.

Only call this if is_reached_limit() is true.

Return type:: str

get_success()

Describes a secondary email that was successfully added to a user.

Only call this if is_success() is true.

Return type:: secondary_emails.SecondaryEmail

get_too_many_updates()

An error occurred due to conflicting updates. Please try again later.

Only call this if is_too_many_updates() is true.

Return type:: str

get_transient_error()

A transient error occurred. Please try again later.

Only call this if is_transient_error() is true.

Return type:: str

get_unavailable()

Secondary email is not available to be claimed by the user.

Only call this if is_unavailable() is true.

Return type:: str

get_unknown_error()

An unknown error occurred.

Only call this if is_unknown_error() is true.

Return type:: str

is_already_owned_by_user()

Check if the union tag is already_owned_by_user.

Return type:: bool

is_already_pending()

Check if the union tag is already_pending.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_rate_limited()

Check if the union tag is rate_limited.

Return type:: bool

is_reached_limit()

Check if the union tag is reached_limit.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

is_too_many_updates()

Check if the union tag is too_many_updates.

Return type:: bool

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

is_unavailable()

Check if the union tag is unavailable.

Return type:: bool

is_unknown_error()

Check if the union tag is unknown_error.

Return type:: bool

other = AddSecondaryEmailResult('other', None)

classmethod rate_limited(val)

Create an instance of this class set to the rate_limited tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod reached_limit(val)

Create an instance of this class set to the reached_limit tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (secondary_emails.SecondaryEmail) –
Return type:: AddSecondaryEmailResult

classmethod too_many_updates(val)

Create an instance of this class set to the too_many_updates tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod transient_error(val)

Create an instance of this class set to the transient_error tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod unavailable(val)

Create an instance of this class set to the unavailable tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

classmethod unknown_error(val)

Create an instance of this class set to the unknown_error tag with value val.

Parameters:: val (str) –
Return type:: AddSecondaryEmailResult

class dropbox.team.AddSecondaryEmailsArg(new_secondary_emails=None)

Bases: Struct

Variables:: team.AddSecondaryEmailsArg.new_secondary_emails – List of users and secondary emails to add.

__init__(new_secondary_emails=None)

new_secondary_emails

class dropbox.team.AddSecondaryEmailsError(tag, value=None)

Bases: Union

Error returned when adding secondary emails fails.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.AddSecondaryEmailsError.secondary_emails_disabled – Secondary emails are disabled for the team.
team.AddSecondaryEmailsError.too_many_emails – A maximum of 20 secondary emails can be added in a single call.

is_other()

Check if the union tag is other.

Return type:: bool

is_secondary_emails_disabled()

Check if the union tag is secondary_emails_disabled.

Return type:: bool

is_too_many_emails()

Check if the union tag is too_many_emails.

Return type:: bool

other = AddSecondaryEmailsError('other', None)

secondary_emails_disabled = AddSecondaryEmailsError('secondary_emails_disabled', None)

too_many_emails = AddSecondaryEmailsError('too_many_emails', None)

class dropbox.team.AddSecondaryEmailsResult(results=None)

Bases: Struct

Variables:: team.AddSecondaryEmailsResult.results – List of users and secondary email results.

__init__(results=None)

results

class dropbox.team.AdminTier(tag, value=None)

Bases: Union

Describes which team-related admin permissions a user has.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.AdminTier.team_admin – User is an administrator of the team - has all permissions.
team.AdminTier.user_management_admin – User can do most user provisioning, de-provisioning and management.
team.AdminTier.support_admin – User can do a limited set of common support tasks for existing users. Note: Dropbox is adding new types of admin roles; these may display as support_admin.
team.AdminTier.member_only – User is not an admin of the team.

is_member_only()

Check if the union tag is member_only.

Return type:: bool

is_support_admin()

Check if the union tag is support_admin.

Return type:: bool

is_team_admin()

Check if the union tag is team_admin.

Return type:: bool

is_user_management_admin()

Check if the union tag is user_management_admin.

Return type:: bool

member_only = AdminTier('member_only', None)

support_admin = AdminTier('support_admin', None)

team_admin = AdminTier('team_admin', None)

user_management_admin = AdminTier('user_management_admin', None)

class dropbox.team.ApiApp(app_id=None, app_name=None, is_app_folder=None, publisher=None, publisher_url=None, linked=None)

Bases: Struct

Information on linked third party applications.

Variables:

team.ApiApp.app_id – The application unique id.
team.ApiApp.app_name – The application name.
team.ApiApp.publisher – The application publisher name.
team.ApiApp.publisher_url – The publisher’s URL.
team.ApiApp.linked – The time this application was linked.
team.ApiApp.is_app_folder – Whether the linked application uses a dedicated folder.

__init__(app_id=None, app_name=None, is_app_folder=None, publisher=None, publisher_url=None, linked=None)

app_id

app_name

is_app_folder

linked

publisher

publisher_url

class dropbox.team.BaseDfbReport(start_date=None)

Bases: Struct

Base report structure.

Variables:: team.BaseDfbReport.start_date – First date present in the results as ‘YYYY-MM-DD’ or None.

__init__(start_date=None)

start_date

class dropbox.team.BaseTeamFolderError(tag, value=None)

Bases: Union

Base error that all errors for existing team folders should extend.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

classmethod access_error(val)

Create an instance of this class set to the access_error tag with value val.

Parameters:: val (TeamFolderAccessError) –
Return type:: BaseTeamFolderError

get_access_error()

Only call this if is_access_error() is true.

Return type:: TeamFolderAccessError

get_status_error()

Only call this if is_status_error() is true.

Return type:: TeamFolderInvalidStatusError

get_team_shared_dropbox_error()

Only call this if is_team_shared_dropbox_error() is true.

Return type:: TeamFolderTeamSharedDropboxError

is_access_error()

Check if the union tag is access_error.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_status_error()

Check if the union tag is status_error.

Return type:: bool

is_team_shared_dropbox_error()

Check if the union tag is team_shared_dropbox_error.

Return type:: bool

other = BaseTeamFolderError('other', None)

classmethod status_error(val)

Create an instance of this class set to the status_error tag with value val.

Parameters:: val (TeamFolderInvalidStatusError) –
Return type:: BaseTeamFolderError

classmethod team_shared_dropbox_error(val)

Create an instance of this class set to the team_shared_dropbox_error tag with value val.

Parameters:: val (TeamFolderTeamSharedDropboxError) –
Return type:: BaseTeamFolderError

class dropbox.team.CustomQuotaError(tag, value=None)

Bases: Union

Error returned when getting member custom quota.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.CustomQuotaError.too_many_users – A maximum of 1000 users can be set for a single call.

is_other()

Check if the union tag is other.

Return type:: bool

is_too_many_users()

Check if the union tag is too_many_users.

Return type:: bool

other = CustomQuotaError('other', None)

too_many_users = CustomQuotaError('too_many_users', None)

class dropbox.team.CustomQuotaResult(tag, value=None)

Bases: Union

User custom quota.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

CustomQuotaResult.success (UserCustomQuotaResult) – User’s custom quota.
CustomQuotaResult.invalid_user (UserSelectorArg) – Invalid user (not in team).

get_invalid_user()

Invalid user (not in team).

Only call this if is_invalid_user() is true.

Return type:: UserSelectorArg

get_success()

User’s custom quota.

Only call this if is_success() is true.

Return type:: UserCustomQuotaResult

classmethod invalid_user(val)

Create an instance of this class set to the invalid_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: CustomQuotaResult

is_invalid_user()

Check if the union tag is invalid_user.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = CustomQuotaResult('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (UserCustomQuotaResult) –
Return type:: CustomQuotaResult

class dropbox.team.CustomQuotaUsersArg(users=None)

Bases: Struct

Variables:: team.CustomQuotaUsersArg.users – List of users.

__init__(users=None)

users

class dropbox.team.DateRange(start_date=None, end_date=None)

Bases: Struct

Input arguments that can be provided for most reports.

Variables:

team.DateRange.start_date – Optional starting date (inclusive). If start_date is None or too long ago, this field will be set to 6 months ago.
team.DateRange.end_date – Optional ending date (exclusive).

__init__(start_date=None, end_date=None)

end_date

start_date

class dropbox.team.DateRangeError(tag, value=None)

Bases: Union

Errors that can originate from problems in input arguments to reports.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = DateRangeError('other', None)

class dropbox.team.DeleteSecondaryEmailResult(tag, value=None)

Bases: Union

Result of trying to delete a secondary email address. ‘success’ is the only value indicating that a secondary email was successfully deleted. The other values explain the type of error that occurred, and include the email for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.DeleteSecondaryEmailResult.success (str) – The secondary email was successfully deleted.
team.DeleteSecondaryEmailResult.not_found (str) – The email address was not found for the user.
team.DeleteSecondaryEmailResult.cannot_remove_primary (str) – The email address is the primary email address of the user, and cannot be removed.

classmethod cannot_remove_primary(val)

Create an instance of this class set to the cannot_remove_primary tag with value val.

Parameters:: val (str) –
Return type:: DeleteSecondaryEmailResult

get_cannot_remove_primary()

The email address is the primary email address of the user, and cannot be removed.

Only call this if is_cannot_remove_primary() is true.

Return type:: str

get_not_found()

The email address was not found for the user.

Only call this if is_not_found() is true.

Return type:: str

get_success()

The secondary email was successfully deleted.

Only call this if is_success() is true.

Return type:: str

is_cannot_remove_primary()

Check if the union tag is cannot_remove_primary.

Return type:: bool

is_not_found()

Check if the union tag is not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

classmethod not_found(val)

Create an instance of this class set to the not_found tag with value val.

Parameters:: val (str) –
Return type:: DeleteSecondaryEmailResult

other = DeleteSecondaryEmailResult('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (str) –
Return type:: DeleteSecondaryEmailResult

class dropbox.team.DeleteSecondaryEmailsArg(emails_to_delete=None)

Bases: Struct

Variables:: team.DeleteSecondaryEmailsArg.emails_to_delete – List of users and their secondary emails to delete.

__init__(emails_to_delete=None)

emails_to_delete

class dropbox.team.DeleteSecondaryEmailsResult(results=None)

Bases: Struct

__init__(results=None)

results

class dropbox.team.DesktopClientSession(session_id=None, host_name=None, client_type=None, client_version=None, platform=None, is_delete_on_unlink_supported=None, ip_address=None, country=None, created=None, updated=None)

Bases: DeviceSession

Information about linked Dropbox desktop client sessions.

Variables:

team.DesktopClientSession.host_name – Name of the hosting desktop.
team.DesktopClientSession.client_type – The Dropbox desktop client type.
team.DesktopClientSession.client_version – The Dropbox client version.
team.DesktopClientSession.platform – Information on the hosting platform.
team.DesktopClientSession.is_delete_on_unlink_supported – Whether it’s possible to delete all of the account files upon unlinking.

__init__(session_id=None, host_name=None, client_type=None, client_version=None, platform=None, is_delete_on_unlink_supported=None, ip_address=None, country=None, created=None, updated=None)

client_type

client_version

host_name

is_delete_on_unlink_supported

platform

class dropbox.team.DesktopPlatform(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.DesktopPlatform.windows – Official Windows Dropbox desktop client.
team.DesktopPlatform.mac – Official Mac Dropbox desktop client.
team.DesktopPlatform.linux – Official Linux Dropbox desktop client.

is_linux()

Check if the union tag is linux.

Return type:: bool

is_mac()

Check if the union tag is mac.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_windows()

Check if the union tag is windows.

Return type:: bool

linux = DesktopPlatform('linux', None)

mac = DesktopPlatform('mac', None)

other = DesktopPlatform('other', None)

windows = DesktopPlatform('windows', None)

class dropbox.team.DeviceSession(session_id=None, ip_address=None, country=None, created=None, updated=None)

Bases: Struct

Variables:

team.DeviceSession.session_id – The session id.
team.DeviceSession.ip_address – The IP address of the last activity from this session.
team.DeviceSession.country – The country from which the last activity from this session was made.
team.DeviceSession.created – The time this session was created.
team.DeviceSession.updated – The time of the last activity from this session.

__init__(session_id=None, ip_address=None, country=None, created=None, updated=None)

country

created

ip_address

session_id

updated

class dropbox.team.DeviceSessionArg(session_id=None, team_member_id=None)

Bases: Struct

Variables:

team.DeviceSessionArg.session_id – The session id.
team.DeviceSessionArg.team_member_id – The unique id of the member owning the device.

__init__(session_id=None, team_member_id=None)

session_id

team_member_id

class dropbox.team.DevicesActive(windows=None, macos=None, linux=None, ios=None, android=None, other=None, total=None)

Bases: Struct

Each of the items is an array of values, one value per day. The value is the number of devices active within a time window, ending with that day. If there is no data for a day, then the value will be None.

Variables:

team.DevicesActive.windows – Array of number of linked windows (desktop) clients with activity.
team.DevicesActive.macos – Array of number of linked mac (desktop) clients with activity.
team.DevicesActive.linux – Array of number of linked linus (desktop) clients with activity.
team.DevicesActive.ios – Array of number of linked ios devices with activity.
team.DevicesActive.android – Array of number of linked android devices with activity.
team.DevicesActive.other – Array of number of other linked devices (blackberry, windows phone, etc) with activity.
team.DevicesActive.total – Array of total number of linked clients with activity.

__init__(windows=None, macos=None, linux=None, ios=None, android=None, other=None, total=None)

android

ios

linux

macos

other

total

windows

class dropbox.team.ExcludedUsersListArg(limit=None)

Bases: Struct

Excluded users list argument.

Variables:: team.ExcludedUsersListArg.limit – Number of results to return per call.

__init__(limit=None)

limit

class dropbox.team.ExcludedUsersListContinueArg(cursor=None)

Bases: Struct

Excluded users list continue argument.

Variables:: team.ExcludedUsersListContinueArg.cursor – Indicates from what point to get the next set of users.

__init__(cursor=None)

cursor

class dropbox.team.ExcludedUsersListContinueError(tag, value=None)

Bases: Union

Excluded users list continue error.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ExcludedUsersListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = ExcludedUsersListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = ExcludedUsersListContinueError('other', None)

class dropbox.team.ExcludedUsersListError(tag, value=None)

Bases: Union

Excluded users list error.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ExcludedUsersListError.list_error – An error occurred.

is_list_error()

Check if the union tag is list_error.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

list_error = ExcludedUsersListError('list_error', None)

other = ExcludedUsersListError('other', None)

class dropbox.team.ExcludedUsersListResult(users=None, has_more=None, cursor=None)

Bases: Struct

Excluded users list result.

Variables:

team.ExcludedUsersListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_member_space_limits_excluded_users_list_continue() to obtain additional excluded users.
team.ExcludedUsersListResult.has_more – Is true if there are additional excluded users that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_member_space_limits_excluded_users_list_continue() can retrieve them.

__init__(users=None, has_more=None, cursor=None)

cursor

has_more

users

class dropbox.team.ExcludedUsersUpdateArg(users=None)

Bases: Struct

Argument of excluded users update operation. Should include a list of users to add/remove (according to endpoint), Maximum size of the list is 1000 users.

Variables:: team.ExcludedUsersUpdateArg.users – List of users to be added/removed.

__init__(users=None)

users

class dropbox.team.ExcludedUsersUpdateError(tag, value=None)

Bases: Union

Excluded users update error.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.ExcludedUsersUpdateError.users_not_in_team – At least one of the users is not part of your team.
team.ExcludedUsersUpdateError.too_many_users – A maximum of 1000 users for each of addition/removal can be supplied.

is_other()

Check if the union tag is other.

Return type:: bool

is_too_many_users()

Check if the union tag is too_many_users.

Return type:: bool

is_users_not_in_team()

Check if the union tag is users_not_in_team.

Return type:: bool

other = ExcludedUsersUpdateError('other', None)

too_many_users = ExcludedUsersUpdateError('too_many_users', None)

users_not_in_team = ExcludedUsersUpdateError('users_not_in_team', None)

class dropbox.team.ExcludedUsersUpdateResult(status=None)

Bases: Struct

Excluded users update result.

Variables:: team.ExcludedUsersUpdateResult.status – Update status.

__init__(status=None)

status

class dropbox.team.ExcludedUsersUpdateStatus(tag, value=None)

Bases: Union

Excluded users update operation status.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ExcludedUsersUpdateStatus.success – Update successful.

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = ExcludedUsersUpdateStatus('other', None)

success = ExcludedUsersUpdateStatus('success', None)

class dropbox.team.Feature(tag, value=None)

Bases: Union

A set of features that a Dropbox Business account may support.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.Feature.upload_api_rate_limit – The number of upload API calls allowed per month.
team.Feature.has_team_shared_dropbox – Does this team have a shared team root.
team.Feature.has_team_file_events – Does this team have file events.
team.Feature.has_team_selective_sync – Does this team have team selective sync enabled.

has_team_file_events = Feature('has_team_file_events', None)

has_team_selective_sync = Feature('has_team_selective_sync', None)

has_team_shared_dropbox = Feature('has_team_shared_dropbox', None)

is_has_team_file_events()

Check if the union tag is has_team_file_events.

Return type:: bool

is_has_team_selective_sync()

Check if the union tag is has_team_selective_sync.

Return type:: bool

is_has_team_shared_dropbox()

Check if the union tag is has_team_shared_dropbox.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_upload_api_rate_limit()

Check if the union tag is upload_api_rate_limit.

Return type:: bool

other = Feature('other', None)

upload_api_rate_limit = Feature('upload_api_rate_limit', None)

class dropbox.team.FeatureValue(tag, value=None)

Bases: Union

The values correspond to entries in Feature. You may get different value according to your Dropbox Business plan.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

get_has_team_file_events()

Only call this if is_has_team_file_events() is true.

Return type:: HasTeamFileEventsValue

get_has_team_selective_sync()

Only call this if is_has_team_selective_sync() is true.

Return type:: HasTeamSelectiveSyncValue

get_has_team_shared_dropbox()

Only call this if is_has_team_shared_dropbox() is true.

Return type:: HasTeamSharedDropboxValue

get_upload_api_rate_limit()

Only call this if is_upload_api_rate_limit() is true.

Return type:: UploadApiRateLimitValue

classmethod has_team_file_events(val)

Create an instance of this class set to the has_team_file_events tag with value val.

Parameters:: val (HasTeamFileEventsValue) –
Return type:: FeatureValue

classmethod has_team_selective_sync(val)

Create an instance of this class set to the has_team_selective_sync tag with value val.

Parameters:: val (HasTeamSelectiveSyncValue) –
Return type:: FeatureValue

classmethod has_team_shared_dropbox(val)

Create an instance of this class set to the has_team_shared_dropbox tag with value val.

Parameters:: val (HasTeamSharedDropboxValue) –
Return type:: FeatureValue

is_has_team_file_events()

Check if the union tag is has_team_file_events.

Return type:: bool

is_has_team_selective_sync()

Check if the union tag is has_team_selective_sync.

Return type:: bool

is_has_team_shared_dropbox()

Check if the union tag is has_team_shared_dropbox.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_upload_api_rate_limit()

Check if the union tag is upload_api_rate_limit.

Return type:: bool

other = FeatureValue('other', None)

classmethod upload_api_rate_limit(val)

Create an instance of this class set to the upload_api_rate_limit tag with value val.

Parameters:: val (UploadApiRateLimitValue) –
Return type:: FeatureValue

class dropbox.team.FeaturesGetValuesBatchArg(features=None)

Bases: Struct

Variables:: team.FeaturesGetValuesBatchArg.features – A list of features in Feature. If the list is empty, this route will return FeaturesGetValuesBatchError.

__init__(features=None)

features

class dropbox.team.FeaturesGetValuesBatchError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.FeaturesGetValuesBatchError.empty_features_list – At least one Feature must be included in the FeaturesGetValuesBatchArg.features list.

empty_features_list = FeaturesGetValuesBatchError('empty_features_list', None)

is_empty_features_list()

Check if the union tag is empty_features_list.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = FeaturesGetValuesBatchError('other', None)

class dropbox.team.FeaturesGetValuesBatchResult(values=None)

Bases: Struct

__init__(values=None)

values

class dropbox.team.GetActivityReport(start_date=None, adds=None, edits=None, deletes=None, active_users_28_day=None, active_users_7_day=None, active_users_1_day=None, active_shared_folders_28_day=None, active_shared_folders_7_day=None, active_shared_folders_1_day=None, shared_links_created=None, shared_links_viewed_by_team=None, shared_links_viewed_by_outside_user=None, shared_links_viewed_by_not_logged_in=None, shared_links_viewed_total=None)

Bases: BaseDfbReport

Activity Report Result. Each of the items in the storage report is an array of values, one value per day. If there is no data for a day, then the value will be None.

Variables:

team.GetActivityReport.adds – Array of total number of adds by team members.
team.GetActivityReport.edits – Array of number of edits by team members. If the same user edits the same file multiple times this is counted as a single edit.
team.GetActivityReport.deletes – Array of total number of deletes by team members.
team.GetActivityReport.active_users_28_day – Array of the number of users who have been active in the last 28 days.
team.GetActivityReport.active_users_7_day – Array of the number of users who have been active in the last week.
team.GetActivityReport.active_users_1_day – Array of the number of users who have been active in the last day.
team.GetActivityReport.active_shared_folders_28_day – Array of the number of shared folders with some activity in the last 28 days.
team.GetActivityReport.active_shared_folders_7_day – Array of the number of shared folders with some activity in the last week.
team.GetActivityReport.active_shared_folders_1_day – Array of the number of shared folders with some activity in the last day.
team.GetActivityReport.shared_links_created – Array of the number of shared links created.
team.GetActivityReport.shared_links_viewed_by_team – Array of the number of views by team users to shared links created by the team.
team.GetActivityReport.shared_links_viewed_by_outside_user – Array of the number of views by users outside of the team to shared links created by the team.
team.GetActivityReport.shared_links_viewed_by_not_logged_in – Array of the number of views by non-logged-in users to shared links created by the team.
team.GetActivityReport.shared_links_viewed_total – Array of the total number of views to shared links created by the team.

__init__(start_date=None, adds=None, edits=None, deletes=None, active_users_28_day=None, active_users_7_day=None, active_users_1_day=None, active_shared_folders_28_day=None, active_shared_folders_7_day=None, active_shared_folders_1_day=None, shared_links_created=None, shared_links_viewed_by_team=None, shared_links_viewed_by_outside_user=None, shared_links_viewed_by_not_logged_in=None, shared_links_viewed_total=None)

active_shared_folders_1_day

active_shared_folders_28_day

active_shared_folders_7_day

active_users_1_day

active_users_28_day

active_users_7_day

adds

deletes

edits

shared_links_created

shared_links_viewed_by_not_logged_in

shared_links_viewed_by_outside_user

shared_links_viewed_by_team

shared_links_viewed_total

class dropbox.team.GetDevicesReport(start_date=None, active_1_day=None, active_7_day=None, active_28_day=None)

Bases: BaseDfbReport

Devices Report Result. Contains subsections for different time ranges of activity. Each of the items in each subsection of the storage report is an array of values, one value per day. If there is no data for a day, then the value will be None.

Variables:

team.GetDevicesReport.active_1_day – Report of the number of devices active in the last day.
team.GetDevicesReport.active_7_day – Report of the number of devices active in the last 7 days.
team.GetDevicesReport.active_28_day – Report of the number of devices active in the last 28 days.

__init__(start_date=None, active_1_day=None, active_7_day=None, active_28_day=None)

active_1_day

active_28_day

active_7_day

class dropbox.team.GetMembershipReport(start_date=None, team_size=None, pending_invites=None, members_joined=None, suspended_members=None, licenses=None)

Bases: BaseDfbReport

Membership Report Result. Each of the items in the storage report is an array of values, one value per day. If there is no data for a day, then the value will be None.

Variables:

team.GetMembershipReport.team_size – Team size, for each day.
team.GetMembershipReport.pending_invites – The number of pending invites to the team, for each day.
team.GetMembershipReport.members_joined – The number of members that joined the team, for each day.
team.GetMembershipReport.suspended_members – The number of suspended team members, for each day.
team.GetMembershipReport.licenses – The total number of licenses the team has, for each day.

__init__(start_date=None, team_size=None, pending_invites=None, members_joined=None, suspended_members=None, licenses=None)

licenses

members_joined

pending_invites

suspended_members

team_size

class dropbox.team.GetStorageReport(start_date=None, total_usage=None, shared_usage=None, unshared_usage=None, shared_folders=None, member_storage_map=None)

Bases: BaseDfbReport

Storage Report Result. Each of the items in the storage report is an array of values, one value per day. If there is no data for a day, then the value will be None.

Variables:

team.GetStorageReport.total_usage – Sum of the shared, unshared, and datastore usages, for each day.
team.GetStorageReport.shared_usage – Array of the combined size (bytes) of team members’ shared folders, for each day.
team.GetStorageReport.unshared_usage – Array of the combined size (bytes) of team members’ root namespaces, for each day.
team.GetStorageReport.shared_folders – Array of the number of shared folders owned by team members, for each day.
team.GetStorageReport.member_storage_map – Array of storage summaries of team members’ account sizes. Each storage summary is an array of key, value pairs, where each pair describes a storage bucket. The key indicates the upper bound of the bucket and the value is the number of users in that bucket. There is one such summary per day. If there is no data for a day, the storage summary will be empty.

__init__(start_date=None, total_usage=None, shared_usage=None, unshared_usage=None, shared_folders=None, member_storage_map=None)

member_storage_map

shared_folders

shared_usage

total_usage

unshared_usage

class dropbox.team.GroupAccessType(tag, value=None)

Bases: Union

Role of a user in group.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupAccessType.member – User is a member of the group, but has no special permissions.
team.GroupAccessType.owner – User can rename the group, and add/remove members.

is_member()

Check if the union tag is member.

Return type:: bool

is_owner()

Check if the union tag is owner.

Return type:: bool

member = GroupAccessType('member', None)

owner = GroupAccessType('owner', None)

class dropbox.team.GroupCreateArg(group_name=None, add_creator_as_owner=None, group_external_id=None, group_management_type=None)

Bases: Struct

Variables:

team.GroupCreateArg.group_name – Group name.
team.GroupCreateArg.add_creator_as_owner – Automatically add the creator of the group.
team.GroupCreateArg.group_external_id – The creator of a team can associate an arbitrary external ID to the group.
team.GroupCreateArg.group_management_type – Whether the team can be managed by selected users, or only by team admins.

__init__(group_name=None, add_creator_as_owner=None, group_external_id=None, group_management_type=None)

add_creator_as_owner

group_external_id

group_management_type

group_name

class dropbox.team.GroupCreateError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupCreateError.group_name_already_used – The requested group name is already being used by another group.
team.GroupCreateError.group_name_invalid – Group name is empty or has invalid characters.
team.GroupCreateError.external_id_already_in_use – The requested external ID is already being used by another group.
team.GroupCreateError.system_managed_group_disallowed – System-managed group cannot be manually created.

external_id_already_in_use = GroupCreateError('external_id_already_in_use', None)

group_name_already_used = GroupCreateError('group_name_already_used', None)

group_name_invalid = GroupCreateError('group_name_invalid', None)

is_external_id_already_in_use()

Check if the union tag is external_id_already_in_use.

Return type:: bool

is_group_name_already_used()

Check if the union tag is group_name_already_used.

Return type:: bool

is_group_name_invalid()

Check if the union tag is group_name_invalid.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_system_managed_group_disallowed()

Check if the union tag is system_managed_group_disallowed.

Return type:: bool

other = GroupCreateError('other', None)

system_managed_group_disallowed = GroupCreateError('system_managed_group_disallowed', None)

class dropbox.team.GroupDeleteError(tag, value=None)

Bases: GroupSelectorWithTeamGroupError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupDeleteError.group_already_deleted – This group has already been deleted.

group_already_deleted = GroupDeleteError('group_already_deleted', None)

is_group_already_deleted()

Check if the union tag is group_already_deleted.

Return type:: bool

class dropbox.team.GroupFullInfo(group_name=None, group_id=None, group_management_type=None, created=None, group_external_id=None, member_count=None, members=None)

Bases: GroupSummary

Full description of a group.

Variables:

team.GroupFullInfo.members – List of group members.
team.GroupFullInfo.created – The group creation time as a UTC timestamp in milliseconds since the Unix epoch.

__init__(group_name=None, group_id=None, group_management_type=None, created=None, group_external_id=None, member_count=None, members=None)

created

members

class dropbox.team.GroupMemberInfo(profile=None, access_type=None)

Bases: Struct

Profile of group member, and role in group.

Variables:

team.GroupMemberInfo.profile – Profile of group member.
team.GroupMemberInfo.access_type – The role that the user has in the group.

__init__(profile=None, access_type=None)

access_type

profile

class dropbox.team.GroupMemberSelector(group=None, user=None)

Bases: Struct

Argument for selecting a group and a single user.

Variables:

team.GroupMemberSelector.group – Specify a group.
team.GroupMemberSelector.user – Identity of a user that is a member of group.

__init__(group=None, user=None)

group

user

class dropbox.team.GroupMemberSelectorError(tag, value=None)

Bases: GroupSelectorWithTeamGroupError

Error that can be raised when GroupMemberSelector is used, and the user is required to be a member of the specified group.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupMemberSelectorError.member_not_in_group – The specified user is not a member of this group.

is_member_not_in_group()

Check if the union tag is member_not_in_group.

Return type:: bool

member_not_in_group = GroupMemberSelectorError('member_not_in_group', None)

class dropbox.team.GroupMemberSetAccessTypeError(tag, value=None)

Bases: GroupMemberSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar: team.GroupMemberSetAccessTypeError.user_cannot_be_manager_of_company_managed_group: A company managed group cannot be managed by a user.

is_user_cannot_be_manager_of_company_managed_group()

Check if the union tag is user_cannot_be_manager_of_company_managed_group.

Return type:: bool

user_cannot_be_manager_of_company_managed_group = GroupMemberSetAccessTypeError('user_cannot_be_manager_of_company_managed_group', None)

class dropbox.team.GroupMembersAddArg(group=None, members=None, return_members=None)

Bases: IncludeMembersArg

Variables:

team.GroupMembersAddArg.group – Group to which users will be added.
team.GroupMembersAddArg.members – List of users to be added to the group.

__init__(group=None, members=None, return_members=None)

group

members

class dropbox.team.GroupMembersAddError(tag, value=None)

Bases: GroupSelectorWithTeamGroupError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupMembersAddError.duplicate_user – You cannot add duplicate users. One or more of the members you are trying to add is already a member of the group.
team.GroupMembersAddError.group_not_in_team – Group is not in this team. You cannot add members to a group that is outside of your team.
team.GroupMembersAddError.members_not_in_team (list of [str]) – These members are not part of your team. Currently, you cannot add members to a group if they are not part of your team, though this may change in a subsequent version. To add new members to your Dropbox Business team, use the :route:`members/add` endpoint.
team.GroupMembersAddError.users_not_found (list of [str]) – These users were not found in Dropbox.
team.GroupMembersAddError.user_must_be_active_to_be_owner – A suspended user cannot be added to a group as GroupAccessType.owner.

:ivar list of [str]: team.GroupMembersAddError.user_cannot_be_manager_of_company_managed_group: A company-managed group cannot be managed by a user.

duplicate_user = GroupMembersAddError('duplicate_user', None)

get_members_not_in_team()

These members are not part of your team. Currently, you cannot add members to a group if they are not part of your team, though this may change in a subsequent version. To add new members to your Dropbox Business team, use the dropbox.dropbox_client.Dropbox.team_members_add() endpoint.

Only call this if is_members_not_in_team() is true.

Return type:: list of [str]

get_user_cannot_be_manager_of_company_managed_group()

A company-managed group cannot be managed by a user.

Only call this if is_user_cannot_be_manager_of_company_managed_group() is true.

Return type:: list of [str]

get_users_not_found()

These users were not found in Dropbox.

Only call this if is_users_not_found() is true.

Return type:: list of [str]

group_not_in_team = GroupMembersAddError('group_not_in_team', None)

is_duplicate_user()

Check if the union tag is duplicate_user.

Return type:: bool

is_group_not_in_team()

Check if the union tag is group_not_in_team.

Return type:: bool

is_members_not_in_team()

Check if the union tag is members_not_in_team.

Return type:: bool

is_user_cannot_be_manager_of_company_managed_group()

Check if the union tag is user_cannot_be_manager_of_company_managed_group.

Return type:: bool

is_user_must_be_active_to_be_owner()

Check if the union tag is user_must_be_active_to_be_owner.

Return type:: bool

is_users_not_found()

Check if the union tag is users_not_found.

Return type:: bool

classmethod members_not_in_team(val)

Create an instance of this class set to the members_not_in_team tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupMembersAddError

classmethod user_cannot_be_manager_of_company_managed_group(val)

Create an instance of this class set to the user_cannot_be_manager_of_company_managed_group tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupMembersAddError

user_must_be_active_to_be_owner = GroupMembersAddError('user_must_be_active_to_be_owner', None)

classmethod users_not_found(val)

Create an instance of this class set to the users_not_found tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupMembersAddError

class dropbox.team.GroupMembersChangeResult(group_info=None, async_job_id=None)

Bases: Struct

Result returned by dropbox.dropbox_client.Dropbox.team_groups_members_add() and dropbox.dropbox_client.Dropbox.team_groups_members_remove().

Variables:

team.GroupMembersChangeResult.group_info – The group info after member change operation has been performed.
team.GroupMembersChangeResult.async_job_id – For legacy purposes async_job_id will always return one space ‘ ‘. Formerly, it was an ID that was used to obtain the status of granting/revoking group-owned resources. It’s no longer necessary because the async processing now happens automatically.

__init__(group_info=None, async_job_id=None)

async_job_id

group_info

class dropbox.team.GroupMembersRemoveArg(group=None, users=None, return_members=None)

Bases: IncludeMembersArg

Variables:

team.GroupMembersRemoveArg.group – Group from which users will be removed.
team.GroupMembersRemoveArg.users – List of users to be removed from the group.

__init__(group=None, users=None, return_members=None)

group

users

class dropbox.team.GroupMembersRemoveError(tag, value=None)

Bases: GroupMembersSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupMembersRemoveError.group_not_in_team – Group is not in this team. You cannot remove members from a group that is outside of your team.
team.GroupMembersRemoveError.members_not_in_team (list of [str]) – These members are not part of your team.
team.GroupMembersRemoveError.users_not_found (list of [str]) – These users were not found in Dropbox.

get_members_not_in_team()

These members are not part of your team.

Only call this if is_members_not_in_team() is true.

Return type:: list of [str]

get_users_not_found()

These users were not found in Dropbox.

Only call this if is_users_not_found() is true.

Return type:: list of [str]

group_not_in_team = GroupMembersRemoveError('group_not_in_team', None)

is_group_not_in_team()

Check if the union tag is group_not_in_team.

Return type:: bool

is_members_not_in_team()

Check if the union tag is members_not_in_team.

Return type:: bool

is_users_not_found()

Check if the union tag is users_not_found.

Return type:: bool

classmethod members_not_in_team(val)

Create an instance of this class set to the members_not_in_team tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupMembersRemoveError

classmethod users_not_found(val)

Create an instance of this class set to the users_not_found tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupMembersRemoveError

class dropbox.team.GroupMembersSelector(group=None, users=None)

Bases: Struct

Argument for selecting a group and a list of users.

Variables:

team.GroupMembersSelector.group – Specify a group.
team.GroupMembersSelector.users – A list of users that are members of group.

__init__(group=None, users=None)

group

users

class dropbox.team.GroupMembersSelectorError(tag, value=None)

Bases: GroupSelectorWithTeamGroupError

Error that can be raised when GroupMembersSelector is used, and the users are required to be members of the specified group.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupMembersSelectorError.member_not_in_group – At least one of the specified users is not a member of the group.

is_member_not_in_group()

Check if the union tag is member_not_in_group.

Return type:: bool

member_not_in_group = GroupMembersSelectorError('member_not_in_group', None)

class dropbox.team.GroupMembersSetAccessTypeArg(group=None, user=None, access_type=None, return_members=None)

Bases: GroupMemberSelector

Variables:

team.GroupMembersSetAccessTypeArg.access_type – New group access type the user will have.
team.GroupMembersSetAccessTypeArg.return_members – Whether to return the list of members in the group. Note that the default value will cause all the group members to be returned in the response. This may take a long time for large groups.

__init__(group=None, user=None, access_type=None, return_members=None)

access_type

return_members

class dropbox.team.GroupSelector(tag, value=None)

Bases: Union

Argument for selecting a single group, either by group_id or by external group ID.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupSelector.group_id (str) – Group ID.
team.GroupSelector.group_external_id (str) – External ID of the group.

get_group_external_id()

External ID of the group.

Only call this if is_group_external_id() is true.

Return type:: str

get_group_id()

Group ID.

Only call this if is_group_id() is true.

Return type:: str

classmethod group_external_id(val)

Create an instance of this class set to the group_external_id tag with value val.

Parameters:: val (str) –
Return type:: GroupSelector

classmethod group_id(val)

Create an instance of this class set to the group_id tag with value val.

Parameters:: val (str) –
Return type:: GroupSelector

is_group_external_id()

Check if the union tag is group_external_id.

Return type:: bool

is_group_id()

Check if the union tag is group_id.

Return type:: bool

class dropbox.team.GroupSelectorError(tag, value=None)

Bases: Union

Error that can be raised when GroupSelector is used.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupSelectorError.group_not_found – No matching group found. No groups match the specified group ID.

group_not_found = GroupSelectorError('group_not_found', None)

is_group_not_found()

Check if the union tag is group_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = GroupSelectorError('other', None)

class dropbox.team.GroupSelectorWithTeamGroupError(tag, value=None)

Bases: GroupSelectorError

Error that can be raised when GroupSelector is used and team groups are disallowed from being used.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupSelectorWithTeamGroupError.system_managed_group_disallowed – This operation is not supported on system-managed groups.

is_system_managed_group_disallowed()

Check if the union tag is system_managed_group_disallowed.

Return type:: bool

system_managed_group_disallowed = GroupSelectorWithTeamGroupError('system_managed_group_disallowed', None)

class dropbox.team.GroupUpdateArgs(group=None, return_members=None, new_group_name=None, new_group_external_id=None, new_group_management_type=None)

Bases: IncludeMembersArg

Variables:

team.GroupUpdateArgs.group – Specify a group.
team.GroupUpdateArgs.new_group_name – Optional argument. Set group name to this if provided.
team.GroupUpdateArgs.new_group_external_id – Optional argument. New group external ID. If the argument is None, the group’s external_id won’t be updated. If the argument is empty string, the group’s external id will be cleared.
team.GroupUpdateArgs.new_group_management_type – Set new group management type, if provided.

__init__(group=None, return_members=None, new_group_name=None, new_group_external_id=None, new_group_management_type=None)

group

new_group_external_id

new_group_management_type

new_group_name

class dropbox.team.GroupUpdateError(tag, value=None)

Bases: GroupSelectorWithTeamGroupError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupUpdateError.group_name_already_used – The requested group name is already being used by another group.
team.GroupUpdateError.group_name_invalid – Group name is empty or has invalid characters.
team.GroupUpdateError.external_id_already_in_use – The requested external ID is already being used by another group.

external_id_already_in_use = GroupUpdateError('external_id_already_in_use', None)

group_name_already_used = GroupUpdateError('group_name_already_used', None)

group_name_invalid = GroupUpdateError('group_name_invalid', None)

is_external_id_already_in_use()

Check if the union tag is external_id_already_in_use.

Return type:: bool

is_group_name_already_used()

Check if the union tag is group_name_already_used.

Return type:: bool

is_group_name_invalid()

Check if the union tag is group_name_invalid.

Return type:: bool

class dropbox.team.GroupsGetInfoError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupsGetInfoError.group_not_on_team – The group is not on your team.

group_not_on_team = GroupsGetInfoError('group_not_on_team', None)

is_group_not_on_team()

Check if the union tag is group_not_on_team.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = GroupsGetInfoError('other', None)

class dropbox.team.GroupsGetInfoItem(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupsGetInfoItem.id_not_found (str) – An ID that was provided as a parameter to :route:`groups/get_info`, and did not match a corresponding group. The ID can be a group ID, or an external ID, depending on how the method was called.
GroupsGetInfoItem.group_info (GroupFullInfo) – Info about a group.

get_group_info()

Info about a group.

Only call this if is_group_info() is true.

Return type:: GroupFullInfo

get_id_not_found()

An ID that was provided as a parameter to dropbox.dropbox_client.Dropbox.team_groups_get_info(), and did not match a corresponding group. The ID can be a group ID, or an external ID, depending on how the method was called.

Only call this if is_id_not_found() is true.

Return type:: str

classmethod group_info(val)

Create an instance of this class set to the group_info tag with value val.

Parameters:: val (GroupFullInfo) –
Return type:: GroupsGetInfoItem

classmethod id_not_found(val)

Create an instance of this class set to the id_not_found tag with value val.

Parameters:: val (str) –
Return type:: GroupsGetInfoItem

is_group_info()

Check if the union tag is group_info.

Return type:: bool

is_id_not_found()

Check if the union tag is id_not_found.

Return type:: bool

class dropbox.team.GroupsListArg(limit=None)

Bases: Struct

Variables:: team.GroupsListArg.limit – Number of results to return per call.

__init__(limit=None)

limit

class dropbox.team.GroupsListContinueArg(cursor=None)

Bases: Struct

Variables:: team.GroupsListContinueArg.cursor – Indicates from what point to get the next set of groups.

__init__(cursor=None)

cursor

class dropbox.team.GroupsListContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupsListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = GroupsListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = GroupsListContinueError('other', None)

class dropbox.team.GroupsListResult(groups=None, cursor=None, has_more=None)

Bases: Struct

Variables:

team.GroupsListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_groups_list_continue() to obtain the additional groups.
team.GroupsListResult.has_more – Is true if there are additional groups that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_groups_list_continue() can retrieve them.

__init__(groups=None, cursor=None, has_more=None)

cursor

groups

has_more

class dropbox.team.GroupsMembersListArg(group=None, limit=None)

Bases: Struct

Variables:

team.GroupsMembersListArg.group – The group whose members are to be listed.
team.GroupsMembersListArg.limit – Number of results to return per call.

__init__(group=None, limit=None)

group

limit

class dropbox.team.GroupsMembersListContinueArg(cursor=None)

Bases: Struct

Variables:: team.GroupsMembersListContinueArg.cursor – Indicates from what point to get the next set of groups.

__init__(cursor=None)

cursor

class dropbox.team.GroupsMembersListContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupsMembersListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = GroupsMembersListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = GroupsMembersListContinueError('other', None)

class dropbox.team.GroupsMembersListResult(members=None, cursor=None, has_more=None)

Bases: Struct

Variables:

team.GroupsMembersListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_groups_members_list_continue() to obtain additional group members.
team.GroupsMembersListResult.has_more – Is true if there are additional group members that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_groups_members_list_continue() can retrieve them.

__init__(members=None, cursor=None, has_more=None)

cursor

has_more

members

class dropbox.team.GroupsPollError(tag, value=None)

Bases: PollError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.GroupsPollError.access_denied – You are not allowed to poll this job.

access_denied = GroupsPollError('access_denied', None)

is_access_denied()

Check if the union tag is access_denied.

Return type:: bool

class dropbox.team.GroupsSelector(tag, value=None)

Bases: Union

Argument for selecting a list of groups, either by group_ids, or external group IDs.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.GroupsSelector.group_ids (list of [str]) – List of group IDs.
team.GroupsSelector.group_external_ids (list of [str]) – List of external IDs of groups.

get_group_external_ids()

List of external IDs of groups.

Only call this if is_group_external_ids() is true.

Return type:: list of [str]

get_group_ids()

List of group IDs.

Only call this if is_group_ids() is true.

Return type:: list of [str]

classmethod group_external_ids(val)

Create an instance of this class set to the group_external_ids tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupsSelector

classmethod group_ids(val)

Create an instance of this class set to the group_ids tag with value val.

Parameters:: val (list of [str]) –
Return type:: GroupsSelector

is_group_external_ids()

Check if the union tag is group_external_ids.

Return type:: bool

is_group_ids()

Check if the union tag is group_ids.

Return type:: bool

class dropbox.team.HasTeamFileEventsValue(tag, value=None)

Bases: Union

The value for Feature.has_team_file_events.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.HasTeamFileEventsValue.enabled (bool) – Does this team have file events.

classmethod enabled(val)

Create an instance of this class set to the enabled tag with value val.

Parameters:: val (bool) –
Return type:: HasTeamFileEventsValue

get_enabled()

Does this team have file events.

Only call this if is_enabled() is true.

Return type:: bool

is_enabled()

Check if the union tag is enabled.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = HasTeamFileEventsValue('other', None)

class dropbox.team.HasTeamSelectiveSyncValue(tag, value=None)

Bases: Union

The value for Feature.has_team_selective_sync.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.HasTeamSelectiveSyncValue.has_team_selective_sync (bool) – Does this team have team selective sync enabled.

get_has_team_selective_sync()

Does this team have team selective sync enabled.

Only call this if is_has_team_selective_sync() is true.

Return type:: bool

classmethod has_team_selective_sync(val)

Create an instance of this class set to the has_team_selective_sync tag with value val.

Parameters:: val (bool) –
Return type:: HasTeamSelectiveSyncValue

is_has_team_selective_sync()

Check if the union tag is has_team_selective_sync.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = HasTeamSelectiveSyncValue('other', None)

class dropbox.team.HasTeamSharedDropboxValue(tag, value=None)

Bases: Union

The value for Feature.has_team_shared_dropbox.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.HasTeamSharedDropboxValue.has_team_shared_dropbox (bool) – Does this team have a shared team root.

get_has_team_shared_dropbox()

Does this team have a shared team root.

Only call this if is_has_team_shared_dropbox() is true.

Return type:: bool

classmethod has_team_shared_dropbox(val)

Create an instance of this class set to the has_team_shared_dropbox tag with value val.

Parameters:: val (bool) –
Return type:: HasTeamSharedDropboxValue

is_has_team_shared_dropbox()

Check if the union tag is has_team_shared_dropbox.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = HasTeamSharedDropboxValue('other', None)

class dropbox.team.IncludeMembersArg(return_members=None)

Bases: Struct

Variables:: team.IncludeMembersArg.return_members – Whether to return the list of members in the group. Note that the default value will cause all the group members to be returned in the response. This may take a long time for large groups.

__init__(return_members=None)

return_members

class dropbox.team.LegalHoldHeldRevisionMetadata(new_filename=None, original_revision_id=None, original_file_path=None, server_modified=None, author_member_id=None, author_member_status=None, author_email=None, file_type=None, size=None, content_hash=None)

Bases: Struct

Variables:

team.LegalHoldHeldRevisionMetadata.new_filename – The held revision filename.
team.LegalHoldHeldRevisionMetadata.original_revision_id – The id of the held revision.
team.LegalHoldHeldRevisionMetadata.original_file_path – The original path of the held revision.
team.LegalHoldHeldRevisionMetadata.server_modified – The last time the file was modified on Dropbox.
team.LegalHoldHeldRevisionMetadata.author_member_id – The member id of the revision’s author.
team.LegalHoldHeldRevisionMetadata.author_member_status – The member status of the revision’s author.
team.LegalHoldHeldRevisionMetadata.author_email – The email address of the held revision author.
team.LegalHoldHeldRevisionMetadata.file_type – The type of the held revision’s file.
team.LegalHoldHeldRevisionMetadata.size – The file size in bytes.
team.LegalHoldHeldRevisionMetadata.content_hash – A hash of the file content. This field can be used to verify data integrity. For more information see our Content hash page.

__init__(new_filename=None, original_revision_id=None, original_file_path=None, server_modified=None, author_member_id=None, author_member_status=None, author_email=None, file_type=None, size=None, content_hash=None)

author_email

author_member_id

author_member_status

content_hash

file_type

new_filename

original_file_path

original_revision_id

server_modified

size

class dropbox.team.LegalHoldPolicy(id=None, name=None, members=None, status=None, start_date=None, description=None, activation_time=None, end_date=None)

Bases: Struct

Variables:

team.LegalHoldPolicy.id – The legal hold id.
team.LegalHoldPolicy.name – Policy name.
team.LegalHoldPolicy.description – A description of the legal hold policy.
team.LegalHoldPolicy.activation_time – The time at which the legal hold was activated.
team.LegalHoldPolicy.members – Team members IDs and number of permanently deleted members under hold.
team.LegalHoldPolicy.status – The current state of the hold.
team.LegalHoldPolicy.start_date – Start date of the legal hold policy.
team.LegalHoldPolicy.end_date – End date of the legal hold policy.

__init__(id=None, name=None, members=None, status=None, start_date=None, description=None, activation_time=None, end_date=None)

activation_time

description

end_date

id

members

name

start_date

status

class dropbox.team.LegalHoldStatus(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.LegalHoldStatus.active – The legal hold policy is active.
team.LegalHoldStatus.released – The legal hold policy was released.
team.LegalHoldStatus.activating – The legal hold policy is activating.
team.LegalHoldStatus.updating – The legal hold policy is updating.
team.LegalHoldStatus.exporting – The legal hold policy is exporting.
team.LegalHoldStatus.releasing – The legal hold policy is releasing.

activating = LegalHoldStatus('activating', None)

active = LegalHoldStatus('active', None)

exporting = LegalHoldStatus('exporting', None)

is_activating()

Check if the union tag is activating.

Return type:: bool

is_active()

Check if the union tag is active.

Return type:: bool

is_exporting()

Check if the union tag is exporting.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_released()

Check if the union tag is released.

Return type:: bool

is_releasing()

Check if the union tag is releasing.

Return type:: bool

is_updating()

Check if the union tag is updating.

Return type:: bool

other = LegalHoldStatus('other', None)

released = LegalHoldStatus('released', None)

releasing = LegalHoldStatus('releasing', None)

updating = LegalHoldStatus('updating', None)

class dropbox.team.LegalHoldsError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.LegalHoldsError.unknown_legal_hold_error – There has been an unknown legal hold error.
team.LegalHoldsError.insufficient_permissions – You don’t have permissions to perform this action.

insufficient_permissions = LegalHoldsError('insufficient_permissions', None)

is_insufficient_permissions()

Check if the union tag is insufficient_permissions.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_unknown_legal_hold_error()

Check if the union tag is unknown_legal_hold_error.

Return type:: bool

other = LegalHoldsError('other', None)

unknown_legal_hold_error = LegalHoldsError('unknown_legal_hold_error', None)

class dropbox.team.LegalHoldsGetPolicyArg(id=None)

Bases: Struct

Variables:: team.LegalHoldsGetPolicyArg.id – The legal hold Id.

__init__(id=None)

id

class dropbox.team.LegalHoldsGetPolicyError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.LegalHoldsGetPolicyError.legal_hold_policy_not_found – Legal hold policy does not exist for LegalHoldsGetPolicyArg.id.

is_legal_hold_policy_not_found()

Check if the union tag is legal_hold_policy_not_found.

Return type:: bool

legal_hold_policy_not_found = LegalHoldsGetPolicyError('legal_hold_policy_not_found', None)

dropbox.team.LegalHoldsGetPolicyResult: alias of LegalHoldPolicy

class dropbox.team.LegalHoldsListHeldRevisionResult(entries=None, has_more=None, cursor=None)

Bases: Struct

Variables:

team.LegalHoldsListHeldRevisionResult.entries – List of file entries that under the hold.
team.LegalHoldsListHeldRevisionResult.cursor – The cursor idicates where to continue reading file metadata entries for the next API call. When there are no more entries, the cursor will return none. Pass the cursor into /2/team/legal_holds/list_held_revisions/continue.
team.LegalHoldsListHeldRevisionResult.has_more – True if there are more file entries that haven’t been returned. You can retrieve them with a call to /legal_holds/list_held_revisions_continue.

__init__(entries=None, has_more=None, cursor=None)

cursor

entries

has_more

class dropbox.team.LegalHoldsListHeldRevisionsArg(id=None)

Bases: Struct

Variables:: team.LegalHoldsListHeldRevisionsArg.id – The legal hold Id.

__init__(id=None)

id

class dropbox.team.LegalHoldsListHeldRevisionsContinueArg(id=None, cursor=None)

Bases: Struct

Variables:

team.LegalHoldsListHeldRevisionsContinueArg.id – The legal hold Id.
team.LegalHoldsListHeldRevisionsContinueArg.cursor – The cursor idicates where to continue reading file metadata entries for the next API call. When there are no more entries, the cursor will return none.

__init__(id=None, cursor=None)

cursor

id

class dropbox.team.LegalHoldsListHeldRevisionsContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar: team.LegalHoldsListHeldRevisionsContinueError.unknown_legal_hold_error: There has been an unknown legal hold error.

Variables:

team.LegalHoldsListHeldRevisionsContinueError.transient_error – Temporary infrastructure failure, please retry.
team.LegalHoldsListHeldRevisionsContinueError.reset – Indicates that the cursor has been invalidated. Call dropbox.dropbox_client.Dropbox.team_legal_holds_list_held_revisions_continue() again with an empty cursor to obtain a new cursor.

is_other()

Check if the union tag is other.

Return type:: bool

is_reset()

Check if the union tag is reset.

Return type:: bool

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

is_unknown_legal_hold_error()

Check if the union tag is unknown_legal_hold_error.

Return type:: bool

other = LegalHoldsListHeldRevisionsContinueError('other', None)

reset = LegalHoldsListHeldRevisionsContinueError('reset', None)

transient_error = LegalHoldsListHeldRevisionsContinueError('transient_error', None)

unknown_legal_hold_error = LegalHoldsListHeldRevisionsContinueError('unknown_legal_hold_error', None)

class dropbox.team.LegalHoldsListHeldRevisionsError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.LegalHoldsListHeldRevisionsError.transient_error – Temporary infrastructure failure, please retry.
team.LegalHoldsListHeldRevisionsError.legal_hold_still_empty – The legal hold is not holding any revisions yet.
team.LegalHoldsListHeldRevisionsError.inactive_legal_hold – Trying to list revisions for an inactive legal hold.

inactive_legal_hold = LegalHoldsListHeldRevisionsError('inactive_legal_hold', None)

is_inactive_legal_hold()

Check if the union tag is inactive_legal_hold.

Return type:: bool

is_legal_hold_still_empty()

Check if the union tag is legal_hold_still_empty.

Return type:: bool

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

legal_hold_still_empty = LegalHoldsListHeldRevisionsError('legal_hold_still_empty', None)

transient_error = LegalHoldsListHeldRevisionsError('transient_error', None)

class dropbox.team.LegalHoldsListPoliciesArg(include_released=None)

Bases: Struct

Variables:: team.LegalHoldsListPoliciesArg.include_released – Whether to return holds that were released.

__init__(include_released=None)

include_released

class dropbox.team.LegalHoldsListPoliciesError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.LegalHoldsListPoliciesError.transient_error – Temporary infrastructure failure, please retry.

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

transient_error = LegalHoldsListPoliciesError('transient_error', None)

class dropbox.team.LegalHoldsListPoliciesResult(policies=None)

Bases: Struct

__init__(policies=None)

policies

class dropbox.team.LegalHoldsPolicyCreateArg(name=None, members=None, description=None, start_date=None, end_date=None)

Bases: Struct

Variables:

team.LegalHoldsPolicyCreateArg.name – Policy name.
team.LegalHoldsPolicyCreateArg.description – A description of the legal hold policy.
team.LegalHoldsPolicyCreateArg.members – List of team member IDs added to the hold.
team.LegalHoldsPolicyCreateArg.start_date – start date of the legal hold policy.
team.LegalHoldsPolicyCreateArg.end_date – end date of the legal hold policy.

__init__(name=None, members=None, description=None, start_date=None, end_date=None)

description

end_date

members

name

start_date

class dropbox.team.LegalHoldsPolicyCreateError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.LegalHoldsPolicyCreateError.start_date_is_later_than_end_date – Start date must be earlier than end date.
team.LegalHoldsPolicyCreateError.empty_members_list – The users list must have at least one user.
team.LegalHoldsPolicyCreateError.invalid_members – Some members in the members list are not valid to be placed under legal hold.

:ivar: team.LegalHoldsPolicyCreateError.number_of_users_on_hold_is_greater_than_hold_limitation: You cannot add more than 5 users in a legal hold.

Variables:

team.LegalHoldsPolicyCreateError.transient_error – Temporary infrastructure failure, please retry.
team.LegalHoldsPolicyCreateError.name_must_be_unique – The name provided is already in use by another legal hold.
team.LegalHoldsPolicyCreateError.team_exceeded_legal_hold_quota – Team exceeded legal hold quota.
team.LegalHoldsPolicyCreateError.invalid_date – The provided date is invalid.

empty_members_list = LegalHoldsPolicyCreateError('empty_members_list', None)

invalid_date = LegalHoldsPolicyCreateError('invalid_date', None)

invalid_members = LegalHoldsPolicyCreateError('invalid_members', None)

is_empty_members_list()

Check if the union tag is empty_members_list.

Return type:: bool

is_invalid_date()

Check if the union tag is invalid_date.

Return type:: bool

is_invalid_members()

Check if the union tag is invalid_members.

Return type:: bool

is_name_must_be_unique()

Check if the union tag is name_must_be_unique.

Return type:: bool

is_number_of_users_on_hold_is_greater_than_hold_limitation()

Check if the union tag is number_of_users_on_hold_is_greater_than_hold_limitation.

Return type:: bool

is_start_date_is_later_than_end_date()

Check if the union tag is start_date_is_later_than_end_date.

Return type:: bool

is_team_exceeded_legal_hold_quota()

Check if the union tag is team_exceeded_legal_hold_quota.

Return type:: bool

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

name_must_be_unique = LegalHoldsPolicyCreateError('name_must_be_unique', None)

number_of_users_on_hold_is_greater_than_hold_limitation = LegalHoldsPolicyCreateError('number_of_users_on_hold_is_greater_than_hold_limitation', None)

start_date_is_later_than_end_date = LegalHoldsPolicyCreateError('start_date_is_later_than_end_date', None)

team_exceeded_legal_hold_quota = LegalHoldsPolicyCreateError('team_exceeded_legal_hold_quota', None)

transient_error = LegalHoldsPolicyCreateError('transient_error', None)

dropbox.team.LegalHoldsPolicyCreateResult: alias of LegalHoldPolicy

class dropbox.team.LegalHoldsPolicyReleaseArg(id=None)

Bases: Struct

Variables:: team.LegalHoldsPolicyReleaseArg.id – The legal hold Id.

__init__(id=None)

id

class dropbox.team.LegalHoldsPolicyReleaseError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar: team.LegalHoldsPolicyReleaseError.legal_hold_performing_another_operation: Legal hold is currently performing another operation.

Variables:

team.LegalHoldsPolicyReleaseError.legal_hold_already_releasing – Legal hold is currently performing a release or is already released.
team.LegalHoldsPolicyReleaseError.legal_hold_policy_not_found – Legal hold policy does not exist for LegalHoldsPolicyReleaseArg.id.

is_legal_hold_already_releasing()

Check if the union tag is legal_hold_already_releasing.

Return type:: bool

is_legal_hold_performing_another_operation()

Check if the union tag is legal_hold_performing_another_operation.

Return type:: bool

is_legal_hold_policy_not_found()

Check if the union tag is legal_hold_policy_not_found.

Return type:: bool

legal_hold_already_releasing = LegalHoldsPolicyReleaseError('legal_hold_already_releasing', None)

legal_hold_performing_another_operation = LegalHoldsPolicyReleaseError('legal_hold_performing_another_operation', None)

legal_hold_policy_not_found = LegalHoldsPolicyReleaseError('legal_hold_policy_not_found', None)

class dropbox.team.LegalHoldsPolicyUpdateArg(id=None, name=None, description=None, members=None)

Bases: Struct

Variables:

team.LegalHoldsPolicyUpdateArg.id – The legal hold Id.
team.LegalHoldsPolicyUpdateArg.name – Policy new name.
team.LegalHoldsPolicyUpdateArg.description – Policy new description.
team.LegalHoldsPolicyUpdateArg.members – List of team member IDs to apply the policy on.

__init__(id=None, name=None, description=None, members=None)

description

id

members

name

class dropbox.team.LegalHoldsPolicyUpdateError(tag, value=None)

Bases: LegalHoldsError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.LegalHoldsPolicyUpdateError.transient_error – Temporary infrastructure failure, please retry.
team.LegalHoldsPolicyUpdateError.inactive_legal_hold – Trying to release an inactive legal hold.

:ivar: team.LegalHoldsPolicyUpdateError.legal_hold_performing_another_operation: Legal hold is currently performing another operation.

Variables:: team.LegalHoldsPolicyUpdateError.invalid_members – Some members in the members list are not valid to be placed under legal hold.

:ivar: team.LegalHoldsPolicyUpdateError.number_of_users_on_hold_is_greater_than_hold_limitation: You cannot add more than 5 users in a legal hold.

Variables:

team.LegalHoldsPolicyUpdateError.empty_members_list – The users list must have at least one user.
team.LegalHoldsPolicyUpdateError.name_must_be_unique – The name provided is already in use by another legal hold.
team.LegalHoldsPolicyUpdateError.legal_hold_policy_not_found – Legal hold policy does not exist for LegalHoldsPolicyUpdateArg.id.

empty_members_list = LegalHoldsPolicyUpdateError('empty_members_list', None)

inactive_legal_hold = LegalHoldsPolicyUpdateError('inactive_legal_hold', None)

invalid_members = LegalHoldsPolicyUpdateError('invalid_members', None)

is_empty_members_list()

Check if the union tag is empty_members_list.

Return type:: bool

is_inactive_legal_hold()

Check if the union tag is inactive_legal_hold.

Return type:: bool

is_invalid_members()

Check if the union tag is invalid_members.

Return type:: bool

is_legal_hold_performing_another_operation()

Check if the union tag is legal_hold_performing_another_operation.

Return type:: bool

is_legal_hold_policy_not_found()

Check if the union tag is legal_hold_policy_not_found.

Return type:: bool

is_name_must_be_unique()

Check if the union tag is name_must_be_unique.

Return type:: bool

is_number_of_users_on_hold_is_greater_than_hold_limitation()

Check if the union tag is number_of_users_on_hold_is_greater_than_hold_limitation.

Return type:: bool

is_transient_error()

Check if the union tag is transient_error.

Return type:: bool

legal_hold_performing_another_operation = LegalHoldsPolicyUpdateError('legal_hold_performing_another_operation', None)

legal_hold_policy_not_found = LegalHoldsPolicyUpdateError('legal_hold_policy_not_found', None)

name_must_be_unique = LegalHoldsPolicyUpdateError('name_must_be_unique', None)

number_of_users_on_hold_is_greater_than_hold_limitation = LegalHoldsPolicyUpdateError('number_of_users_on_hold_is_greater_than_hold_limitation', None)

transient_error = LegalHoldsPolicyUpdateError('transient_error', None)

dropbox.team.LegalHoldsPolicyUpdateResult: alias of LegalHoldPolicy

class dropbox.team.ListMemberAppsArg(team_member_id=None)

Bases: Struct

Variables:: team.ListMemberAppsArg.team_member_id – The team member id.

__init__(team_member_id=None)

team_member_id

class dropbox.team.ListMemberAppsError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_linked_apps_list_member_linked_apps().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListMemberAppsError.member_not_found – Member not found.

is_member_not_found()

Check if the union tag is member_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

member_not_found = ListMemberAppsError('member_not_found', None)

other = ListMemberAppsError('other', None)

class dropbox.team.ListMemberAppsResult(linked_api_apps=None)

Bases: Struct

Variables:: team.ListMemberAppsResult.linked_api_apps – List of third party applications linked by this team member.

__init__(linked_api_apps=None)

linked_api_apps

class dropbox.team.ListMemberDevicesArg(team_member_id=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

Bases: Struct

Variables:

team.ListMemberDevicesArg.team_member_id – The team’s member id.
team.ListMemberDevicesArg.include_web_sessions – Whether to list web sessions of the team’s member.
team.ListMemberDevicesArg.include_desktop_clients – Whether to list linked desktop devices of the team’s member.
team.ListMemberDevicesArg.include_mobile_clients – Whether to list linked mobile devices of the team’s member.

__init__(team_member_id=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

include_desktop_clients

include_mobile_clients

include_web_sessions

team_member_id

class dropbox.team.ListMemberDevicesError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListMemberDevicesError.member_not_found – Member not found.

is_member_not_found()

Check if the union tag is member_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

member_not_found = ListMemberDevicesError('member_not_found', None)

other = ListMemberDevicesError('other', None)

class dropbox.team.ListMemberDevicesResult(active_web_sessions=None, desktop_client_sessions=None, mobile_client_sessions=None)

Bases: Struct

Variables:

team.ListMemberDevicesResult.active_web_sessions – List of web sessions made by this team member.
team.ListMemberDevicesResult.desktop_client_sessions – List of desktop clients used by this team member.
team.ListMemberDevicesResult.mobile_client_sessions – List of mobile client used by this team member.

__init__(active_web_sessions=None, desktop_client_sessions=None, mobile_client_sessions=None)

active_web_sessions

desktop_client_sessions

mobile_client_sessions

class dropbox.team.ListMembersAppsArg(cursor=None)

Bases: Struct

Arguments for dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps().

Variables:: team.ListMembersAppsArg.cursor – At the first call to the dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps() the cursor shouldn’t be passed. Then, if the result of the call includes a cursor, the following requests should include the received cursors in order to receive the next sub list of the team applications.

__init__(cursor=None)

cursor

class dropbox.team.ListMembersAppsError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListMembersAppsError.reset – Indicates that the cursor has been invalidated. Call dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps() again with an empty cursor to obtain a new cursor.

is_other()

Check if the union tag is other.

Return type:: bool

is_reset()

Check if the union tag is reset.

Return type:: bool

other = ListMembersAppsError('other', None)

reset = ListMembersAppsError('reset', None)

class dropbox.team.ListMembersAppsResult(apps=None, has_more=None, cursor=None)

Bases: Struct

Information returned by dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps().

Variables:

team.ListMembersAppsResult.apps – The linked applications of each member of the team.
team.ListMembersAppsResult.has_more – If true, then there are more apps available. Pass the cursor to dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps() to retrieve the rest.
team.ListMembersAppsResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_linked_apps_list_members_linked_apps() to receive the next sub list of team’s applications.

__init__(apps=None, has_more=None, cursor=None)

apps

cursor

has_more

class dropbox.team.ListMembersDevicesArg(cursor=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

Bases: Struct

Variables:

team.ListMembersDevicesArg.cursor – At the first call to the dropbox.dropbox_client.Dropbox.team_devices_list_members_devices() the cursor shouldn’t be passed. Then, if the result of the call includes a cursor, the following requests should include the received cursors in order to receive the next sub list of team devices.
team.ListMembersDevicesArg.include_web_sessions – Whether to list web sessions of the team members.
team.ListMembersDevicesArg.include_desktop_clients – Whether to list desktop clients of the team members.
team.ListMembersDevicesArg.include_mobile_clients – Whether to list mobile clients of the team members.

__init__(cursor=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

cursor

include_desktop_clients

include_mobile_clients

include_web_sessions

class dropbox.team.ListMembersDevicesError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListMembersDevicesError.reset – Indicates that the cursor has been invalidated. Call dropbox.dropbox_client.Dropbox.team_devices_list_members_devices() again with an empty cursor to obtain a new cursor.

is_other()

Check if the union tag is other.

Return type:: bool

is_reset()

Check if the union tag is reset.

Return type:: bool

other = ListMembersDevicesError('other', None)

reset = ListMembersDevicesError('reset', None)

class dropbox.team.ListMembersDevicesResult(devices=None, has_more=None, cursor=None)

Bases: Struct

Variables:

team.ListMembersDevicesResult.devices – The devices of each member of the team.
team.ListMembersDevicesResult.has_more – If true, then there are more devices available. Pass the cursor to dropbox.dropbox_client.Dropbox.team_devices_list_members_devices() to retrieve the rest.
team.ListMembersDevicesResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_devices_list_members_devices() to receive the next sub list of team’s devices.

__init__(devices=None, has_more=None, cursor=None)

cursor

devices

has_more

class dropbox.team.ListTeamAppsArg(cursor=None)

Bases: Struct

Arguments for dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps().

Variables:: team.ListTeamAppsArg.cursor – At the first call to the dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps() the cursor shouldn’t be passed. Then, if the result of the call includes a cursor, the following requests should include the received cursors in order to receive the next sub list of the team applications.

__init__(cursor=None)

cursor

class dropbox.team.ListTeamAppsError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListTeamAppsError.reset – Indicates that the cursor has been invalidated. Call dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps() again with an empty cursor to obtain a new cursor.

is_other()

Check if the union tag is other.

Return type:: bool

is_reset()

Check if the union tag is reset.

Return type:: bool

other = ListTeamAppsError('other', None)

reset = ListTeamAppsError('reset', None)

class dropbox.team.ListTeamAppsResult(apps=None, has_more=None, cursor=None)

Bases: Struct

Information returned by dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps().

Variables:

team.ListTeamAppsResult.apps – The linked applications of each member of the team.
team.ListTeamAppsResult.has_more – If true, then there are more apps available. Pass the cursor to dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps() to retrieve the rest.
team.ListTeamAppsResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_linked_apps_list_team_linked_apps() to receive the next sub list of team’s applications.

__init__(apps=None, has_more=None, cursor=None)

apps

cursor

has_more

class dropbox.team.ListTeamDevicesArg(cursor=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

Bases: Struct

Variables:

team.ListTeamDevicesArg.cursor – At the first call to the dropbox.dropbox_client.Dropbox.team_devices_list_team_devices() the cursor shouldn’t be passed. Then, if the result of the call includes a cursor, the following requests should include the received cursors in order to receive the next sub list of team devices.
team.ListTeamDevicesArg.include_web_sessions – Whether to list web sessions of the team members.
team.ListTeamDevicesArg.include_desktop_clients – Whether to list desktop clients of the team members.
team.ListTeamDevicesArg.include_mobile_clients – Whether to list mobile clients of the team members.

__init__(cursor=None, include_web_sessions=None, include_desktop_clients=None, include_mobile_clients=None)

cursor

include_desktop_clients

include_mobile_clients

include_web_sessions

class dropbox.team.ListTeamDevicesError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.ListTeamDevicesError.reset – Indicates that the cursor has been invalidated. Call dropbox.dropbox_client.Dropbox.team_devices_list_team_devices() again with an empty cursor to obtain a new cursor.

is_other()

Check if the union tag is other.

Return type:: bool

is_reset()

Check if the union tag is reset.

Return type:: bool

other = ListTeamDevicesError('other', None)

reset = ListTeamDevicesError('reset', None)

class dropbox.team.ListTeamDevicesResult(devices=None, has_more=None, cursor=None)

Bases: Struct

Variables:

team.ListTeamDevicesResult.devices – The devices of each member of the team.
team.ListTeamDevicesResult.has_more – If true, then there are more devices available. Pass the cursor to dropbox.dropbox_client.Dropbox.team_devices_list_team_devices() to retrieve the rest.
team.ListTeamDevicesResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_devices_list_team_devices() to receive the next sub list of team’s devices.

__init__(devices=None, has_more=None, cursor=None)

cursor

devices

has_more

class dropbox.team.MemberAccess(user=None, access_type=None)

Bases: Struct

Specify access type a member should have when joined to a group.

Variables:

team.MemberAccess.user – Identity of a user.
team.MemberAccess.access_type – Access type.

__init__(user=None, access_type=None)

access_type

user

class dropbox.team.MemberAddArg(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None, role=None)

Bases: MemberAddArgBase

__init__(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None, role=None)

role

class dropbox.team.MemberAddArgBase(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None)

Bases: Struct

Variables:

team.MemberAddArgBase.member_given_name – Member’s first name.
team.MemberAddArgBase.member_surname – Member’s last name.
team.MemberAddArgBase.member_external_id – External ID for member.
team.MemberAddArgBase.member_persistent_id – Persistent ID for member. This field is only available to teams using persistent ID SAML configuration.
team.MemberAddArgBase.send_welcome_email – Whether to send a welcome email to the member. If send_welcome_email is false, no email invitation will be sent to the user. This may be useful for apps using single sign-on (SSO) flows for onboarding that want to handle announcements themselves.
team.MemberAddArgBase.is_directory_restricted – Whether a user is directory restricted.

__init__(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None)

is_directory_restricted

member_email

member_external_id

member_given_name

member_persistent_id

member_surname

send_welcome_email

class dropbox.team.MemberAddResult(tag, value=None)

Bases: MemberAddResultBase

Describes the result of attempting to add a single user to the team. ‘success’ is the only value indicating that a user was indeed added to the team - the other values explain the type of failure that occurred, and include the email of the user for which the operation has failed.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: MemberAddResult.success (TeamMemberInfo) – Describes a user that was successfully added to the team.

get_success()

Describes a user that was successfully added to the team.

Only call this if is_success() is true.

Return type:: TeamMemberInfo

is_success()

Check if the union tag is success.

Return type:: bool

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (TeamMemberInfo) –
Return type:: MemberAddResult

class dropbox.team.MemberAddResultBase(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MemberAddResultBase.team_license_limit (str) – Team is already full. The organization has no available licenses.
team.MemberAddResultBase.free_team_member_limit_reached (str) – Team is already full. The free team member limit has been reached.
team.MemberAddResultBase.user_already_on_team (str) – User is already on this team. The provided email address is associated with a user who is already a member of (including in recoverable state) or invited to the team.
team.MemberAddResultBase.user_on_another_team (str) – User is already on another team. The provided email address is associated with a user that is already a member or invited to another team.
team.MemberAddResultBase.user_already_paired (str) – User is already paired.
team.MemberAddResultBase.user_migration_failed (str) – User migration has failed.
team.MemberAddResultBase.duplicate_external_member_id (str) – A user with the given external member ID already exists on the team (including in recoverable state).
team.MemberAddResultBase.duplicate_member_persistent_id (str) – A user with the given persistent ID already exists on the team (including in recoverable state).
team.MemberAddResultBase.persistent_id_disabled (str) – Persistent ID is only available to teams with persistent ID SAML configuration. Please contact Dropbox for more information.
team.MemberAddResultBase.user_creation_failed (str) – User creation has failed.

classmethod duplicate_external_member_id(val)

Create an instance of this class set to the duplicate_external_member_id tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod duplicate_member_persistent_id(val)

Create an instance of this class set to the duplicate_member_persistent_id tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod free_team_member_limit_reached(val)

Create an instance of this class set to the free_team_member_limit_reached tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

get_duplicate_external_member_id()

A user with the given external member ID already exists on the team (including in recoverable state).

Only call this if is_duplicate_external_member_id() is true.

Return type:: str

get_duplicate_member_persistent_id()

A user with the given persistent ID already exists on the team (including in recoverable state).

Only call this if is_duplicate_member_persistent_id() is true.

Return type:: str

get_free_team_member_limit_reached()

Team is already full. The free team member limit has been reached.

Only call this if is_free_team_member_limit_reached() is true.

Return type:: str

get_persistent_id_disabled()

Persistent ID is only available to teams with persistent ID SAML configuration. Please contact Dropbox for more information.

Only call this if is_persistent_id_disabled() is true.

Return type:: str

get_team_license_limit()

Team is already full. The organization has no available licenses.

Only call this if is_team_license_limit() is true.

Return type:: str

get_user_already_on_team()

User is already on this team. The provided email address is associated with a user who is already a member of (including in recoverable state) or invited to the team.

Only call this if is_user_already_on_team() is true.

Return type:: str

get_user_already_paired()

User is already paired.

Only call this if is_user_already_paired() is true.

Return type:: str

get_user_creation_failed()

User creation has failed.

Only call this if is_user_creation_failed() is true.

Return type:: str

get_user_migration_failed()

User migration has failed.

Only call this if is_user_migration_failed() is true.

Return type:: str

get_user_on_another_team()

User is already on another team. The provided email address is associated with a user that is already a member or invited to another team.

Only call this if is_user_on_another_team() is true.

Return type:: str

is_duplicate_external_member_id()

Check if the union tag is duplicate_external_member_id.

Return type:: bool

is_duplicate_member_persistent_id()

Check if the union tag is duplicate_member_persistent_id.

Return type:: bool

is_free_team_member_limit_reached()

Check if the union tag is free_team_member_limit_reached.

Return type:: bool

is_persistent_id_disabled()

Check if the union tag is persistent_id_disabled.

Return type:: bool

is_team_license_limit()

Check if the union tag is team_license_limit.

Return type:: bool

is_user_already_on_team()

Check if the union tag is user_already_on_team.

Return type:: bool

is_user_already_paired()

Check if the union tag is user_already_paired.

Return type:: bool

is_user_creation_failed()

Check if the union tag is user_creation_failed.

Return type:: bool

is_user_migration_failed()

Check if the union tag is user_migration_failed.

Return type:: bool

is_user_on_another_team()

Check if the union tag is user_on_another_team.

Return type:: bool

classmethod persistent_id_disabled(val)

Create an instance of this class set to the persistent_id_disabled tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod team_license_limit(val)

Create an instance of this class set to the team_license_limit tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod user_already_on_team(val)

Create an instance of this class set to the user_already_on_team tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod user_already_paired(val)

Create an instance of this class set to the user_already_paired tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod user_creation_failed(val)

Create an instance of this class set to the user_creation_failed tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod user_migration_failed(val)

Create an instance of this class set to the user_migration_failed tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

classmethod user_on_another_team(val)

Create an instance of this class set to the user_on_another_team tag with value val.

Parameters:: val (str) –
Return type:: MemberAddResultBase

class dropbox.team.MemberAddV2Arg(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None, role_ids=None)

Bases: MemberAddArgBase

__init__(member_email=None, member_given_name=None, member_surname=None, member_external_id=None, member_persistent_id=None, send_welcome_email=None, is_directory_restricted=None, role_ids=None)

role_ids

class dropbox.team.MemberAddV2Result(tag, value=None)

Bases: MemberAddResultBase

Describes the result of attempting to add a single user to the team. ‘success’ is the only value indicating that a user was indeed added to the team - the other values explain the type of failure that occurred, and include the email of the user for which the operation has failed.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: MemberAddV2Result.success (TeamMemberInfoV2) – Describes a user that was successfully added to the team.

get_success()

Describes a user that was successfully added to the team.

Only call this if is_success() is true.

Return type:: TeamMemberInfoV2

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = MemberAddV2Result('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (TeamMemberInfoV2) –
Return type:: MemberAddV2Result

class dropbox.team.MemberDevices(team_member_id=None, web_sessions=None, desktop_clients=None, mobile_clients=None)

Bases: Struct

Information on devices of a team’s member.

Variables:

team.MemberDevices.team_member_id – The member unique Id.
team.MemberDevices.web_sessions – List of web sessions made by this team member.
team.MemberDevices.desktop_clients – List of desktop clients by this team member.
team.MemberDevices.mobile_clients – List of mobile clients by this team member.

__init__(team_member_id=None, web_sessions=None, desktop_clients=None, mobile_clients=None)

desktop_clients

mobile_clients

team_member_id

web_sessions

class dropbox.team.MemberLinkedApps(team_member_id=None, linked_api_apps=None)

Bases: Struct

Information on linked applications of a team member.

Variables:

team.MemberLinkedApps.team_member_id – The member unique Id.
team.MemberLinkedApps.linked_api_apps – List of third party applications linked by this team member.

__init__(team_member_id=None, linked_api_apps=None)

linked_api_apps

team_member_id

class dropbox.team.MemberProfile(team_member_id=None, email=None, email_verified=None, status=None, name=None, membership_type=None, external_id=None, account_id=None, secondary_emails=None, invited_on=None, joined_on=None, suspended_on=None, persistent_id=None, is_directory_restricted=None, profile_photo_url=None)

Bases: Struct

Basic member profile.

Variables:

team.MemberProfile.team_member_id – ID of user as a member of a team.
team.MemberProfile.external_id – External ID that a team can attach to the user. An application using the API may find it easier to use their own IDs instead of Dropbox IDs like account_id or team_member_id.
team.MemberProfile.account_id – A user’s account identifier.
team.MemberProfile.email – Email address of user.
team.MemberProfile.email_verified – Is true if the user’s email is verified to be owned by the user.
team.MemberProfile.secondary_emails – Secondary emails of a user.
team.MemberProfile.status – The user’s status as a member of a specific team.
team.MemberProfile.name – Representations for a person’s name.
team.MemberProfile.membership_type – The user’s membership type: full (normal team member) vs limited (does not use a license; no access to the team’s shared quota).
team.MemberProfile.invited_on – The date and time the user was invited to the team (contains value only when the member’s status matches TeamMemberStatus.invited).
team.MemberProfile.joined_on – The date and time the user joined as a member of a specific team.
team.MemberProfile.suspended_on – The date and time the user was suspended from the team (contains value only when the member’s status matches TeamMemberStatus.suspended).
team.MemberProfile.persistent_id – Persistent ID that a team can attach to the user. The persistent ID is unique ID to be used for SAML authentication.
team.MemberProfile.is_directory_restricted – Whether the user is a directory restricted user.
team.MemberProfile.profile_photo_url – URL for the photo representing the user, if one is set.

__init__(team_member_id=None, email=None, email_verified=None, status=None, name=None, membership_type=None, external_id=None, account_id=None, secondary_emails=None, invited_on=None, joined_on=None, suspended_on=None, persistent_id=None, is_directory_restricted=None, profile_photo_url=None)

account_id

email

email_verified

external_id

invited_on

is_directory_restricted

joined_on

membership_type

name

persistent_id

profile_photo_url

secondary_emails

status

suspended_on

team_member_id

class dropbox.team.MemberSelectorError(tag, value=None)

Bases: UserSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MemberSelectorError.user_not_in_team – The user is not a member of the team.

is_user_not_in_team()

Check if the union tag is user_not_in_team.

Return type:: bool

user_not_in_team = MemberSelectorError('user_not_in_team', None)

class dropbox.team.MembersAddArg(new_members=None, force_async=None)

Bases: MembersAddArgBase

Variables:: team.MembersAddArg.new_members – Details of new members to be added to the team.

__init__(new_members=None, force_async=None)

new_members

class dropbox.team.MembersAddArgBase(force_async=None)

Bases: Struct

Variables:: team.MembersAddArgBase.force_async – Whether to force the add to happen asynchronously.

__init__(force_async=None)

force_async

class dropbox.team.MembersAddJobStatus(tag, value=None)

Bases: PollResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersAddJobStatus.complete (list of [MemberAddResult]) – The asynchronous job has finished. For each member that was specified in the parameter :type:`MembersAddArg` that was provided to :route:`members/add`, a corresponding item is returned in this list.
team.MembersAddJobStatus.failed (str) – The asynchronous job returned an error. The string contains an error message.

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (list of [MemberAddResult]) –
Return type:: MembersAddJobStatus

classmethod failed(val)

Create an instance of this class set to the failed tag with value val.

Parameters:: val (str) –
Return type:: MembersAddJobStatus

get_complete()

The asynchronous job has finished. For each member that was specified in the parameter MembersAddArg that was provided to dropbox.dropbox_client.Dropbox.team_members_add(), a corresponding item is returned in this list.

Only call this if is_complete() is true.

Return type:: list of [MemberAddResult]

get_failed()

The asynchronous job returned an error. The string contains an error message.

Only call this if is_failed() is true.

Return type:: str

is_complete()

Check if the union tag is complete.

Return type:: bool

is_failed()

Check if the union tag is failed.

Return type:: bool

class dropbox.team.MembersAddJobStatusV2Result(tag, value=None)

Bases: PollResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersAddJobStatusV2Result.complete (list of [MemberAddV2Result]) – The asynchronous job has finished. For each member that was specified in the parameter :type:`MembersAddArg` that was provided to :route:`members/add:2`, a corresponding item is returned in this list.
team.MembersAddJobStatusV2Result.failed (str) – The asynchronous job returned an error. The string contains an error message.

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (list of [MemberAddV2Result]) –
Return type:: MembersAddJobStatusV2Result

classmethod failed(val)

Create an instance of this class set to the failed tag with value val.

Parameters:: val (str) –
Return type:: MembersAddJobStatusV2Result

get_complete()

The asynchronous job has finished. For each member that was specified in the parameter MembersAddArg that was provided to dropbox.dropbox_client.Dropbox.team_members_add(), a corresponding item is returned in this list.

Only call this if is_complete() is true.

Return type:: list of [MemberAddV2Result]

get_failed()

The asynchronous job returned an error. The string contains an error message.

Only call this if is_failed() is true.

Return type:: str

is_complete()

Check if the union tag is complete.

Return type:: bool

is_failed()

Check if the union tag is failed.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersAddJobStatusV2Result('other', None)

class dropbox.team.MembersAddLaunch(tag, value=None)

Bases: LaunchResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (list of [MemberAddResult]) –
Return type:: MembersAddLaunch

get_complete()

Only call this if is_complete() is true.

Return type:: list of [MemberAddResult]

is_complete()

Check if the union tag is complete.

Return type:: bool

class dropbox.team.MembersAddLaunchV2Result(tag, value=None)

Bases: LaunchResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (list of [MemberAddV2Result]) –
Return type:: MembersAddLaunchV2Result

get_complete()

Only call this if is_complete() is true.

Return type:: list of [MemberAddV2Result]

is_complete()

Check if the union tag is complete.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersAddLaunchV2Result('other', None)

class dropbox.team.MembersAddV2Arg(new_members=None, force_async=None)

Bases: MembersAddArgBase

Variables:: team.MembersAddV2Arg.new_members – Details of new members to be added to the team.

__init__(new_members=None, force_async=None)

new_members

class dropbox.team.MembersDataTransferArg(user=None, transfer_dest_id=None, transfer_admin_id=None)

Bases: MembersDeactivateBaseArg

Variables:

team.MembersDataTransferArg.transfer_dest_id – Files from the deleted member account will be transferred to this user.
team.MembersDataTransferArg.transfer_admin_id – Errors during the transfer process will be sent via email to this user.

__init__(user=None, transfer_dest_id=None, transfer_admin_id=None)

transfer_admin_id

transfer_dest_id

class dropbox.team.MembersDeactivateArg(user=None, wipe_data=None)

Bases: MembersDeactivateBaseArg

Variables:: team.MembersDeactivateArg.wipe_data – If provided, controls if the user’s data will be deleted on their linked devices.

__init__(user=None, wipe_data=None)

wipe_data

class dropbox.team.MembersDeactivateBaseArg(user=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account.

Variables:: team.MembersDeactivateBaseArg.user – Identity of user to remove/suspend/have their files moved.

__init__(user=None)

user

class dropbox.team.MembersDeactivateError(tag, value=None)

Bases: UserSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MembersDeactivateError.user_not_in_team – The user is not a member of the team.

is_other()

Check if the union tag is other.

Return type:: bool

is_user_not_in_team()

Check if the union tag is user_not_in_team.

Return type:: bool

other = MembersDeactivateError('other', None)

user_not_in_team = MembersDeactivateError('user_not_in_team', None)

class dropbox.team.MembersDeleteProfilePhotoArg(user=None)

Bases: Struct

Variables:: team.MembersDeleteProfilePhotoArg.user – Identity of the user whose profile photo will be deleted.

__init__(user=None)

user

class dropbox.team.MembersDeleteProfilePhotoError(tag, value=None)

Bases: MemberSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MembersDeleteProfilePhotoError.set_profile_disallowed – Modifying deleted users is not allowed.

is_other()

Check if the union tag is other.

Return type:: bool

is_set_profile_disallowed()

Check if the union tag is set_profile_disallowed.

Return type:: bool

other = MembersDeleteProfilePhotoError('other', None)

set_profile_disallowed = MembersDeleteProfilePhotoError('set_profile_disallowed', None)

class dropbox.team.MembersGetAvailableTeamMemberRolesResult(roles=None)

Bases: Struct

Available TeamMemberRole for the connected team. To be used with dropbox.dropbox_client.Dropbox.team_members_set_admin_permissions().

Variables:: team.MembersGetAvailableTeamMemberRolesResult.roles – Available roles.

__init__(roles=None)

roles

class dropbox.team.MembersGetInfoArgs(members=None)

Bases: Struct

Variables:: team.MembersGetInfoArgs.members – List of team members.

__init__(members=None)

members

class dropbox.team.MembersGetInfoError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersGetInfoError('other', None)

class dropbox.team.MembersGetInfoItem(tag, value=None)

Bases: MembersGetInfoItemBase

Describes a result obtained for a single user whose id was specified in the parameter of dropbox.dropbox_client.Dropbox.team_members_get_info().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: MembersGetInfoItem.member_info (TeamMemberInfo) – Info about a team member.

get_member_info()

Info about a team member.

Only call this if is_member_info() is true.

Return type:: TeamMemberInfo

is_member_info()

Check if the union tag is member_info.

Return type:: bool

classmethod member_info(val)

Create an instance of this class set to the member_info tag with value val.

Parameters:: val (TeamMemberInfo) –
Return type:: MembersGetInfoItem

class dropbox.team.MembersGetInfoItemBase(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MembersGetInfoItemBase.id_not_found (str) – An ID that was provided as a parameter to :route:`members/get_info` or :route:`members/get_info:2`, and did not match a corresponding user. This might be a team_member_id, an email, or an external ID, depending on how the method was called.

get_id_not_found()

An ID that was provided as a parameter to dropbox.dropbox_client.Dropbox.team_members_get_info() or dropbox.dropbox_client.Dropbox.team_members_get_info(), and did not match a corresponding user. This might be a team_member_id, an email, or an external ID, depending on how the method was called.

Only call this if is_id_not_found() is true.

Return type:: str

classmethod id_not_found(val)

Create an instance of this class set to the id_not_found tag with value val.

Parameters:: val (str) –
Return type:: MembersGetInfoItemBase

is_id_not_found()

Check if the union tag is id_not_found.

Return type:: bool

class dropbox.team.MembersGetInfoItemV2(tag, value=None)

Bases: MembersGetInfoItemBase

Describes a result obtained for a single user whose id was specified in the parameter of dropbox.dropbox_client.Dropbox.team_members_get_info().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: MembersGetInfoItemV2.member_info (TeamMemberInfoV2) – Info about a team member.

get_member_info()

Info about a team member.

Only call this if is_member_info() is true.

Return type:: TeamMemberInfoV2

is_member_info()

Check if the union tag is member_info.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

classmethod member_info(val)

Create an instance of this class set to the member_info tag with value val.

Parameters:: val (TeamMemberInfoV2) –
Return type:: MembersGetInfoItemV2

other = MembersGetInfoItemV2('other', None)

class dropbox.team.MembersGetInfoV2Arg(members=None)

Bases: Struct

Variables:: team.MembersGetInfoV2Arg.members – List of team members.

__init__(members=None)

members

class dropbox.team.MembersGetInfoV2Result(members_info=None)

Bases: Struct

Variables:: team.MembersGetInfoV2Result.members_info – List of team members info.

__init__(members_info=None)

members_info

class dropbox.team.MembersInfo(team_member_ids=None, permanently_deleted_users=None)

Bases: Struct

Variables:

team.MembersInfo.team_member_ids – Team member IDs of the users under this hold.
team.MembersInfo.permanently_deleted_users – The number of permanently deleted users that were under this hold.

__init__(team_member_ids=None, permanently_deleted_users=None)

permanently_deleted_users

team_member_ids

class dropbox.team.MembersListArg(limit=None, include_removed=None)

Bases: Struct

Variables:

team.MembersListArg.limit – Number of results to return per call.
team.MembersListArg.include_removed – Whether to return removed members.

__init__(limit=None, include_removed=None)

include_removed

limit

class dropbox.team.MembersListContinueArg(cursor=None)

Bases: Struct

Variables:: team.MembersListContinueArg.cursor – Indicates from what point to get the next set of members.

__init__(cursor=None)

cursor

class dropbox.team.MembersListContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MembersListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = MembersListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersListContinueError('other', None)

class dropbox.team.MembersListError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersListError('other', None)

class dropbox.team.MembersListResult(members=None, cursor=None, has_more=None)

Bases: Struct

Variables:

team.MembersListResult.members – List of team members.
team.MembersListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_members_list_continue() to obtain the additional members.
team.MembersListResult.has_more – Is true if there are additional team members that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_members_list_continue() can retrieve them.

__init__(members=None, cursor=None, has_more=None)

cursor

has_more

members

class dropbox.team.MembersListV2Result(members=None, cursor=None, has_more=None)

Bases: Struct

Variables:

team.MembersListV2Result.members – List of team members.
team.MembersListV2Result.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_members_list_continue() to obtain the additional members.
team.MembersListV2Result.has_more – Is true if there are additional team members that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_members_list_continue() can retrieve them.

__init__(members=None, cursor=None, has_more=None)

cursor

has_more

members

class dropbox.team.MembersRecoverArg(user=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account.

Variables:: team.MembersRecoverArg.user – Identity of user to recover.

__init__(user=None)

user

class dropbox.team.MembersRecoverError(tag, value=None)

Bases: UserSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersRecoverError.user_unrecoverable – The user is not recoverable.
team.MembersRecoverError.user_not_in_team – The user is not a member of the team.
team.MembersRecoverError.team_license_limit – Team is full. The organization has no available licenses.

is_other()

Check if the union tag is other.

Return type:: bool

is_team_license_limit()

Check if the union tag is team_license_limit.

Return type:: bool

is_user_not_in_team()

Check if the union tag is user_not_in_team.

Return type:: bool

is_user_unrecoverable()

Check if the union tag is user_unrecoverable.

Return type:: bool

other = MembersRecoverError('other', None)

team_license_limit = MembersRecoverError('team_license_limit', None)

user_not_in_team = MembersRecoverError('user_not_in_team', None)

user_unrecoverable = MembersRecoverError('user_unrecoverable', None)

class dropbox.team.MembersRemoveArg(user=None, wipe_data=None, transfer_dest_id=None, transfer_admin_id=None, keep_account=None, retain_team_shares=None)

Bases: MembersDeactivateArg

Variables:

team.MembersRemoveArg.transfer_dest_id – If provided, files from the deleted member account will be transferred to this user.
team.MembersRemoveArg.transfer_admin_id – If provided, errors during the transfer process will be sent via email to this user. If the transfer_dest_id argument was provided, then this argument must be provided as well.
team.MembersRemoveArg.keep_account – Downgrade the member to a Basic account. The user will retain the email address associated with their Dropbox account and data in their account that is not restricted to team members. In order to keep the account the argument wipe_data should be set to False.
team.MembersRemoveArg.retain_team_shares – If provided, allows removed users to keep access to Dropbox folders (not Dropbox Paper folders) already explicitly shared with them (not via a group) when they are downgraded to a Basic account. Users will not retain access to folders that do not allow external sharing. In order to keep the sharing relationships, the arguments wipe_data should be set to False and keep_account should be set to True.

__init__(user=None, wipe_data=None, transfer_dest_id=None, transfer_admin_id=None, keep_account=None, retain_team_shares=None)

keep_account

retain_team_shares

transfer_admin_id

transfer_dest_id

class dropbox.team.MembersRemoveError(tag, value=None)

Bases: MembersTransferFilesError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersRemoveError.remove_last_admin – The user is the last admin of the team, so it cannot be removed from it.
team.MembersRemoveError.cannot_keep_account_and_transfer – Cannot keep account and transfer the data to another user at the same time.
team.MembersRemoveError.cannot_keep_account_and_delete_data – Cannot keep account and delete the data at the same time. To keep the account the argument wipe_data should be set to False.
team.MembersRemoveError.email_address_too_long_to_be_disabled – The email address of the user is too long to be disabled.
team.MembersRemoveError.cannot_keep_invited_user_account – Cannot keep account of an invited user.
team.MembersRemoveError.cannot_retain_shares_when_data_wiped – Cannot retain team shares when the user’s data is marked for deletion on their linked devices. The argument wipe_data should be set to False.
team.MembersRemoveError.cannot_retain_shares_when_no_account_kept – The user’s account must be kept in order to retain team shares. The argument keep_account should be set to True.

:ivar: team.MembersRemoveError.cannot_retain_shares_when_team_external_sharing_off: Externally sharing files, folders, and links must be enabled in team settings in order to retain team shares for the user.

Variables:

team.MembersRemoveError.cannot_keep_account – Only a team admin, can convert this account to a Basic account.
team.MembersRemoveError.cannot_keep_account_under_legal_hold – This user content is currently being held. To convert this member’s account to a Basic account, you’ll first need to remove them from the hold.
team.MembersRemoveError.cannot_keep_account_required_to_sign_tos – To convert this member to a Basic account, they’ll first need to sign in to Dropbox and agree to the terms of service.

cannot_keep_account = MembersRemoveError('cannot_keep_account', None)

cannot_keep_account_and_delete_data = MembersRemoveError('cannot_keep_account_and_delete_data', None)

cannot_keep_account_and_transfer = MembersRemoveError('cannot_keep_account_and_transfer', None)

cannot_keep_account_required_to_sign_tos = MembersRemoveError('cannot_keep_account_required_to_sign_tos', None)

cannot_keep_account_under_legal_hold = MembersRemoveError('cannot_keep_account_under_legal_hold', None)

cannot_keep_invited_user_account = MembersRemoveError('cannot_keep_invited_user_account', None)

cannot_retain_shares_when_data_wiped = MembersRemoveError('cannot_retain_shares_when_data_wiped', None)

cannot_retain_shares_when_no_account_kept = MembersRemoveError('cannot_retain_shares_when_no_account_kept', None)

cannot_retain_shares_when_team_external_sharing_off = MembersRemoveError('cannot_retain_shares_when_team_external_sharing_off', None)

email_address_too_long_to_be_disabled = MembersRemoveError('email_address_too_long_to_be_disabled', None)

is_cannot_keep_account()

Check if the union tag is cannot_keep_account.

Return type:: bool

is_cannot_keep_account_and_delete_data()

Check if the union tag is cannot_keep_account_and_delete_data.

Return type:: bool

is_cannot_keep_account_and_transfer()

Check if the union tag is cannot_keep_account_and_transfer.

Return type:: bool

is_cannot_keep_account_required_to_sign_tos()

Check if the union tag is cannot_keep_account_required_to_sign_tos.

Return type:: bool

is_cannot_keep_account_under_legal_hold()

Check if the union tag is cannot_keep_account_under_legal_hold.

Return type:: bool

is_cannot_keep_invited_user_account()

Check if the union tag is cannot_keep_invited_user_account.

Return type:: bool

is_cannot_retain_shares_when_data_wiped()

Check if the union tag is cannot_retain_shares_when_data_wiped.

Return type:: bool

is_cannot_retain_shares_when_no_account_kept()

Check if the union tag is cannot_retain_shares_when_no_account_kept.

Return type:: bool

is_cannot_retain_shares_when_team_external_sharing_off()

Check if the union tag is cannot_retain_shares_when_team_external_sharing_off.

Return type:: bool

is_email_address_too_long_to_be_disabled()

Check if the union tag is email_address_too_long_to_be_disabled.

Return type:: bool

is_remove_last_admin()

Check if the union tag is remove_last_admin.

Return type:: bool

remove_last_admin = MembersRemoveError('remove_last_admin', None)

class dropbox.team.MembersSendWelcomeError(tag, value=None)

Bases: MemberSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = MembersSendWelcomeError('other', None)

class dropbox.team.MembersSetPermissions2Arg(user=None, new_roles=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account.

Variables:

team.MembersSetPermissions2Arg.user – Identity of user whose role will be set.
team.MembersSetPermissions2Arg.new_roles – The new roles for the member. Send empty list to make user member only. For now, only up to one role is allowed.

__init__(user=None, new_roles=None)

new_roles

user

class dropbox.team.MembersSetPermissions2Error(tag, value=None)

Bases: UserSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersSetPermissions2Error.last_admin – Cannot remove the admin setting of the last admin.
team.MembersSetPermissions2Error.user_not_in_team – The user is not a member of the team.
team.MembersSetPermissions2Error.cannot_set_permissions – Cannot remove/grant permissions. This can happen if the team member is suspended.
team.MembersSetPermissions2Error.role_not_found – No matching role found. At least one of the provided new_roles does not exist on this team.

cannot_set_permissions = MembersSetPermissions2Error('cannot_set_permissions', None)

is_cannot_set_permissions()

Check if the union tag is cannot_set_permissions.

Return type:: bool

is_last_admin()

Check if the union tag is last_admin.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_role_not_found()

Check if the union tag is role_not_found.

Return type:: bool

is_user_not_in_team()

Check if the union tag is user_not_in_team.

Return type:: bool

last_admin = MembersSetPermissions2Error('last_admin', None)

other = MembersSetPermissions2Error('other', None)

role_not_found = MembersSetPermissions2Error('role_not_found', None)

user_not_in_team = MembersSetPermissions2Error('user_not_in_team', None)

class dropbox.team.MembersSetPermissions2Result(team_member_id=None, roles=None)

Bases: Struct

Variables:

team.MembersSetPermissions2Result.team_member_id – The member ID of the user to which the change was applied.
team.MembersSetPermissions2Result.roles – The roles after the change. Empty in case the user become a non-admin.

__init__(team_member_id=None, roles=None)

roles

team_member_id

class dropbox.team.MembersSetPermissionsArg(user=None, new_role=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account.

Variables:

team.MembersSetPermissionsArg.user – Identity of user whose role will be set.
team.MembersSetPermissionsArg.new_role – The new role of the member.

__init__(user=None, new_role=None)

new_role

user

class dropbox.team.MembersSetPermissionsError(tag, value=None)

Bases: UserSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersSetPermissionsError.last_admin – Cannot remove the admin setting of the last admin.
team.MembersSetPermissionsError.user_not_in_team – The user is not a member of the team.
team.MembersSetPermissionsError.cannot_set_permissions – Cannot remove/grant permissions.
team.MembersSetPermissionsError.team_license_limit – Team is full. The organization has no available licenses.

cannot_set_permissions = MembersSetPermissionsError('cannot_set_permissions', None)

is_cannot_set_permissions()

Check if the union tag is cannot_set_permissions.

Return type:: bool

is_last_admin()

Check if the union tag is last_admin.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_team_license_limit()

Check if the union tag is team_license_limit.

Return type:: bool

is_user_not_in_team()

Check if the union tag is user_not_in_team.

Return type:: bool

last_admin = MembersSetPermissionsError('last_admin', None)

other = MembersSetPermissionsError('other', None)

team_license_limit = MembersSetPermissionsError('team_license_limit', None)

user_not_in_team = MembersSetPermissionsError('user_not_in_team', None)

class dropbox.team.MembersSetPermissionsResult(team_member_id=None, role=None)

Bases: Struct

Variables:

team.MembersSetPermissionsResult.team_member_id – The member ID of the user to which the change was applied.
team.MembersSetPermissionsResult.role – The role after the change.

__init__(team_member_id=None, role=None)

role

team_member_id

class dropbox.team.MembersSetProfileArg(user=None, new_email=None, new_external_id=None, new_given_name=None, new_surname=None, new_persistent_id=None, new_is_directory_restricted=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account. At least one of new_email, new_external_id, new_given_name, and/or new_surname must be provided.

Variables:

team.MembersSetProfileArg.user – Identity of user whose profile will be set.
team.MembersSetProfileArg.new_email – New email for member.
team.MembersSetProfileArg.new_external_id – New external ID for member.
team.MembersSetProfileArg.new_given_name – New given name for member.
team.MembersSetProfileArg.new_surname – New surname for member.
team.MembersSetProfileArg.new_persistent_id – New persistent ID. This field only available to teams using persistent ID SAML configuration.
team.MembersSetProfileArg.new_is_directory_restricted – New value for whether the user is a directory restricted user.

__init__(user=None, new_email=None, new_external_id=None, new_given_name=None, new_surname=None, new_persistent_id=None, new_is_directory_restricted=None)

new_email

new_external_id

new_given_name

new_is_directory_restricted

new_persistent_id

new_surname

user

class dropbox.team.MembersSetProfileError(tag, value=None)

Bases: MemberSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersSetProfileError.external_id_and_new_external_id_unsafe – It is unsafe to use both external_id and new_external_id.
team.MembersSetProfileError.no_new_data_specified – None of new_email, new_given_name, new_surname, or new_external_id are specified.
team.MembersSetProfileError.email_reserved_for_other_user – Email is already reserved for another user.
team.MembersSetProfileError.external_id_used_by_other_user – The external ID is already in use by another team member.
team.MembersSetProfileError.set_profile_disallowed – Modifying deleted users is not allowed.
team.MembersSetProfileError.param_cannot_be_empty – Parameter new_email cannot be empty.
team.MembersSetProfileError.persistent_id_disabled – Persistent ID is only available to teams with persistent ID SAML configuration. Please contact Dropbox for more information.
team.MembersSetProfileError.persistent_id_used_by_other_user – The persistent ID is already in use by another team member.
team.MembersSetProfileError.directory_restricted_off – Directory Restrictions option is not available.

directory_restricted_off = MembersSetProfileError('directory_restricted_off', None)

email_reserved_for_other_user = MembersSetProfileError('email_reserved_for_other_user', None)

external_id_and_new_external_id_unsafe = MembersSetProfileError('external_id_and_new_external_id_unsafe', None)

external_id_used_by_other_user = MembersSetProfileError('external_id_used_by_other_user', None)

is_directory_restricted_off()

Check if the union tag is directory_restricted_off.

Return type:: bool

is_email_reserved_for_other_user()

Check if the union tag is email_reserved_for_other_user.

Return type:: bool

is_external_id_and_new_external_id_unsafe()

Check if the union tag is external_id_and_new_external_id_unsafe.

Return type:: bool

is_external_id_used_by_other_user()

Check if the union tag is external_id_used_by_other_user.

Return type:: bool

is_no_new_data_specified()

Check if the union tag is no_new_data_specified.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_param_cannot_be_empty()

Check if the union tag is param_cannot_be_empty.

Return type:: bool

is_persistent_id_disabled()

Check if the union tag is persistent_id_disabled.

Return type:: bool

is_persistent_id_used_by_other_user()

Check if the union tag is persistent_id_used_by_other_user.

Return type:: bool

is_set_profile_disallowed()

Check if the union tag is set_profile_disallowed.

Return type:: bool

no_new_data_specified = MembersSetProfileError('no_new_data_specified', None)

other = MembersSetProfileError('other', None)

param_cannot_be_empty = MembersSetProfileError('param_cannot_be_empty', None)

persistent_id_disabled = MembersSetProfileError('persistent_id_disabled', None)

persistent_id_used_by_other_user = MembersSetProfileError('persistent_id_used_by_other_user', None)

set_profile_disallowed = MembersSetProfileError('set_profile_disallowed', None)

class dropbox.team.MembersSetProfilePhotoArg(user=None, photo=None)

Bases: Struct

Variables:

team.MembersSetProfilePhotoArg.user – Identity of the user whose profile photo will be set.
team.MembersSetProfilePhotoArg.photo – Image to set as the member’s new profile photo.

__init__(user=None, photo=None)

photo

user

class dropbox.team.MembersSetProfilePhotoError(tag, value=None)

Bases: MemberSelectorError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.MembersSetProfilePhotoError.set_profile_disallowed – Modifying deleted users is not allowed.

get_photo_error()

Only call this if is_photo_error() is true.

Return type:: account.SetProfilePhotoError

is_other()

Check if the union tag is other.

Return type:: bool

is_photo_error()

Check if the union tag is photo_error.

Return type:: bool

is_set_profile_disallowed()

Check if the union tag is set_profile_disallowed.

Return type:: bool

other = MembersSetProfilePhotoError('other', None)

classmethod photo_error(val)

Create an instance of this class set to the photo_error tag with value val.

Parameters:: val (account.SetProfilePhotoError) –
Return type:: MembersSetProfilePhotoError

set_profile_disallowed = MembersSetProfilePhotoError('set_profile_disallowed', None)

class dropbox.team.MembersSuspendError(tag, value=None)

Bases: MembersDeactivateError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersSuspendError.suspend_inactive_user – The user is not active, so it cannot be suspended.
team.MembersSuspendError.suspend_last_admin – The user is the last admin of the team, so it cannot be suspended.
team.MembersSuspendError.team_license_limit – Team is full. The organization has no available licenses.

is_suspend_inactive_user()

Check if the union tag is suspend_inactive_user.

Return type:: bool

is_suspend_last_admin()

Check if the union tag is suspend_last_admin.

Return type:: bool

is_team_license_limit()

Check if the union tag is team_license_limit.

Return type:: bool

suspend_inactive_user = MembersSuspendError('suspend_inactive_user', None)

suspend_last_admin = MembersSuspendError('suspend_last_admin', None)

team_license_limit = MembersSuspendError('team_license_limit', None)

class dropbox.team.MembersTransferFilesError(tag, value=None)

Bases: MembersDeactivateError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar: team.MembersTransferFilesError.removed_and_transfer_dest_should_differ: Expected removed user and transfer_dest user to be different.
:ivar: team.MembersTransferFilesError.removed_and_transfer_admin_should_differ: Expected removed user and transfer_admin user to be different.

Variables:

team.MembersTransferFilesError.transfer_dest_user_not_found – No matching user found for the argument transfer_dest_id.
team.MembersTransferFilesError.transfer_dest_user_not_in_team – The provided transfer_dest_id does not exist on this team.
team.MembersTransferFilesError.transfer_admin_user_not_in_team – The provided transfer_admin_id does not exist on this team.
team.MembersTransferFilesError.transfer_admin_user_not_found – No matching user found for the argument transfer_admin_id.
team.MembersTransferFilesError.unspecified_transfer_admin_id – The transfer_admin_id argument must be provided when file transfer is requested.
team.MembersTransferFilesError.transfer_admin_is_not_admin – Specified transfer_admin user is not a team admin.
team.MembersTransferFilesError.recipient_not_verified – The recipient user’s email is not verified.

is_recipient_not_verified()

Check if the union tag is recipient_not_verified.

Return type:: bool

is_removed_and_transfer_admin_should_differ()

Check if the union tag is removed_and_transfer_admin_should_differ.

Return type:: bool

is_removed_and_transfer_dest_should_differ()

Check if the union tag is removed_and_transfer_dest_should_differ.

Return type:: bool

is_transfer_admin_is_not_admin()

Check if the union tag is transfer_admin_is_not_admin.

Return type:: bool

is_transfer_admin_user_not_found()

Check if the union tag is transfer_admin_user_not_found.

Return type:: bool

is_transfer_admin_user_not_in_team()

Check if the union tag is transfer_admin_user_not_in_team.

Return type:: bool

is_transfer_dest_user_not_found()

Check if the union tag is transfer_dest_user_not_found.

Return type:: bool

is_transfer_dest_user_not_in_team()

Check if the union tag is transfer_dest_user_not_in_team.

Return type:: bool

is_unspecified_transfer_admin_id()

Check if the union tag is unspecified_transfer_admin_id.

Return type:: bool

recipient_not_verified = MembersTransferFilesError('recipient_not_verified', None)

removed_and_transfer_admin_should_differ = MembersTransferFilesError('removed_and_transfer_admin_should_differ', None)

removed_and_transfer_dest_should_differ = MembersTransferFilesError('removed_and_transfer_dest_should_differ', None)

transfer_admin_is_not_admin = MembersTransferFilesError('transfer_admin_is_not_admin', None)

transfer_admin_user_not_found = MembersTransferFilesError('transfer_admin_user_not_found', None)

transfer_admin_user_not_in_team = MembersTransferFilesError('transfer_admin_user_not_in_team', None)

transfer_dest_user_not_found = MembersTransferFilesError('transfer_dest_user_not_found', None)

transfer_dest_user_not_in_team = MembersTransferFilesError('transfer_dest_user_not_in_team', None)

unspecified_transfer_admin_id = MembersTransferFilesError('unspecified_transfer_admin_id', None)

class dropbox.team.MembersTransferFormerMembersFilesError(tag, value=None)

Bases: MembersTransferFilesError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar: team.MembersTransferFormerMembersFilesError.user_data_is_being_transferred: The user’s data is being transferred. Please wait some time before retrying.

Variables:: team.MembersTransferFormerMembersFilesError.user_not_removed – No matching removed user found for the argument user.

:ivar: team.MembersTransferFormerMembersFilesError.user_data_cannot_be_transferred: User files aren’t transferable anymore.
:ivar: team.MembersTransferFormerMembersFilesError.user_data_already_transferred: User’s data has already been transferred to another user.

is_user_data_already_transferred()

Check if the union tag is user_data_already_transferred.

Return type:: bool

is_user_data_cannot_be_transferred()

Check if the union tag is user_data_cannot_be_transferred.

Return type:: bool

is_user_data_is_being_transferred()

Check if the union tag is user_data_is_being_transferred.

Return type:: bool

is_user_not_removed()

Check if the union tag is user_not_removed.

Return type:: bool

user_data_already_transferred = MembersTransferFormerMembersFilesError('user_data_already_transferred', None)

user_data_cannot_be_transferred = MembersTransferFormerMembersFilesError('user_data_cannot_be_transferred', None)

user_data_is_being_transferred = MembersTransferFormerMembersFilesError('user_data_is_being_transferred', None)

user_not_removed = MembersTransferFormerMembersFilesError('user_not_removed', None)

class dropbox.team.MembersUnsuspendArg(user=None)

Bases: Struct

Exactly one of team_member_id, email, or external_id must be provided to identify the user account.

Variables:: team.MembersUnsuspendArg.user – Identity of user to unsuspend.

__init__(user=None)

user

class dropbox.team.MembersUnsuspendError(tag, value=None)

Bases: MembersDeactivateError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MembersUnsuspendError.unsuspend_non_suspended_member – The user is unsuspended, so it cannot be unsuspended again.
team.MembersUnsuspendError.team_license_limit – Team is full. The organization has no available licenses.

is_team_license_limit()

Check if the union tag is team_license_limit.

Return type:: bool

is_unsuspend_non_suspended_member()

Check if the union tag is unsuspend_non_suspended_member.

Return type:: bool

team_license_limit = MembersUnsuspendError('team_license_limit', None)

unsuspend_non_suspended_member = MembersUnsuspendError('unsuspend_non_suspended_member', None)

class dropbox.team.MobileClientPlatform(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.MobileClientPlatform.iphone – Official Dropbox iPhone client.
team.MobileClientPlatform.ipad – Official Dropbox iPad client.
team.MobileClientPlatform.android – Official Dropbox Android client.
team.MobileClientPlatform.windows_phone – Official Dropbox Windows phone client.
team.MobileClientPlatform.blackberry – Official Dropbox Blackberry client.

android = MobileClientPlatform('android', None)

blackberry = MobileClientPlatform('blackberry', None)

ipad = MobileClientPlatform('ipad', None)

iphone = MobileClientPlatform('iphone', None)

is_android()

Check if the union tag is android.

Return type:: bool

is_blackberry()

Check if the union tag is blackberry.

Return type:: bool

is_ipad()

Check if the union tag is ipad.

Return type:: bool

is_iphone()

Check if the union tag is iphone.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_windows_phone()

Check if the union tag is windows_phone.

Return type:: bool

other = MobileClientPlatform('other', None)

windows_phone = MobileClientPlatform('windows_phone', None)

class dropbox.team.MobileClientSession(session_id=None, device_name=None, client_type=None, ip_address=None, country=None, created=None, updated=None, client_version=None, os_version=None, last_carrier=None)

Bases: DeviceSession

Information about linked Dropbox mobile client sessions.

Variables:

team.MobileClientSession.device_name – The device name.
team.MobileClientSession.client_type – The mobile application type.
team.MobileClientSession.client_version – The dropbox client version.
team.MobileClientSession.os_version – The hosting OS version.
team.MobileClientSession.last_carrier – last carrier used by the device.

__init__(session_id=None, device_name=None, client_type=None, ip_address=None, country=None, created=None, updated=None, client_version=None, os_version=None, last_carrier=None)

client_type

client_version

device_name

last_carrier

os_version

class dropbox.team.NamespaceMetadata(name=None, namespace_id=None, namespace_type=None, team_member_id=None)

Bases: Struct

Properties of a namespace.

Variables:

team.NamespaceMetadata.name – The name of this namespace.
team.NamespaceMetadata.namespace_id – The ID of this namespace.
team.NamespaceMetadata.namespace_type – The type of this namespace.
team.NamespaceMetadata.team_member_id – If this is a team member or app folder, the ID of the owning team member. Otherwise, this field is not present.

__init__(name=None, namespace_id=None, namespace_type=None, team_member_id=None)

name

namespace_id

namespace_type

team_member_id

class dropbox.team.NamespaceType(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.NamespaceType.app_folder – App sandbox folder.
team.NamespaceType.shared_folder – Shared folder.
team.NamespaceType.team_folder – Top-level team-owned folder.
team.NamespaceType.team_member_folder – Team member’s home folder.

app_folder = NamespaceType('app_folder', None)

is_app_folder()

Check if the union tag is app_folder.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_shared_folder()

Check if the union tag is shared_folder.

Return type:: bool

is_team_folder()

Check if the union tag is team_folder.

Return type:: bool

is_team_member_folder()

Check if the union tag is team_member_folder.

Return type:: bool

other = NamespaceType('other', None)

shared_folder = NamespaceType('shared_folder', None)

team_folder = NamespaceType('team_folder', None)

team_member_folder = NamespaceType('team_member_folder', None)

class dropbox.team.RemoveCustomQuotaResult(tag, value=None)

Bases: Union

User result for setting member custom quota.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

RemoveCustomQuotaResult.success (UserSelectorArg) – Successfully removed user.
RemoveCustomQuotaResult.invalid_user (UserSelectorArg) – Invalid user (not in team).

get_invalid_user()

Invalid user (not in team).

Only call this if is_invalid_user() is true.

Return type:: UserSelectorArg

get_success()

Successfully removed user.

Only call this if is_success() is true.

Return type:: UserSelectorArg

classmethod invalid_user(val)

Create an instance of this class set to the invalid_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: RemoveCustomQuotaResult

is_invalid_user()

Check if the union tag is invalid_user.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = RemoveCustomQuotaResult('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: RemoveCustomQuotaResult

class dropbox.team.RemovedStatus(is_recoverable=None, is_disconnected=None)

Bases: Struct

Variables:

team.RemovedStatus.is_recoverable – True if the removed team member is recoverable.
team.RemovedStatus.is_disconnected – True if the team member’s account was converted to individual account.

__init__(is_recoverable=None, is_disconnected=None)

is_disconnected

is_recoverable

class dropbox.team.ResendSecondaryEmailResult(tag, value=None)

Bases: Union

Result of trying to resend verification email to a secondary email address. ‘success’ is the only value indicating that a verification email was successfully sent. The other values explain the type of error that occurred, and include the email for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.ResendSecondaryEmailResult.success (str) – A verification email was successfully sent to the secondary email address.
team.ResendSecondaryEmailResult.not_pending (str) – This secondary email address is not pending for the user.
team.ResendSecondaryEmailResult.rate_limited (str) – Too many emails are being sent to this email address. Please try again later.

get_not_pending()

This secondary email address is not pending for the user.

Only call this if is_not_pending() is true.

Return type:: str

get_rate_limited()

Too many emails are being sent to this email address. Please try again later.

Only call this if is_rate_limited() is true.

Return type:: str

get_success()

A verification email was successfully sent to the secondary email address.

Only call this if is_success() is true.

Return type:: str

is_not_pending()

Check if the union tag is not_pending.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_rate_limited()

Check if the union tag is rate_limited.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

classmethod not_pending(val)

Create an instance of this class set to the not_pending tag with value val.

Parameters:: val (str) –
Return type:: ResendSecondaryEmailResult

other = ResendSecondaryEmailResult('other', None)

classmethod rate_limited(val)

Create an instance of this class set to the rate_limited tag with value val.

Parameters:: val (str) –
Return type:: ResendSecondaryEmailResult

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (str) –
Return type:: ResendSecondaryEmailResult

class dropbox.team.ResendVerificationEmailArg(emails_to_resend=None)

Bases: Struct

Variables:: team.ResendVerificationEmailArg.emails_to_resend – List of users and secondary emails to resend verification emails to.

__init__(emails_to_resend=None)

emails_to_resend

class dropbox.team.ResendVerificationEmailResult(results=None)

Bases: Struct

List of users and resend results.

__init__(results=None)

results

class dropbox.team.RevokeDesktopClientArg(session_id=None, team_member_id=None, delete_on_unlink=None)

Bases: DeviceSessionArg

Variables:: team.RevokeDesktopClientArg.delete_on_unlink – Whether to delete all files of the account (this is possible only if supported by the desktop client and will be made the next time the client access the account).

__init__(session_id=None, team_member_id=None, delete_on_unlink=None)

delete_on_unlink

class dropbox.team.RevokeDeviceSessionArg(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

RevokeDeviceSessionArg.web_session (DeviceSessionArg) – End an active session.
RevokeDeviceSessionArg.desktop_client (RevokeDesktopClientArg) – Unlink a linked desktop device.
RevokeDeviceSessionArg.mobile_client (DeviceSessionArg) – Unlink a linked mobile device.

classmethod desktop_client(val)

Create an instance of this class set to the desktop_client tag with value val.

Parameters:: val (RevokeDesktopClientArg) –
Return type:: RevokeDeviceSessionArg

get_desktop_client()

Unlink a linked desktop device.

Only call this if is_desktop_client() is true.

Return type:: RevokeDesktopClientArg

get_mobile_client()

Unlink a linked mobile device.

Only call this if is_mobile_client() is true.

Return type:: DeviceSessionArg

get_web_session()

End an active session.

Only call this if is_web_session() is true.

Return type:: DeviceSessionArg

is_desktop_client()

Check if the union tag is desktop_client.

Return type:: bool

is_mobile_client()

Check if the union tag is mobile_client.

Return type:: bool

is_web_session()

Check if the union tag is web_session.

Return type:: bool

classmethod mobile_client(val)

Create an instance of this class set to the mobile_client tag with value val.

Parameters:: val (DeviceSessionArg) –
Return type:: RevokeDeviceSessionArg

classmethod web_session(val)

Create an instance of this class set to the web_session tag with value val.

Parameters:: val (DeviceSessionArg) –
Return type:: RevokeDeviceSessionArg

class dropbox.team.RevokeDeviceSessionBatchArg(revoke_devices=None)

Bases: Struct

__init__(revoke_devices=None)

revoke_devices

class dropbox.team.RevokeDeviceSessionBatchError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = RevokeDeviceSessionBatchError('other', None)

class dropbox.team.RevokeDeviceSessionBatchResult(revoke_devices_status=None)

Bases: Struct

__init__(revoke_devices_status=None)

revoke_devices_status

class dropbox.team.RevokeDeviceSessionError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.RevokeDeviceSessionError.device_session_not_found – Device session not found.
team.RevokeDeviceSessionError.member_not_found – Member not found.

device_session_not_found = RevokeDeviceSessionError('device_session_not_found', None)

is_device_session_not_found()

Check if the union tag is device_session_not_found.

Return type:: bool

is_member_not_found()

Check if the union tag is member_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

member_not_found = RevokeDeviceSessionError('member_not_found', None)

other = RevokeDeviceSessionError('other', None)

class dropbox.team.RevokeDeviceSessionStatus(success=None, error_type=None)

Bases: Struct

Variables:

team.RevokeDeviceSessionStatus.success – Result of the revoking request.
team.RevokeDeviceSessionStatus.error_type – The error cause in case of a failure.

__init__(success=None, error_type=None)

error_type

success

class dropbox.team.RevokeLinkedApiAppArg(app_id=None, team_member_id=None, keep_app_folder=None)

Bases: Struct

Variables:

team.RevokeLinkedApiAppArg.app_id – The application’s unique id.
team.RevokeLinkedApiAppArg.team_member_id – The unique id of the member owning the device.
team.RevokeLinkedApiAppArg.keep_app_folder – This flag is not longer supported, the application dedicated folder (in case the application uses one) will be kept.

__init__(app_id=None, team_member_id=None, keep_app_folder=None)

app_id

keep_app_folder

team_member_id

class dropbox.team.RevokeLinkedApiAppBatchArg(revoke_linked_app=None)

Bases: Struct

__init__(revoke_linked_app=None)

revoke_linked_app

class dropbox.team.RevokeLinkedAppBatchError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_linked_apps_revoke_linked_app_batch().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

is_other()

Check if the union tag is other.

Return type:: bool

other = RevokeLinkedAppBatchError('other', None)

class dropbox.team.RevokeLinkedAppBatchResult(revoke_linked_app_status=None)

Bases: Struct

__init__(revoke_linked_app_status=None)

revoke_linked_app_status

class dropbox.team.RevokeLinkedAppError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_linked_apps_revoke_linked_app().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.RevokeLinkedAppError.app_not_found – Application not found.
team.RevokeLinkedAppError.member_not_found – Member not found.
team.RevokeLinkedAppError.app_folder_removal_not_supported – App folder removal is not supported.

app_folder_removal_not_supported = RevokeLinkedAppError('app_folder_removal_not_supported', None)

app_not_found = RevokeLinkedAppError('app_not_found', None)

is_app_folder_removal_not_supported()

Check if the union tag is app_folder_removal_not_supported.

Return type:: bool

is_app_not_found()

Check if the union tag is app_not_found.

Return type:: bool

is_member_not_found()

Check if the union tag is member_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

member_not_found = RevokeLinkedAppError('member_not_found', None)

other = RevokeLinkedAppError('other', None)

class dropbox.team.RevokeLinkedAppStatus(success=None, error_type=None)

Bases: Struct

Variables:

team.RevokeLinkedAppStatus.success – Result of the revoking request.
team.RevokeLinkedAppStatus.error_type – The error cause in case of a failure.

__init__(success=None, error_type=None)

error_type

success

class dropbox.team.SetCustomQuotaArg(users_and_quotas=None)

Bases: Struct

Variables:: team.SetCustomQuotaArg.users_and_quotas – List of users and their custom quotas.

__init__(users_and_quotas=None)

users_and_quotas

class dropbox.team.SetCustomQuotaError(tag, value=None)

Bases: CustomQuotaError

Error returned when setting member custom quota.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.SetCustomQuotaError.some_users_are_excluded – Some of the users are on the excluded users list and can’t have custom quota set.

is_some_users_are_excluded()

Check if the union tag is some_users_are_excluded.

Return type:: bool

some_users_are_excluded = SetCustomQuotaError('some_users_are_excluded', None)

class dropbox.team.SharingAllowlistAddArgs(domains=None, emails=None)

Bases: Struct

Structure representing Approve List entries. Domain and emails are supported. At least one entry of any supported type is required.

Variables:

team.SharingAllowlistAddArgs.domains – List of domains represented by valid string representation (RFC-1034/5).
team.SharingAllowlistAddArgs.emails – List of emails represented by valid string representation (RFC-5322/822).

__init__(domains=None, emails=None)

domains

emails

class dropbox.team.SharingAllowlistAddError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.SharingAllowlistAddError.malformed_entry (str) – One of provided values is not valid.
team.SharingAllowlistAddError.no_entries_provided – Neither single domain nor email provided.
team.SharingAllowlistAddError.too_many_entries_provided – Too many entries provided within one call.
team.SharingAllowlistAddError.team_limit_reached – Team entries limit reached.
team.SharingAllowlistAddError.unknown_error – Unknown error.
team.SharingAllowlistAddError.entries_already_exist (str) – Entries already exists.

classmethod entries_already_exist(val)

Create an instance of this class set to the entries_already_exist tag with value val.

Parameters:: val (str) –
Return type:: SharingAllowlistAddError

get_entries_already_exist()

Entries already exists.

Only call this if is_entries_already_exist() is true.

Return type:: str

get_malformed_entry()

One of provided values is not valid.

Only call this if is_malformed_entry() is true.

Return type:: str

is_entries_already_exist()

Check if the union tag is entries_already_exist.

Return type:: bool

is_malformed_entry()

Check if the union tag is malformed_entry.

Return type:: bool

is_no_entries_provided()

Check if the union tag is no_entries_provided.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_team_limit_reached()

Check if the union tag is team_limit_reached.

Return type:: bool

is_too_many_entries_provided()

Check if the union tag is too_many_entries_provided.

Return type:: bool

is_unknown_error()

Check if the union tag is unknown_error.

Return type:: bool

classmethod malformed_entry(val)

Create an instance of this class set to the malformed_entry tag with value val.

Parameters:: val (str) –
Return type:: SharingAllowlistAddError

no_entries_provided = SharingAllowlistAddError('no_entries_provided', None)

other = SharingAllowlistAddError('other', None)

team_limit_reached = SharingAllowlistAddError('team_limit_reached', None)

too_many_entries_provided = SharingAllowlistAddError('too_many_entries_provided', None)

unknown_error = SharingAllowlistAddError('unknown_error', None)

class dropbox.team.SharingAllowlistAddResponse

Bases: Struct

This struct is empty. The comment here is intentionally emitted to avoid indentation issues with Stone.

__init__()

class dropbox.team.SharingAllowlistListArg(limit=None)

Bases: Struct

Variables:: team.SharingAllowlistListArg.limit – The number of entries to fetch at one time.

__init__(limit=None)

limit

class dropbox.team.SharingAllowlistListContinueArg(cursor=None)

Bases: Struct

Variables:: team.SharingAllowlistListContinueArg.cursor – The cursor returned from a previous call to dropbox.dropbox_client.Dropbox.team_sharing_allowlist_list() or dropbox.dropbox_client.Dropbox.team_sharing_allowlist_list_continue().

__init__(cursor=None)

cursor

class dropbox.team.SharingAllowlistListContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.SharingAllowlistListContinueError.invalid_cursor – Provided cursor is not valid.

invalid_cursor = SharingAllowlistListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = SharingAllowlistListContinueError('other', None)

class dropbox.team.SharingAllowlistListError

Bases: Struct

This struct is empty. The comment here is intentionally emitted to avoid indentation issues with Stone.

__init__()

class dropbox.team.SharingAllowlistListResponse(domains=None, emails=None, cursor=None, has_more=None)

Bases: Struct

Variables:

team.SharingAllowlistListResponse.domains – List of domains represented by valid string representation (RFC-1034/5).
team.SharingAllowlistListResponse.emails – List of emails represented by valid string representation (RFC-5322/822).
team.SharingAllowlistListResponse.cursor – If this is nonempty, there are more entries that can be fetched with dropbox.dropbox_client.Dropbox.team_sharing_allowlist_list_continue().
team.SharingAllowlistListResponse.has_more – if true indicates that more entries can be fetched with dropbox.dropbox_client.Dropbox.team_sharing_allowlist_list_continue().

__init__(domains=None, emails=None, cursor=None, has_more=None)

cursor

domains

emails

has_more

class dropbox.team.SharingAllowlistRemoveArgs(domains=None, emails=None)

Bases: Struct

Variables:

team.SharingAllowlistRemoveArgs.domains – List of domains represented by valid string representation (RFC-1034/5).
team.SharingAllowlistRemoveArgs.emails – List of emails represented by valid string representation (RFC-5322/822).

__init__(domains=None, emails=None)

domains

emails

class dropbox.team.SharingAllowlistRemoveError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.SharingAllowlistRemoveError.malformed_entry (str) – One of provided values is not valid.
team.SharingAllowlistRemoveError.entries_do_not_exist (str) – One or more provided values do not exist.
team.SharingAllowlistRemoveError.no_entries_provided – Neither single domain nor email provided.
team.SharingAllowlistRemoveError.too_many_entries_provided – Too many entries provided within one call.
team.SharingAllowlistRemoveError.unknown_error – Unknown error.

classmethod entries_do_not_exist(val)

Create an instance of this class set to the entries_do_not_exist tag with value val.

Parameters:: val (str) –
Return type:: SharingAllowlistRemoveError

get_entries_do_not_exist()

One or more provided values do not exist.

Only call this if is_entries_do_not_exist() is true.

Return type:: str

get_malformed_entry()

One of provided values is not valid.

Only call this if is_malformed_entry() is true.

Return type:: str

is_entries_do_not_exist()

Check if the union tag is entries_do_not_exist.

Return type:: bool

is_malformed_entry()

Check if the union tag is malformed_entry.

Return type:: bool

is_no_entries_provided()

Check if the union tag is no_entries_provided.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_too_many_entries_provided()

Check if the union tag is too_many_entries_provided.

Return type:: bool

is_unknown_error()

Check if the union tag is unknown_error.

Return type:: bool

classmethod malformed_entry(val)

Create an instance of this class set to the malformed_entry tag with value val.

Parameters:: val (str) –
Return type:: SharingAllowlistRemoveError

no_entries_provided = SharingAllowlistRemoveError('no_entries_provided', None)

other = SharingAllowlistRemoveError('other', None)

too_many_entries_provided = SharingAllowlistRemoveError('too_many_entries_provided', None)

unknown_error = SharingAllowlistRemoveError('unknown_error', None)

class dropbox.team.SharingAllowlistRemoveResponse

Bases: Struct

This struct is empty. The comment here is intentionally emitted to avoid indentation issues with Stone.

__init__()

class dropbox.team.StorageBucket(bucket=None, users=None)

Bases: Struct

Describes the number of users in a specific storage bucket.

Variables:

team.StorageBucket.bucket – The name of the storage bucket. For example, ‘1G’ is a bucket of users with storage size up to 1 Giga.
team.StorageBucket.users – The number of people whose storage is in the range of this storage bucket.

__init__(bucket=None, users=None)

bucket

users

class dropbox.team.TeamFolderAccessError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderAccessError.invalid_team_folder_id – The team folder ID is invalid.
team.TeamFolderAccessError.no_access – The authenticated app does not have permission to manage that team folder.

invalid_team_folder_id = TeamFolderAccessError('invalid_team_folder_id', None)

is_invalid_team_folder_id()

Check if the union tag is invalid_team_folder_id.

Return type:: bool

is_no_access()

Check if the union tag is no_access.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

no_access = TeamFolderAccessError('no_access', None)

other = TeamFolderAccessError('other', None)

class dropbox.team.TeamFolderActivateError(tag, value=None)

Bases: BaseTeamFolderError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

class dropbox.team.TeamFolderArchiveArg(team_folder_id=None, force_async_off=None)

Bases: TeamFolderIdArg

Variables:: team.TeamFolderArchiveArg.force_async_off – Whether to force the archive to happen synchronously.

__init__(team_folder_id=None, force_async_off=None)

force_async_off

class dropbox.team.TeamFolderArchiveError(tag, value=None)

Bases: BaseTeamFolderError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

class dropbox.team.TeamFolderArchiveJobStatus(tag, value=None)

Bases: PollResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

TeamFolderArchiveJobStatus.complete (TeamFolderMetadata) – The archive job has finished. The value is the metadata for the resulting team folder.
TeamFolderArchiveJobStatus.failed (TeamFolderArchiveError) – Error occurred while performing an asynchronous job from dropbox.dropbox_client.Dropbox.team_team_folder_archive().

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (TeamFolderMetadata) –
Return type:: TeamFolderArchiveJobStatus

classmethod failed(val)

Create an instance of this class set to the failed tag with value val.

Parameters:: val (TeamFolderArchiveError) –
Return type:: TeamFolderArchiveJobStatus

get_complete()

The archive job has finished. The value is the metadata for the resulting team folder.

Only call this if is_complete() is true.

Return type:: TeamFolderMetadata

get_failed()

Error occurred while performing an asynchronous job from dropbox.dropbox_client.Dropbox.team_team_folder_archive().

Only call this if is_failed() is true.

Return type:: TeamFolderArchiveError

is_complete()

Check if the union tag is complete.

Return type:: bool

is_failed()

Check if the union tag is failed.

Return type:: bool

class dropbox.team.TeamFolderArchiveLaunch(tag, value=None)

Bases: LaunchResultBase

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

classmethod complete(val)

Create an instance of this class set to the complete tag with value val.

Parameters:: val (TeamFolderMetadata) –
Return type:: TeamFolderArchiveLaunch

get_complete()

Only call this if is_complete() is true.

Return type:: TeamFolderMetadata

is_complete()

Check if the union tag is complete.

Return type:: bool

class dropbox.team.TeamFolderCreateArg(name=None, sync_setting=None)

Bases: Struct

Variables:

team.TeamFolderCreateArg.name – Name for the new team folder.
team.TeamFolderCreateArg.sync_setting – The sync setting to apply to this team folder. Only permitted if the team has team selective sync enabled.

__init__(name=None, sync_setting=None)

name

sync_setting

class dropbox.team.TeamFolderCreateError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderCreateError.invalid_folder_name – The provided name cannot be used.
team.TeamFolderCreateError.folder_name_already_used – There is already a team folder with the provided name.
team.TeamFolderCreateError.folder_name_reserved – The provided name cannot be used because it is reserved.
TeamFolderCreateError.sync_settings_error (SyncSettingsError) – An error occurred setting the sync settings.

folder_name_already_used = TeamFolderCreateError('folder_name_already_used', None)

folder_name_reserved = TeamFolderCreateError('folder_name_reserved', None)

get_sync_settings_error()

An error occurred setting the sync settings.

Only call this if is_sync_settings_error() is true.

Return type:: files.SyncSettingsError

invalid_folder_name = TeamFolderCreateError('invalid_folder_name', None)

is_folder_name_already_used()

Check if the union tag is folder_name_already_used.

Return type:: bool

is_folder_name_reserved()

Check if the union tag is folder_name_reserved.

Return type:: bool

is_invalid_folder_name()

Check if the union tag is invalid_folder_name.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_sync_settings_error()

Check if the union tag is sync_settings_error.

Return type:: bool

other = TeamFolderCreateError('other', None)

classmethod sync_settings_error(val)

Create an instance of this class set to the sync_settings_error tag with value val.

Parameters:: val (files.SyncSettingsError) –
Return type:: TeamFolderCreateError

class dropbox.team.TeamFolderGetInfoItem(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderGetInfoItem.id_not_found (str) – An ID that was provided as a parameter to :route:`team_folder/get_info` did not match any of the team’s team folders.
TeamFolderGetInfoItem.team_folder_metadata (TeamFolderMetadata) – Properties of a team folder.

get_id_not_found()

An ID that was provided as a parameter to dropbox.dropbox_client.Dropbox.team_team_folder_get_info() did not match any of the team’s team folders.

Only call this if is_id_not_found() is true.

Return type:: str

get_team_folder_metadata()

Properties of a team folder.

Only call this if is_team_folder_metadata() is true.

Return type:: TeamFolderMetadata

classmethod id_not_found(val)

Create an instance of this class set to the id_not_found tag with value val.

Parameters:: val (str) –
Return type:: TeamFolderGetInfoItem

is_id_not_found()

Check if the union tag is id_not_found.

Return type:: bool

is_team_folder_metadata()

Check if the union tag is team_folder_metadata.

Return type:: bool

classmethod team_folder_metadata(val)

Create an instance of this class set to the team_folder_metadata tag with value val.

Parameters:: val (TeamFolderMetadata) –
Return type:: TeamFolderGetInfoItem

class dropbox.team.TeamFolderIdArg(team_folder_id=None)

Bases: Struct

Variables:: team.TeamFolderIdArg.team_folder_id – The ID of the team folder.

__init__(team_folder_id=None)

team_folder_id

class dropbox.team.TeamFolderIdListArg(team_folder_ids=None)

Bases: Struct

Variables:: team.TeamFolderIdListArg.team_folder_ids – The list of team folder IDs.

__init__(team_folder_ids=None)

team_folder_ids

class dropbox.team.TeamFolderInvalidStatusError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderInvalidStatusError.active – The folder is active and the operation did not succeed.
team.TeamFolderInvalidStatusError.archived – The folder is archived and the operation did not succeed.
team.TeamFolderInvalidStatusError.archive_in_progress – The folder is being archived and the operation did not succeed.

active = TeamFolderInvalidStatusError('active', None)

archive_in_progress = TeamFolderInvalidStatusError('archive_in_progress', None)

archived = TeamFolderInvalidStatusError('archived', None)

is_active()

Check if the union tag is active.

Return type:: bool

is_archive_in_progress()

Check if the union tag is archive_in_progress.

Return type:: bool

is_archived()

Check if the union tag is archived.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = TeamFolderInvalidStatusError('other', None)

class dropbox.team.TeamFolderListArg(limit=None)

Bases: Struct

Variables:: team.TeamFolderListArg.limit – The maximum number of results to return per request.

__init__(limit=None)

limit

class dropbox.team.TeamFolderListContinueArg(cursor=None)

Bases: Struct

Variables:: team.TeamFolderListContinueArg.cursor – Indicates from what point to get the next set of team folders.

__init__(cursor=None)

cursor

class dropbox.team.TeamFolderListContinueError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.TeamFolderListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = TeamFolderListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = TeamFolderListContinueError('other', None)

class dropbox.team.TeamFolderListError(access_error=None)

Bases: Struct

__init__(access_error=None)

access_error

class dropbox.team.TeamFolderListResult(team_folders=None, cursor=None, has_more=None)

Bases: Struct

Result for dropbox.dropbox_client.Dropbox.team_team_folder_list() and dropbox.dropbox_client.Dropbox.team_team_folder_list_continue().

Variables:

team.TeamFolderListResult.team_folders – List of all team folders in the authenticated team.
team.TeamFolderListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_team_folder_list_continue() to obtain additional team folders.
team.TeamFolderListResult.has_more – Is true if there are additional team folders that have not been returned yet. An additional call to dropbox.dropbox_client.Dropbox.team_team_folder_list_continue() can retrieve them.

__init__(team_folders=None, cursor=None, has_more=None)

cursor

has_more

team_folders

class dropbox.team.TeamFolderMetadata(team_folder_id=None, name=None, status=None, is_team_shared_dropbox=None, sync_setting=None, content_sync_settings=None)

Bases: Struct

Properties of a team folder.

Variables:

team.TeamFolderMetadata.team_folder_id – The ID of the team folder.
team.TeamFolderMetadata.name – The name of the team folder.
team.TeamFolderMetadata.status – The status of the team folder.
team.TeamFolderMetadata.is_team_shared_dropbox – True if this team folder is a shared team root.
team.TeamFolderMetadata.sync_setting – The sync setting applied to this team folder.
team.TeamFolderMetadata.content_sync_settings – Sync settings applied to contents of this team folder.

__init__(team_folder_id=None, name=None, status=None, is_team_shared_dropbox=None, sync_setting=None, content_sync_settings=None)

content_sync_settings

is_team_shared_dropbox

name

status

sync_setting

team_folder_id

class dropbox.team.TeamFolderPermanentlyDeleteError(tag, value=None)

Bases: BaseTeamFolderError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

class dropbox.team.TeamFolderRenameArg(team_folder_id=None, name=None)

Bases: TeamFolderIdArg

Variables:: team.TeamFolderRenameArg.name – New team folder name.

__init__(team_folder_id=None, name=None)

name

class dropbox.team.TeamFolderRenameError(tag, value=None)

Bases: BaseTeamFolderError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderRenameError.invalid_folder_name – The provided folder name cannot be used.
team.TeamFolderRenameError.folder_name_already_used – There is already a team folder with the same name.
team.TeamFolderRenameError.folder_name_reserved – The provided name cannot be used because it is reserved.

folder_name_already_used = TeamFolderRenameError('folder_name_already_used', None)

folder_name_reserved = TeamFolderRenameError('folder_name_reserved', None)

invalid_folder_name = TeamFolderRenameError('invalid_folder_name', None)

is_folder_name_already_used()

Check if the union tag is folder_name_already_used.

Return type:: bool

is_folder_name_reserved()

Check if the union tag is folder_name_reserved.

Return type:: bool

is_invalid_folder_name()

Check if the union tag is invalid_folder_name.

Return type:: bool

class dropbox.team.TeamFolderStatus(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamFolderStatus.active – The team folder and sub-folders are available to all members.
team.TeamFolderStatus.archived – The team folder is not accessible outside of the team folder manager.
team.TeamFolderStatus.archive_in_progress – The team folder is not accessible outside of the team folder manager.

active = TeamFolderStatus('active', None)

archive_in_progress = TeamFolderStatus('archive_in_progress', None)

archived = TeamFolderStatus('archived', None)

is_active()

Check if the union tag is active.

Return type:: bool

is_archive_in_progress()

Check if the union tag is archive_in_progress.

Return type:: bool

is_archived()

Check if the union tag is archived.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = TeamFolderStatus('other', None)

class dropbox.team.TeamFolderTeamSharedDropboxError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.TeamFolderTeamSharedDropboxError.disallowed – This action is not allowed for a shared team root.

disallowed = TeamFolderTeamSharedDropboxError('disallowed', None)

is_disallowed()

Check if the union tag is disallowed.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = TeamFolderTeamSharedDropboxError('other', None)

class dropbox.team.TeamFolderUpdateSyncSettingsArg(team_folder_id=None, sync_setting=None, content_sync_settings=None)

Bases: TeamFolderIdArg

Variables:

team.TeamFolderUpdateSyncSettingsArg.sync_setting – Sync setting to apply to the team folder itself. Only meaningful if the team folder is not a shared team root.
team.TeamFolderUpdateSyncSettingsArg.content_sync_settings – Sync settings to apply to contents of this team folder.

__init__(team_folder_id=None, sync_setting=None, content_sync_settings=None)

content_sync_settings

sync_setting

class dropbox.team.TeamFolderUpdateSyncSettingsError(tag, value=None)

Bases: BaseTeamFolderError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

:ivar SyncSettingsError: TeamFolderUpdateSyncSettingsError.sync_settings_error: An error occurred setting the sync settings.

get_sync_settings_error()

An error occurred setting the sync settings.

Only call this if is_sync_settings_error() is true.

Return type:: files.SyncSettingsError

is_sync_settings_error()

Check if the union tag is sync_settings_error.

Return type:: bool

classmethod sync_settings_error(val)

Create an instance of this class set to the sync_settings_error tag with value val.

Parameters:: val (files.SyncSettingsError) –
Return type:: TeamFolderUpdateSyncSettingsError

class dropbox.team.TeamGetInfoResult(name=None, team_id=None, num_licensed_users=None, num_provisioned_users=None, policies=None, num_used_licenses=None)

Bases: Struct

Variables:

team.TeamGetInfoResult.name – The name of the team.
team.TeamGetInfoResult.team_id – The ID of the team.
team.TeamGetInfoResult.num_licensed_users – The number of licenses available to the team.
team.TeamGetInfoResult.num_provisioned_users – The number of accounts that have been invited or are already active members of the team.
team.TeamGetInfoResult.num_used_licenses – The number of licenses used on the team.

__init__(name=None, team_id=None, num_licensed_users=None, num_provisioned_users=None, policies=None, num_used_licenses=None)

name

num_licensed_users

num_provisioned_users

num_used_licenses

policies

team_id

class dropbox.team.TeamMemberInfo(profile=None, role=None)

Bases: Struct

Information about a team member.

Variables:

team.TeamMemberInfo.profile – Profile of a user as a member of a team.
team.TeamMemberInfo.role – The user’s role in the team.

__init__(profile=None, role=None)

profile

role

class dropbox.team.TeamMemberInfoV2(profile=None, roles=None)

Bases: Struct

Information about a team member.

Variables:

team.TeamMemberInfoV2.profile – Profile of a user as a member of a team.
team.TeamMemberInfoV2.roles – The user’s roles in the team.

__init__(profile=None, roles=None)

profile

roles

class dropbox.team.TeamMemberInfoV2Result(member_info=None)

Bases: Struct

Information about a team member, after the change, like at dropbox.dropbox_client.Dropbox.team_members_set_profile().

Variables:: team.TeamMemberInfoV2Result.member_info – Member info, after the change.

__init__(member_info=None)

member_info

class dropbox.team.TeamMemberProfile(team_member_id=None, email=None, email_verified=None, status=None, name=None, membership_type=None, groups=None, member_folder_id=None, external_id=None, account_id=None, secondary_emails=None, invited_on=None, joined_on=None, suspended_on=None, persistent_id=None, is_directory_restricted=None, profile_photo_url=None)

Bases: MemberProfile

Profile of a user as a member of a team.

Variables:

team.TeamMemberProfile.groups – List of group IDs of groups that the user belongs to.
team.TeamMemberProfile.member_folder_id – The namespace id of the user’s root folder.

__init__(team_member_id=None, email=None, email_verified=None, status=None, name=None, membership_type=None, groups=None, member_folder_id=None, external_id=None, account_id=None, secondary_emails=None, invited_on=None, joined_on=None, suspended_on=None, persistent_id=None, is_directory_restricted=None, profile_photo_url=None)

groups

member_folder_id

class dropbox.team.TeamMemberRole(role_id=None, name=None, description=None)

Bases: Struct

A role which can be attached to a team member. This replaces AdminTier; each AdminTier corresponds to a new TeamMemberRole with a matching name.

Variables:

team.TeamMemberRole.role_id – A string containing encoded role ID. For roles defined by Dropbox, this is the same across all teams.
team.TeamMemberRole.name – The role display name.
team.TeamMemberRole.description – Role description. Describes which permissions come with this role.

__init__(role_id=None, name=None, description=None)

description

name

role_id

class dropbox.team.TeamMemberStatus(tag, value=None)

Bases: Union

The user’s status as a member of a specific team.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamMemberStatus.active – User has successfully joined the team.
team.TeamMemberStatus.invited – User has been invited to a team, but has not joined the team yet.
team.TeamMemberStatus.suspended – User is no longer a member of the team, but the account can be un-suspended, re-establishing the user as a team member.
TeamMemberStatus.removed (RemovedStatus) – User is no longer a member of the team. Removed users are only listed when include_removed is true in members/list.

active = TeamMemberStatus('active', None)

get_removed()

User is no longer a member of the team. Removed users are only listed when include_removed is true in members/list.

Only call this if is_removed() is true.

Return type:: RemovedStatus

invited = TeamMemberStatus('invited', None)

is_active()

Check if the union tag is active.

Return type:: bool

is_invited()

Check if the union tag is invited.

Return type:: bool

is_removed()

Check if the union tag is removed.

Return type:: bool

is_suspended()

Check if the union tag is suspended.

Return type:: bool

classmethod removed(val)

Create an instance of this class set to the removed tag with value val.

Parameters:: val (RemovedStatus) –
Return type:: TeamMemberStatus

suspended = TeamMemberStatus('suspended', None)

class dropbox.team.TeamMembershipType(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamMembershipType.full – User uses a license and has full access to team resources like the shared quota.
team.TeamMembershipType.limited – User does not have access to the shared quota and team admins have restricted administrative control.

full = TeamMembershipType('full', None)

is_full()

Check if the union tag is full.

Return type:: bool

is_limited()

Check if the union tag is limited.

Return type:: bool

limited = TeamMembershipType('limited', None)

class dropbox.team.TeamNamespacesListArg(limit=None)

Bases: Struct

Variables:: team.TeamNamespacesListArg.limit – Specifying a value here has no effect.

__init__(limit=None)

limit

class dropbox.team.TeamNamespacesListContinueArg(cursor=None)

Bases: Struct

Variables:: team.TeamNamespacesListContinueArg.cursor – Indicates from what point to get the next set of team-accessible namespaces.

__init__(cursor=None)

cursor

class dropbox.team.TeamNamespacesListContinueError(tag, value=None)

Bases: TeamNamespacesListError

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.TeamNamespacesListContinueError.invalid_cursor – The cursor is invalid.

invalid_cursor = TeamNamespacesListContinueError('invalid_cursor', None)

is_invalid_cursor()

Check if the union tag is invalid_cursor.

Return type:: bool

class dropbox.team.TeamNamespacesListError(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.TeamNamespacesListError.invalid_arg – Argument passed in is invalid.

invalid_arg = TeamNamespacesListError('invalid_arg', None)

is_invalid_arg()

Check if the union tag is invalid_arg.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

other = TeamNamespacesListError('other', None)

class dropbox.team.TeamNamespacesListResult(namespaces=None, cursor=None, has_more=None)

Bases: Struct

Result for dropbox.dropbox_client.Dropbox.team_namespaces_list().

Variables:

team.TeamNamespacesListResult.namespaces – List of all namespaces the team can access.
team.TeamNamespacesListResult.cursor – Pass the cursor into dropbox.dropbox_client.Dropbox.team_namespaces_list_continue() to obtain additional namespaces. Note that duplicate namespaces may be returned.
team.TeamNamespacesListResult.has_more – Is true if there are additional namespaces that have not been returned yet.

__init__(namespaces=None, cursor=None, has_more=None)

cursor

has_more

namespaces

class dropbox.team.TeamReportFailureReason(tag, value=None)

Bases: Union

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TeamReportFailureReason.temporary_error – We couldn’t create the report, but we think this was a fluke. Everything should work if you try it again.
team.TeamReportFailureReason.many_reports_at_once – Too many other reports are being created right now. Try creating this report again once the others finish.
team.TeamReportFailureReason.too_much_data – We couldn’t create the report. Try creating the report again with less data.

is_many_reports_at_once()

Check if the union tag is many_reports_at_once.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_temporary_error()

Check if the union tag is temporary_error.

Return type:: bool

is_too_much_data()

Check if the union tag is too_much_data.

Return type:: bool

many_reports_at_once = TeamReportFailureReason('many_reports_at_once', None)

other = TeamReportFailureReason('other', None)

temporary_error = TeamReportFailureReason('temporary_error', None)

too_much_data = TeamReportFailureReason('too_much_data', None)

class dropbox.team.TokenGetAuthenticatedAdminError(tag, value=None)

Bases: Union

Error returned by dropbox.dropbox_client.Dropbox.team_token_get_authenticated_admin().

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.TokenGetAuthenticatedAdminError.mapping_not_found – The current token is not associated with a team admin, because mappings were not recorded when the token was created. Consider re-authorizing a new access token to record its authenticating admin.
team.TokenGetAuthenticatedAdminError.admin_not_active – Either the team admin that authorized this token is no longer an active member of the team or no longer a team admin.

admin_not_active = TokenGetAuthenticatedAdminError('admin_not_active', None)

is_admin_not_active()

Check if the union tag is admin_not_active.

Return type:: bool

is_mapping_not_found()

Check if the union tag is mapping_not_found.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

mapping_not_found = TokenGetAuthenticatedAdminError('mapping_not_found', None)

other = TokenGetAuthenticatedAdminError('other', None)

class dropbox.team.TokenGetAuthenticatedAdminResult(admin_profile=None)

Bases: Struct

Results for dropbox.dropbox_client.Dropbox.team_token_get_authenticated_admin().

Variables:: team.TokenGetAuthenticatedAdminResult.admin_profile – The admin who authorized the token.

__init__(admin_profile=None)

admin_profile

class dropbox.team.UploadApiRateLimitValue(tag, value=None)

Bases: Union

The value for Feature.upload_api_rate_limit.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.UploadApiRateLimitValue.unlimited – This team has unlimited upload API quota. So far both server version account and legacy account type have unlimited monthly upload api quota.
team.UploadApiRateLimitValue.limit (int) – The number of upload API calls allowed per month.

get_limit()

The number of upload API calls allowed per month.

Only call this if is_limit() is true.

Return type:: int

is_limit()

Check if the union tag is limit.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_unlimited()

Check if the union tag is unlimited.

Return type:: bool

classmethod limit(val)

Create an instance of this class set to the limit tag with value val.

Parameters:: val (int) –
Return type:: UploadApiRateLimitValue

other = UploadApiRateLimitValue('other', None)

unlimited = UploadApiRateLimitValue('unlimited', None)

class dropbox.team.UserAddResult(tag, value=None)

Bases: Union

Result of trying to add secondary emails to a user. ‘success’ is the only value indicating that a user was successfully retrieved for adding secondary emails. The other values explain the type of error that occurred, and include the user for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

UserAddResult.success (UserSecondaryEmailsResult) – Describes a user and the results for each attempt to add a secondary email.
UserAddResult.invalid_user (UserSelectorArg) – Specified user is not a valid target for adding secondary emails.
UserAddResult.unverified (UserSelectorArg) – Secondary emails can only be added to verified users.
UserAddResult.placeholder_user (UserSelectorArg) – Secondary emails cannot be added to placeholder users.

get_invalid_user()

Specified user is not a valid target for adding secondary emails.

Only call this if is_invalid_user() is true.

Return type:: UserSelectorArg

get_placeholder_user()

Secondary emails cannot be added to placeholder users.

Only call this if is_placeholder_user() is true.

Return type:: UserSelectorArg

get_success()

Describes a user and the results for each attempt to add a secondary email.

Only call this if is_success() is true.

Return type:: UserSecondaryEmailsResult

get_unverified()

Secondary emails can only be added to verified users.

Only call this if is_unverified() is true.

Return type:: UserSelectorArg

classmethod invalid_user(val)

Create an instance of this class set to the invalid_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: UserAddResult

is_invalid_user()

Check if the union tag is invalid_user.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_placeholder_user()

Check if the union tag is placeholder_user.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

is_unverified()

Check if the union tag is unverified.

Return type:: bool

other = UserAddResult('other', None)

classmethod placeholder_user(val)

Create an instance of this class set to the placeholder_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: UserAddResult

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (UserSecondaryEmailsResult) –
Return type:: UserAddResult

classmethod unverified(val)

Create an instance of this class set to the unverified tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: UserAddResult

class dropbox.team.UserCustomQuotaArg(user=None, quota_gb=None)

Bases: Struct

User and their required custom quota in GB (1 TB = 1024 GB).

__init__(user=None, quota_gb=None)

quota_gb

user

class dropbox.team.UserCustomQuotaResult(user=None, quota_gb=None)

Bases: Struct

User and their custom quota in GB (1 TB = 1024 GB). No quota returns if the user has no custom quota set.

__init__(user=None, quota_gb=None)

quota_gb

user

class dropbox.team.UserDeleteEmailsResult(user=None, results=None)

Bases: Struct

__init__(user=None, results=None)

results

user

class dropbox.team.UserDeleteResult(tag, value=None)

Bases: Union

Result of trying to delete a user’s secondary emails. ‘success’ is the only value indicating that a user was successfully retrieved for deleting secondary emails. The other values explain the type of error that occurred, and include the user for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

UserDeleteResult.success (UserDeleteEmailsResult) – Describes a user and the results for each attempt to delete a secondary email.
UserDeleteResult.invalid_user (UserSelectorArg) – Specified user is not a valid target for deleting secondary emails.

get_invalid_user()

Specified user is not a valid target for deleting secondary emails.

Only call this if is_invalid_user() is true.

Return type:: UserSelectorArg

get_success()

Describes a user and the results for each attempt to delete a secondary email.

Only call this if is_success() is true.

Return type:: UserDeleteEmailsResult

classmethod invalid_user(val)

Create an instance of this class set to the invalid_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: UserDeleteResult

is_invalid_user()

Check if the union tag is invalid_user.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = UserDeleteResult('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (UserDeleteEmailsResult) –
Return type:: UserDeleteResult

class dropbox.team.UserResendEmailsResult(user=None, results=None)

Bases: Struct

__init__(user=None, results=None)

results

user

class dropbox.team.UserResendResult(tag, value=None)

Bases: Union

Result of trying to resend verification emails to a user. ‘success’ is the only value indicating that a user was successfully retrieved for sending verification emails. The other values explain the type of error that occurred, and include the user for which the error occurred.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

UserResendResult.success (UserResendEmailsResult) – Describes a user and the results for each attempt to resend verification emails.
UserResendResult.invalid_user (UserSelectorArg) – Specified user is not a valid target for resending verification emails.

get_invalid_user()

Specified user is not a valid target for resending verification emails.

Only call this if is_invalid_user() is true.

Return type:: UserSelectorArg

get_success()

Describes a user and the results for each attempt to resend verification emails.

Only call this if is_success() is true.

Return type:: UserResendEmailsResult

classmethod invalid_user(val)

Create an instance of this class set to the invalid_user tag with value val.

Parameters:: val (UserSelectorArg) –
Return type:: UserResendResult

is_invalid_user()

Check if the union tag is invalid_user.

Return type:: bool

is_other()

Check if the union tag is other.

Return type:: bool

is_success()

Check if the union tag is success.

Return type:: bool

other = UserResendResult('other', None)

classmethod success(val)

Create an instance of this class set to the success tag with value val.

Parameters:: val (UserResendEmailsResult) –
Return type:: UserResendResult

class dropbox.team.UserSecondaryEmailsArg(user=None, secondary_emails=None)

Bases: Struct

User and a list of secondary emails.

__init__(user=None, secondary_emails=None)

secondary_emails

user

class dropbox.team.UserSecondaryEmailsResult(user=None, results=None)

Bases: Struct

__init__(user=None, results=None)

results

user

class dropbox.team.UserSelectorArg(tag, value=None)

Bases: Union

Argument for selecting a single user, either by team_member_id, external_id or email.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

classmethod email(val)

Create an instance of this class set to the email tag with value val.

Parameters:: val (str) –
Return type:: UserSelectorArg

classmethod external_id(val)

Create an instance of this class set to the external_id tag with value val.

Parameters:: val (str) –
Return type:: UserSelectorArg

get_email()

Only call this if is_email() is true.

Return type:: str

get_external_id()

Only call this if is_external_id() is true.

Return type:: str

get_team_member_id()

Only call this if is_team_member_id() is true.

Return type:: str

is_email()

Check if the union tag is email.

Return type:: bool

is_external_id()

Check if the union tag is external_id.

Return type:: bool

is_team_member_id()

Check if the union tag is team_member_id.

Return type:: bool

classmethod team_member_id(val)

Create an instance of this class set to the team_member_id tag with value val.

Parameters:: val (str) –
Return type:: UserSelectorArg

class dropbox.team.UserSelectorError(tag, value=None)

Bases: Union

Error that can be returned whenever a struct derived from UserSelectorArg is used.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:: team.UserSelectorError.user_not_found – No matching user found. The provided team_member_id, email, or external_id does not exist on this team.

is_user_not_found()

Check if the union tag is user_not_found.

Return type:: bool

user_not_found = UserSelectorError('user_not_found', None)

class dropbox.team.UsersSelectorArg(tag, value=None)

Bases: Union

Argument for selecting a list of users, either by team_member_ids, external_ids or emails.

This class acts as a tagged union. Only one of the is_* methods will return true. To get the associated value of a tag (if one exists), use the corresponding get_* method.

Variables:

team.UsersSelectorArg.team_member_ids (list of [str]) – List of member IDs.
team.UsersSelectorArg.external_ids (list of [str]) – List of external user IDs.
team.UsersSelectorArg.emails (list of [str]) – List of email addresses.

classmethod emails(val)

Create an instance of this class set to the emails tag with value val.

Parameters:: val (list of [str]) –
Return type:: UsersSelectorArg

classmethod external_ids(val)

Create an instance of this class set to the external_ids tag with value val.

Parameters:: val (list of [str]) –
Return type:: UsersSelectorArg

get_emails()

List of email addresses.

Only call this if is_emails() is true.

Return type:: list of [str]

get_external_ids()

List of external user IDs.

Only call this if is_external_ids() is true.

Return type:: list of [str]

get_team_member_ids()

List of member IDs.

Only call this if is_team_member_ids() is true.

Return type:: list of [str]

is_emails()

Check if the union tag is emails.

Return type:: bool

is_external_ids()

Check if the union tag is external_ids.

Return type:: bool

is_team_member_ids()

Check if the union tag is team_member_ids.

Return type:: bool

classmethod team_member_ids(val)

Create an instance of this class set to the team_member_ids tag with value val.

Parameters:: val (list of [str]) –
Return type:: UsersSelectorArg

dropbox.team – Team

`dropbox.team` – Team