def __repr__(self):
return 'TimeRange(start_time={!r}, end_time={!r})'.format(
self._start_time_value,
self._end_time_value,
)
TimeRange_validator = bv.Struct(TimeRange)
GroupExternalId_validator = bv.String()
GroupId_validator = bv.String()
MemberExternalId_validator = bv.String(max_length=64)
ResellerId_validator = bv.String()
TeamMemberId_validator = bv.String()
GroupManagementType._user_managed_validator = bv.Void()
GroupManagementType._company_managed_validator = bv.Void()
GroupManagementType._system_managed_validator = bv.Void()
GroupManagementType._other_validator = bv.Void()
GroupManagementType._tagmap = {
'user_managed': GroupManagementType._user_managed_validator,
'company_managed': GroupManagementType._company_managed_validator,
'system_managed': GroupManagementType._system_managed_validator,
'other': GroupManagementType._other_validator,
}
GroupManagementType.user_managed = GroupManagementType('user_managed')
GroupManagementType.company_managed = GroupManagementType('company_managed')
GroupManagementType.system_managed = GroupManagementType('system_managed')
GroupManagementType.other = GroupManagementType('other')
FileRequestDeadline_validator)
CreateFileRequestArgs._open_validator = bv.Boolean()
CreateFileRequestArgs._all_field_names_ = set([
'title',
'destination',
'deadline',
'open',
])
CreateFileRequestArgs._all_fields_ = [
('title', CreateFileRequestArgs._title_validator),
('destination', CreateFileRequestArgs._destination_validator),
('deadline', CreateFileRequestArgs._deadline_validator),
('open', CreateFileRequestArgs._open_validator),
]
GeneralFileRequestsError._disabled_for_team_validator = bv.Void()
GeneralFileRequestsError._other_validator = bv.Void()
GeneralFileRequestsError._tagmap = {
'disabled_for_team': GeneralFileRequestsError._disabled_for_team_validator,
'other': GeneralFileRequestsError._other_validator,
}
GeneralFileRequestsError.disabled_for_team = GeneralFileRequestsError(
'disabled_for_team')
GeneralFileRequestsError.other = GeneralFileRequestsError('other')
FileRequestError._not_found_validator = bv.Void()
FileRequestError._not_a_folder_validator = bv.Void()
FileRequestError._app_lacks_access_validator = bv.Void()
FileRequestError._no_permission_validator = bv.Void()
FileRequestError._email_unverified_validator = bv.Void()
('description', PropertyGroupTemplate._description_validator),
('fields', PropertyGroupTemplate._fields_validator),
]
GetPropertyTemplateResult._all_field_names_ = PropertyGroupTemplate._all_field_names_.union(
set([]))
GetPropertyTemplateResult._all_fields_ = PropertyGroupTemplate._all_fields_ + []
ListPropertyTemplateIds._template_ids_validator = bv.List(TemplateId_validator)
ListPropertyTemplateIds._all_field_names_ = set(['template_ids'])
ListPropertyTemplateIds._all_fields_ = [
('template_ids', ListPropertyTemplateIds._template_ids_validator)
]
PropertyTemplateError._template_not_found_validator = TemplateId_validator
PropertyTemplateError._restricted_content_validator = bv.Void()
PropertyTemplateError._other_validator = bv.Void()
PropertyTemplateError._tagmap = {
'template_not_found': PropertyTemplateError._template_not_found_validator,
'restricted_content': PropertyTemplateError._restricted_content_validator,
'other': PropertyTemplateError._other_validator,
}
PropertyTemplateError.restricted_content = PropertyTemplateError(
'restricted_content')
PropertyTemplateError.other = PropertyTemplateError('other')
ModifyPropertyTemplateError._conflicting_property_names_validator = bv.Void()
ModifyPropertyTemplateError._too_many_properties_validator = bv.Void()
ModifyPropertyTemplateError._too_many_templates_validator = bv.Void()
ModifyPropertyTemplateError._template_attribute_too_large_validator = bv.Void()
def __repr__(self):
return 'TimeRange(start_time={!r}, end_time={!r})'.format(
self._start_time_value,
self._end_time_value,
)
TimeRange_validator = bv.Struct(TimeRange)
GroupExternalId_validator = bv.String()
GroupId_validator = bv.String()
MemberExternalId_validator = bv.String(max_length=64)
ResellerId_validator = bv.String()
TeamMemberId_validator = bv.String()
GroupManagementType._user_managed_validator = bv.Void()
GroupManagementType._company_managed_validator = bv.Void()
GroupManagementType._system_managed_validator = bv.Void()
GroupManagementType._other_validator = bv.Void()
GroupManagementType._tagmap = {
'user_managed': GroupManagementType._user_managed_validator,
'company_managed': GroupManagementType._company_managed_validator,
'system_managed': GroupManagementType._system_managed_validator,
'other': GroupManagementType._other_validator,
}
GroupManagementType.user_managed = GroupManagementType('user_managed')
GroupManagementType.company_managed = GroupManagementType('company_managed')
GroupManagementType.system_managed = GroupManagementType('system_managed')
GroupManagementType.other = GroupManagementType('other')
return self._tag == 'require_tfa_disable'
def is_other(self):
"""
Check if the union tag is ``other``.
:rtype: bool
"""
return self._tag == 'other'
def __repr__(self):
return 'TwoStepVerificationPolicy(%r, %r)' % (self._tag, self._value)
TwoStepVerificationPolicy_validator = bv.Union(TwoStepVerificationPolicy)
EmmState._disabled_validator = bv.Void()
EmmState._optional_validator = bv.Void()
EmmState._required_validator = bv.Void()
EmmState._other_validator = bv.Void()
EmmState._tagmap = {
'disabled': EmmState._disabled_validator,
'optional': EmmState._optional_validator,
'required': EmmState._required_validator,
'other': EmmState._other_validator,
}
EmmState.disabled = EmmState('disabled')
EmmState.optional = EmmState('optional')
EmmState.required = EmmState('required')
EmmState.other = EmmState('other')
PathRootError_validator = bv.Union(PathRootError)
Date_validator = bv.Timestamp(u'%Y-%m-%d')
DisplayName_validator = bv.String(min_length=1, pattern=u'[^/:?*<>"|]*')
DropboxTimestamp_validator = bv.Timestamp(u'%Y-%m-%dT%H:%M:%SZ')
EmailAddress_validator = bv.String(max_length=255, pattern=u"^['&A-Za-z0-9._%+-]+@[A-Za-z0-9-][A-Za-z0-9.-]*.[A-Za-z]{2,15}$")
NamePart_validator = bv.String(min_length=1, max_length=100, pattern=u'[^/:?*<>"|]*')
NamespaceId_validator = bv.String(pattern=u'[-_0-9a-zA-Z:]+')
PathRootId_validator = NamespaceId_validator
SessionId_validator = bv.String()
SharedFolderId_validator = NamespaceId_validator
InvalidPathRootError._path_root_validator = bv.Nullable(PathRootId_validator)
InvalidPathRootError._all_field_names_ = set(['path_root'])
InvalidPathRootError._all_fields_ = [('path_root', InvalidPathRootError._path_root_validator)]
PathRoot._home_validator = bv.Void()
PathRoot._member_home_validator = bv.Void()
PathRoot._team_validator = PathRootId_validator
PathRoot._user_home_validator = bv.Void()
PathRoot._shared_folder_validator = PathRootId_validator
PathRoot._other_validator = bv.Void()
PathRoot._tagmap = {
'home': PathRoot._home_validator,
'member_home': PathRoot._member_home_validator,
'team': PathRoot._team_validator,
'user_home': PathRoot._user_home_validator,
'shared_folder': PathRoot._shared_folder_validator,
'other': PathRoot._other_validator,
}
PathRoot.home = PathRoot('home')
@shared_link_create_policy.deleter
def shared_link_create_policy(self):
self._shared_link_create_policy_value = None
self._shared_link_create_policy_present = False
def __repr__(self):
return 'TeamSharingPolicies(shared_folder_member_policy={!r}, shared_folder_join_policy={!r}, shared_link_create_policy={!r})'.format(
self._shared_folder_member_policy_value,
self._shared_folder_join_policy_value,
self._shared_link_create_policy_value,
)
TeamSharingPolicies_validator = bv.Struct(TeamSharingPolicies)
EmmState._disabled_validator = bv.Void()
EmmState._optional_validator = bv.Void()
EmmState._required_validator = bv.Void()
EmmState._other_validator = bv.Void()
EmmState._tagmap = {
'disabled': EmmState._disabled_validator,
'optional': EmmState._optional_validator,
'required': EmmState._required_validator,
'other': EmmState._other_validator,
}
EmmState.disabled = EmmState('disabled')
EmmState.optional = EmmState('optional')
EmmState.required = EmmState('required')
EmmState.other = EmmState('other')
"""
return self._tag == 'other'
def _process_custom_annotations(self, annotation_type, field_path,
processor):
super(PlatformType,
self)._process_custom_annotations(annotation_type, field_path,
processor)
def __repr__(self):
return 'PlatformType(%r, %r)' % (self._tag, self._value)
PlatformType_validator = bv.Union(PlatformType)
PlatformType._web_validator = bv.Void()
PlatformType._desktop_validator = bv.Void()
PlatformType._mobile_ios_validator = bv.Void()
PlatformType._mobile_android_validator = bv.Void()
PlatformType._api_validator = bv.Void()
PlatformType._unknown_validator = bv.Void()
PlatformType._mobile_validator = bv.Void()
PlatformType._other_validator = bv.Void()
PlatformType._tagmap = {
'web': PlatformType._web_validator,
'desktop': PlatformType._desktop_validator,
'mobile_ios': PlatformType._mobile_ios_validator,
'mobile_android': PlatformType._mobile_android_validator,
'api': PlatformType._api_validator,
'unknown': PlatformType._unknown_validator,
'mobile': PlatformType._mobile_validator,
def is_business(self):
"""
Check if the union tag is ``business``.
:rtype: bool
"""
return self._tag == 'business'
def __repr__(self):
return 'AccountType(%r, %r)' % (self._tag, self._value)
AccountType_validator = bv.Union(AccountType)
AccountId_validator = bv.String(min_length=40, max_length=40)
AccountType._basic_validator = bv.Void()
AccountType._pro_validator = bv.Void()
AccountType._business_validator = bv.Void()
AccountType._tagmap = {
'basic': AccountType._basic_validator,
'pro': AccountType._pro_validator,
'business': AccountType._business_validator,
}
AccountType.basic = AccountType('basic')
AccountType.pro = AccountType('pro')
AccountType.business = AccountType('business')
ROUTES = {}
EchoArg._query_validator = bv.String()
EchoArg._all_field_names_ = set(['query'])
EchoArg._all_fields_ = [('query', EchoArg._query_validator)]
EchoResult._result_validator = bv.String()
EchoResult._all_field_names_ = set(['result'])
EchoResult._all_fields_ = [('result', EchoResult._result_validator)]
app = bb.Route(
'app',
1,
False,
EchoArg_validator,
EchoResult_validator,
bv.Void(),
{
'host': u'api',
'style': u'rpc'
},
)
user = bb.Route(
'user',
1,
False,
EchoArg_validator,
EchoResult_validator,
bv.Void(),
{
'host': u'api',
'style': u'rpc'
@oauth2_token.deleter
def oauth2_token(self):
self._oauth2_token_value = None
self._oauth2_token_present = False
def __repr__(self):
return 'TokenFromOAuth1Result(oauth2_token={!r})'.format(
self._oauth2_token_value,
)
TokenFromOAuth1Result_validator = bv.Struct(TokenFromOAuth1Result)
AccessError._invalid_account_type_validator = InvalidAccountTypeError_validator
AccessError._paper_access_denied_validator = PaperAccessError_validator
AccessError._other_validator = bv.Void()
AccessError._tagmap = {
'invalid_account_type': AccessError._invalid_account_type_validator,
'paper_access_denied': AccessError._paper_access_denied_validator,
'other': AccessError._other_validator,
}
AccessError.other = AccessError('other')
AuthError._invalid_access_token_validator = bv.Void()
AuthError._invalid_select_user_validator = bv.Void()
AuthError._invalid_select_admin_validator = bv.Void()
AuthError._user_suspended_validator = bv.Void()
AuthError._other_validator = bv.Void()
AuthError._tagmap = {
'invalid_access_token': AuthError._invalid_access_token_validator,
('office_addin_policy', FullTeam._office_addin_policy_validator),
]
GetAccountArg._account_id_validator = users_common.AccountId_validator
GetAccountArg._all_field_names_ = set(['account_id'])
GetAccountArg._all_fields_ = [('account_id',
GetAccountArg._account_id_validator)]
GetAccountBatchArg._account_ids_validator = bv.List(
users_common.AccountId_validator, min_items=1)
GetAccountBatchArg._all_field_names_ = set(['account_ids'])
GetAccountBatchArg._all_fields_ = [('account_ids',
GetAccountBatchArg._account_ids_validator)]
GetAccountBatchError._no_account_validator = users_common.AccountId_validator
GetAccountBatchError._other_validator = bv.Void()
GetAccountBatchError._tagmap = {
'no_account': GetAccountBatchError._no_account_validator,
'other': GetAccountBatchError._other_validator,
}
GetAccountBatchError.other = GetAccountBatchError('other')
GetAccountError._no_account_validator = bv.Void()
GetAccountError._other_validator = bv.Void()
GetAccountError._tagmap = {
'no_account': GetAccountError._no_account_validator,
'other': GetAccountError._other_validator,
}
GetAccountError.no_account = GetAccountError('no_account')
def is_other(self):
"""
Check if the union tag is ``other``.
:rtype: bool
"""
return self._tag == 'other'
def __repr__(self):
return 'AuthError(%r, %r)' % (self._tag, self._value)
AuthError_validator = bv.Union(AuthError)
AuthError._invalid_access_token_validator = bv.Void()
AuthError._invalid_select_user_validator = bv.Void()
AuthError._other_validator = bv.Void()
AuthError._tagmap = {
'invalid_access_token': AuthError._invalid_access_token_validator,
'invalid_select_user': AuthError._invalid_select_user_validator,
'other': AuthError._other_validator,
}
AuthError.invalid_access_token = AuthError('invalid_access_token')
AuthError.invalid_select_user = AuthError('invalid_select_user')
AuthError.other = AuthError('other')
token_revoke = bb.Route(
'token/revoke',
False,
def _process_custom_annotations(self, annotation_type, field_path,
processor):
super(SetProfilePhotoResult,
self)._process_custom_annotations(annotation_type, field_path,
processor)
def __repr__(self):
return 'SetProfilePhotoResult(profile_photo_url={!r})'.format(
self._profile_photo_url_value, )
SetProfilePhotoResult_validator = bv.Struct(SetProfilePhotoResult)
PhotoSourceArg._base64_data_validator = bv.String()
PhotoSourceArg._other_validator = bv.Void()
PhotoSourceArg._tagmap = {
'base64_data': PhotoSourceArg._base64_data_validator,
'other': PhotoSourceArg._other_validator,
}
PhotoSourceArg.other = PhotoSourceArg('other')
SetProfilePhotoArg._photo_validator = PhotoSourceArg_validator
SetProfilePhotoArg._all_field_names_ = set(['photo'])
SetProfilePhotoArg._all_fields_ = [('photo',
SetProfilePhotoArg._photo_validator)]
SetProfilePhotoError._file_type_error_validator = bv.Void()
SetProfilePhotoError._file_size_error_validator = bv.Void()
SetProfilePhotoError._dimension_error_validator = bv.Void()
def __repr__(self):
return 'DeleteManualContactsError(%r, %r)' % (self._tag, self._value)
DeleteManualContactsError_validator = bv.Union(DeleteManualContactsError)
DeleteManualContactsArg._email_addresses_validator = bv.List(
common.EmailAddress_validator)
DeleteManualContactsArg._all_field_names_ = set(['email_addresses'])
DeleteManualContactsArg._all_fields_ = [
('email_addresses', DeleteManualContactsArg._email_addresses_validator)
]
DeleteManualContactsError._contacts_not_found_validator = bv.List(
common.EmailAddress_validator)
DeleteManualContactsError._other_validator = bv.Void()
DeleteManualContactsError._tagmap = {
'contacts_not_found':
DeleteManualContactsError._contacts_not_found_validator,
'other': DeleteManualContactsError._other_validator,
}
DeleteManualContactsError.other = DeleteManualContactsError('other')
delete_manual_contacts = bb.Route(
'delete_manual_contacts',
1,
False,
bv.Void(),
bv.Void(),
bv.Void(),
return self._tag == 'too_many_write_operations'
def is_other(self):
"""
Check if the union tag is ``other``.
:rtype: bool
"""
return self._tag == 'other'
def __repr__(self):
return 'RateLimitReason(%r, %r)' % (self._tag, self._value)
RateLimitReason_validator = bv.Union(RateLimitReason)
AuthError._invalid_access_token_validator = bv.Void()
AuthError._invalid_select_user_validator = bv.Void()
AuthError._invalid_select_admin_validator = bv.Void()
AuthError._other_validator = bv.Void()
AuthError._tagmap = {
'invalid_access_token': AuthError._invalid_access_token_validator,
'invalid_select_user': AuthError._invalid_select_user_validator,
'invalid_select_admin': AuthError._invalid_select_admin_validator,
'other': AuthError._other_validator,
}
AuthError.invalid_access_token = AuthError('invalid_access_token')
AuthError.invalid_select_user = AuthError('invalid_select_user')
AuthError.invalid_select_admin = AuthError('invalid_select_admin')
AuthError.other = AuthError('other')
"""
return self._tag == 'other'
def __repr__(self):
return 'PollError(%r, %r)' % (self._tag, self._value)
PollError_validator = bv.Union(PollError)
AsyncJobId_validator = bv.String(min_length=1)
LaunchResultBase._async_job_id_validator = AsyncJobId_validator
LaunchResultBase._tagmap = {
'async_job_id': LaunchResultBase._async_job_id_validator,
}
LaunchEmptyResult._complete_validator = bv.Void()
LaunchEmptyResult._tagmap = {
'complete': LaunchEmptyResult._complete_validator,
}
LaunchEmptyResult._tagmap.update(LaunchResultBase._tagmap)
LaunchEmptyResult.complete = LaunchEmptyResult('complete')
PollArg._async_job_id_validator = AsyncJobId_validator
PollArg._all_field_names_ = set(['async_job_id'])
PollArg._all_fields_ = [('async_job_id', PollArg._async_job_id_validator)]
PollResultBase._in_progress_validator = bv.Void()
PollResultBase._tagmap = {
'in_progress': PollResultBase._in_progress_validator,
}
'name',
'email',
'email_verified',
'profile_photo_url',
'disabled',
])
Account._all_fields_ = [
('account_id', Account._account_id_validator),
('name', Account._name_validator),
('email', Account._email_validator),
('email_verified', Account._email_verified_validator),
('profile_photo_url', Account._profile_photo_url_validator),
('disabled', Account._disabled_validator),
]
AccountType._basic_validator = bv.Void()
AccountType._pro_validator = bv.Void()
AccountType._business_validator = bv.Void()
AccountType._tagmap = {
'basic': AccountType._basic_validator,
'pro': AccountType._pro_validator,
'business': AccountType._business_validator,
}
AccountType.basic = AccountType('basic')
AccountType.pro = AccountType('pro')
AccountType.business = AccountType('business')
BasicAccount._is_teammate_validator = bv.Boolean()
BasicAccount._team_member_id_validator = bv.Nullable(bv.String())
BasicAccount._all_field_names_ = Account._all_field_names_.union(
:rtype: bool
"""
return self._tag == 'other'
def _process_custom_annotations(self, annotation_type, processor):
super(PlatformType,
self)._process_custom_annotations(annotation_type, processor)
def __repr__(self):
return 'PlatformType(%r, %r)' % (self._tag, self._value)
PlatformType_validator = bv.Union(PlatformType)
PlatformType._web_validator = bv.Void()
PlatformType._mobile_validator = bv.Void()
PlatformType._desktop_validator = bv.Void()
PlatformType._unknown_validator = bv.Void()
PlatformType._other_validator = bv.Void()
PlatformType._tagmap = {
'web': PlatformType._web_validator,
'mobile': PlatformType._mobile_validator,
'desktop': PlatformType._desktop_validator,
'unknown': PlatformType._unknown_validator,
'other': PlatformType._other_validator,
}
PlatformType.web = PlatformType('web')
PlatformType.mobile = PlatformType('mobile')
PlatformType.desktop = PlatformType('desktop')
super(MixedInternalOnlyEnum,
self)._process_custom_annotations(annotation_type, field_path,
processor)
def __repr__(self):
return 'MixedInternalOnlyEnum(%r, %r)' % (self._tag, self._value)
MixedInternalOnlyEnum_validator = bv.Union(MixedInternalOnlyEnum)
EmptyContainer._all_field_names_ = set([])
EmptyContainer._all_fields_ = []
MixedInternalOnlyContainer._public_value_validator = bv.Int32()
MixedInternalOnlyContainer._all_field_names_ = set(['public_value'])
MixedInternalOnlyContainer._all_fields_ = [
('public_value', MixedInternalOnlyContainer._public_value_validator)
]
MixedInternalOnlyEnum._public_validator = bv.Void()
MixedInternalOnlyEnum._other_validator = bv.Void()
MixedInternalOnlyEnum._tagmap = {
'public': MixedInternalOnlyEnum._public_validator,
'other': MixedInternalOnlyEnum._other_validator,
}
MixedInternalOnlyEnum.public = MixedInternalOnlyEnum('public')
MixedInternalOnlyEnum.other = MixedInternalOnlyEnum('other')
ROUTES = {}
