team

type ActiveWebSession struct {
	DeviceSession
	// UserAgent : Information on the hosting device.
	UserAgent string `json:"user_agent"`
	// Os : Information on the hosting operating system.
	Os string `json:"os"`
	// Browser : Information on the browser used for this web session.
	Browser string `json:"browser"`
	// Expires : The time this session expires.
	Expires time.Time `json:"expires,omitempty"`
}

type AdminTier struct {
	dropbox.Tagged
}

type ApiApp struct {
	// AppId : The application unique id.
	AppId string `json:"app_id"`
	// AppName : The application name.
	AppName string `json:"app_name"`
	// Publisher : The application publisher name.
	Publisher string `json:"publisher,omitempty"`
	// PublisherUrl : The publisher's URL.
	PublisherUrl string `json:"publisher_url,omitempty"`
	// Linked : The time this application was linked.
	Linked time.Time `json:"linked,omitempty"`
	// IsAppFolder : Whether the linked application uses a dedicated folder.
	IsAppFolder bool `json:"is_app_folder"`
}

type BaseDfbReport struct {
	// StartDate : First date present in the results as 'YYYY-MM-DD' or None.
	StartDate string `json:"start_date"`
}

type BaseTeamFolderError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
}

type Client interface {
	// DevicesListMemberDevices : List all device sessions of a team's member.
	DevicesListMemberDevices(arg *ListMemberDevicesArg) (res *ListMemberDevicesResult, err error)
	// DevicesListMembersDevices : List all device sessions of a team.
	// Permission : Team member file access.
	DevicesListMembersDevices(arg *ListMembersDevicesArg) (res *ListMembersDevicesResult, err error)
	// DevicesListTeamDevices : List all device sessions of a team. Permission :
	// Team member file access.
	// Deprecated: Use `DevicesListMembersDevices` instead
	DevicesListTeamDevices(arg *ListTeamDevicesArg) (res *ListTeamDevicesResult, err error)
	// DevicesRevokeDeviceSession : Revoke a device session of a team's member.
	DevicesRevokeDeviceSession(arg *RevokeDeviceSessionArg) (err error)
	// DevicesRevokeDeviceSessionBatch : Revoke a list of device sessions of
	// team members.
	DevicesRevokeDeviceSessionBatch(arg *RevokeDeviceSessionBatchArg) (res *RevokeDeviceSessionBatchResult, err error)
	// FeaturesGetValues : Get the values for one or more featues. This route
	// allows you to check your account's capability for what feature you can
	// access or what value you have for certain features. Permission : Team
	// information.
	FeaturesGetValues(arg *FeaturesGetValuesBatchArg) (res *FeaturesGetValuesBatchResult, err error)
	// GetInfo : Retrieves information about a team.
	GetInfo() (res *TeamGetInfoResult, err error)
	// GroupsCreate : Creates a new, empty group, with a requested name.
	// Permission : Team member management.
	GroupsCreate(arg *GroupCreateArg) (res *GroupFullInfo, err error)
	// GroupsDelete : Deletes a group. The group is deleted immediately. However
	// the revoking of group-owned resources may take additional time. Use the
	// `groupsJobStatusGet` to determine whether this process has completed.
	// Permission : Team member management.
	GroupsDelete(arg *GroupSelector) (res *async.LaunchEmptyResult, err error)
	// GroupsGetInfo : Retrieves information about one or more groups. Note that
	// the optional field  `GroupFullInfo.members` is not returned for
	// system-managed groups. Permission : Team Information.
	GroupsGetInfo(arg *GroupsSelector) (res []*GroupsGetInfoItem, err error)
	// GroupsJobStatusGet : Once an async_job_id is returned from
	// `groupsDelete`, `groupsMembersAdd` , or `groupsMembersRemove` use this
	// method to poll the status of granting/revoking group members' access to
	// group-owned resources. Permission : Team member management.
	GroupsJobStatusGet(arg *async.PollArg) (res *async.PollEmptyResult, err error)
	// GroupsList : Lists groups on a team. Permission : Team Information.
	GroupsList(arg *GroupsListArg) (res *GroupsListResult, err error)
	// GroupsListContinue : Once a cursor has been retrieved from `groupsList`,
	// use this to paginate through all groups. Permission : Team Information.
	GroupsListContinue(arg *GroupsListContinueArg) (res *GroupsListResult, err error)
	// GroupsMembersAdd : Adds members to a group. The members are added
	// immediately. However the granting of group-owned resources may take
	// additional time. Use the `groupsJobStatusGet` to determine whether this
	// process has completed. Permission : Team member management.
	GroupsMembersAdd(arg *GroupMembersAddArg) (res *GroupMembersChangeResult, err error)
	// GroupsMembersList : Lists members of a group. Permission : Team
	// Information.
	GroupsMembersList(arg *GroupsMembersListArg) (res *GroupsMembersListResult, err error)
	// GroupsMembersListContinue : Once a cursor has been retrieved from
	// `groupsMembersList`, use this to paginate through all members of the
	// group. Permission : Team information.
	GroupsMembersListContinue(arg *GroupsMembersListContinueArg) (res *GroupsMembersListResult, err error)
	// GroupsMembersRemove : Removes members from a group. The members are
	// removed immediately. However the revoking of group-owned resources may
	// take additional time. Use the `groupsJobStatusGet` to determine whether
	// this process has completed. This method permits removing the only owner
	// of a group, even in cases where this is not possible via the web client.
	// Permission : Team member management.
	GroupsMembersRemove(arg *GroupMembersRemoveArg) (res *GroupMembersChangeResult, err error)
	// GroupsMembersSetAccessType : Sets a member's access type in a group.
	// Permission : Team member management.
	GroupsMembersSetAccessType(arg *GroupMembersSetAccessTypeArg) (res []*GroupsGetInfoItem, err error)
	// GroupsUpdate : Updates a group's name and/or external ID. Permission :
	// Team member management.
	GroupsUpdate(arg *GroupUpdateArgs) (res *GroupFullInfo, err error)
	// LinkedAppsListMemberLinkedApps : List all linked applications of the team
	// member. Note, this endpoint does not list any team-linked applications.
	LinkedAppsListMemberLinkedApps(arg *ListMemberAppsArg) (res *ListMemberAppsResult, err error)
	// LinkedAppsListMembersLinkedApps : List all applications linked to the
	// team members' accounts. Note, this endpoint does not list any team-linked
	// applications.
	LinkedAppsListMembersLinkedApps(arg *ListMembersAppsArg) (res *ListMembersAppsResult, err error)
	// LinkedAppsListTeamLinkedApps : List all applications linked to the team
	// members' accounts. Note, this endpoint doesn't list any team-linked
	// applications.
	// Deprecated: Use `LinkedAppsListMembersLinkedApps` instead
	LinkedAppsListTeamLinkedApps(arg *ListTeamAppsArg) (res *ListTeamAppsResult, err error)
	// LinkedAppsRevokeLinkedApp : Revoke a linked application of the team
	// member.
	LinkedAppsRevokeLinkedApp(arg *RevokeLinkedApiAppArg) (err error)
	// LinkedAppsRevokeLinkedAppBatch : Revoke a list of linked applications of
	// the team members.
	LinkedAppsRevokeLinkedAppBatch(arg *RevokeLinkedApiAppBatchArg) (res *RevokeLinkedAppBatchResult, err error)
	// MemberSpaceLimitsExcludedUsersAdd : Add users to member space limits
	// excluded users list.
	MemberSpaceLimitsExcludedUsersAdd(arg *ExcludedUsersUpdateArg) (res *ExcludedUsersUpdateResult, err error)
	// MemberSpaceLimitsExcludedUsersList : List member space limits excluded
	// users.
	MemberSpaceLimitsExcludedUsersList(arg *ExcludedUsersListArg) (res *ExcludedUsersListResult, err error)
	// MemberSpaceLimitsExcludedUsersListContinue : Continue listing member
	// space limits excluded users.
	MemberSpaceLimitsExcludedUsersListContinue(arg *ExcludedUsersListContinueArg) (res *ExcludedUsersListResult, err error)
	// MemberSpaceLimitsExcludedUsersRemove : Remove users from member space
	// limits excluded users list.
	MemberSpaceLimitsExcludedUsersRemove(arg *ExcludedUsersUpdateArg) (res *ExcludedUsersUpdateResult, err error)
	// MemberSpaceLimitsGetCustomQuota : Get users custom quota. Returns none as
	// the custom quota if none was set. A maximum of 1000 members can be
	// specified in a single call.
	MemberSpaceLimitsGetCustomQuota(arg *CustomQuotaUsersArg) (res []*CustomQuotaResult, err error)
	// MemberSpaceLimitsRemoveCustomQuota : Remove users custom quota. A maximum
	// of 1000 members can be specified in a single call.
	MemberSpaceLimitsRemoveCustomQuota(arg *CustomQuotaUsersArg) (res []*RemoveCustomQuotaResult, err error)
	// MemberSpaceLimitsSetCustomQuota : Set users custom quota. Custom quota
	// has to be at least 15GB. A maximum of 1000 members can be specified in a
	// single call.
	MemberSpaceLimitsSetCustomQuota(arg *SetCustomQuotaArg) (res []*CustomQuotaResult, err error)
	// MembersAdd : Adds members to a team. Permission : Team member management
	// A maximum of 20 members can be specified in a single call. If no Dropbox
	// account exists with the email address specified, a new Dropbox account
	// will be created with the given email address, and that account will be
	// invited to the team. If a personal Dropbox account exists with the email
	// address specified in the call, this call will create a placeholder
	// Dropbox account for the user on the team and send an email inviting the
	// user to migrate their existing personal account onto the team. Team
	// member management apps are required to set an initial given_name and
	// surname for a user to use in the team invitation and for 'Perform as team
	// member' actions taken on the user before they become 'active'.
	MembersAdd(arg *MembersAddArg) (res *MembersAddLaunch, err error)
	// MembersAddJobStatusGet : Once an async_job_id is returned from
	// `membersAdd` , use this to poll the status of the asynchronous request.
	// Permission : Team member management.
	MembersAddJobStatusGet(arg *async.PollArg) (res *MembersAddJobStatus, err error)
	// MembersGetInfo : Returns information about multiple team members.
	// Permission : Team information This endpoint will return
	// `MembersGetInfoItem.id_not_found`, for IDs (or emails) that cannot be
	// matched to a valid team member.
	MembersGetInfo(arg *MembersGetInfoArgs) (res []*MembersGetInfoItem, err error)
	// MembersList : Lists members of a team. Permission : Team information.
	MembersList(arg *MembersListArg) (res *MembersListResult, err error)
	// MembersListContinue : Once a cursor has been retrieved from
	// `membersList`, use this to paginate through all team members. Permission
	// : Team information.
	MembersListContinue(arg *MembersListContinueArg) (res *MembersListResult, err error)
	// MembersMoveFormerMemberFiles : Moves removed member's files to a
	// different member. This endpoint initiates an asynchronous job. To obtain
	// the final result of the job, the client should periodically poll
	// `membersMoveFormerMemberFilesJobStatusCheck`. Permission : Team member
	// management.
	MembersMoveFormerMemberFiles(arg *MembersDataTransferArg) (res *async.LaunchEmptyResult, err error)
	// MembersMoveFormerMemberFilesJobStatusCheck : Once an async_job_id is
	// returned from `membersMoveFormerMemberFiles` , use this to poll the
	// status of the asynchronous request. Permission : Team member management.
	MembersMoveFormerMemberFilesJobStatusCheck(arg *async.PollArg) (res *async.PollEmptyResult, err error)
	// MembersRecover : Recover a deleted member. Permission : Team member
	// management Exactly one of team_member_id, email, or external_id must be
	// provided to identify the user account.
	MembersRecover(arg *MembersRecoverArg) (err error)
	// MembersRemove : Removes a member from a team. Permission : Team member
	// management Exactly one of team_member_id, email, or external_id must be
	// provided to identify the user account. Accounts can be recovered via
	// `membersRecover` for a 7 day period or until the account has been
	// permanently deleted or transferred to another account (whichever comes
	// first). Calling `membersAdd` while a user is still recoverable on your
	// team will return with `MemberAddResult.user_already_on_team`. Accounts
	// can have their files transferred via the admin console for a limited
	// time, based on the version history length associated with the team (120
	// days for most teams). This endpoint may initiate an asynchronous job. To
	// obtain the final result of the job, the client should periodically poll
	// `membersRemoveJobStatusGet`.
	MembersRemove(arg *MembersRemoveArg) (res *async.LaunchEmptyResult, err error)
	// MembersRemoveJobStatusGet : Once an async_job_id is returned from
	// `membersRemove` , use this to poll the status of the asynchronous
	// request. Permission : Team member management.
	MembersRemoveJobStatusGet(arg *async.PollArg) (res *async.PollEmptyResult, err error)
	// MembersSendWelcomeEmail : Sends welcome email to pending team member.
	// Permission : Team member management Exactly one of team_member_id, email,
	// or external_id must be provided to identify the user account. No-op if
	// team member is not pending.
	MembersSendWelcomeEmail(arg *UserSelectorArg) (err error)
	// MembersSetAdminPermissions : Updates a team member's permissions.
	// Permission : Team member management.
	MembersSetAdminPermissions(arg *MembersSetPermissionsArg) (res *MembersSetPermissionsResult, err error)
	// MembersSetProfile : Updates a team member's profile. Permission : Team
	// member management.
	MembersSetProfile(arg *MembersSetProfileArg) (res *TeamMemberInfo, err error)
	// MembersSuspend : Suspend a member from a team. Permission : Team member
	// management Exactly one of team_member_id, email, or external_id must be
	// provided to identify the user account.
	MembersSuspend(arg *MembersDeactivateArg) (err error)
	// MembersUnsuspend : Unsuspend a member from a team. Permission : Team
	// member management Exactly one of team_member_id, email, or external_id
	// must be provided to identify the user account.
	MembersUnsuspend(arg *MembersUnsuspendArg) (err error)
	// NamespacesList : Returns a list of all team-accessible namespaces. This
	// list includes team folders, shared folders containing team members, team
	// members' home namespaces, and team members' app folders. Home namespaces
	// and app folders are always owned by this team or members of the team, but
	// shared folders may be owned by other users or other teams. Duplicates may
	// occur in the list.
	NamespacesList(arg *TeamNamespacesListArg) (res *TeamNamespacesListResult, err error)
	// NamespacesListContinue : Once a cursor has been retrieved from
	// `namespacesList`, use this to paginate through all team-accessible
	// namespaces. Duplicates may occur in the list.
	NamespacesListContinue(arg *TeamNamespacesListContinueArg) (res *TeamNamespacesListResult, err error)
	// PropertiesTemplateAdd : Permission : Team member file access.
	// Deprecated:
	PropertiesTemplateAdd(arg *file_properties.AddTemplateArg) (res *file_properties.AddTemplateResult, err error)
	// PropertiesTemplateGet : Permission : Team member file access.
	// Deprecated:
	PropertiesTemplateGet(arg *file_properties.GetTemplateArg) (res *file_properties.GetTemplateResult, err error)
	// PropertiesTemplateList : Permission : Team member file access.
	// Deprecated:
	PropertiesTemplateList() (res *file_properties.ListTemplateResult, err error)
	// PropertiesTemplateUpdate : Permission : Team member file access.
	// Deprecated:
	PropertiesTemplateUpdate(arg *file_properties.UpdateTemplateArg) (res *file_properties.UpdateTemplateResult, err error)
	// ReportsGetActivity : Retrieves reporting data about a team's user
	// activity.
	ReportsGetActivity(arg *DateRange) (res *GetActivityReport, err error)
	// ReportsGetDevices : Retrieves reporting data about a team's linked
	// devices.
	ReportsGetDevices(arg *DateRange) (res *GetDevicesReport, err error)
	// ReportsGetMembership : Retrieves reporting data about a team's
	// membership.
	ReportsGetMembership(arg *DateRange) (res *GetMembershipReport, err error)
	// ReportsGetStorage : Retrieves reporting data about a team's storage
	// usage.
	ReportsGetStorage(arg *DateRange) (res *GetStorageReport, err error)
	// TeamFolderActivate : Sets an archived team folder's status to active.
	// Permission : Team member file access.
	TeamFolderActivate(arg *TeamFolderIdArg) (res *TeamFolderMetadata, err error)
	// TeamFolderArchive : Sets an active team folder's status to archived and
	// removes all folder and file members. Permission : Team member file
	// access.
	TeamFolderArchive(arg *TeamFolderArchiveArg) (res *TeamFolderArchiveLaunch, err error)
	// TeamFolderArchiveCheck : Returns the status of an asynchronous job for
	// archiving a team folder. Permission : Team member file access.
	TeamFolderArchiveCheck(arg *async.PollArg) (res *TeamFolderArchiveJobStatus, err error)
	// TeamFolderCreate : Creates a new, active, team folder with no members.
	// Permission : Team member file access.
	TeamFolderCreate(arg *TeamFolderCreateArg) (res *TeamFolderMetadata, err error)
	// TeamFolderGetInfo : Retrieves metadata for team folders. Permission :
	// Team member file access.
	TeamFolderGetInfo(arg *TeamFolderIdListArg) (res []*TeamFolderGetInfoItem, err error)
	// TeamFolderList : Lists all team folders. Permission : Team member file
	// access.
	TeamFolderList(arg *TeamFolderListArg) (res *TeamFolderListResult, err error)
	// TeamFolderListContinue : Once a cursor has been retrieved from
	// `teamFolderList`, use this to paginate through all team folders.
	// Permission : Team member file access.
	TeamFolderListContinue(arg *TeamFolderListContinueArg) (res *TeamFolderListResult, err error)
	// TeamFolderPermanentlyDelete : Permanently deletes an archived team
	// folder. Permission : Team member file access.
	TeamFolderPermanentlyDelete(arg *TeamFolderIdArg) (err error)
	// TeamFolderRename : Changes an active team folder's name. Permission :
	// Team member file access.
	TeamFolderRename(arg *TeamFolderRenameArg) (res *TeamFolderMetadata, err error)
	// TeamFolderUpdateSyncSettings : Updates the sync settings on a team folder
	// or its contents.  Use of this endpoint requires that the team has team
	// selective sync enabled.
	TeamFolderUpdateSyncSettings(arg *TeamFolderUpdateSyncSettingsArg) (res *TeamFolderMetadata, err error)
	// TokenGetAuthenticatedAdmin : Returns the member profile of the admin who
	// generated the team access token used to make the call.
	TokenGetAuthenticatedAdmin() (res *TokenGetAuthenticatedAdminResult, err error)
}

type CustomQuotaError struct {
	dropbox.Tagged
}

type CustomQuotaResult struct {
	dropbox.Tagged
	// Success : User's custom quota.
	Success *UserCustomQuotaResult `json:"success,omitempty"`
	// InvalidUser : Invalid user (not in team).
	InvalidUser *UserSelectorArg `json:"invalid_user,omitempty"`
}

type CustomQuotaUsersArg struct {
	// Users : List of users.
	Users []*UserSelectorArg `json:"users"`
}

type DateRange struct {
	// StartDate : Optional starting date (inclusive).
	StartDate time.Time `json:"start_date,omitempty"`
	// EndDate : Optional ending date (exclusive).
	EndDate time.Time `json:"end_date,omitempty"`
}

type DateRangeError struct {
	dropbox.Tagged
}

type DesktopClientSession struct {
	DeviceSession
	// HostName : Name of the hosting desktop.
	HostName string `json:"host_name"`
	// ClientType : The Dropbox desktop client type.
	ClientType *DesktopPlatform `json:"client_type"`
	// ClientVersion : The Dropbox client version.
	ClientVersion string `json:"client_version"`
	// Platform : Information on the hosting platform.
	Platform string `json:"platform"`
	// IsDeleteOnUnlinkSupported : Whether it's possible to delete all of the
	// account files upon unlinking.
	IsDeleteOnUnlinkSupported bool `json:"is_delete_on_unlink_supported"`
}

type DesktopPlatform struct {
	dropbox.Tagged
}

type DeviceSession struct {
	// SessionId : The session id.
	SessionId string `json:"session_id"`
	// IpAddress : The IP address of the last activity from this session.
	IpAddress string `json:"ip_address,omitempty"`
	// Country : The country from which the last activity from this session was
	// made.
	Country string `json:"country,omitempty"`
	// Created : The time this session was created.
	Created time.Time `json:"created,omitempty"`
	// Updated : The time of the last activity from this session.
	Updated time.Time `json:"updated,omitempty"`
}

type DeviceSessionArg struct {
	// SessionId : The session id.
	SessionId string `json:"session_id"`
	// TeamMemberId : The unique id of the member owning the device.
	TeamMemberId string `json:"team_member_id"`
}

type DevicesActive struct {
	// Windows : Array of number of linked windows (desktop) clients with
	// activity.
	Windows []uint64 `json:"windows"`
	// Macos : Array of number of linked mac (desktop) clients with activity.
	Macos []uint64 `json:"macos"`
	// Linux : Array of number of linked linus (desktop) clients with activity.
	Linux []uint64 `json:"linux"`
	// Ios : Array of number of linked ios devices with activity.
	Ios []uint64 `json:"ios"`
	// Android : Array of number of linked android devices with activity.
	Android []uint64 `json:"android"`
	// Other : Array of number of other linked devices (blackberry, windows
	// phone, etc)  with activity.
	Other []uint64 `json:"other"`
	// Total : Array of total number of linked clients with activity.
	Total []uint64 `json:"total"`
}

type DevicesListMemberDevicesAPIError struct {
	dropbox.APIError
	EndpointError *ListMemberDevicesError `json:"error"`
}

type DevicesListMembersDevicesAPIError struct {
	dropbox.APIError
	EndpointError *ListMembersDevicesError `json:"error"`
}

type DevicesListTeamDevicesAPIError struct {
	dropbox.APIError
	EndpointError *ListTeamDevicesError `json:"error"`
}

type DevicesRevokeDeviceSessionAPIError struct {
	dropbox.APIError
	EndpointError *RevokeDeviceSessionError `json:"error"`
}

type DevicesRevokeDeviceSessionBatchAPIError struct {
	dropbox.APIError
	EndpointError *RevokeDeviceSessionBatchError `json:"error"`
}

type ExcludedUsersListArg struct {
	// Limit : Number of results to return per call.
	Limit uint32 `json:"limit"`
}

type ExcludedUsersListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of users.
	Cursor string `json:"cursor"`
}

type ExcludedUsersListContinueError struct {
	dropbox.Tagged
}

type ExcludedUsersListError struct {
	dropbox.Tagged
}

type ExcludedUsersListResult struct {
	// Users : has no documentation (yet)
	Users []*MemberProfile `json:"users"`
	// Cursor : Pass the cursor into
	// `memberSpaceLimitsExcludedUsersListContinue` to obtain additional
	// excluded users.
	Cursor string `json:"cursor,omitempty"`
	// HasMore : Is true if there are additional excluded users that have not
	// been returned yet. An additional call to
	// `memberSpaceLimitsExcludedUsersListContinue` can retrieve them.
	HasMore bool `json:"has_more"`
}

type ExcludedUsersUpdateArg struct {
	// Users : List of users to be added/removed.
	Users []*UserSelectorArg `json:"users,omitempty"`
}

type ExcludedUsersUpdateError struct {
	dropbox.Tagged
}

type ExcludedUsersUpdateResult struct {
	// Status : Update status.
	Status *ExcludedUsersUpdateStatus `json:"status"`
}

type ExcludedUsersUpdateStatus struct {
	dropbox.Tagged
}

type Feature struct {
	dropbox.Tagged
}

type FeatureValue struct {
	dropbox.Tagged
	// UploadApiRateLimit : has no documentation (yet)
	UploadApiRateLimit *UploadApiRateLimitValue `json:"upload_api_rate_limit,omitempty"`
	// HasTeamSharedDropbox : has no documentation (yet)
	HasTeamSharedDropbox *HasTeamSharedDropboxValue `json:"has_team_shared_dropbox,omitempty"`
	// HasTeamFileEvents : has no documentation (yet)
	HasTeamFileEvents *HasTeamFileEventsValue `json:"has_team_file_events,omitempty"`
	// HasTeamSelectiveSync : has no documentation (yet)
	HasTeamSelectiveSync *HasTeamSelectiveSyncValue `json:"has_team_selective_sync,omitempty"`
}

type FeaturesGetValuesAPIError struct {
	dropbox.APIError
	EndpointError *FeaturesGetValuesBatchError `json:"error"`
}

type FeaturesGetValuesBatchArg struct {
	// Features : A list of features in `Feature`. If the list is empty, this
	// route will return `FeaturesGetValuesBatchError`.
	Features []*Feature `json:"features"`
}

type FeaturesGetValuesBatchError struct {
	dropbox.Tagged
}

type FeaturesGetValuesBatchResult struct {
	// Values : has no documentation (yet)
	Values []*FeatureValue `json:"values"`
}

type GetActivityReport struct {
	BaseDfbReport
	// Adds : Array of total number of adds by team members.
	Adds []uint64 `json:"adds"`
	// 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.
	Edits []uint64 `json:"edits"`
	// Deletes : Array of total number of deletes by team members.
	Deletes []uint64 `json:"deletes"`
	// ActiveUsers28Day : Array of the number of users who have been active in
	// the last 28 days.
	ActiveUsers28Day []uint64 `json:"active_users_28_day"`
	// ActiveUsers7Day : Array of the number of users who have been active in
	// the last week.
	ActiveUsers7Day []uint64 `json:"active_users_7_day"`
	// ActiveUsers1Day : Array of the number of users who have been active in
	// the last day.
	ActiveUsers1Day []uint64 `json:"active_users_1_day"`
	// ActiveSharedFolders28Day : Array of the number of shared folders with
	// some activity in the last 28 days.
	ActiveSharedFolders28Day []uint64 `json:"active_shared_folders_28_day"`
	// ActiveSharedFolders7Day : Array of the number of shared folders with some
	// activity in the last week.
	ActiveSharedFolders7Day []uint64 `json:"active_shared_folders_7_day"`
	// ActiveSharedFolders1Day : Array of the number of shared folders with some
	// activity in the last day.
	ActiveSharedFolders1Day []uint64 `json:"active_shared_folders_1_day"`
	// SharedLinksCreated : Array of the number of shared links created.
	SharedLinksCreated []uint64 `json:"shared_links_created"`
	// SharedLinksViewedByTeam : Array of the number of views by team users to
	// shared links created by the team.
	SharedLinksViewedByTeam []uint64 `json:"shared_links_viewed_by_team"`
	// SharedLinksViewedByOutsideUser : Array of the number of views by users
	// outside of the team to shared links created by the team.
	SharedLinksViewedByOutsideUser []uint64 `json:"shared_links_viewed_by_outside_user"`
	// SharedLinksViewedByNotLoggedIn : Array of the number of views by
	// non-logged-in users to shared links created by the team.
	SharedLinksViewedByNotLoggedIn []uint64 `json:"shared_links_viewed_by_not_logged_in"`
	// SharedLinksViewedTotal : Array of the total number of views to shared
	// links created by the team.
	SharedLinksViewedTotal []uint64 `json:"shared_links_viewed_total"`
}

type GetDevicesReport struct {
	BaseDfbReport
	// Active1Day : Report of the number of devices active in the last day.
	Active1Day *DevicesActive `json:"active_1_day"`
	// Active7Day : Report of the number of devices active in the last 7 days.
	Active7Day *DevicesActive `json:"active_7_day"`
	// Active28Day : Report of the number of devices active in the last 28 days.
	Active28Day *DevicesActive `json:"active_28_day"`
}

type GetInfoAPIError struct {
	dropbox.APIError
	EndpointError struct{} `json:"error"`
}

type GetMembershipReport struct {
	BaseDfbReport
	// TeamSize : Team size, for each day.
	TeamSize []uint64 `json:"team_size"`
	// PendingInvites : The number of pending invites to the team, for each day.
	PendingInvites []uint64 `json:"pending_invites"`
	// MembersJoined : The number of members that joined the team, for each day.
	MembersJoined []uint64 `json:"members_joined"`
	// SuspendedMembers : The number of suspended team members, for each day.
	SuspendedMembers []uint64 `json:"suspended_members"`
	// Licenses : The total number of licenses the team has, for each day.
	Licenses []uint64 `json:"licenses"`
}

type GetStorageReport struct {
	BaseDfbReport
	// TotalUsage : Sum of the shared, unshared, and datastore usages, for each
	// day.
	TotalUsage []uint64 `json:"total_usage"`
	// SharedUsage : Array of the combined size (bytes) of team members' shared
	// folders, for each day.
	SharedUsage []uint64 `json:"shared_usage"`
	// UnsharedUsage : Array of the combined size (bytes) of team members' root
	// namespaces, for each day.
	UnsharedUsage []uint64 `json:"unshared_usage"`
	// SharedFolders : Array of the number of shared folders owned by team
	// members, for each day.
	SharedFolders []uint64 `json:"shared_folders"`
	// MemberStorageMap : 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.
	MemberStorageMap [][]*StorageBucket `json:"member_storage_map"`
}

type GroupAccessType struct {
	dropbox.Tagged
}

type GroupCreateArg struct {
	// GroupName : Group name.
	GroupName string `json:"group_name"`
	// GroupExternalId : The creator of a team can associate an arbitrary
	// external ID to the group.
	GroupExternalId string `json:"group_external_id,omitempty"`
	// GroupManagementType : Whether the team can be managed by selected users,
	// or only by team admins.
	GroupManagementType *team_common.GroupManagementType `json:"group_management_type,omitempty"`
}

type GroupCreateError struct {
	dropbox.Tagged
}

type GroupDeleteError struct {
	dropbox.Tagged
}

type GroupFullInfo struct {
	team_common.GroupSummary
	// Members : List of group members.
	Members []*GroupMemberInfo `json:"members,omitempty"`
	// Created : The group creation time as a UTC timestamp in milliseconds
	// since the Unix epoch.
	Created uint64 `json:"created"`
}

type GroupMemberInfo struct {
	// Profile : Profile of group member.
	Profile *MemberProfile `json:"profile"`
	// AccessType : The role that the user has in the group.
	AccessType *GroupAccessType `json:"access_type"`
}

type GroupMemberSelector struct {
	// Group : Specify a group.
	Group *GroupSelector `json:"group"`
	// User : Identity of a user that is a member of `group`.
	User *UserSelectorArg `json:"user"`
}

type GroupMemberSelectorError struct {
	dropbox.Tagged
}

type GroupMemberSetAccessTypeError struct {
	dropbox.Tagged
}

type GroupMembersAddArg struct {
	IncludeMembersArg
	// Group : Group to which users will be added.
	Group *GroupSelector `json:"group"`
	// Members : List of users to be added to the group.
	Members []*MemberAccess `json:"members"`
}

type GroupMembersAddError struct {
	dropbox.Tagged
	// MembersNotInTeam : 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 `membersAdd` endpoint.
	MembersNotInTeam []string `json:"members_not_in_team,omitempty"`
	// UsersNotFound : These users were not found in Dropbox.
	UsersNotFound []string `json:"users_not_found,omitempty"`
	// UserCannotBeManagerOfCompanyManagedGroup : A company-managed group cannot
	// be managed by a user.
	UserCannotBeManagerOfCompanyManagedGroup []string `json:"user_cannot_be_manager_of_company_managed_group,omitempty"`
}

type GroupMembersChangeResult struct {
	// GroupInfo : The group info after member change operation has been
	// performed.
	GroupInfo *GroupFullInfo `json:"group_info"`
	// AsyncJobId : An ID that can be used to obtain the status of
	// granting/revoking group-owned resources.
	AsyncJobId string `json:"async_job_id"`
}

type GroupMembersRemoveArg struct {
	IncludeMembersArg
	// Group : Group from which users will be removed.
	Group *GroupSelector `json:"group"`
	// Users : List of users to be removed from the group.
	Users []*UserSelectorArg `json:"users"`
}

type GroupMembersRemoveError struct {
	dropbox.Tagged
	// MembersNotInTeam : These members are not part of your team.
	MembersNotInTeam []string `json:"members_not_in_team,omitempty"`
	// UsersNotFound : These users were not found in Dropbox.
	UsersNotFound []string `json:"users_not_found,omitempty"`
}

type GroupMembersSelector struct {
	// Group : Specify a group.
	Group *GroupSelector `json:"group"`
	// Users : A list of users that are members of `group`.
	Users *UsersSelectorArg `json:"users"`
}

type GroupMembersSelectorError struct {
	dropbox.Tagged
}

type GroupMembersSetAccessTypeArg struct {
	GroupMemberSelector
	// AccessType : New group access type the user will have.
	AccessType *GroupAccessType `json:"access_type"`
	// ReturnMembers : 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.
	ReturnMembers bool `json:"return_members"`
}

type GroupSelector struct {
	dropbox.Tagged
	// GroupId : Group ID.
	GroupId string `json:"group_id,omitempty"`
	// GroupExternalId : External ID of the group.
	GroupExternalId string `json:"group_external_id,omitempty"`
}

type GroupSelectorError struct {
	dropbox.Tagged
}

type GroupSelectorWithTeamGroupError struct {
	dropbox.Tagged
}

type GroupUpdateArgs struct {
	IncludeMembersArg
	// Group : Specify a group.
	Group *GroupSelector `json:"group"`
	// NewGroupName : Optional argument. Set group name to this if provided.
	NewGroupName string `json:"new_group_name,omitempty"`
	// NewGroupExternalId : 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.
	NewGroupExternalId string `json:"new_group_external_id,omitempty"`
	// NewGroupManagementType : Set new group management type, if provided.
	NewGroupManagementType *team_common.GroupManagementType `json:"new_group_management_type,omitempty"`
}

type GroupUpdateError struct {
	dropbox.Tagged
}

type GroupsCreateAPIError struct {
	dropbox.APIError
	EndpointError *GroupCreateError `json:"error"`
}

type GroupsDeleteAPIError struct {
	dropbox.APIError
	EndpointError *GroupDeleteError `json:"error"`
}

type GroupsGetInfoAPIError struct {
	dropbox.APIError
	EndpointError *GroupsGetInfoError `json:"error"`
}

type GroupsGetInfoError struct {
	dropbox.Tagged
}

type GroupsGetInfoItem struct {
	dropbox.Tagged
	// IdNotFound : An ID that was provided as a parameter to `groupsGetInfo`,
	// 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.
	IdNotFound string `json:"id_not_found,omitempty"`
	// GroupInfo : Info about a group.
	GroupInfo *GroupFullInfo `json:"group_info,omitempty"`
}

type GroupsJobStatusGetAPIError struct {
	dropbox.APIError
	EndpointError *GroupsPollError `json:"error"`
}

type GroupsListAPIError struct {
	dropbox.APIError
	EndpointError struct{} `json:"error"`
}

type GroupsListArg struct {
	// Limit : Number of results to return per call.
	Limit uint32 `json:"limit"`
}

type GroupsListContinueAPIError struct {
	dropbox.APIError
	EndpointError *GroupsListContinueError `json:"error"`
}

type GroupsListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of groups.
	Cursor string `json:"cursor"`
}

type GroupsListContinueError struct {
	dropbox.Tagged
}

type GroupsListResult struct {
	// Groups : has no documentation (yet)
	Groups []*team_common.GroupSummary `json:"groups"`
	// Cursor : Pass the cursor into `groupsListContinue` to obtain the
	// additional groups.
	Cursor string `json:"cursor"`
	// HasMore : Is true if there are additional groups that have not been
	// returned yet. An additional call to `groupsListContinue` can retrieve
	// them.
	HasMore bool `json:"has_more"`
}

type GroupsMembersAddAPIError struct {
	dropbox.APIError
	EndpointError *GroupMembersAddError `json:"error"`
}

type GroupsMembersListAPIError struct {
	dropbox.APIError
	EndpointError *GroupSelectorError `json:"error"`
}

type GroupsMembersListArg struct {
	// Group : The group whose members are to be listed.
	Group *GroupSelector `json:"group"`
	// Limit : Number of results to return per call.
	Limit uint32 `json:"limit"`
}

type GroupsMembersListContinueAPIError struct {
	dropbox.APIError
	EndpointError *GroupsMembersListContinueError `json:"error"`
}

type GroupsMembersListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of groups.
	Cursor string `json:"cursor"`
}

type GroupsMembersListContinueError struct {
	dropbox.Tagged
}

type GroupsMembersListResult struct {
	// Members : has no documentation (yet)
	Members []*GroupMemberInfo `json:"members"`
	// Cursor : Pass the cursor into `groupsMembersListContinue` to obtain
	// additional group members.
	Cursor string `json:"cursor"`
	// HasMore : Is true if there are additional group members that have not
	// been returned yet. An additional call to `groupsMembersListContinue` can
	// retrieve them.
	HasMore bool `json:"has_more"`
}

type GroupsMembersRemoveAPIError struct {
	dropbox.APIError
	EndpointError *GroupMembersRemoveError `json:"error"`
}

type GroupsMembersSetAccessTypeAPIError struct {
	dropbox.APIError
	EndpointError *GroupMemberSetAccessTypeError `json:"error"`
}

type GroupsPollError struct {
	dropbox.Tagged
}

type GroupsSelector struct {
	dropbox.Tagged
	// GroupIds : List of group IDs.
	GroupIds []string `json:"group_ids,omitempty"`
	// GroupExternalIds : List of external IDs of groups.
	GroupExternalIds []string `json:"group_external_ids,omitempty"`
}

type GroupsUpdateAPIError struct {
	dropbox.APIError
	EndpointError *GroupUpdateError `json:"error"`
}

type HasTeamFileEventsValue struct {
	dropbox.Tagged
	// Enabled : Does this team have file events.
	Enabled bool `json:"enabled,omitempty"`
}

type HasTeamSelectiveSyncValue struct {
	dropbox.Tagged
	// HasTeamSelectiveSync : Does this team have team selective sync enabled.
	HasTeamSelectiveSync bool `json:"has_team_selective_sync,omitempty"`
}

type HasTeamSharedDropboxValue struct {
	dropbox.Tagged
	// HasTeamSharedDropbox : Does this team have a shared team root.
	HasTeamSharedDropbox bool `json:"has_team_shared_dropbox,omitempty"`
}

type IncludeMembersArg struct {
	// ReturnMembers : 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.
	ReturnMembers bool `json:"return_members"`
}

type LinkedAppsListMemberLinkedAppsAPIError struct {
	dropbox.APIError
	EndpointError *ListMemberAppsError `json:"error"`
}

type LinkedAppsListMembersLinkedAppsAPIError struct {
	dropbox.APIError
	EndpointError *ListMembersAppsError `json:"error"`
}

type LinkedAppsListTeamLinkedAppsAPIError struct {
	dropbox.APIError
	EndpointError *ListTeamAppsError `json:"error"`
}

type LinkedAppsRevokeLinkedAppAPIError struct {
	dropbox.APIError
	EndpointError *RevokeLinkedAppError `json:"error"`
}

type LinkedAppsRevokeLinkedAppBatchAPIError struct {
	dropbox.APIError
	EndpointError *RevokeLinkedAppBatchError `json:"error"`
}

type ListMemberAppsArg struct {
	// TeamMemberId : The team member id.
	TeamMemberId string `json:"team_member_id"`
}

type ListMemberAppsError struct {
	dropbox.Tagged
}

type ListMemberAppsResult struct {
	// LinkedApiApps : List of third party applications linked by this team
	// member.
	LinkedApiApps []*ApiApp `json:"linked_api_apps"`
}

type ListMemberDevicesArg struct {
	// TeamMemberId : The team's member id.
	TeamMemberId string `json:"team_member_id"`
	// IncludeWebSessions : Whether to list web sessions of the team's member.
	IncludeWebSessions bool `json:"include_web_sessions"`
	// IncludeDesktopClients : Whether to list linked desktop devices of the
	// team's member.
	IncludeDesktopClients bool `json:"include_desktop_clients"`
	// IncludeMobileClients : Whether to list linked mobile devices of the
	// team's member.
	IncludeMobileClients bool `json:"include_mobile_clients"`
}

type ListMemberDevicesError struct {
	dropbox.Tagged
}

type ListMemberDevicesResult struct {
	// ActiveWebSessions : List of web sessions made by this team member.
	ActiveWebSessions []*ActiveWebSession `json:"active_web_sessions,omitempty"`
	// DesktopClientSessions : List of desktop clients used by this team member.
	DesktopClientSessions []*DesktopClientSession `json:"desktop_client_sessions,omitempty"`
	// MobileClientSessions : List of mobile client used by this team member.
	MobileClientSessions []*MobileClientSession `json:"mobile_client_sessions,omitempty"`
}

type ListMembersAppsArg struct {
	// Cursor : At the first call to the `linkedAppsListMembersLinkedApps` 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.
	Cursor string `json:"cursor,omitempty"`
}

type ListMembersAppsError struct {
	dropbox.Tagged
}

type ListMembersAppsResult struct {
	// Apps : The linked applications of each member of the team.
	Apps []*MemberLinkedApps `json:"apps"`
	// HasMore : If true, then there are more apps available. Pass the cursor to
	// `linkedAppsListMembersLinkedApps` to retrieve the rest.
	HasMore bool `json:"has_more"`
	// Cursor : Pass the cursor into `linkedAppsListMembersLinkedApps` to
	// receive the next sub list of team's applications.
	Cursor string `json:"cursor,omitempty"`
}

type ListMembersDevicesArg struct {
	// Cursor : At the first call to the `devicesListMembersDevices` 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.
	Cursor string `json:"cursor,omitempty"`
	// IncludeWebSessions : Whether to list web sessions of the team members.
	IncludeWebSessions bool `json:"include_web_sessions"`
	// IncludeDesktopClients : Whether to list desktop clients of the team
	// members.
	IncludeDesktopClients bool `json:"include_desktop_clients"`
	// IncludeMobileClients : Whether to list mobile clients of the team
	// members.
	IncludeMobileClients bool `json:"include_mobile_clients"`
}

type ListMembersDevicesError struct {
	dropbox.Tagged
}

type ListMembersDevicesResult struct {
	// Devices : The devices of each member of the team.
	Devices []*MemberDevices `json:"devices"`
	// HasMore : If true, then there are more devices available. Pass the cursor
	// to `devicesListMembersDevices` to retrieve the rest.
	HasMore bool `json:"has_more"`
	// Cursor : Pass the cursor into `devicesListMembersDevices` to receive the
	// next sub list of team's devices.
	Cursor string `json:"cursor,omitempty"`
}

type ListTeamAppsArg struct {
	// Cursor : At the first call to the `linkedAppsListTeamLinkedApps` 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.
	Cursor string `json:"cursor,omitempty"`
}

type ListTeamAppsError struct {
	dropbox.Tagged
}

type ListTeamAppsResult struct {
	// Apps : The linked applications of each member of the team.
	Apps []*MemberLinkedApps `json:"apps"`
	// HasMore : If true, then there are more apps available. Pass the cursor to
	// `linkedAppsListTeamLinkedApps` to retrieve the rest.
	HasMore bool `json:"has_more"`
	// Cursor : Pass the cursor into `linkedAppsListTeamLinkedApps` to receive
	// the next sub list of team's applications.
	Cursor string `json:"cursor,omitempty"`
}

type ListTeamDevicesArg struct {
	// Cursor : At the first call to the `devicesListTeamDevices` 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.
	Cursor string `json:"cursor,omitempty"`
	// IncludeWebSessions : Whether to list web sessions of the team members.
	IncludeWebSessions bool `json:"include_web_sessions"`
	// IncludeDesktopClients : Whether to list desktop clients of the team
	// members.
	IncludeDesktopClients bool `json:"include_desktop_clients"`
	// IncludeMobileClients : Whether to list mobile clients of the team
	// members.
	IncludeMobileClients bool `json:"include_mobile_clients"`
}

type ListTeamDevicesError struct {
	dropbox.Tagged
}

type ListTeamDevicesResult struct {
	// Devices : The devices of each member of the team.
	Devices []*MemberDevices `json:"devices"`
	// HasMore : If true, then there are more devices available. Pass the cursor
	// to `devicesListTeamDevices` to retrieve the rest.
	HasMore bool `json:"has_more"`
	// Cursor : Pass the cursor into `devicesListTeamDevices` to receive the
	// next sub list of team's devices.
	Cursor string `json:"cursor,omitempty"`
}

type MemberAccess struct {
	// User : Identity of a user.
	User *UserSelectorArg `json:"user"`
	// AccessType : Access type.
	AccessType *GroupAccessType `json:"access_type"`
}

type MemberAddArg struct {
	// MemberEmail : has no documentation (yet)
	MemberEmail string `json:"member_email"`
	// MemberGivenName : Member's first name.
	MemberGivenName string `json:"member_given_name,omitempty"`
	// MemberSurname : Member's last name.
	MemberSurname string `json:"member_surname,omitempty"`
	// MemberExternalId : External ID for member.
	MemberExternalId string `json:"member_external_id,omitempty"`
	// MemberPersistentId : Persistent ID for member. This field is only
	// available to teams using persistent ID SAML configuration.
	MemberPersistentId string `json:"member_persistent_id,omitempty"`
	// SendWelcomeEmail : 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.
	SendWelcomeEmail bool `json:"send_welcome_email"`
	// Role : has no documentation (yet)
	Role *AdminTier `json:"role"`
	// IsDirectoryRestricted : Whether a user is directory restricted.
	IsDirectoryRestricted bool `json:"is_directory_restricted,omitempty"`
}

type MemberAddResult struct {
	dropbox.Tagged
	// Success : Describes a user that was successfully added to the team.
	Success *TeamMemberInfo `json:"success,omitempty"`
	// TeamLicenseLimit : Team is already full. The organization has no
	// available licenses.
	TeamLicenseLimit string `json:"team_license_limit,omitempty"`
	// FreeTeamMemberLimitReached : Team is already full. The free team member
	// limit has been reached.
	FreeTeamMemberLimitReached string `json:"free_team_member_limit_reached,omitempty"`
	// UserAlreadyOnTeam : 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.
	UserAlreadyOnTeam string `json:"user_already_on_team,omitempty"`
	// UserOnAnotherTeam : 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.
	UserOnAnotherTeam string `json:"user_on_another_team,omitempty"`
	// UserAlreadyPaired : User is already paired.
	UserAlreadyPaired string `json:"user_already_paired,omitempty"`
	// UserMigrationFailed : User migration has failed.
	UserMigrationFailed string `json:"user_migration_failed,omitempty"`
	// DuplicateExternalMemberId : A user with the given external member ID
	// already exists on the team (including in recoverable state).
	DuplicateExternalMemberId string `json:"duplicate_external_member_id,omitempty"`
	// DuplicateMemberPersistentId : A user with the given persistent ID already
	// exists on the team (including in recoverable state).
	DuplicateMemberPersistentId string `json:"duplicate_member_persistent_id,omitempty"`
	// PersistentIdDisabled : Persistent ID is only available to teams with
	// persistent ID SAML configuration. Please contact Dropbox for more
	// information.
	PersistentIdDisabled string `json:"persistent_id_disabled,omitempty"`
	// UserCreationFailed : User creation has failed.
	UserCreationFailed string `json:"user_creation_failed,omitempty"`
}

type MemberDevices struct {
	// TeamMemberId : The member unique Id.
	TeamMemberId string `json:"team_member_id"`
	// WebSessions : List of web sessions made by this team member.
	WebSessions []*ActiveWebSession `json:"web_sessions,omitempty"`
	// DesktopClients : List of desktop clients by this team member.
	DesktopClients []*DesktopClientSession `json:"desktop_clients,omitempty"`
	// MobileClients : List of mobile clients by this team member.
	MobileClients []*MobileClientSession `json:"mobile_clients,omitempty"`
}

type MemberLinkedApps struct {
	// TeamMemberId : The member unique Id.
	TeamMemberId string `json:"team_member_id"`
	// LinkedApiApps : List of third party applications linked by this team
	// member.
	LinkedApiApps []*ApiApp `json:"linked_api_apps"`
}

type MemberProfile struct {
	// TeamMemberId : ID of user as a member of a team.
	TeamMemberId string `json:"team_member_id"`
	// ExternalId : 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.
	ExternalId string `json:"external_id,omitempty"`
	// AccountId : A user's account identifier.
	AccountId string `json:"account_id,omitempty"`
	// Email : Email address of user.
	Email string `json:"email"`
	// EmailVerified : Is true if the user's email is verified to be owned by
	// the user.
	EmailVerified bool `json:"email_verified"`
	// Status : The user's status as a member of a specific team.
	Status *TeamMemberStatus `json:"status"`
	// Name : Representations for a person's name.
	Name *users.Name `json:"name"`
	// MembershipType : The user's membership type: full (normal team member) vs
	// limited (does not use a license; no access to the team's shared quota).
	MembershipType *TeamMembershipType `json:"membership_type"`
	// JoinedOn : The date and time the user joined as a member of a specific
	// team.
	JoinedOn time.Time `json:"joined_on,omitempty"`
	// SuspendedOn : The date and time the user was suspended from the team
	// (contains value only when the member's status matches
	// `TeamMemberStatus.suspended`.
	SuspendedOn time.Time `json:"suspended_on,omitempty"`
	// PersistentId : Persistent ID that a team can attach to the user. The
	// persistent ID is unique ID to be used for SAML authentication.
	PersistentId string `json:"persistent_id,omitempty"`
	// IsDirectoryRestricted : Whether the user is a directory restricted user.
	IsDirectoryRestricted bool `json:"is_directory_restricted,omitempty"`
	// ProfilePhotoUrl : URL for the photo representing the user, if one is set.
	ProfilePhotoUrl string `json:"profile_photo_url,omitempty"`
}

type MemberSelectorError struct {
	dropbox.Tagged
}

type MemberSpaceLimitsExcludedUsersAddAPIError struct {
	dropbox.APIError
	EndpointError *ExcludedUsersUpdateError `json:"error"`
}

type MemberSpaceLimitsExcludedUsersListAPIError struct {
	dropbox.APIError
	EndpointError *ExcludedUsersListError `json:"error"`
}

type MemberSpaceLimitsExcludedUsersListContinueAPIError struct {
	dropbox.APIError
	EndpointError *ExcludedUsersListContinueError `json:"error"`
}

type MemberSpaceLimitsExcludedUsersRemoveAPIError struct {
	dropbox.APIError
	EndpointError *ExcludedUsersUpdateError `json:"error"`
}

type MemberSpaceLimitsGetCustomQuotaAPIError struct {
	dropbox.APIError
	EndpointError *CustomQuotaError `json:"error"`
}

type MemberSpaceLimitsRemoveCustomQuotaAPIError struct {
	dropbox.APIError
	EndpointError *CustomQuotaError `json:"error"`
}

type MemberSpaceLimitsSetCustomQuotaAPIError struct {
	dropbox.APIError
	EndpointError *SetCustomQuotaError `json:"error"`
}

type MembersAddAPIError struct {
	dropbox.APIError
	EndpointError struct{} `json:"error"`
}

type MembersAddArg struct {
	// NewMembers : Details of new members to be added to the team.
	NewMembers []*MemberAddArg `json:"new_members"`
	// ForceAsync : Whether to force the add to happen asynchronously.
	ForceAsync bool `json:"force_async"`
}

type MembersAddJobStatus struct {
	dropbox.Tagged
	// Complete : The asynchronous job has finished. For each member that was
	// specified in the parameter `MembersAddArg` that was provided to
	// `membersAdd`, a corresponding item is returned in this list.
	Complete []*MemberAddResult `json:"complete,omitempty"`
	// Failed : The asynchronous job returned an error. The string contains an
	// error message.
	Failed string `json:"failed,omitempty"`
}

type MembersAddJobStatusGetAPIError struct {
	dropbox.APIError
	EndpointError *async.PollError `json:"error"`
}

type MembersAddLaunch struct {
	dropbox.Tagged
	// AsyncJobId : This response indicates that the processing is asynchronous.
	// The string is an id that can be used to obtain the status of the
	// asynchronous job.
	AsyncJobId string `json:"async_job_id,omitempty"`
	// Complete : has no documentation (yet)
	Complete []*MemberAddResult `json:"complete,omitempty"`
}

type MembersDataTransferArg struct {
	MembersDeactivateBaseArg
	// TransferDestId : Files from the deleted member account will be
	// transferred to this user.
	TransferDestId *UserSelectorArg `json:"transfer_dest_id"`
	// TransferAdminId : Errors during the transfer process will be sent via
	// email to this user.
	TransferAdminId *UserSelectorArg `json:"transfer_admin_id"`
}

type MembersDeactivateArg struct {
	MembersDeactivateBaseArg
	// WipeData : If provided, controls if the user's data will be deleted on
	// their linked devices.
	WipeData bool `json:"wipe_data"`
}

type MembersDeactivateBaseArg struct {
	// User : Identity of user to remove/suspend/have their files moved.
	User *UserSelectorArg `json:"user"`
}

type MembersDeactivateError struct {
	dropbox.Tagged
}

type MembersGetInfoAPIError struct {
	dropbox.APIError
	EndpointError *MembersGetInfoError `json:"error"`
}

type MembersGetInfoArgs struct {
	// Members : List of team members.
	Members []*UserSelectorArg `json:"members"`
}

type MembersGetInfoError struct {
	dropbox.Tagged
}

type MembersGetInfoItem struct {
	dropbox.Tagged
	// IdNotFound : An ID that was provided as a parameter to `membersGetInfo`,
	// 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.
	IdNotFound string `json:"id_not_found,omitempty"`
	// MemberInfo : Info about a team member.
	MemberInfo *TeamMemberInfo `json:"member_info,omitempty"`
}

type MembersListAPIError struct {
	dropbox.APIError
	EndpointError *MembersListError `json:"error"`
}

type MembersListArg struct {
	// Limit : Number of results to return per call.
	Limit uint32 `json:"limit"`
	// IncludeRemoved : Whether to return removed members.
	IncludeRemoved bool `json:"include_removed"`
}

type MembersListContinueAPIError struct {
	dropbox.APIError
	EndpointError *MembersListContinueError `json:"error"`
}

type MembersListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of members.
	Cursor string `json:"cursor"`
}

type MembersListContinueError struct {
	dropbox.Tagged
}

type MembersListError struct {
	dropbox.Tagged
}

type MembersListResult struct {
	// Members : List of team members.
	Members []*TeamMemberInfo `json:"members"`
	// Cursor : Pass the cursor into `membersListContinue` to obtain the
	// additional members.
	Cursor string `json:"cursor"`
	// HasMore : Is true if there are additional team members that have not been
	// returned yet. An additional call to `membersListContinue` can retrieve
	// them.
	HasMore bool `json:"has_more"`
}

type MembersMoveFormerMemberFilesAPIError struct {
	dropbox.APIError
	EndpointError *MembersTransferFormerMembersFilesError `json:"error"`
}

type MembersMoveFormerMemberFilesJobStatusCheckAPIError struct {
	dropbox.APIError
	EndpointError *async.PollError `json:"error"`
}

type MembersRecoverAPIError struct {
	dropbox.APIError
	EndpointError *MembersRecoverError `json:"error"`
}

type MembersRecoverArg struct {
	// User : Identity of user to recover.
	User *UserSelectorArg `json:"user"`
}

type MembersRecoverError struct {
	dropbox.Tagged
}

type MembersRemoveAPIError struct {
	dropbox.APIError
	EndpointError *MembersRemoveError `json:"error"`
}

type MembersRemoveArg struct {
	MembersDeactivateArg
	// TransferDestId : If provided, files from the deleted member account will
	// be transferred to this user.
	TransferDestId *UserSelectorArg `json:"transfer_dest_id,omitempty"`
	// TransferAdminId : 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.
	TransferAdminId *UserSelectorArg `json:"transfer_admin_id,omitempty"`
	// KeepAccount : 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.
	KeepAccount bool `json:"keep_account"`
}

type MembersRemoveError struct {
	dropbox.Tagged
}

type MembersRemoveJobStatusGetAPIError struct {
	dropbox.APIError
	EndpointError *async.PollError `json:"error"`
}

type MembersSendWelcomeEmailAPIError struct {
	dropbox.APIError
	EndpointError *MembersSendWelcomeError `json:"error"`
}

type MembersSendWelcomeError struct {
	dropbox.Tagged
}

type MembersSetAdminPermissionsAPIError struct {
	dropbox.APIError
	EndpointError *MembersSetPermissionsError `json:"error"`
}

type MembersSetPermissionsArg struct {
	// User : Identity of user whose role will be set.
	User *UserSelectorArg `json:"user"`
	// NewRole : The new role of the member.
	NewRole *AdminTier `json:"new_role"`
}

type MembersSetPermissionsError struct {
	dropbox.Tagged
}

type MembersSetPermissionsResult struct {
	// TeamMemberId : The member ID of the user to which the change was applied.
	TeamMemberId string `json:"team_member_id"`
	// Role : The role after the change.
	Role *AdminTier `json:"role"`
}

type MembersSetProfileAPIError struct {
	dropbox.APIError
	EndpointError *MembersSetProfileError `json:"error"`
}

type MembersSetProfileArg struct {
	// User : Identity of user whose profile will be set.
	User *UserSelectorArg `json:"user"`
	// NewEmail : New email for member.
	NewEmail string `json:"new_email,omitempty"`
	// NewExternalId : New external ID for member.
	NewExternalId string `json:"new_external_id,omitempty"`
	// NewGivenName : New given name for member.
	NewGivenName string `json:"new_given_name,omitempty"`
	// NewSurname : New surname for member.
	NewSurname string `json:"new_surname,omitempty"`
	// NewPersistentId : New persistent ID. This field only available to teams
	// using persistent ID SAML configuration.
	NewPersistentId string `json:"new_persistent_id,omitempty"`
	// NewIsDirectoryRestricted : New value for whether the user is a directory
	// restricted user.
	NewIsDirectoryRestricted bool `json:"new_is_directory_restricted,omitempty"`
}

type MembersSetProfileError struct {
	dropbox.Tagged
}

type MembersSuspendAPIError struct {
	dropbox.APIError
	EndpointError *MembersSuspendError `json:"error"`
}

type MembersSuspendError struct {
	dropbox.Tagged
}

type MembersTransferFilesError struct {
	dropbox.Tagged
}

type MembersTransferFormerMembersFilesError struct {
	dropbox.Tagged
}

type MembersUnsuspendAPIError struct {
	dropbox.APIError
	EndpointError *MembersUnsuspendError `json:"error"`
}

type MembersUnsuspendArg struct {
	// User : Identity of user to unsuspend.
	User *UserSelectorArg `json:"user"`
}

type MembersUnsuspendError struct {
	dropbox.Tagged
}

type MobileClientPlatform struct {
	dropbox.Tagged
}

type MobileClientSession struct {
	DeviceSession
	// DeviceName : The device name.
	DeviceName string `json:"device_name"`
	// ClientType : The mobile application type.
	ClientType *MobileClientPlatform `json:"client_type"`
	// ClientVersion : The dropbox client version.
	ClientVersion string `json:"client_version,omitempty"`
	// OsVersion : The hosting OS version.
	OsVersion string `json:"os_version,omitempty"`
	// LastCarrier : last carrier used by the device.
	LastCarrier string `json:"last_carrier,omitempty"`
}

type NamespaceMetadata struct {
	// Name : The name of this namespace.
	Name string `json:"name"`
	// NamespaceId : The ID of this namespace.
	NamespaceId string `json:"namespace_id"`
	// NamespaceType : The type of this namespace.
	NamespaceType *NamespaceType `json:"namespace_type"`
	// TeamMemberId : If this is a team member or app folder, the ID of the
	// owning team member. Otherwise, this field is not present.
	TeamMemberId string `json:"team_member_id,omitempty"`
}

type NamespaceType struct {
	dropbox.Tagged
}

type NamespacesListAPIError struct {
	dropbox.APIError
	EndpointError *TeamNamespacesListError `json:"error"`
}

type NamespacesListContinueAPIError struct {
	dropbox.APIError
	EndpointError *TeamNamespacesListContinueError `json:"error"`
}

type PropertiesTemplateAddAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.ModifyTemplateError `json:"error"`
}

type PropertiesTemplateGetAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.TemplateError `json:"error"`
}

type PropertiesTemplateListAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.TemplateError `json:"error"`
}

type PropertiesTemplateUpdateAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.ModifyTemplateError `json:"error"`
}

type RemoveCustomQuotaResult struct {
	dropbox.Tagged
	// Success : Successfully removed user.
	Success *UserSelectorArg `json:"success,omitempty"`
	// InvalidUser : Invalid user (not in team).
	InvalidUser *UserSelectorArg `json:"invalid_user,omitempty"`
}

type RemovedStatus struct {
	// IsRecoverable : True if the removed team member is recoverable.
	IsRecoverable bool `json:"is_recoverable"`
	// IsDisconnected : True if the team member's account was converted to
	// individual account.
	IsDisconnected bool `json:"is_disconnected"`
}

type ReportsGetActivityAPIError struct {
	dropbox.APIError
	EndpointError *DateRangeError `json:"error"`
}

type ReportsGetDevicesAPIError struct {
	dropbox.APIError
	EndpointError *DateRangeError `json:"error"`
}

type ReportsGetMembershipAPIError struct {
	dropbox.APIError
	EndpointError *DateRangeError `json:"error"`
}

type ReportsGetStorageAPIError struct {
	dropbox.APIError
	EndpointError *DateRangeError `json:"error"`
}

type RevokeDesktopClientArg struct {
	DeviceSessionArg
	// DeleteOnUnlink : 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).
	DeleteOnUnlink bool `json:"delete_on_unlink"`
}

type RevokeDeviceSessionArg struct {
	dropbox.Tagged
	// WebSession : End an active session.
	WebSession *DeviceSessionArg `json:"web_session,omitempty"`
	// DesktopClient : Unlink a linked desktop device.
	DesktopClient *RevokeDesktopClientArg `json:"desktop_client,omitempty"`
	// MobileClient : Unlink a linked mobile device.
	MobileClient *DeviceSessionArg `json:"mobile_client,omitempty"`
}

type RevokeDeviceSessionBatchArg struct {
	// RevokeDevices : has no documentation (yet)
	RevokeDevices []*RevokeDeviceSessionArg `json:"revoke_devices"`
}

type RevokeDeviceSessionBatchError struct {
	dropbox.Tagged
}

type RevokeDeviceSessionBatchResult struct {
	// RevokeDevicesStatus : has no documentation (yet)
	RevokeDevicesStatus []*RevokeDeviceSessionStatus `json:"revoke_devices_status"`
}

type RevokeDeviceSessionError struct {
	dropbox.Tagged
}

type RevokeDeviceSessionStatus struct {
	// Success : Result of the revoking request.
	Success bool `json:"success"`
	// ErrorType : The error cause in case of a failure.
	ErrorType *RevokeDeviceSessionError `json:"error_type,omitempty"`
}

type RevokeLinkedApiAppArg struct {
	// AppId : The application's unique id.
	AppId string `json:"app_id"`
	// TeamMemberId : The unique id of the member owning the device.
	TeamMemberId string `json:"team_member_id"`
	// KeepAppFolder : Whether to keep the application dedicated folder (in case
	// the application uses  one).
	KeepAppFolder bool `json:"keep_app_folder"`
}

type RevokeLinkedApiAppBatchArg struct {
	// RevokeLinkedApp : has no documentation (yet)
	RevokeLinkedApp []*RevokeLinkedApiAppArg `json:"revoke_linked_app"`
}

type RevokeLinkedAppBatchError struct {
	dropbox.Tagged
}

type RevokeLinkedAppBatchResult struct {
	// RevokeLinkedAppStatus : has no documentation (yet)
	RevokeLinkedAppStatus []*RevokeLinkedAppStatus `json:"revoke_linked_app_status"`
}

type RevokeLinkedAppError struct {
	dropbox.Tagged
}

type RevokeLinkedAppStatus struct {
	// Success : Result of the revoking request.
	Success bool `json:"success"`
	// ErrorType : The error cause in case of a failure.
	ErrorType *RevokeLinkedAppError `json:"error_type,omitempty"`
}

type SetCustomQuotaArg struct {
	// UsersAndQuotas : List of users and their custom quotas.
	UsersAndQuotas []*UserCustomQuotaArg `json:"users_and_quotas"`
}

type SetCustomQuotaError struct {
	dropbox.Tagged
}

type StorageBucket struct {
	// Bucket : The name of the storage bucket. For example, '1G' is a bucket of
	// users with storage size up to 1 Giga.
	Bucket string `json:"bucket"`
	// Users : The number of people whose storage is in the range of this
	// storage bucket.
	Users uint64 `json:"users"`
}

type TeamFolderAccessError struct {
	dropbox.Tagged
}

type TeamFolderActivateAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderActivateError `json:"error"`
}

type TeamFolderActivateError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
}

type TeamFolderArchiveAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderArchiveError `json:"error"`
}

type TeamFolderArchiveArg struct {
	TeamFolderIdArg
	// ForceAsyncOff : Whether to force the archive to happen synchronously.
	ForceAsyncOff bool `json:"force_async_off"`
}

type TeamFolderArchiveCheckAPIError struct {
	dropbox.APIError
	EndpointError *async.PollError `json:"error"`
}

type TeamFolderArchiveError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
}

type TeamFolderArchiveJobStatus struct {
	dropbox.Tagged
	// Complete : The archive job has finished. The value is the metadata for
	// the resulting team folder.
	Complete *TeamFolderMetadata `json:"complete,omitempty"`
	// Failed : Error occurred while performing an asynchronous job from
	// `teamFolderArchive`.
	Failed *TeamFolderArchiveError `json:"failed,omitempty"`
}

type TeamFolderArchiveLaunch struct {
	dropbox.Tagged
	// AsyncJobId : This response indicates that the processing is asynchronous.
	// The string is an id that can be used to obtain the status of the
	// asynchronous job.
	AsyncJobId string `json:"async_job_id,omitempty"`
	// Complete : has no documentation (yet)
	Complete *TeamFolderMetadata `json:"complete,omitempty"`
}

type TeamFolderCreateAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderCreateError `json:"error"`
}

type TeamFolderCreateArg struct {
	// Name : Name for the new team folder.
	Name string `json:"name"`
	// SyncSetting : The sync setting to apply to this team folder. Only
	// permitted if the team has team selective sync enabled.
	SyncSetting *files.SyncSettingArg `json:"sync_setting,omitempty"`
}

type TeamFolderCreateError struct {
	dropbox.Tagged
	// SyncSettingsError : An error occurred setting the sync settings.
	SyncSettingsError *files.SyncSettingsError `json:"sync_settings_error,omitempty"`
}

type TeamFolderGetInfoAPIError struct {
	dropbox.APIError
	EndpointError struct{} `json:"error"`
}

type TeamFolderGetInfoItem struct {
	dropbox.Tagged
	// IdNotFound : An ID that was provided as a parameter to
	// `teamFolderGetInfo` did not match any of the team's team folders.
	IdNotFound string `json:"id_not_found,omitempty"`
	// TeamFolderMetadata : Properties of a team folder.
	TeamFolderMetadata *TeamFolderMetadata `json:"team_folder_metadata,omitempty"`
}

type TeamFolderIdArg struct {
	// TeamFolderId : The ID of the team folder.
	TeamFolderId string `json:"team_folder_id"`
}

type TeamFolderIdListArg struct {
	// TeamFolderIds : The list of team folder IDs.
	TeamFolderIds []string `json:"team_folder_ids"`
}

type TeamFolderInvalidStatusError struct {
	dropbox.Tagged
}

type TeamFolderListAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderListError `json:"error"`
}

type TeamFolderListArg struct {
	// Limit : The maximum number of results to return per request.
	Limit uint32 `json:"limit"`
}

type TeamFolderListContinueAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderListContinueError `json:"error"`
}

type TeamFolderListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of team folders.
	Cursor string `json:"cursor"`
}

type TeamFolderListContinueError struct {
	dropbox.Tagged
}

type TeamFolderListError struct {
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error"`
}

type TeamFolderListResult struct {
	// TeamFolders : List of all team folders in the authenticated team.
	TeamFolders []*TeamFolderMetadata `json:"team_folders"`
	// Cursor : Pass the cursor into `teamFolderListContinue` to obtain
	// additional team folders.
	Cursor string `json:"cursor"`
	// HasMore : Is true if there are additional team folders that have not been
	// returned yet. An additional call to `teamFolderListContinue` can retrieve
	// them.
	HasMore bool `json:"has_more"`
}

type TeamFolderMetadata struct {
	// TeamFolderId : The ID of the team folder.
	TeamFolderId string `json:"team_folder_id"`
	// Name : The name of the team folder.
	Name string `json:"name"`
	// Status : The status of the team folder.
	Status *TeamFolderStatus `json:"status"`
	// IsTeamSharedDropbox : True if this team folder is a shared team root.
	IsTeamSharedDropbox bool `json:"is_team_shared_dropbox"`
	// SyncSetting : The sync setting applied to this team folder.
	SyncSetting *files.SyncSetting `json:"sync_setting"`
	// ContentSyncSettings : Sync settings applied to contents of this team
	// folder.
	ContentSyncSettings []*files.ContentSyncSetting `json:"content_sync_settings"`
}

type TeamFolderPermanentlyDeleteAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderPermanentlyDeleteError `json:"error"`
}

type TeamFolderPermanentlyDeleteError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
}

type TeamFolderRenameAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderRenameError `json:"error"`
}

type TeamFolderRenameArg struct {
	TeamFolderIdArg
	// Name : New team folder name.
	Name string `json:"name"`
}

type TeamFolderRenameError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
}

type TeamFolderStatus struct {
	dropbox.Tagged
}

type TeamFolderTeamSharedDropboxError struct {
	dropbox.Tagged
}

type TeamFolderUpdateSyncSettingsAPIError struct {
	dropbox.APIError
	EndpointError *TeamFolderUpdateSyncSettingsError `json:"error"`
}

type TeamFolderUpdateSyncSettingsArg struct {
	TeamFolderIdArg
	// SyncSetting : Sync setting to apply to the team folder itself. Only
	// meaningful if the team folder is not a shared team root.
	SyncSetting *files.SyncSettingArg `json:"sync_setting,omitempty"`
	// ContentSyncSettings : Sync settings to apply to contents of this team
	// folder.
	ContentSyncSettings []*files.ContentSyncSettingArg `json:"content_sync_settings,omitempty"`
}

type TeamFolderUpdateSyncSettingsError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *TeamFolderAccessError `json:"access_error,omitempty"`
	// StatusError : has no documentation (yet)
	StatusError *TeamFolderInvalidStatusError `json:"status_error,omitempty"`
	// TeamSharedDropboxError : has no documentation (yet)
	TeamSharedDropboxError *TeamFolderTeamSharedDropboxError `json:"team_shared_dropbox_error,omitempty"`
	// SyncSettingsError : An error occurred setting the sync settings.
	SyncSettingsError *files.SyncSettingsError `json:"sync_settings_error,omitempty"`
}

type TeamGetInfoResult struct {
	// Name : The name of the team.
	Name string `json:"name"`
	// TeamId : The ID of the team.
	TeamId string `json:"team_id"`
	// NumLicensedUsers : The number of licenses available to the team.
	NumLicensedUsers uint32 `json:"num_licensed_users"`
	// NumProvisionedUsers : The number of accounts that have been invited or
	// are already active members of the team.
	NumProvisionedUsers uint32 `json:"num_provisioned_users"`
	// Policies : has no documentation (yet)
	Policies *team_policies.TeamMemberPolicies `json:"policies"`
}

type TeamMemberInfo struct {
	// Profile : Profile of a user as a member of a team.
	Profile *TeamMemberProfile `json:"profile"`
	// Role : The user's role in the team.
	Role *AdminTier `json:"role"`
}

type TeamMemberProfile struct {
	MemberProfile
	// Groups : List of group IDs of groups that the user belongs to.
	Groups []string `json:"groups"`
	// MemberFolderId : The namespace id of the user's root folder.
	MemberFolderId string `json:"member_folder_id"`
}

type TeamMemberStatus struct {
	dropbox.Tagged
	// Removed : User is no longer a member of the team. Removed users are only
	// listed when include_removed is true in members/list.
	Removed *RemovedStatus `json:"removed,omitempty"`
}

type TeamMembershipType struct {
	dropbox.Tagged
}

type TeamNamespacesListArg struct {
	// Limit : Specifying a value here has no effect.
	Limit uint32 `json:"limit"`
}

type TeamNamespacesListContinueArg struct {
	// Cursor : Indicates from what point to get the next set of team-accessible
	// namespaces.
	Cursor string `json:"cursor"`
}

type TeamNamespacesListContinueError struct {
	dropbox.Tagged
}

type TeamNamespacesListError struct {
	dropbox.Tagged
}

type TeamNamespacesListResult struct {
	// Namespaces : List of all namespaces the team can access.
	Namespaces []*NamespaceMetadata `json:"namespaces"`
	// Cursor : Pass the cursor into `namespacesListContinue` to obtain
	// additional namespaces. Note that duplicate namespaces may be returned.
	Cursor string `json:"cursor"`
	// HasMore : Is true if there are additional namespaces that have not been
	// returned yet.
	HasMore bool `json:"has_more"`
}

type TeamReportFailureReason struct {
	dropbox.Tagged
}

type TokenGetAuthenticatedAdminAPIError struct {
	dropbox.APIError
	EndpointError *TokenGetAuthenticatedAdminError `json:"error"`
}

type TokenGetAuthenticatedAdminError struct {
	dropbox.Tagged
}

type TokenGetAuthenticatedAdminResult struct {
	// AdminProfile : The admin who authorized the token.
	AdminProfile *TeamMemberProfile `json:"admin_profile"`
}

type UploadApiRateLimitValue struct {
	dropbox.Tagged
	// Limit : The number of upload API calls allowed per month.
	Limit uint32 `json:"limit,omitempty"`
}