class TimeRange(bb.Struct): """ Time range. :ivar team_common.TimeRange.start_time: Optional starting time (inclusive). :ivar team_common.TimeRange.end_time: Optional ending time (exclusive). """ __slots__ = [ '_start_time_value', '_end_time_value', ] _has_required_fields = False def __init__(self, start_time=None, end_time=None): self._start_time_value = bb.NOT_SET self._end_time_value = bb.NOT_SET if start_time is not None: self.start_time = start_time if end_time is not None: self.end_time = end_time # Instance attribute type: datetime.datetime (validator is set below) start_time = bb.Attribute("start_time", nullable=True) # Instance attribute type: datetime.datetime (validator is set below) end_time = bb.Attribute("end_time", nullable=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(TimeRange, self)._process_custom_annotations(annotation_type, field_path, processor)
class Team(bb.Struct): """ Information about a team. :ivar users.Team.id: The team's unique ID. :ivar users.Team.name: The name of the team. """ __slots__ = [ '_id_value', '_name_value', ] _has_required_fields = True def __init__(self, id=None, name=None): self._id_value = bb.NOT_SET self._name_value = bb.NOT_SET if id is not None: self.id = id if name is not None: self.name = name # Instance attribute type: str (validator is set below) id = bb.Attribute("id") # Instance attribute type: str (validator is set below) name = bb.Attribute("name") def _process_custom_annotations(self, annotation_type, field_path, processor): super(Team, self)._process_custom_annotations(annotation_type, field_path, processor)
class SecondaryEmail(bb.Struct): """ :ivar secondary_emails.SecondaryEmail.email: Secondary email address. :ivar secondary_emails.SecondaryEmail.is_verified: Whether or not the secondary email address is verified to be owned by a user. """ __slots__ = [ '_email_value', '_is_verified_value', ] _has_required_fields = True def __init__(self, email=None, is_verified=None): self._email_value = bb.NOT_SET self._is_verified_value = bb.NOT_SET if email is not None: self.email = email if is_verified is not None: self.is_verified = is_verified # Instance attribute type: str (validator is set below) email = bb.Attribute("email") # Instance attribute type: bool (validator is set below) is_verified = bb.Attribute("is_verified") def _process_custom_annotations(self, annotation_type, field_path, processor): super(SecondaryEmail, self)._process_custom_annotations(annotation_type, field_path, processor)
class FileRequestDeadline(bb.Struct): """ :ivar file_requests.FileRequestDeadline.deadline: The deadline for this file request. :ivar file_requests.FileRequestDeadline.allow_late_uploads: If set, allow uploads after the deadline has passed. These uploads will be marked overdue. """ __slots__ = [ '_deadline_value', '_allow_late_uploads_value', ] _has_required_fields = True def __init__(self, deadline=None, allow_late_uploads=None): self._deadline_value = bb.NOT_SET self._allow_late_uploads_value = bb.NOT_SET if deadline is not None: self.deadline = deadline if allow_late_uploads is not None: self.allow_late_uploads = allow_late_uploads # Instance attribute type: datetime.datetime (validator is set below) deadline = bb.Attribute("deadline") # Instance attribute type: GracePeriod (validator is set below) allow_late_uploads = bb.Attribute("allow_late_uploads", nullable=True, user_defined=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(FileRequestDeadline, self)._process_custom_annotations(annotation_type, field_path, processor)
class RateLimitError(bb.Struct): """ Error occurred because the app is being rate limited. :ivar auth.RateLimitError.reason: The reason why the app is being rate limited. :ivar auth.RateLimitError.retry_after: The number of seconds that the app should wait before making another request. """ __slots__ = [ '_reason_value', '_retry_after_value', ] _has_required_fields = True def __init__(self, reason=None, retry_after=None): self._reason_value = bb.NOT_SET self._retry_after_value = bb.NOT_SET if reason is not None: self.reason = reason if retry_after is not None: self.retry_after = retry_after # Instance attribute type: RateLimitReason (validator is set below) reason = bb.Attribute("reason", user_defined=True) # Instance attribute type: int (validator is set below) retry_after = bb.Attribute("retry_after") def _process_custom_annotations(self, annotation_type, field_path, processor): super(RateLimitError, self)._process_custom_annotations(annotation_type, field_path, processor)
class TokenFromOAuth1Arg(bb.Struct): """ :ivar auth.TokenFromOAuth1Arg.oauth1_token: The supplied OAuth 1.0 access token. :ivar auth.TokenFromOAuth1Arg.oauth1_token_secret: The token secret associated with the supplied access token. """ __slots__ = [ '_oauth1_token_value', '_oauth1_token_secret_value', ] _has_required_fields = True def __init__(self, oauth1_token=None, oauth1_token_secret=None): self._oauth1_token_value = bb.NOT_SET self._oauth1_token_secret_value = bb.NOT_SET if oauth1_token is not None: self.oauth1_token = oauth1_token if oauth1_token_secret is not None: self.oauth1_token_secret = oauth1_token_secret # Instance attribute type: str (validator is set below) oauth1_token = bb.Attribute("oauth1_token") # Instance attribute type: str (validator is set below) oauth1_token_secret = bb.Attribute("oauth1_token_secret") def _process_custom_annotations(self, annotation_type, field_path, processor): super(TokenFromOAuth1Arg, self)._process_custom_annotations(annotation_type, field_path, processor)
class SpaceUsage(bb.Struct): """ Information about a user's space usage and quota. :ivar users.SpaceUsage.used: The user's total space usage (bytes). :ivar users.SpaceUsage.allocation: The user's space allocation. """ __slots__ = [ '_used_value', '_allocation_value', ] _has_required_fields = True def __init__(self, used=None, allocation=None): self._used_value = bb.NOT_SET self._allocation_value = bb.NOT_SET if used is not None: self.used = used if allocation is not None: self.allocation = allocation # Instance attribute type: int (validator is set below) used = bb.Attribute("used") # Instance attribute type: SpaceAllocation (validator is set below) allocation = bb.Attribute("allocation", user_defined=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(SpaceUsage, self)._process_custom_annotations(annotation_type, field_path, processor)
class BasicAccount(Account): """ Basic information about any account. :ivar users.BasicAccount.is_teammate: Whether this user is a teammate of the current user. If this account is the current user's account, then this will be ``True``. :ivar users.BasicAccount.team_member_id: The user's unique team member id. This field will only be present if the user is part of a team and ``is_teammate`` is ``True``. """ __slots__ = [ '_is_teammate_value', '_team_member_id_value', ] _has_required_fields = True def __init__(self, account_id=None, name=None, email=None, email_verified=None, disabled=None, is_teammate=None, profile_photo_url=None, team_member_id=None): super(BasicAccount, self).__init__(account_id, name, email, email_verified, disabled, profile_photo_url) self._is_teammate_value = bb.NOT_SET self._team_member_id_value = bb.NOT_SET if is_teammate is not None: self.is_teammate = is_teammate if team_member_id is not None: self.team_member_id = team_member_id # Instance attribute type: bool (validator is set below) is_teammate = bb.Attribute("is_teammate") # Instance attribute type: str (validator is set below) team_member_id = bb.Attribute("team_member_id", nullable=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(BasicAccount, self)._process_custom_annotations(annotation_type, field_path, processor)
class ListFileRequestsV2Result(bb.Struct): """ Result for :meth:`dropbox.dropbox_client.Dropbox.file_requests_list` and :meth:`dropbox.dropbox_client.Dropbox.file_requests_list_continue`. :ivar file_requests.ListFileRequestsV2Result.file_requests: The file requests owned by this user. Apps with the app folder permission will only see file requests in their app folder. :ivar file_requests.ListFileRequestsV2Result.cursor: Pass the cursor into :meth:`dropbox.dropbox_client.Dropbox.file_requests_list_continue` to obtain additional file requests. :ivar file_requests.ListFileRequestsV2Result.has_more: Is true if there are additional file requests that have not been returned yet. An additional call to :route:list/continue` can retrieve them. """ __slots__ = [ '_file_requests_value', '_cursor_value', '_has_more_value', ] _has_required_fields = True def __init__(self, file_requests=None, cursor=None, has_more=None): self._file_requests_value = bb.NOT_SET self._cursor_value = bb.NOT_SET self._has_more_value = bb.NOT_SET if file_requests is not None: self.file_requests = file_requests if cursor is not None: self.cursor = cursor if has_more is not None: self.has_more = has_more # Instance attribute type: list of [FileRequest] (validator is set below) file_requests = bb.Attribute("file_requests") # Instance attribute type: str (validator is set below) cursor = bb.Attribute("cursor") # Instance attribute type: bool (validator is set below) has_more = bb.Attribute("has_more") def _process_custom_annotations(self, annotation_type, field_path, processor): super(ListFileRequestsV2Result, self)._process_custom_annotations(annotation_type, field_path, processor)
class ListFileRequestsResult(bb.Struct): """ Result for :meth:`dropbox.dropbox_client.Dropbox.file_requests_list`. :ivar file_requests.ListFileRequestsResult.file_requests: The file requests owned by this user. Apps with the app folder permission will only see file requests in their app folder. """ __slots__ = [ '_file_requests_value', ] _has_required_fields = True def __init__(self, file_requests=None): self._file_requests_value = bb.NOT_SET if file_requests is not None: self.file_requests = file_requests # Instance attribute type: list of [FileRequest] (validator is set below) file_requests = bb.Attribute("file_requests") def _process_custom_annotations(self, annotation_type, field_path, processor): super(ListFileRequestsResult, self)._process_custom_annotations(annotation_type, field_path, processor)
class GetAccountBatchArg(bb.Struct): """ :ivar users.GetAccountBatchArg.account_ids: List of user account identifiers. Should not contain any duplicate account IDs. """ __slots__ = [ '_account_ids_value', ] _has_required_fields = True def __init__(self, account_ids=None): self._account_ids_value = bb.NOT_SET if account_ids is not None: self.account_ids = account_ids # Instance attribute type: list of [str] (validator is set below) account_ids = bb.Attribute("account_ids") def _process_custom_annotations(self, annotation_type, field_path, processor): super(GetAccountBatchArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class UserFeaturesGetValuesBatchArg(bb.Struct): """ :ivar users.UserFeaturesGetValuesBatchArg.features: A list of features in :class:`UserFeature`. If the list is empty, this route will return :class:`UserFeaturesGetValuesBatchError`. """ __slots__ = [ '_features_value', ] _has_required_fields = True def __init__(self, features=None): self._features_value = bb.NOT_SET if features is not None: self.features = features # Instance attribute type: list of [UserFeature] (validator is set below) features = bb.Attribute("features") def _process_custom_annotations(self, annotation_type, field_path, processor): super(UserFeaturesGetValuesBatchArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class PollArg(bb.Struct): """ Arguments for methods that poll the status of an asynchronous job. :ivar async.PollArg.async_job_id: Id of the asynchronous job. This is the value of a response returned from the method that launched the job. """ __slots__ = [ '_async_job_id_value', ] _has_required_fields = True def __init__(self, async_job_id=None): self._async_job_id_value = bb.NOT_SET if async_job_id is not None: self.async_job_id = async_job_id # Instance attribute type: str (validator is set below) async_job_id = bb.Attribute("async_job_id") def _process_custom_annotations(self, annotation_type, field_path, processor): super(PollArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class CountFileRequestsResult(bb.Struct): """ Result for :meth:`dropbox.dropbox_client.Dropbox.file_requests_count`. :ivar file_requests.CountFileRequestsResult.file_request_count: The number file requests owner by this user. """ __slots__ = [ '_file_request_count_value', ] _has_required_fields = True def __init__(self, file_request_count=None): self._file_request_count_value = bb.NOT_SET if file_request_count is not None: self.file_request_count = file_request_count # Instance attribute type: int (validator is set below) file_request_count = bb.Attribute("file_request_count") def _process_custom_annotations(self, annotation_type, field_path, processor): super(CountFileRequestsResult, self)._process_custom_annotations(annotation_type, field_path, processor)
class ListFileRequestsArg(bb.Struct): """ Arguments for :meth:`dropbox.dropbox_client.Dropbox.file_requests_list`. :ivar file_requests.ListFileRequestsArg.limit: The maximum number of file requests that should be returned per request. """ __slots__ = [ '_limit_value', ] _has_required_fields = False def __init__(self, limit=None): self._limit_value = bb.NOT_SET if limit is not None: self.limit = limit # Instance attribute type: int (validator is set below) limit = bb.Attribute("limit") def _process_custom_annotations(self, annotation_type, field_path, processor): super(ListFileRequestsArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class GetFileRequestArgs(bb.Struct): """ Arguments for :meth:`dropbox.dropbox_client.Dropbox.file_requests_get`. :ivar file_requests.GetFileRequestArgs.id: The ID of the file request to retrieve. """ __slots__ = [ '_id_value', ] _has_required_fields = True def __init__(self, id=None): self._id_value = bb.NOT_SET if id is not None: self.id = id # Instance attribute type: str (validator is set below) id = bb.Attribute("id") def _process_custom_annotations(self, annotation_type, field_path, processor): super(GetFileRequestArgs, self)._process_custom_annotations(annotation_type, field_path, processor)
class DeleteFileRequestsResult(bb.Struct): """ Result for :meth:`dropbox.dropbox_client.Dropbox.file_requests_delete`. :ivar file_requests.DeleteFileRequestsResult.file_requests: The file requests deleted by the request. """ __slots__ = [ '_file_requests_value', ] _has_required_fields = True def __init__(self, file_requests=None): self._file_requests_value = bb.NOT_SET if file_requests is not None: self.file_requests = file_requests # Instance attribute type: list of [FileRequest] (validator is set below) file_requests = bb.Attribute("file_requests") def _process_custom_annotations(self, annotation_type, field_path, processor): super(DeleteFileRequestsResult, self)._process_custom_annotations(annotation_type, field_path, processor)
class DeleteFileRequestArgs(bb.Struct): """ Arguments for :meth:`dropbox.dropbox_client.Dropbox.file_requests_delete`. :ivar file_requests.DeleteFileRequestArgs.ids: List IDs of the file requests to delete. """ __slots__ = [ '_ids_value', ] _has_required_fields = True def __init__(self, ids=None): self._ids_value = bb.NOT_SET if ids is not None: self.ids = ids # Instance attribute type: list of [str] (validator is set below) ids = bb.Attribute("ids") def _process_custom_annotations(self, annotation_type, field_path, processor): super(DeleteFileRequestArgs, self)._process_custom_annotations(annotation_type, field_path, processor)
class EchoResult(bb.Struct): """ EchoResult contains the result returned from the Dropbox servers. :ivar check.EchoResult.result: If everything worked correctly, this would be the same as query. """ __slots__ = [ '_result_value', ] _has_required_fields = False def __init__(self, result=None): self._result_value = bb.NOT_SET if result is not None: self.result = result # Instance attribute type: str (validator is set below) result = bb.Attribute("result") def _process_custom_annotations(self, annotation_type, field_path, processor): super(EchoResult, self)._process_custom_annotations(annotation_type, field_path, processor)
class EchoArg(bb.Struct): """ EchoArg contains the arguments to be sent to the Dropbox servers. :ivar check.EchoArg.query: The string that you'd like to be echoed back to you. """ __slots__ = [ '_query_value', ] _has_required_fields = False def __init__(self, query=None): self._query_value = bb.NOT_SET if query is not None: self.query = query # Instance attribute type: str (validator is set below) query = bb.Attribute("query") def _process_custom_annotations(self, annotation_type, field_path, processor): super(EchoArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class IndividualSpaceAllocation(bb.Struct): """ :ivar users.IndividualSpaceAllocation.allocated: The total space allocated to the user's account (bytes). """ __slots__ = [ '_allocated_value', ] _has_required_fields = True def __init__(self, allocated=None): self._allocated_value = bb.NOT_SET if allocated is not None: self.allocated = allocated # Instance attribute type: int (validator is set below) allocated = bb.Attribute("allocated") def _process_custom_annotations(self, annotation_type, field_path, processor): super(IndividualSpaceAllocation, self)._process_custom_annotations(annotation_type, field_path, processor)
class SetProfilePhotoResult(bb.Struct): """ :ivar account.SetProfilePhotoResult.profile_photo_url: URL for the photo representing the user, if one is set. """ __slots__ = [ '_profile_photo_url_value', ] _has_required_fields = True def __init__(self, profile_photo_url=None): self._profile_photo_url_value = bb.NOT_SET if profile_photo_url is not None: self.profile_photo_url = profile_photo_url # Instance attribute type: str (validator is set below) profile_photo_url = bb.Attribute("profile_photo_url") def _process_custom_annotations(self, annotation_type, field_path, processor): super(SetProfilePhotoResult, self)._process_custom_annotations(annotation_type, field_path, processor)
class SetProfilePhotoArg(bb.Struct): """ :ivar account.SetProfilePhotoArg.photo: Image to set as the user's new profile photo. """ __slots__ = [ '_photo_value', ] _has_required_fields = True def __init__(self, photo=None): self._photo_value = bb.NOT_SET if photo is not None: self.photo = photo # Instance attribute type: PhotoSourceArg (validator is set below) photo = bb.Attribute("photo", user_defined=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(SetProfilePhotoArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class TokenFromOAuth1Result(bb.Struct): """ :ivar auth.TokenFromOAuth1Result.oauth2_token: The OAuth 2.0 token generated from the supplied OAuth 1.0 token. """ __slots__ = [ '_oauth2_token_value', ] _has_required_fields = True def __init__(self, oauth2_token=None): self._oauth2_token_value = bb.NOT_SET if oauth2_token is not None: self.oauth2_token = oauth2_token # Instance attribute type: str (validator is set below) oauth2_token = bb.Attribute("oauth2_token") def _process_custom_annotations(self, annotation_type, field_path, processor): super(TokenFromOAuth1Result, self)._process_custom_annotations(annotation_type, field_path, processor)
class TokenScopeError(bb.Struct): """ :ivar auth.TokenScopeError.required_scope: The required scope to access the route. """ __slots__ = [ '_required_scope_value', ] _has_required_fields = True def __init__(self, required_scope=None): self._required_scope_value = bb.NOT_SET if required_scope is not None: self.required_scope = required_scope # Instance attribute type: str (validator is set below) required_scope = bb.Attribute("required_scope") def _process_custom_annotations(self, annotation_type, field_path, processor): super(TokenScopeError, self)._process_custom_annotations(annotation_type, field_path, processor)
class DeleteManualContactsArg(bb.Struct): """ :ivar contacts.DeleteManualContactsArg.email_addresses: List of manually added contacts to be deleted. """ __slots__ = [ '_email_addresses_value', ] _has_required_fields = True def __init__(self, email_addresses=None): self._email_addresses_value = bb.NOT_SET if email_addresses is not None: self.email_addresses = email_addresses # Instance attribute type: list of [str] (validator is set below) email_addresses = bb.Attribute("email_addresses") def _process_custom_annotations(self, annotation_type, field_path, processor): super(DeleteManualContactsArg, self)._process_custom_annotations(annotation_type, field_path, processor)
class TeamRootInfo(RootInfo): """ Root info when user is member of a team with a separate root namespace ID. :ivar common.TeamRootInfo.home_path: The path for user's home directory under the shared team root. """ __slots__ = [ '_home_path_value', ] _has_required_fields = True def __init__(self, root_namespace_id=None, home_namespace_id=None, home_path=None): super(TeamRootInfo, self).__init__(root_namespace_id, home_namespace_id) self._home_path_value = bb.NOT_SET if home_path is not None: self.home_path = home_path # Instance attribute type: str (validator is set below) home_path = bb.Attribute("home_path") def _process_custom_annotations(self, annotation_type, field_path, processor): super(TeamRootInfo, self)._process_custom_annotations(annotation_type, field_path, processor)
class FullTeam(Team): """ Detailed information about a team. :ivar users.FullTeam.sharing_policies: Team policies governing sharing. :ivar users.FullTeam.office_addin_policy: Team policy governing the use of the Office Add-In. """ __slots__ = [ '_sharing_policies_value', '_office_addin_policy_value', ] _has_required_fields = True def __init__(self, id=None, name=None, sharing_policies=None, office_addin_policy=None): super(FullTeam, self).__init__(id, name) self._sharing_policies_value = bb.NOT_SET self._office_addin_policy_value = bb.NOT_SET if sharing_policies is not None: self.sharing_policies = sharing_policies if office_addin_policy is not None: self.office_addin_policy = office_addin_policy # Instance attribute type: team_policies.TeamSharingPolicies (validator is set below) sharing_policies = bb.Attribute("sharing_policies", user_defined=True) # Instance attribute type: team_policies.OfficeAddInPolicy (validator is set below) office_addin_policy = bb.Attribute("office_addin_policy", user_defined=True) def _process_custom_annotations(self, annotation_type, field_path, processor): super(FullTeam, self)._process_custom_annotations(annotation_type, field_path, processor)
class RootInfo(bb.Struct): """ Information about current user's root. :ivar common.RootInfo.root_namespace_id: The namespace ID for user's root namespace. It will be the namespace ID of the shared team root if the user is member of a team with a separate team root. Otherwise it will be same as ``RootInfo.home_namespace_id``. :ivar common.RootInfo.home_namespace_id: The namespace ID for user's home namespace. """ __slots__ = [ '_root_namespace_id_value', '_home_namespace_id_value', ] _has_required_fields = True def __init__(self, root_namespace_id=None, home_namespace_id=None): self._root_namespace_id_value = bb.NOT_SET self._home_namespace_id_value = bb.NOT_SET if root_namespace_id is not None: self.root_namespace_id = root_namespace_id if home_namespace_id is not None: self.home_namespace_id = home_namespace_id # Instance attribute type: str (validator is set below) root_namespace_id = bb.Attribute("root_namespace_id") # Instance attribute type: str (validator is set below) home_namespace_id = bb.Attribute("home_namespace_id") def _process_custom_annotations(self, annotation_type, field_path, processor): super(RootInfo, self)._process_custom_annotations(annotation_type, field_path, processor)
class UserFeaturesGetValuesBatchResult(bb.Struct): __slots__ = [ '_values_value', ] _has_required_fields = True def __init__(self, values=None): self._values_value = bb.NOT_SET if values is not None: self.values = values # Instance attribute type: list of [UserFeatureValue] (validator is set below) values = bb.Attribute("values") def _process_custom_annotations(self, annotation_type, field_path, processor): super(UserFeaturesGetValuesBatchResult, self)._process_custom_annotations(annotation_type, field_path, processor)