sharing

package
v5.6.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2019 License: MIT Imports: 14 Imported by: 0

Documentation

Overview

Package sharing : This namespace contains endpoints and data types for creating and managing shared links and shared folders.

Index

Constants

View Source 
const (
	AccessInheritanceInherit   = "inherit"
	AccessInheritanceNoInherit = "no_inherit"
	AccessInheritanceOther     = "other"
)

Valid tag values for AccessInheritance

View Source 
const (
	AccessLevelOwner           = "owner"
	AccessLevelEditor          = "editor"
	AccessLevelViewer          = "viewer"
	AccessLevelViewerNoComment = "viewer_no_comment"
	AccessLevelOther           = "other"
)

Valid tag values for AccessLevel

View Source 
const (
	AclUpdatePolicyOwner   = "owner"
	AclUpdatePolicyEditors = "editors"
	AclUpdatePolicyOther   = "other"
)

Valid tag values for AclUpdatePolicy

View Source 
const (
	AddFileMemberErrorUserError      = "user_error"
	AddFileMemberErrorAccessError    = "access_error"
	AddFileMemberErrorRateLimit      = "rate_limit"
	AddFileMemberErrorInvalidComment = "invalid_comment"
	AddFileMemberErrorOther          = "other"
)

Valid tag values for AddFileMemberError

View Source 
const (
	AddFolderMemberErrorAccessError           = "access_error"
	AddFolderMemberErrorEmailUnverified       = "email_unverified"
	AddFolderMemberErrorBannedMember          = "banned_member"
	AddFolderMemberErrorBadMember             = "bad_member"
	AddFolderMemberErrorCantShareOutsideTeam  = "cant_share_outside_team"
	AddFolderMemberErrorTooManyMembers        = "too_many_members"
	AddFolderMemberErrorTooManyPendingInvites = "too_many_pending_invites"
	AddFolderMemberErrorRateLimit             = "rate_limit"
	AddFolderMemberErrorTooManyInvitees       = "too_many_invitees"
	AddFolderMemberErrorInsufficientPlan      = "insufficient_plan"
	AddFolderMemberErrorTeamFolder            = "team_folder"
	AddFolderMemberErrorNoPermission          = "no_permission"
	AddFolderMemberErrorOther                 = "other"
)

Valid tag values for AddFolderMemberError

View Source 
const (
	AddMemberSelectorErrorAutomaticGroup      = "automatic_group"
	AddMemberSelectorErrorInvalidDropboxId    = "invalid_dropbox_id"
	AddMemberSelectorErrorInvalidEmail        = "invalid_email"
	AddMemberSelectorErrorUnverifiedDropboxId = "unverified_dropbox_id"
	AddMemberSelectorErrorGroupDeleted        = "group_deleted"
	AddMemberSelectorErrorGroupNotOnTeam      = "group_not_on_team"
	AddMemberSelectorErrorOther               = "other"
)

Valid tag values for AddMemberSelectorError

View Source 
const (
	LinkMetadataPath       = "path"
	LinkMetadataCollection = "collection"
)

Valid tag values for LinkMetadata

View Source 
const (
	CreateSharedLinkErrorPath  = "path"
	CreateSharedLinkErrorOther = "other"
)

Valid tag values for CreateSharedLinkError

View Source 
const (
	CreateSharedLinkWithSettingsErrorPath                    = "path"
	CreateSharedLinkWithSettingsErrorEmailNotVerified        = "email_not_verified"
	CreateSharedLinkWithSettingsErrorSharedLinkAlreadyExists = "shared_link_already_exists"
	CreateSharedLinkWithSettingsErrorSettingsError           = "settings_error"
	CreateSharedLinkWithSettingsErrorAccessDenied            = "access_denied"
)

Valid tag values for CreateSharedLinkWithSettingsError

View Source 
const (
	FileActionDisableViewerInfo     = "disable_viewer_info"
	FileActionEditContents          = "edit_contents"
	FileActionEnableViewerInfo      = "enable_viewer_info"
	FileActionInviteViewer          = "invite_viewer"
	FileActionInviteViewerNoComment = "invite_viewer_no_comment"
	FileActionInviteEditor          = "invite_editor"
	FileActionUnshare               = "unshare"
	FileActionRelinquishMembership  = "relinquish_membership"
	FileActionShareLink             = "share_link"
	FileActionCreateLink            = "create_link"
	FileActionCreateViewLink        = "create_view_link"
	FileActionCreateEditLink        = "create_edit_link"
	FileActionOther                 = "other"
)

Valid tag values for FileAction

View Source 
const (
	FileErrorResultFileNotFoundError      = "file_not_found_error"
	FileErrorResultInvalidFileActionError = "invalid_file_action_error"
	FileErrorResultPermissionDeniedError  = "permission_denied_error"
	FileErrorResultOther                  = "other"
)

Valid tag values for FileErrorResult

View Source 
const (
	SharedLinkMetadataFile   = "file"
	SharedLinkMetadataFolder = "folder"
)

Valid tag values for SharedLinkMetadata

View Source 
const (
	FileMemberActionErrorInvalidMember    = "invalid_member"
	FileMemberActionErrorNoPermission     = "no_permission"
	FileMemberActionErrorAccessError      = "access_error"
	FileMemberActionErrorNoExplicitAccess = "no_explicit_access"
	FileMemberActionErrorOther            = "other"
)

Valid tag values for FileMemberActionError

View Source 
const (
	FileMemberActionIndividualResultSuccess     = "success"
	FileMemberActionIndividualResultMemberError = "member_error"
)

Valid tag values for FileMemberActionIndividualResult

View Source 
const (
	FileMemberRemoveActionResultSuccess     = "success"
	FileMemberRemoveActionResultMemberError = "member_error"
	FileMemberRemoveActionResultOther       = "other"
)

Valid tag values for FileMemberRemoveActionResult

View Source 
const (
	FolderActionChangeOptions         = "change_options"
	FolderActionDisableViewerInfo     = "disable_viewer_info"
	FolderActionEditContents          = "edit_contents"
	FolderActionEnableViewerInfo      = "enable_viewer_info"
	FolderActionInviteEditor          = "invite_editor"
	FolderActionInviteViewer          = "invite_viewer"
	FolderActionInviteViewerNoComment = "invite_viewer_no_comment"
	FolderActionRelinquishMembership  = "relinquish_membership"
	FolderActionUnmount               = "unmount"
	FolderActionUnshare               = "unshare"
	FolderActionLeaveACopy            = "leave_a_copy"
	FolderActionShareLink             = "share_link"
	FolderActionCreateLink            = "create_link"
	FolderActionSetAccessInheritance  = "set_access_inheritance"
	FolderActionOther                 = "other"
)

Valid tag values for FolderAction

View Source 
const (
	GetFileMetadataErrorUserError   = "user_error"
	GetFileMetadataErrorAccessError = "access_error"
	GetFileMetadataErrorOther       = "other"
)

Valid tag values for GetFileMetadataError

View Source 
const (
	GetFileMetadataIndividualResultMetadata    = "metadata"
	GetFileMetadataIndividualResultAccessError = "access_error"
	GetFileMetadataIndividualResultOther       = "other"
)

Valid tag values for GetFileMetadataIndividualResult

View Source 
const (
	SharedLinkErrorSharedLinkNotFound     = "shared_link_not_found"
	SharedLinkErrorSharedLinkAccessDenied = "shared_link_access_denied"
	SharedLinkErrorUnsupportedLinkType    = "unsupported_link_type"
	SharedLinkErrorOther                  = "other"
)

Valid tag values for SharedLinkError

View Source 
const (
	GetSharedLinkFileErrorSharedLinkNotFound     = "shared_link_not_found"
	GetSharedLinkFileErrorSharedLinkAccessDenied = "shared_link_access_denied"
	GetSharedLinkFileErrorUnsupportedLinkType    = "unsupported_link_type"
	GetSharedLinkFileErrorOther                  = "other"
	GetSharedLinkFileErrorSharedLinkIsDirectory  = "shared_link_is_directory"
)

Valid tag values for GetSharedLinkFileError

View Source 
const (
	GetSharedLinksErrorPath  = "path"
	GetSharedLinksErrorOther = "other"
)

Valid tag values for GetSharedLinksError

View Source 
const (
	InviteeInfoEmail = "email"
	InviteeInfoOther = "other"
)

Valid tag values for InviteeInfo

View Source 
const (
	JobErrorUnshareFolderError              = "unshare_folder_error"
	JobErrorRemoveFolderMemberError         = "remove_folder_member_error"
	JobErrorRelinquishFolderMembershipError = "relinquish_folder_membership_error"
	JobErrorOther                           = "other"
)

Valid tag values for JobError

View Source 
const (
	JobStatusInProgress = "in_progress"
	JobStatusComplete   = "complete"
	JobStatusFailed     = "failed"
)

Valid tag values for JobStatus

View Source 
const (
	LinkAccessLevelViewer = "viewer"
	LinkAccessLevelEditor = "editor"
	LinkAccessLevelOther  = "other"
)

Valid tag values for LinkAccessLevel

View Source 
const (
	LinkActionChangeAccessLevel = "change_access_level"
	LinkActionChangeAudience    = "change_audience"
	LinkActionRemoveExpiry      = "remove_expiry"
	LinkActionRemovePassword    = "remove_password"
	LinkActionSetExpiry         = "set_expiry"
	LinkActionSetPassword       = "set_password"
	LinkActionOther             = "other"
)

Valid tag values for LinkAction

View Source 
const (
	LinkAudiencePublic   = "public"
	LinkAudienceTeam     = "team"
	LinkAudienceNoOne    = "no_one"
	LinkAudiencePassword = "password"
	LinkAudienceMembers  = "members"
	LinkAudienceOther    = "other"
)

Valid tag values for LinkAudience

View Source 
const (
	LinkExpiryRemoveExpiry = "remove_expiry"
	LinkExpirySetExpiry    = "set_expiry"
	LinkExpiryOther        = "other"
)

Valid tag values for LinkExpiry

View Source 
const (
	LinkPasswordRemovePassword = "remove_password"
	LinkPasswordSetPassword    = "set_password"
	LinkPasswordOther          = "other"
)

Valid tag values for LinkPassword

View Source 
const (
	ListFileMembersContinueErrorUserError     = "user_error"
	ListFileMembersContinueErrorAccessError   = "access_error"
	ListFileMembersContinueErrorInvalidCursor = "invalid_cursor"
	ListFileMembersContinueErrorOther         = "other"
)

Valid tag values for ListFileMembersContinueError

View Source 
const (
	ListFileMembersErrorUserError   = "user_error"
	ListFileMembersErrorAccessError = "access_error"
	ListFileMembersErrorOther       = "other"
)

Valid tag values for ListFileMembersError

View Source 
const (
	ListFileMembersIndividualResultResult      = "result"
	ListFileMembersIndividualResultAccessError = "access_error"
	ListFileMembersIndividualResultOther       = "other"
)

Valid tag values for ListFileMembersIndividualResult

View Source 
const (
	ListFilesContinueErrorUserError     = "user_error"
	ListFilesContinueErrorInvalidCursor = "invalid_cursor"
	ListFilesContinueErrorOther         = "other"
)

Valid tag values for ListFilesContinueError

View Source 
const (
	ListFolderMembersContinueErrorAccessError   = "access_error"
	ListFolderMembersContinueErrorInvalidCursor = "invalid_cursor"
	ListFolderMembersContinueErrorOther         = "other"
)

Valid tag values for ListFolderMembersContinueError

View Source 
const (
	ListFoldersContinueErrorInvalidCursor = "invalid_cursor"
	ListFoldersContinueErrorOther         = "other"
)

Valid tag values for ListFoldersContinueError

View Source 
const (
	ListSharedLinksErrorPath  = "path"
	ListSharedLinksErrorReset = "reset"
	ListSharedLinksErrorOther = "other"
)

Valid tag values for ListSharedLinksError

View Source 
const (
	MemberActionLeaveACopy          = "leave_a_copy"
	MemberActionMakeEditor          = "make_editor"
	MemberActionMakeOwner           = "make_owner"
	MemberActionMakeViewer          = "make_viewer"
	MemberActionMakeViewerNoComment = "make_viewer_no_comment"
	MemberActionRemove              = "remove"
	MemberActionOther               = "other"
)

Valid tag values for MemberAction

View Source 
const (
	MemberPolicyTeam   = "team"
	MemberPolicyAnyone = "anyone"
	MemberPolicyOther  = "other"
)

Valid tag values for MemberPolicy

View Source 
const (
	MemberSelectorDropboxId = "dropbox_id"
	MemberSelectorEmail     = "email"
	MemberSelectorOther     = "other"
)

Valid tag values for MemberSelector

View Source 
const (
	ModifySharedLinkSettingsErrorSharedLinkNotFound     = "shared_link_not_found"
	ModifySharedLinkSettingsErrorSharedLinkAccessDenied = "shared_link_access_denied"
	ModifySharedLinkSettingsErrorUnsupportedLinkType    = "unsupported_link_type"
	ModifySharedLinkSettingsErrorOther                  = "other"
	ModifySharedLinkSettingsErrorSettingsError          = "settings_error"
	ModifySharedLinkSettingsErrorEmailNotVerified       = "email_not_verified"
)

Valid tag values for ModifySharedLinkSettingsError

View Source 
const (
	MountFolderErrorAccessError        = "access_error"
	MountFolderErrorInsideSharedFolder = "inside_shared_folder"
	MountFolderErrorInsufficientQuota  = "insufficient_quota"
	MountFolderErrorAlreadyMounted     = "already_mounted"
	MountFolderErrorNoPermission       = "no_permission"
	MountFolderErrorNotMountable       = "not_mountable"
	MountFolderErrorOther              = "other"
)

Valid tag values for MountFolderError

View Source 
const (
	PendingUploadModeFile   = "file"
	PendingUploadModeFolder = "folder"
)

Valid tag values for PendingUploadMode

View Source 
const (
	PermissionDeniedReasonUserNotSameTeamAsOwner     = "user_not_same_team_as_owner"
	PermissionDeniedReasonUserNotAllowedByOwner      = "user_not_allowed_by_owner"
	PermissionDeniedReasonTargetIsIndirectMember     = "target_is_indirect_member"
	PermissionDeniedReasonTargetIsOwner              = "target_is_owner"
	PermissionDeniedReasonTargetIsSelf               = "target_is_self"
	PermissionDeniedReasonTargetNotActive            = "target_not_active"
	PermissionDeniedReasonFolderIsLimitedTeamFolder  = "folder_is_limited_team_folder"
	PermissionDeniedReasonOwnerNotOnTeam             = "owner_not_on_team"
	PermissionDeniedReasonPermissionDenied           = "permission_denied"
	PermissionDeniedReasonRestrictedByTeam           = "restricted_by_team"
	PermissionDeniedReasonUserAccountType            = "user_account_type"
	PermissionDeniedReasonUserNotOnTeam              = "user_not_on_team"
	PermissionDeniedReasonFolderIsInsideSharedFolder = "folder_is_inside_shared_folder"
	PermissionDeniedReasonRestrictedByParentFolder   = "restricted_by_parent_folder"
	PermissionDeniedReasonInsufficientPlan           = "insufficient_plan"
	PermissionDeniedReasonOther                      = "other"
)

Valid tag values for PermissionDeniedReason

View Source 
const (
	RelinquishFileMembershipErrorAccessError  = "access_error"
	RelinquishFileMembershipErrorGroupAccess  = "group_access"
	RelinquishFileMembershipErrorNoPermission = "no_permission"
	RelinquishFileMembershipErrorOther        = "other"
)

Valid tag values for RelinquishFileMembershipError

View Source 
const (
	RelinquishFolderMembershipErrorAccessError      = "access_error"
	RelinquishFolderMembershipErrorFolderOwner      = "folder_owner"
	RelinquishFolderMembershipErrorMounted          = "mounted"
	RelinquishFolderMembershipErrorGroupAccess      = "group_access"
	RelinquishFolderMembershipErrorTeamFolder       = "team_folder"
	RelinquishFolderMembershipErrorNoPermission     = "no_permission"
	RelinquishFolderMembershipErrorNoExplicitAccess = "no_explicit_access"
	RelinquishFolderMembershipErrorOther            = "other"
)

Valid tag values for RelinquishFolderMembershipError

View Source 
const (
	RemoveFileMemberErrorUserError        = "user_error"
	RemoveFileMemberErrorAccessError      = "access_error"
	RemoveFileMemberErrorNoExplicitAccess = "no_explicit_access"
	RemoveFileMemberErrorOther            = "other"
)

Valid tag values for RemoveFileMemberError

View Source 
const (
	RemoveFolderMemberErrorAccessError  = "access_error"
	RemoveFolderMemberErrorMemberError  = "member_error"
	RemoveFolderMemberErrorFolderOwner  = "folder_owner"
	RemoveFolderMemberErrorGroupAccess  = "group_access"
	RemoveFolderMemberErrorTeamFolder   = "team_folder"
	RemoveFolderMemberErrorNoPermission = "no_permission"
	RemoveFolderMemberErrorTooManyFiles = "too_many_files"
	RemoveFolderMemberErrorOther        = "other"
)

Valid tag values for RemoveFolderMemberError

View Source 
const (
	RemoveMemberJobStatusInProgress = "in_progress"
	RemoveMemberJobStatusComplete   = "complete"
	RemoveMemberJobStatusFailed     = "failed"
)

Valid tag values for RemoveMemberJobStatus

View Source 
const (
	RequestedLinkAccessLevelViewer = "viewer"
	RequestedLinkAccessLevelEditor = "editor"
	RequestedLinkAccessLevelMax    = "max"
	RequestedLinkAccessLevelOther  = "other"
)

Valid tag values for RequestedLinkAccessLevel

View Source 
const (
	RequestedVisibilityPublic   = "public"
	RequestedVisibilityTeamOnly = "team_only"
	RequestedVisibilityPassword = "password"
)

Valid tag values for RequestedVisibility

View Source 
const (
	ResolvedVisibilityPublic           = "public"
	ResolvedVisibilityTeamOnly         = "team_only"
	ResolvedVisibilityPassword         = "password"
	ResolvedVisibilityTeamAndPassword  = "team_and_password"
	ResolvedVisibilitySharedFolderOnly = "shared_folder_only"
	ResolvedVisibilityOther            = "other"
)

Valid tag values for ResolvedVisibility

View Source 
const (
	RevokeSharedLinkErrorSharedLinkNotFound     = "shared_link_not_found"
	RevokeSharedLinkErrorSharedLinkAccessDenied = "shared_link_access_denied"
	RevokeSharedLinkErrorUnsupportedLinkType    = "unsupported_link_type"
	RevokeSharedLinkErrorOther                  = "other"
	RevokeSharedLinkErrorSharedLinkMalformed    = "shared_link_malformed"
)

Valid tag values for RevokeSharedLinkError

View Source 
const (
	SetAccessInheritanceErrorAccessError  = "access_error"
	SetAccessInheritanceErrorNoPermission = "no_permission"
	SetAccessInheritanceErrorOther        = "other"
)

Valid tag values for SetAccessInheritanceError

View Source 
const (
	ShareFolderErrorBaseEmailUnverified                 = "email_unverified"
	ShareFolderErrorBaseBadPath                         = "bad_path"
	ShareFolderErrorBaseTeamPolicyDisallowsMemberPolicy = "team_policy_disallows_member_policy"
	ShareFolderErrorBaseDisallowedSharedLinkPolicy      = "disallowed_shared_link_policy"
	ShareFolderErrorBaseOther                           = "other"
)

Valid tag values for ShareFolderErrorBase

View Source 
const (
	ShareFolderErrorEmailUnverified                 = "email_unverified"
	ShareFolderErrorBadPath                         = "bad_path"
	ShareFolderErrorTeamPolicyDisallowsMemberPolicy = "team_policy_disallows_member_policy"
	ShareFolderErrorDisallowedSharedLinkPolicy      = "disallowed_shared_link_policy"
	ShareFolderErrorOther                           = "other"
	ShareFolderErrorNoPermission                    = "no_permission"
)

Valid tag values for ShareFolderError

View Source 
const (
	ShareFolderJobStatusInProgress = "in_progress"
	ShareFolderJobStatusComplete   = "complete"
	ShareFolderJobStatusFailed     = "failed"
)

Valid tag values for ShareFolderJobStatus

View Source 
const (
	ShareFolderLaunchAsyncJobId = "async_job_id"
	ShareFolderLaunchComplete   = "complete"
)

Valid tag values for ShareFolderLaunch

View Source 
const (
	SharePathErrorIsFile               = "is_file"
	SharePathErrorInsideSharedFolder   = "inside_shared_folder"
	SharePathErrorContainsSharedFolder = "contains_shared_folder"
	SharePathErrorContainsAppFolder    = "contains_app_folder"
	SharePathErrorContainsTeamFolder   = "contains_team_folder"
	SharePathErrorIsAppFolder          = "is_app_folder"
	SharePathErrorInsideAppFolder      = "inside_app_folder"
	SharePathErrorIsPublicFolder       = "is_public_folder"
	SharePathErrorInsidePublicFolder   = "inside_public_folder"
	SharePathErrorAlreadyShared        = "already_shared"
	SharePathErrorInvalidPath          = "invalid_path"
	SharePathErrorIsOsxPackage         = "is_osx_package"
	SharePathErrorInsideOsxPackage     = "inside_osx_package"
	SharePathErrorOther                = "other"
)

Valid tag values for SharePathError

View Source 
const (
	SharedFolderAccessErrorInvalidId       = "invalid_id"
	SharedFolderAccessErrorNotAMember      = "not_a_member"
	SharedFolderAccessErrorEmailUnverified = "email_unverified"
	SharedFolderAccessErrorUnmounted       = "unmounted"
	SharedFolderAccessErrorOther           = "other"
)

Valid tag values for SharedFolderAccessError

View Source 
const (
	SharedFolderMemberErrorInvalidDropboxId = "invalid_dropbox_id"
	SharedFolderMemberErrorNotAMember       = "not_a_member"
	SharedFolderMemberErrorNoExplicitAccess = "no_explicit_access"
	SharedFolderMemberErrorOther            = "other"
)

Valid tag values for SharedFolderMemberError

View Source 
const (
	SharedLinkAccessFailureReasonLoginRequired       = "login_required"
	SharedLinkAccessFailureReasonEmailVerifyRequired = "email_verify_required"
	SharedLinkAccessFailureReasonPasswordRequired    = "password_required"
	SharedLinkAccessFailureReasonTeamOnly            = "team_only"
	SharedLinkAccessFailureReasonOwnerOnly           = "owner_only"
	SharedLinkAccessFailureReasonOther               = "other"
)

Valid tag values for SharedLinkAccessFailureReason

View Source 
const (
	SharedLinkAlreadyExistsMetadataMetadata = "metadata"
	SharedLinkAlreadyExistsMetadataOther    = "other"
)

Valid tag values for SharedLinkAlreadyExistsMetadata

View Source 
const (
	SharedLinkPolicyAnyone  = "anyone"
	SharedLinkPolicyTeam    = "team"
	SharedLinkPolicyMembers = "members"
	SharedLinkPolicyOther   = "other"
)

Valid tag values for SharedLinkPolicy

View Source 
const (
	SharedLinkSettingsErrorInvalidSettings = "invalid_settings"
	SharedLinkSettingsErrorNotAuthorized   = "not_authorized"
)

Valid tag values for SharedLinkSettingsError

View Source 
const (
	SharingFileAccessErrorNoPermission       = "no_permission"
	SharingFileAccessErrorInvalidFile        = "invalid_file"
	SharingFileAccessErrorIsFolder           = "is_folder"
	SharingFileAccessErrorInsidePublicFolder = "inside_public_folder"
	SharingFileAccessErrorInsideOsxPackage   = "inside_osx_package"
	SharingFileAccessErrorOther              = "other"
)

Valid tag values for SharingFileAccessError

View Source 
const (
	SharingUserErrorEmailUnverified = "email_unverified"
	SharingUserErrorOther           = "other"
)

Valid tag values for SharingUserError

View Source 
const (
	TransferFolderErrorAccessError             = "access_error"
	TransferFolderErrorInvalidDropboxId        = "invalid_dropbox_id"
	TransferFolderErrorNewOwnerNotAMember      = "new_owner_not_a_member"
	TransferFolderErrorNewOwnerUnmounted       = "new_owner_unmounted"
	TransferFolderErrorNewOwnerEmailUnverified = "new_owner_email_unverified"
	TransferFolderErrorTeamFolder              = "team_folder"
	TransferFolderErrorNoPermission            = "no_permission"
	TransferFolderErrorOther                   = "other"
)

Valid tag values for TransferFolderError

View Source 
const (
	UnmountFolderErrorAccessError    = "access_error"
	UnmountFolderErrorNoPermission   = "no_permission"
	UnmountFolderErrorNotUnmountable = "not_unmountable"
	UnmountFolderErrorOther          = "other"
)

Valid tag values for UnmountFolderError

View Source 
const (
	UnshareFileErrorUserError   = "user_error"
	UnshareFileErrorAccessError = "access_error"
	UnshareFileErrorOther       = "other"
)

Valid tag values for UnshareFileError

View Source 
const (
	UnshareFolderErrorAccessError  = "access_error"
	UnshareFolderErrorTeamFolder   = "team_folder"
	UnshareFolderErrorNoPermission = "no_permission"
	UnshareFolderErrorTooManyFiles = "too_many_files"
	UnshareFolderErrorOther        = "other"
)

Valid tag values for UnshareFolderError

View Source 
const (
	UpdateFolderMemberErrorAccessError      = "access_error"
	UpdateFolderMemberErrorMemberError      = "member_error"
	UpdateFolderMemberErrorNoExplicitAccess = "no_explicit_access"
	UpdateFolderMemberErrorInsufficientPlan = "insufficient_plan"
	UpdateFolderMemberErrorNoPermission     = "no_permission"
	UpdateFolderMemberErrorOther            = "other"
)

Valid tag values for UpdateFolderMemberError

View Source 
const (
	UpdateFolderPolicyErrorAccessError                     = "access_error"
	UpdateFolderPolicyErrorNotOnTeam                       = "not_on_team"
	UpdateFolderPolicyErrorTeamPolicyDisallowsMemberPolicy = "team_policy_disallows_member_policy"
	UpdateFolderPolicyErrorDisallowedSharedLinkPolicy      = "disallowed_shared_link_policy"
	UpdateFolderPolicyErrorNoPermission                    = "no_permission"
	UpdateFolderPolicyErrorTeamFolder                      = "team_folder"
	UpdateFolderPolicyErrorOther                           = "other"
)

Valid tag values for UpdateFolderPolicyError

View Source 
const (
	ViewerInfoPolicyEnabled  = "enabled"
	ViewerInfoPolicyDisabled = "disabled"
	ViewerInfoPolicyOther    = "other"
)

Valid tag values for ViewerInfoPolicy

View Source 
const (
	VisibilityPublic           = "public"
	VisibilityTeamOnly         = "team_only"
	VisibilityPassword         = "password"
	VisibilityTeamAndPassword  = "team_and_password"
	VisibilitySharedFolderOnly = "shared_folder_only"
	VisibilityOther            = "other"
)

Valid tag values for Visibility

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessInheritance 

type AccessInheritance struct {
	dropbox.Tagged
}

AccessInheritance : Information about the inheritance policy of a shared folder.

type AccessLevel 

type AccessLevel struct {
	dropbox.Tagged
}

AccessLevel : Defines the access levels for collaborators.

type AclUpdatePolicy 

type AclUpdatePolicy struct {
	dropbox.Tagged
}

AclUpdatePolicy : Who can change a shared folder's access control list (ACL). In other words, who can add, remove, or change the privileges of members.

type AddFileMemberAPIError 

type AddFileMemberAPIError struct {
	dropbox.APIError
	EndpointError *AddFileMemberError `json:"error"`
}

AddFileMemberAPIError is an error-wrapper for the add_file_member route

type AddFileMemberArgs 

type AddFileMemberArgs struct {
	// File : File to which to add members.
	File string `json:"file"`
	// Members : Members to add. Note that even an email address is given, this
	// may result in a user being directy added to the membership if that email
	// is the user's main account email.
	Members []*MemberSelector `json:"members"`
	// CustomMessage : Message to send to added members in their invitation.
	CustomMessage string `json:"custom_message,omitempty"`
	// Quiet : Whether added members should be notified via device notifications
	// of their invitation.
	Quiet bool `json:"quiet"`
	// AccessLevel : AccessLevel union object, describing what access level we
	// want to give new members.
	AccessLevel *AccessLevel `json:"access_level"`
	// AddMessageAsComment : If the custom message should be added as a comment
	// on the file.
	AddMessageAsComment bool `json:"add_message_as_comment"`
}

AddFileMemberArgs : Arguments for `addFileMember`.

func NewAddFileMemberArgs 

func NewAddFileMemberArgs(File string, Members []*MemberSelector) *AddFileMemberArgs

NewAddFileMemberArgs returns a new AddFileMemberArgs instance

type AddFileMemberError 

type AddFileMemberError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

AddFileMemberError : Errors for `addFileMember`.

func (*AddFileMemberError) UnmarshalJSON 

func (u *AddFileMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a AddFileMemberError instance

type AddFolderMemberAPIError 

type AddFolderMemberAPIError struct {
	dropbox.APIError
	EndpointError *AddFolderMemberError `json:"error"`
}

AddFolderMemberAPIError is an error-wrapper for the add_folder_member route

type AddFolderMemberArg 

type AddFolderMemberArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Members : The intended list of members to add.  Added members will
	// receive invites to join the shared folder.
	Members []*AddMember `json:"members"`
	// Quiet : Whether added members should be notified via email and device
	// notifications of their invite.
	Quiet bool `json:"quiet"`
	// CustomMessage : Optional message to display to added members in their
	// invitation.
	CustomMessage string `json:"custom_message,omitempty"`
}

AddFolderMemberArg : has no documentation (yet)

func NewAddFolderMemberArg 

func NewAddFolderMemberArg(SharedFolderId string, Members []*AddMember) *AddFolderMemberArg

NewAddFolderMemberArg returns a new AddFolderMemberArg instance

type AddFolderMemberError 

type AddFolderMemberError struct {
	dropbox.Tagged
	// AccessError : Unable to access shared folder.
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
	// BadMember : `AddFolderMemberArg.members` contains a bad invitation
	// recipient.
	BadMember *AddMemberSelectorError `json:"bad_member,omitempty"`
	// TooManyMembers : The value is the member limit that was reached.
	TooManyMembers uint64 `json:"too_many_members,omitempty"`
	// TooManyPendingInvites : The value is the pending invite limit that was
	// reached.
	TooManyPendingInvites uint64 `json:"too_many_pending_invites,omitempty"`
}

AddFolderMemberError : has no documentation (yet)

func (*AddFolderMemberError) UnmarshalJSON 

func (u *AddFolderMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a AddFolderMemberError instance

type AddMember 

type AddMember struct {
	// Member : The member to add to the shared folder.
	Member *MemberSelector `json:"member"`
	// AccessLevel : The access level to grant `member` to the shared folder.
	// `AccessLevel.owner` is disallowed.
	AccessLevel *AccessLevel `json:"access_level"`
}

AddMember : The member and type of access the member should have when added to a shared folder.

func NewAddMember 

func NewAddMember(Member *MemberSelector) *AddMember

NewAddMember returns a new AddMember instance

type AddMemberSelectorError 

type AddMemberSelectorError struct {
	dropbox.Tagged
	// InvalidDropboxId : The value is the ID that could not be identified.
	InvalidDropboxId string `json:"invalid_dropbox_id,omitempty"`
	// InvalidEmail : The value is the e-email address that is malformed.
	InvalidEmail string `json:"invalid_email,omitempty"`
	// UnverifiedDropboxId : The value is the ID of the Dropbox user with an
	// unverified e-mail address.  Invite unverified users by e-mail address
	// instead of by their Dropbox ID.
	UnverifiedDropboxId string `json:"unverified_dropbox_id,omitempty"`
}

AddMemberSelectorError : has no documentation (yet)

func (*AddMemberSelectorError) UnmarshalJSON 

func (u *AddMemberSelectorError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a AddMemberSelectorError instance

type AudienceExceptionContentInfo 

type AudienceExceptionContentInfo struct {
	// Name : The name of the content, which is either a file or a folder.
	Name string `json:"name"`
}

AudienceExceptionContentInfo : Information about the content that has a link audience different than that of this folder.

func NewAudienceExceptionContentInfo 

func NewAudienceExceptionContentInfo(Name string) *AudienceExceptionContentInfo

NewAudienceExceptionContentInfo returns a new AudienceExceptionContentInfo instance

type AudienceExceptions 

type AudienceExceptions struct {
	// Count : has no documentation (yet)
	Count uint32 `json:"count"`
	// Exceptions : A truncated list of some of the content that is an
	// exception. The length of this list could be smaller than the count since
	// it is only a sample but will not be empty as long as count is not 0.
	Exceptions []*AudienceExceptionContentInfo `json:"exceptions"`
}

AudienceExceptions : The total count and truncated list of information of content inside this folder that has a different audience than the link on this folder. This is only returned for folders.

func NewAudienceExceptions 

func NewAudienceExceptions(Count uint32, Exceptions []*AudienceExceptionContentInfo) *AudienceExceptions

NewAudienceExceptions returns a new AudienceExceptions instance

type AudienceRestrictingSharedFolder 

type AudienceRestrictingSharedFolder struct {
	// SharedFolderId : The ID of the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Name : The name of the shared folder.
	Name string `json:"name"`
	// Audience : The link audience of the shared folder.
	Audience *LinkAudience `json:"audience"`
}

AudienceRestrictingSharedFolder : Information about the shared folder that prevents the link audience for this link from being more restrictive.

func NewAudienceRestrictingSharedFolder 

func NewAudienceRestrictingSharedFolder(SharedFolderId string, Name string, Audience *LinkAudience) *AudienceRestrictingSharedFolder

NewAudienceRestrictingSharedFolder returns a new AudienceRestrictingSharedFolder instance

type ChangeFileMemberAccessAPIError 

type ChangeFileMemberAccessAPIError struct {
	dropbox.APIError
	EndpointError *FileMemberActionError `json:"error"`
}

ChangeFileMemberAccessAPIError is an error-wrapper for the change_file_member_access route

type ChangeFileMemberAccessArgs 

type ChangeFileMemberAccessArgs struct {
	// File : File for which we are changing a member's access.
	File string `json:"file"`
	// Member : The member whose access we are changing.
	Member *MemberSelector `json:"member"`
	// AccessLevel : The new access level for the member.
	AccessLevel *AccessLevel `json:"access_level"`
}

ChangeFileMemberAccessArgs : Arguments for `changeFileMemberAccess`.

func NewChangeFileMemberAccessArgs 

func NewChangeFileMemberAccessArgs(File string, Member *MemberSelector, AccessLevel *AccessLevel) *ChangeFileMemberAccessArgs

NewChangeFileMemberAccessArgs returns a new ChangeFileMemberAccessArgs instance

type CheckJobStatusAPIError 

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

CheckJobStatusAPIError is an error-wrapper for the check_job_status route

type CheckRemoveMemberJobStatusAPIError 

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

CheckRemoveMemberJobStatusAPIError is an error-wrapper for the check_remove_member_job_status route

type CheckShareJobStatusAPIError 

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

CheckShareJobStatusAPIError is an error-wrapper for the check_share_job_status route

type Client 

type Client interface {
	// AddFileMember : Adds specified members to a file.
	AddFileMember(arg *AddFileMemberArgs) (res []*FileMemberActionResult, err error)
	// AddFolderMember : Allows an owner or editor (if the ACL update policy
	// allows) of a shared folder to add another member. For the new member to
	// get access to all the functionality for this folder, you will need to
	// call `mountFolder` on their behalf.
	AddFolderMember(arg *AddFolderMemberArg) (err error)
	// ChangeFileMemberAccess : Identical to update_file_member but with less
	// information returned.
	// Deprecated: Use `UpdateFileMember` instead
	ChangeFileMemberAccess(arg *ChangeFileMemberAccessArgs) (res *FileMemberActionResult, err error)
	// CheckJobStatus : Returns the status of an asynchronous job.
	CheckJobStatus(arg *async.PollArg) (res *JobStatus, err error)
	// CheckRemoveMemberJobStatus : Returns the status of an asynchronous job
	// for sharing a folder.
	CheckRemoveMemberJobStatus(arg *async.PollArg) (res *RemoveMemberJobStatus, err error)
	// CheckShareJobStatus : Returns the status of an asynchronous job for
	// sharing a folder.
	CheckShareJobStatus(arg *async.PollArg) (res *ShareFolderJobStatus, err error)
	// CreateSharedLink : Create a shared link. If a shared link already exists
	// for the given path, that link is returned. Note that in the returned
	// `PathLinkMetadata`, the `PathLinkMetadata.url` field is the shortened URL
	// if `CreateSharedLinkArg.short_url` argument is set to true. Previously,
	// it was technically possible to break a shared link by moving or renaming
	// the corresponding file or folder. In the future, this will no longer be
	// the case, so your app shouldn't rely on this behavior. Instead, if your
	// app needs to revoke a shared link, use `revokeSharedLink`.
	// Deprecated: Use `CreateSharedLinkWithSettings` instead
	CreateSharedLink(arg *CreateSharedLinkArg) (res *PathLinkMetadata, err error)
	// CreateSharedLinkWithSettings : Create a shared link with custom settings.
	// If no settings are given then the default visibility is
	// `RequestedVisibility.public` (The resolved visibility, though, may depend
	// on other aspects such as team and shared folder settings).
	CreateSharedLinkWithSettings(arg *CreateSharedLinkWithSettingsArg) (res IsSharedLinkMetadata, err error)
	// GetFileMetadata : Returns shared file metadata.
	GetFileMetadata(arg *GetFileMetadataArg) (res *SharedFileMetadata, err error)
	// GetFileMetadataBatch : Returns shared file metadata.
	GetFileMetadataBatch(arg *GetFileMetadataBatchArg) (res []*GetFileMetadataBatchResult, err error)
	// GetFolderMetadata : Returns shared folder metadata by its folder ID.
	GetFolderMetadata(arg *GetMetadataArgs) (res *SharedFolderMetadata, err error)
	// GetSharedLinkFile : Download the shared link's file from a user's
	// Dropbox.
	GetSharedLinkFile(arg *GetSharedLinkMetadataArg) (res IsSharedLinkMetadata, content io.ReadCloser, err error)
	// GetSharedLinkMetadata : Get the shared link's metadata.
	GetSharedLinkMetadata(arg *GetSharedLinkMetadataArg) (res IsSharedLinkMetadata, err error)
	// GetSharedLinks : Returns a list of `LinkMetadata` objects for this user,
	// including collection links. If no path is given, returns a list of all
	// shared links for the current user, including collection links, up to a
	// maximum of 1000 links. If a non-empty path is given, returns a list of
	// all shared links that allow access to the given path.  Collection links
	// are never returned in this case. Note that the url field in the response
	// is never the shortened URL.
	// Deprecated: Use `ListSharedLinks` instead
	GetSharedLinks(arg *GetSharedLinksArg) (res *GetSharedLinksResult, err error)
	// ListFileMembers : Use to obtain the members who have been invited to a
	// file, both inherited and uninherited members.
	ListFileMembers(arg *ListFileMembersArg) (res *SharedFileMembers, err error)
	// ListFileMembersBatch : Get members of multiple files at once. The
	// arguments to this route are more limited, and the limit on query result
	// size per file is more strict. To customize the results more, use the
	// individual file endpoint. Inherited users and groups are not included in
	// the result, and permissions are not returned for this endpoint.
	ListFileMembersBatch(arg *ListFileMembersBatchArg) (res []*ListFileMembersBatchResult, err error)
	// ListFileMembersContinue : Once a cursor has been retrieved from
	// `listFileMembers` or `listFileMembersBatch`, use this to paginate through
	// all shared file members.
	ListFileMembersContinue(arg *ListFileMembersContinueArg) (res *SharedFileMembers, err error)
	// ListFolderMembers : Returns shared folder membership by its folder ID.
	ListFolderMembers(arg *ListFolderMembersArgs) (res *SharedFolderMembers, err error)
	// ListFolderMembersContinue : Once a cursor has been retrieved from
	// `listFolderMembers`, use this to paginate through all shared folder
	// members.
	ListFolderMembersContinue(arg *ListFolderMembersContinueArg) (res *SharedFolderMembers, err error)
	// ListFolders : Return the list of all shared folders the current user has
	// access to.
	ListFolders(arg *ListFoldersArgs) (res *ListFoldersResult, err error)
	// ListFoldersContinue : Once a cursor has been retrieved from
	// `listFolders`, use this to paginate through all shared folders. The
	// cursor must come from a previous call to `listFolders` or
	// `listFoldersContinue`.
	ListFoldersContinue(arg *ListFoldersContinueArg) (res *ListFoldersResult, err error)
	// ListMountableFolders : Return the list of all shared folders the current
	// user can mount or unmount.
	ListMountableFolders(arg *ListFoldersArgs) (res *ListFoldersResult, err error)
	// ListMountableFoldersContinue : Once a cursor has been retrieved from
	// `listMountableFolders`, use this to paginate through all mountable shared
	// folders. The cursor must come from a previous call to
	// `listMountableFolders` or `listMountableFoldersContinue`.
	ListMountableFoldersContinue(arg *ListFoldersContinueArg) (res *ListFoldersResult, err error)
	// ListReceivedFiles : Returns a list of all files shared with current user.
	// Does not include files the user has received via shared folders, and does
	// not include unclaimed invitations.
	ListReceivedFiles(arg *ListFilesArg) (res *ListFilesResult, err error)
	// ListReceivedFilesContinue : Get more results with a cursor from
	// `listReceivedFiles`.
	ListReceivedFilesContinue(arg *ListFilesContinueArg) (res *ListFilesResult, err error)
	// ListSharedLinks : List shared links of this user. If no path is given,
	// returns a list of all shared links for the current user. If a non-empty
	// path is given, returns a list of all shared links that allow access to
	// the given path - direct links to the given path and links to parent
	// folders of the given path. Links to parent folders can be suppressed by
	// setting direct_only to true.
	ListSharedLinks(arg *ListSharedLinksArg) (res *ListSharedLinksResult, err error)
	// ModifySharedLinkSettings : Modify the shared link's settings. If the
	// requested visibility conflict with the shared links policy of the team or
	// the shared folder (in case the linked file is part of a shared folder)
	// then the `LinkPermissions.resolved_visibility` of the returned
	// `SharedLinkMetadata` will reflect the actual visibility of the shared
	// link and the `LinkPermissions.requested_visibility` will reflect the
	// requested visibility.
	ModifySharedLinkSettings(arg *ModifySharedLinkSettingsArgs) (res IsSharedLinkMetadata, err error)
	// MountFolder : The current user mounts the designated folder. Mount a
	// shared folder for a user after they have been added as a member. Once
	// mounted, the shared folder will appear in their Dropbox.
	MountFolder(arg *MountFolderArg) (res *SharedFolderMetadata, err error)
	// RelinquishFileMembership : The current user relinquishes their membership
	// in the designated file. Note that the current user may still have
	// inherited access to this file through the parent folder.
	RelinquishFileMembership(arg *RelinquishFileMembershipArg) (err error)
	// RelinquishFolderMembership : The current user relinquishes their
	// membership in the designated shared folder and will no longer have access
	// to the folder.  A folder owner cannot relinquish membership in their own
	// folder. This will run synchronously if leave_a_copy is false, and
	// asynchronously if leave_a_copy is true.
	RelinquishFolderMembership(arg *RelinquishFolderMembershipArg) (res *async.LaunchEmptyResult, err error)
	// RemoveFileMember : Identical to remove_file_member_2 but with less
	// information returned.
	// Deprecated: Use `RemoveFileMember2` instead
	RemoveFileMember(arg *RemoveFileMemberArg) (res *FileMemberActionIndividualResult, err error)
	// RemoveFileMember2 : Removes a specified member from the file.
	RemoveFileMember2(arg *RemoveFileMemberArg) (res *FileMemberRemoveActionResult, err error)
	// RemoveFolderMember : Allows an owner or editor (if the ACL update policy
	// allows) of a shared folder to remove another member.
	RemoveFolderMember(arg *RemoveFolderMemberArg) (res *async.LaunchResultBase, err error)
	// RevokeSharedLink : Revoke a shared link. Note that even after revoking a
	// shared link to a file, the file may be accessible if there are shared
	// links leading to any of the file parent folders. To list all shared links
	// that enable access to a specific file, you can use the `listSharedLinks`
	// with the file as the `ListSharedLinksArg.path` argument.
	RevokeSharedLink(arg *RevokeSharedLinkArg) (err error)
	// SetAccessInheritance : Change the inheritance policy of an existing
	// Shared Folder. Only permitted for shared folders in a shared team root.
	// If a `ShareFolderLaunch.async_job_id` is returned, you'll need to call
	// `checkShareJobStatus` until the action completes to get the metadata for
	// the folder.
	SetAccessInheritance(arg *SetAccessInheritanceArg) (res *ShareFolderLaunch, err error)
	// ShareFolder : Share a folder with collaborators. Most sharing will be
	// completed synchronously. Large folders will be completed asynchronously.
	// To make testing the async case repeatable, set
	// `ShareFolderArg.force_async`. If a `ShareFolderLaunch.async_job_id` is
	// returned, you'll need to call `checkShareJobStatus` until the action
	// completes to get the metadata for the folder.
	ShareFolder(arg *ShareFolderArg) (res *ShareFolderLaunch, err error)
	// TransferFolder : Transfer ownership of a shared folder to a member of the
	// shared folder. User must have `AccessLevel.owner` access to the shared
	// folder to perform a transfer.
	TransferFolder(arg *TransferFolderArg) (err error)
	// UnmountFolder : The current user unmounts the designated folder. They can
	// re-mount the folder at a later time using `mountFolder`.
	UnmountFolder(arg *UnmountFolderArg) (err error)
	// UnshareFile : Remove all members from this file. Does not remove
	// inherited members.
	UnshareFile(arg *UnshareFileArg) (err error)
	// UnshareFolder : Allows a shared folder owner to unshare the folder.
	// You'll need to call `checkJobStatus` to determine if the action has
	// completed successfully.
	UnshareFolder(arg *UnshareFolderArg) (res *async.LaunchEmptyResult, err error)
	// UpdateFileMember : Changes a member's access on a shared file.
	UpdateFileMember(arg *UpdateFileMemberArgs) (res *MemberAccessLevelResult, err error)
	// UpdateFolderMember : Allows an owner or editor of a shared folder to
	// update another member's permissions.
	UpdateFolderMember(arg *UpdateFolderMemberArg) (res *MemberAccessLevelResult, err error)
	// UpdateFolderPolicy : Update the sharing policies for a shared folder.
	// User must have `AccessLevel.owner` access to the shared folder to update
	// its policies.
	UpdateFolderPolicy(arg *UpdateFolderPolicyArg) (res *SharedFolderMetadata, err error)
}

Client interface describes all routes in this namespace

func New 

func New(c dropbox.Config) Client

New returns a Client implementation for this namespace

type CollectionLinkMetadata 

type CollectionLinkMetadata struct {
	LinkMetadata
}

CollectionLinkMetadata : Metadata for a collection-based shared link.

func NewCollectionLinkMetadata 

func NewCollectionLinkMetadata(Url string, Visibility *Visibility) *CollectionLinkMetadata

NewCollectionLinkMetadata returns a new CollectionLinkMetadata instance

type CreateSharedLinkAPIError 

type CreateSharedLinkAPIError struct {
	dropbox.APIError
	EndpointError *CreateSharedLinkError `json:"error"`
}

CreateSharedLinkAPIError is an error-wrapper for the create_shared_link route

type CreateSharedLinkArg 

type CreateSharedLinkArg struct {
	// Path : The path to share.
	Path string `json:"path"`
	// ShortUrl : Whether to return a shortened URL.
	ShortUrl bool `json:"short_url"`
	// PendingUpload : If it's okay to share a path that does not yet exist, set
	// this to either `PendingUploadMode.file` or `PendingUploadMode.folder` to
	// indicate whether to assume it's a file or folder.
	PendingUpload *PendingUploadMode `json:"pending_upload,omitempty"`
}

CreateSharedLinkArg : has no documentation (yet)

func NewCreateSharedLinkArg 

func NewCreateSharedLinkArg(Path string) *CreateSharedLinkArg

NewCreateSharedLinkArg returns a new CreateSharedLinkArg instance

type CreateSharedLinkError 

type CreateSharedLinkError struct {
	dropbox.Tagged
	// Path : has no documentation (yet)
	Path *files.LookupError `json:"path,omitempty"`
}

CreateSharedLinkError : has no documentation (yet)

func (*CreateSharedLinkError) UnmarshalJSON 

func (u *CreateSharedLinkError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a CreateSharedLinkError instance

type CreateSharedLinkWithSettingsAPIError 

type CreateSharedLinkWithSettingsAPIError struct {
	dropbox.APIError
	EndpointError *CreateSharedLinkWithSettingsError `json:"error"`
}

CreateSharedLinkWithSettingsAPIError is an error-wrapper for the create_shared_link_with_settings route

type CreateSharedLinkWithSettingsArg 

type CreateSharedLinkWithSettingsArg struct {
	// Path : The path to be shared by the shared link.
	Path string `json:"path"`
	// Settings : The requested settings for the newly created shared link.
	Settings *SharedLinkSettings `json:"settings,omitempty"`
}

CreateSharedLinkWithSettingsArg : has no documentation (yet)

func NewCreateSharedLinkWithSettingsArg 

func NewCreateSharedLinkWithSettingsArg(Path string) *CreateSharedLinkWithSettingsArg

NewCreateSharedLinkWithSettingsArg returns a new CreateSharedLinkWithSettingsArg instance

type CreateSharedLinkWithSettingsError 

type CreateSharedLinkWithSettingsError struct {
	dropbox.Tagged
	// Path : has no documentation (yet)
	Path *files.LookupError `json:"path,omitempty"`
	// SharedLinkAlreadyExists : The shared link already exists. You can call
	// `listSharedLinks` to get the  existing link, or use the provided metadata
	// if it is returned.
	SharedLinkAlreadyExists *SharedLinkAlreadyExistsMetadata `json:"shared_link_already_exists,omitempty"`
	// SettingsError : There is an error with the given settings.
	SettingsError *SharedLinkSettingsError `json:"settings_error,omitempty"`
}

CreateSharedLinkWithSettingsError : has no documentation (yet)

func (*CreateSharedLinkWithSettingsError) UnmarshalJSON 

func (u *CreateSharedLinkWithSettingsError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a CreateSharedLinkWithSettingsError instance

type ExpectedSharedContentLinkMetadata 

type ExpectedSharedContentLinkMetadata struct {
	SharedContentLinkMetadataBase
}

ExpectedSharedContentLinkMetadata : The expected metadata of a shared link for a file or folder when a link is first created for the content. Absent if the link already exists.

func NewExpectedSharedContentLinkMetadata 

func NewExpectedSharedContentLinkMetadata(AudienceOptions []*LinkAudience, CurrentAudience *LinkAudience, LinkPermissions []*LinkPermission, PasswordProtected bool) *ExpectedSharedContentLinkMetadata

NewExpectedSharedContentLinkMetadata returns a new ExpectedSharedContentLinkMetadata instance

type FileAction 

type FileAction struct {
	dropbox.Tagged
}

FileAction : Sharing actions that may be taken on files.

type FileErrorResult 

type FileErrorResult struct {
	dropbox.Tagged
	// FileNotFoundError : File specified by id was not found.
	FileNotFoundError string `json:"file_not_found_error,omitempty"`
	// InvalidFileActionError : User does not have permission to take the
	// specified action on the file.
	InvalidFileActionError string `json:"invalid_file_action_error,omitempty"`
	// PermissionDeniedError : User does not have permission to access file
	// specified by file.Id.
	PermissionDeniedError string `json:"permission_denied_error,omitempty"`
}

FileErrorResult : has no documentation (yet)

func (*FileErrorResult) UnmarshalJSON 

func (u *FileErrorResult) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a FileErrorResult instance

type FileLinkMetadata 

type FileLinkMetadata struct {
	SharedLinkMetadata
	// ClientModified : The modification time set by the desktop client when the
	// file was added to Dropbox. Since this time is not verified (the Dropbox
	// server stores whatever the desktop client sends up), this should only be
	// used for display purposes (such as sorting) and not, for example, to
	// determine if a file has changed or not.
	ClientModified time.Time `json:"client_modified"`
	// ServerModified : The last time the file was modified on Dropbox.
	ServerModified time.Time `json:"server_modified"`
	// Rev : A unique identifier for the current revision of a file. This field
	// is the same rev as elsewhere in the API and can be used to detect changes
	// and avoid conflicts.
	Rev string `json:"rev"`
	// Size : The file size in bytes.
	Size uint64 `json:"size"`
}

FileLinkMetadata : The metadata of a file shared link.

func NewFileLinkMetadata 

func NewFileLinkMetadata(Url string, Name string, LinkPermissions *LinkPermissions, ClientModified time.Time, ServerModified time.Time, Rev string, Size uint64) *FileLinkMetadata

NewFileLinkMetadata returns a new FileLinkMetadata instance

type FileMemberActionError 

type FileMemberActionError struct {
	dropbox.Tagged
	// AccessError : Specified file was invalid or user does not have access.
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
	// NoExplicitAccess : The action cannot be completed because the target
	// member does not have explicit access to the file. The return value is the
	// access that the member has to the file from a parent folder.
	NoExplicitAccess *MemberAccessLevelResult `json:"no_explicit_access,omitempty"`
}

FileMemberActionError : has no documentation (yet)

func (*FileMemberActionError) UnmarshalJSON 

func (u *FileMemberActionError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a FileMemberActionError instance

type FileMemberActionIndividualResult 

type FileMemberActionIndividualResult struct {
	dropbox.Tagged
	// Success : Member was successfully removed from this file. If AccessLevel
	// is given, the member still has access via a parent shared folder.
	Success *AccessLevel `json:"success,omitempty"`
	// MemberError : User was not able to perform this action.
	MemberError *FileMemberActionError `json:"member_error,omitempty"`
}

FileMemberActionIndividualResult : has no documentation (yet)

func (*FileMemberActionIndividualResult) UnmarshalJSON 

func (u *FileMemberActionIndividualResult) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a FileMemberActionIndividualResult instance

type FileMemberActionResult 

type FileMemberActionResult struct {
	// Member : One of specified input members.
	Member *MemberSelector `json:"member"`
	// Result : The outcome of the action on this member.
	Result *FileMemberActionIndividualResult `json:"result"`
}

FileMemberActionResult : Per-member result for `addFileMember` or `changeFileMemberAccess`.

func NewFileMemberActionResult 

func NewFileMemberActionResult(Member *MemberSelector, Result *FileMemberActionIndividualResult) *FileMemberActionResult

NewFileMemberActionResult returns a new FileMemberActionResult instance

type FileMemberRemoveActionResult 

type FileMemberRemoveActionResult struct {
	dropbox.Tagged
	// Success : Member was successfully removed from this file.
	Success *MemberAccessLevelResult `json:"success,omitempty"`
	// MemberError : User was not able to remove this member.
	MemberError *FileMemberActionError `json:"member_error,omitempty"`
}

FileMemberRemoveActionResult : has no documentation (yet)

func (*FileMemberRemoveActionResult) UnmarshalJSON 

func (u *FileMemberRemoveActionResult) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a FileMemberRemoveActionResult instance

type FilePermission 

type FilePermission struct {
	// Action : The action that the user may wish to take on the file.
	Action *FileAction `json:"action"`
	// Allow : True if the user is allowed to take the action.
	Allow bool `json:"allow"`
	// Reason : The reason why the user is denied the permission. Not present if
	// the action is allowed.
	Reason *PermissionDeniedReason `json:"reason,omitempty"`
}

FilePermission : Whether the user is allowed to take the sharing action on the file.

func NewFilePermission 

func NewFilePermission(Action *FileAction, Allow bool) *FilePermission

NewFilePermission returns a new FilePermission instance

type FolderAction 

type FolderAction struct {
	dropbox.Tagged
}

FolderAction : Actions that may be taken on shared folders.

type FolderLinkMetadata 

type FolderLinkMetadata struct {
	SharedLinkMetadata
}

FolderLinkMetadata : The metadata of a folder shared link.

func NewFolderLinkMetadata 

func NewFolderLinkMetadata(Url string, Name string, LinkPermissions *LinkPermissions) *FolderLinkMetadata

NewFolderLinkMetadata returns a new FolderLinkMetadata instance

type FolderPermission 

type FolderPermission struct {
	// Action : The action that the user may wish to take on the folder.
	Action *FolderAction `json:"action"`
	// Allow : True if the user is allowed to take the action.
	Allow bool `json:"allow"`
	// Reason : The reason why the user is denied the permission. Not present if
	// the action is allowed, or if no reason is available.
	Reason *PermissionDeniedReason `json:"reason,omitempty"`
}

FolderPermission : Whether the user is allowed to take the action on the shared folder.

func NewFolderPermission 

func NewFolderPermission(Action *FolderAction, Allow bool) *FolderPermission

NewFolderPermission returns a new FolderPermission instance

type FolderPolicy 

type FolderPolicy struct {
	// MemberPolicy : Who can be a member of this shared folder, as set on the
	// folder itself. The effective policy may differ from this value if the
	// team-wide policy is more restrictive. Present only if the folder is owned
	// by a team.
	MemberPolicy *MemberPolicy `json:"member_policy,omitempty"`
	// ResolvedMemberPolicy : Who can be a member of this shared folder, taking
	// into account both the folder and the team-wide policy. This value may
	// differ from that of member_policy if the team-wide policy is more
	// restrictive than the folder policy. Present only if the folder is owned
	// by a team.
	ResolvedMemberPolicy *MemberPolicy `json:"resolved_member_policy,omitempty"`
	// AclUpdatePolicy : Who can add and remove members from this shared folder.
	AclUpdatePolicy *AclUpdatePolicy `json:"acl_update_policy"`
	// SharedLinkPolicy : Who links can be shared with.
	SharedLinkPolicy *SharedLinkPolicy `json:"shared_link_policy"`
	// ViewerInfoPolicy : Who can enable/disable viewer info for this shared
	// folder.
	ViewerInfoPolicy *ViewerInfoPolicy `json:"viewer_info_policy,omitempty"`
}

FolderPolicy : A set of policies governing membership and privileges for a shared folder.

func NewFolderPolicy 

func NewFolderPolicy(AclUpdatePolicy *AclUpdatePolicy, SharedLinkPolicy *SharedLinkPolicy) *FolderPolicy

NewFolderPolicy returns a new FolderPolicy instance

type GetFileMetadataAPIError 

type GetFileMetadataAPIError struct {
	dropbox.APIError
	EndpointError *GetFileMetadataError `json:"error"`
}

GetFileMetadataAPIError is an error-wrapper for the get_file_metadata route

type GetFileMetadataArg 

type GetFileMetadataArg struct {
	// File : The file to query.
	File string `json:"file"`
	// Actions : A list of `FileAction`s corresponding to `FilePermission`s that
	// should appear in the  response's `SharedFileMetadata.permissions` field
	// describing the actions the  authenticated user can perform on the file.
	Actions []*FileAction `json:"actions,omitempty"`
}

GetFileMetadataArg : Arguments of `getFileMetadata`.

func NewGetFileMetadataArg 

func NewGetFileMetadataArg(File string) *GetFileMetadataArg

NewGetFileMetadataArg returns a new GetFileMetadataArg instance

type GetFileMetadataBatchAPIError 

type GetFileMetadataBatchAPIError struct {
	dropbox.APIError
	EndpointError *SharingUserError `json:"error"`
}

GetFileMetadataBatchAPIError is an error-wrapper for the get_file_metadata/batch route

type GetFileMetadataBatchArg 

type GetFileMetadataBatchArg struct {
	// Files : The files to query.
	Files []string `json:"files"`
	// Actions : A list of `FileAction`s corresponding to `FilePermission`s that
	// should appear in the  response's `SharedFileMetadata.permissions` field
	// describing the actions the  authenticated user can perform on the file.
	Actions []*FileAction `json:"actions,omitempty"`
}

GetFileMetadataBatchArg : Arguments of `getFileMetadataBatch`.

func NewGetFileMetadataBatchArg 

func NewGetFileMetadataBatchArg(Files []string) *GetFileMetadataBatchArg

NewGetFileMetadataBatchArg returns a new GetFileMetadataBatchArg instance

type GetFileMetadataBatchResult 

type GetFileMetadataBatchResult struct {
	// File : This is the input file identifier corresponding to one of
	// `GetFileMetadataBatchArg.files`.
	File string `json:"file"`
	// Result : The result for this particular file.
	Result *GetFileMetadataIndividualResult `json:"result"`
}

GetFileMetadataBatchResult : Per file results of `getFileMetadataBatch`.

func NewGetFileMetadataBatchResult 

func NewGetFileMetadataBatchResult(File string, Result *GetFileMetadataIndividualResult) *GetFileMetadataBatchResult

NewGetFileMetadataBatchResult returns a new GetFileMetadataBatchResult instance

type GetFileMetadataError 

type GetFileMetadataError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

GetFileMetadataError : Error result for `getFileMetadata`.

func (*GetFileMetadataError) UnmarshalJSON 

func (u *GetFileMetadataError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a GetFileMetadataError instance

type GetFileMetadataIndividualResult 

type GetFileMetadataIndividualResult struct {
	dropbox.Tagged
	// Metadata : The result for this file if it was successful.
	Metadata *SharedFileMetadata `json:"metadata,omitempty"`
	// AccessError : The result for this file if it was an error.
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

GetFileMetadataIndividualResult : has no documentation (yet)

func (*GetFileMetadataIndividualResult) UnmarshalJSON 

func (u *GetFileMetadataIndividualResult) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a GetFileMetadataIndividualResult instance

type GetFolderMetadataAPIError 

type GetFolderMetadataAPIError struct {
	dropbox.APIError
	EndpointError *SharedFolderAccessError `json:"error"`
}

GetFolderMetadataAPIError is an error-wrapper for the get_folder_metadata route

type GetMetadataArgs 

type GetMetadataArgs struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Actions : A list of `FolderAction`s corresponding to `FolderPermission`s
	// that should appear in the  response's `SharedFolderMetadata.permissions`
	// field describing the actions the  authenticated user can perform on the
	// folder.
	Actions []*FolderAction `json:"actions,omitempty"`
}

GetMetadataArgs : has no documentation (yet)

func NewGetMetadataArgs 

func NewGetMetadataArgs(SharedFolderId string) *GetMetadataArgs

NewGetMetadataArgs returns a new GetMetadataArgs instance

type GetSharedLinkFileAPIError 

type GetSharedLinkFileAPIError struct {
	dropbox.APIError
	EndpointError *GetSharedLinkFileError `json:"error"`
}

GetSharedLinkFileAPIError is an error-wrapper for the get_shared_link_file route

type GetSharedLinkFileError 

type GetSharedLinkFileError struct {
	dropbox.Tagged
}

GetSharedLinkFileError : has no documentation (yet)

type GetSharedLinkMetadataAPIError 

type GetSharedLinkMetadataAPIError struct {
	dropbox.APIError
	EndpointError *SharedLinkError `json:"error"`
}

GetSharedLinkMetadataAPIError is an error-wrapper for the get_shared_link_metadata route

type GetSharedLinkMetadataArg 

type GetSharedLinkMetadataArg struct {
	// Url : URL of the shared link.
	Url string `json:"url"`
	// Path : If the shared link is to a folder, this parameter can be used to
	// retrieve the metadata for a specific file or sub-folder in this folder. A
	// relative path should be used.
	Path string `json:"path,omitempty"`
	// LinkPassword : If the shared link has a password, this parameter can be
	// used.
	LinkPassword string `json:"link_password,omitempty"`
}

GetSharedLinkMetadataArg : has no documentation (yet)

func NewGetSharedLinkMetadataArg 

func NewGetSharedLinkMetadataArg(Url string) *GetSharedLinkMetadataArg

NewGetSharedLinkMetadataArg returns a new GetSharedLinkMetadataArg instance

type GetSharedLinksAPIError 

type GetSharedLinksAPIError struct {
	dropbox.APIError
	EndpointError *GetSharedLinksError `json:"error"`
}

GetSharedLinksAPIError is an error-wrapper for the get_shared_links route

type GetSharedLinksArg 

type GetSharedLinksArg struct {
	// Path : See `getSharedLinks` description.
	Path string `json:"path,omitempty"`
}

GetSharedLinksArg : has no documentation (yet)

func NewGetSharedLinksArg 

func NewGetSharedLinksArg() *GetSharedLinksArg

NewGetSharedLinksArg returns a new GetSharedLinksArg instance

type GetSharedLinksError 

type GetSharedLinksError struct {
	dropbox.Tagged
	// Path : has no documentation (yet)
	Path string `json:"path,omitempty"`
}

GetSharedLinksError : has no documentation (yet)

func (*GetSharedLinksError) UnmarshalJSON 

func (u *GetSharedLinksError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a GetSharedLinksError instance

type GetSharedLinksResult 

type GetSharedLinksResult struct {
	// Links : Shared links applicable to the path argument.
	Links []IsLinkMetadata `json:"links"`
}

GetSharedLinksResult : has no documentation (yet)

func NewGetSharedLinksResult 

func NewGetSharedLinksResult(Links []IsLinkMetadata) *GetSharedLinksResult

NewGetSharedLinksResult returns a new GetSharedLinksResult instance

func (*GetSharedLinksResult) UnmarshalJSON 

func (u *GetSharedLinksResult) UnmarshalJSON(b []byte) error

UnmarshalJSON deserializes into a GetSharedLinksResult instance

type GroupInfo 

type GroupInfo struct {
	team_common.GroupSummary
	// GroupType : The type of group.
	GroupType *team_common.GroupType `json:"group_type"`
	// IsMember : If the current user is a member of the group.
	IsMember bool `json:"is_member"`
	// IsOwner : If the current user is an owner of the group.
	IsOwner bool `json:"is_owner"`
	// SameTeam : If the group is owned by the current user's team.
	SameTeam bool `json:"same_team"`
}

GroupInfo : The information about a group. Groups is a way to manage a list of users who need same access permission to the shared folder.

func NewGroupInfo 

func NewGroupInfo(GroupName string, GroupId string, GroupManagementType *team_common.GroupManagementType, GroupType *team_common.GroupType, IsMember bool, IsOwner bool, SameTeam bool) *GroupInfo

NewGroupInfo returns a new GroupInfo instance

type GroupMembershipInfo 

type GroupMembershipInfo struct {
	MembershipInfo
	// Group : The information about the membership group.
	Group *GroupInfo `json:"group"`
}

GroupMembershipInfo : The information about a group member of the shared content.

func NewGroupMembershipInfo 

func NewGroupMembershipInfo(AccessType *AccessLevel, Group *GroupInfo) *GroupMembershipInfo

NewGroupMembershipInfo returns a new GroupMembershipInfo instance

type InsufficientPlan 

type InsufficientPlan struct {
	// Message : A message to tell the user to upgrade in order to support
	// expected action.
	Message string `json:"message"`
	// UpsellUrl : A URL to send the user to in order to obtain the account type
	// they need, e.g. upgrading. Absent if there is no action the user can take
	// to upgrade.
	UpsellUrl string `json:"upsell_url,omitempty"`
}

InsufficientPlan : has no documentation (yet)

func NewInsufficientPlan 

func NewInsufficientPlan(Message string) *InsufficientPlan

NewInsufficientPlan returns a new InsufficientPlan instance

type InsufficientQuotaAmounts 

type InsufficientQuotaAmounts struct {
	// SpaceNeeded : The amount of space needed to add the item (the size of the
	// item).
	SpaceNeeded uint64 `json:"space_needed"`
	// SpaceShortage : The amount of extra space needed to add the item.
	SpaceShortage uint64 `json:"space_shortage"`
	// SpaceLeft : The amount of space left in the user's Dropbox, less than
	// space_needed.
	SpaceLeft uint64 `json:"space_left"`
}

InsufficientQuotaAmounts : has no documentation (yet)

func NewInsufficientQuotaAmounts 

func NewInsufficientQuotaAmounts(SpaceNeeded uint64, SpaceShortage uint64, SpaceLeft uint64) *InsufficientQuotaAmounts

NewInsufficientQuotaAmounts returns a new InsufficientQuotaAmounts instance

type InviteeInfo 

type InviteeInfo struct {
	dropbox.Tagged
	// Email : E-mail address of invited user.
	Email string `json:"email,omitempty"`
}

InviteeInfo : Information about the recipient of a shared content invitation.

func (*InviteeInfo) UnmarshalJSON 

func (u *InviteeInfo) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a InviteeInfo instance

type InviteeMembershipInfo 

type InviteeMembershipInfo struct {
	MembershipInfo
	// Invitee : Recipient of the invitation.
	Invitee *InviteeInfo `json:"invitee"`
	// User : The user this invitation is tied to, if available.
	User *UserInfo `json:"user,omitempty"`
}

InviteeMembershipInfo : Information about an invited member of a shared content.

func NewInviteeMembershipInfo 

func NewInviteeMembershipInfo(AccessType *AccessLevel, Invitee *InviteeInfo) *InviteeMembershipInfo

NewInviteeMembershipInfo returns a new InviteeMembershipInfo instance

type IsLinkMetadata 

type IsLinkMetadata interface {
	IsLinkMetadata()
}

IsLinkMetadata is the interface type for LinkMetadata and its subtypes

func IsLinkMetadataFromJSON 

func IsLinkMetadataFromJSON(data []byte) (IsLinkMetadata, error)

IsLinkMetadataFromJSON converts JSON to a concrete IsLinkMetadata instance

type IsSharedLinkMetadata 

type IsSharedLinkMetadata interface {
	IsSharedLinkMetadata()
}

IsSharedLinkMetadata is the interface type for SharedLinkMetadata and its subtypes

func IsSharedLinkMetadataFromJSON 

func IsSharedLinkMetadataFromJSON(data []byte) (IsSharedLinkMetadata, error)

IsSharedLinkMetadataFromJSON converts JSON to a concrete IsSharedLinkMetadata instance

type JobError 

type JobError struct {
	dropbox.Tagged
	// UnshareFolderError : Error occurred while performing `unshareFolder`
	// action.
	UnshareFolderError *UnshareFolderError `json:"unshare_folder_error,omitempty"`
	// RemoveFolderMemberError : Error occurred while performing
	// `removeFolderMember` action.
	RemoveFolderMemberError *RemoveFolderMemberError `json:"remove_folder_member_error,omitempty"`
	// RelinquishFolderMembershipError : Error occurred while performing
	// `relinquishFolderMembership` action.
	RelinquishFolderMembershipError *RelinquishFolderMembershipError `json:"relinquish_folder_membership_error,omitempty"`
}

JobError : Error occurred while performing an asynchronous job from `unshareFolder` or `removeFolderMember`.

func (*JobError) UnmarshalJSON 

func (u *JobError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a JobError instance

type JobStatus 

type JobStatus struct {
	dropbox.Tagged
	// Failed : The asynchronous job returned an error.
	Failed *JobError `json:"failed,omitempty"`
}

JobStatus : has no documentation (yet)

func (*JobStatus) UnmarshalJSON 

func (u *JobStatus) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a JobStatus instance

type LinkAccessLevel 

type LinkAccessLevel struct {
	dropbox.Tagged
}

LinkAccessLevel : has no documentation (yet)

type LinkAction 

type LinkAction struct {
	dropbox.Tagged
}

LinkAction : Actions that can be performed on a link.

type LinkAudience 

type LinkAudience struct {
	dropbox.Tagged
}

LinkAudience : has no documentation (yet)

type LinkExpiry 

type LinkExpiry struct {
	dropbox.Tagged
	// SetExpiry : Set a new expiry or change an existing expiry.
	SetExpiry time.Time `json:"set_expiry,omitempty"`
}

LinkExpiry : has no documentation (yet)

func (*LinkExpiry) UnmarshalJSON 

func (u *LinkExpiry) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a LinkExpiry instance

type LinkMetadata 

type LinkMetadata struct {
	// Url : URL of the shared link.
	Url string `json:"url"`
	// Visibility : Who can access the link.
	Visibility *Visibility `json:"visibility"`
	// Expires : Expiration time, if set. By default the link won't expire.
	Expires time.Time `json:"expires,omitempty"`
}

LinkMetadata : Metadata for a shared link. This can be either a `PathLinkMetadata` or `CollectionLinkMetadata`.

func NewLinkMetadata 

func NewLinkMetadata(Url string, Visibility *Visibility) *LinkMetadata

NewLinkMetadata returns a new LinkMetadata instance

func (*LinkMetadata) IsLinkMetadata 

func (u *LinkMetadata) IsLinkMetadata()

IsLinkMetadata implements the IsLinkMetadata interface

type LinkPassword 

type LinkPassword struct {
	dropbox.Tagged
	// SetPassword : Set a new password or change an existing password.
	SetPassword string `json:"set_password,omitempty"`
}

LinkPassword : has no documentation (yet)

func (*LinkPassword) UnmarshalJSON 

func (u *LinkPassword) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a LinkPassword instance

type LinkPermission 

type LinkPermission struct {
	// Action : has no documentation (yet)
	Action *LinkAction `json:"action"`
	// Allow : has no documentation (yet)
	Allow bool `json:"allow"`
	// Reason : has no documentation (yet)
	Reason *PermissionDeniedReason `json:"reason,omitempty"`
}

LinkPermission : Permissions for actions that can be performed on a link.

func NewLinkPermission 

func NewLinkPermission(Action *LinkAction, Allow bool) *LinkPermission

NewLinkPermission returns a new LinkPermission instance

type LinkPermissions 

type LinkPermissions struct {
	// ResolvedVisibility : The current visibility of the link after considering
	// the shared links policies of the the team (in case the link's owner is
	// part of a team) and the shared folder (in case the linked file is part of
	// a shared folder). This field is shown only if the caller has access to
	// this info (the link's owner always has access to this data). For some
	// links, an effective_audience value is returned instead.
	ResolvedVisibility *ResolvedVisibility `json:"resolved_visibility,omitempty"`
	// RequestedVisibility : The shared link's requested visibility. This can be
	// overridden by the team and shared folder policies. The final visibility,
	// after considering these policies, can be found in `resolved_visibility`.
	// This is shown only if the caller is the link's owner and
	// resolved_visibility is returned instead of effective_audience.
	RequestedVisibility *RequestedVisibility `json:"requested_visibility,omitempty"`
	// CanRevoke : Whether the caller can revoke the shared link.
	CanRevoke bool `json:"can_revoke"`
	// RevokeFailureReason : The failure reason for revoking the link. This
	// field will only be present if the `can_revoke` is false.
	RevokeFailureReason *SharedLinkAccessFailureReason `json:"revoke_failure_reason,omitempty"`
	// EffectiveAudience : The type of audience who can benefit from the access
	// level specified by the `link_access_level` field.
	EffectiveAudience *LinkAudience `json:"effective_audience,omitempty"`
	// LinkAccessLevel : The access level that the link will grant to its users.
	// A link can grant additional rights to a user beyond their current access
	// level. For example, if a user was invited as a viewer to a file, and then
	// opens a link with `link_access_level` set to `editor`, then they will
	// gain editor privileges. The `link_access_level` is a property of the
	// link, and does not depend on who is calling this API. In particular,
	// `link_access_level` does not take into account the API caller's current
	// permissions to the content.
	LinkAccessLevel *LinkAccessLevel `json:"link_access_level,omitempty"`
}

LinkPermissions : has no documentation (yet)

func NewLinkPermissions 

func NewLinkPermissions(CanRevoke bool) *LinkPermissions

NewLinkPermissions returns a new LinkPermissions instance

type LinkSettings 

type LinkSettings struct {
	// AccessLevel : The access level on the link for this file. Currently, it
	// only accepts 'viewer' and 'viewer_no_comment'.
	AccessLevel *AccessLevel `json:"access_level,omitempty"`
	// Audience : The type of audience on the link for this file.
	Audience *LinkAudience `json:"audience,omitempty"`
	// Expiry : An expiry timestamp to set on a link.
	Expiry *LinkExpiry `json:"expiry,omitempty"`
	// Password : The password for the link.
	Password *LinkPassword `json:"password,omitempty"`
}

LinkSettings : Settings that apply to a link.

func NewLinkSettings 

func NewLinkSettings() *LinkSettings

NewLinkSettings returns a new LinkSettings instance

type ListFileMembersAPIError 

type ListFileMembersAPIError struct {
	dropbox.APIError
	EndpointError *ListFileMembersError `json:"error"`
}

ListFileMembersAPIError is an error-wrapper for the list_file_members route

type ListFileMembersArg 

type ListFileMembersArg struct {
	// File : The file for which you want to see members.
	File string `json:"file"`
	// Actions : The actions for which to return permissions on a member.
	Actions []*MemberAction `json:"actions,omitempty"`
	// IncludeInherited : Whether to include members who only have access from a
	// parent shared folder.
	IncludeInherited bool `json:"include_inherited"`
	// Limit : Number of members to return max per query. Defaults to 100 if no
	// limit is specified.
	Limit uint32 `json:"limit"`
}

ListFileMembersArg : Arguments for `listFileMembers`.

func NewListFileMembersArg 

func NewListFileMembersArg(File string) *ListFileMembersArg

NewListFileMembersArg returns a new ListFileMembersArg instance

type ListFileMembersBatchAPIError 

type ListFileMembersBatchAPIError struct {
	dropbox.APIError
	EndpointError *SharingUserError `json:"error"`
}

ListFileMembersBatchAPIError is an error-wrapper for the list_file_members/batch route

type ListFileMembersBatchArg 

type ListFileMembersBatchArg struct {
	// Files : Files for which to return members.
	Files []string `json:"files"`
	// Limit : Number of members to return max per query. Defaults to 10 if no
	// limit is specified.
	Limit uint32 `json:"limit"`
}

ListFileMembersBatchArg : Arguments for `listFileMembersBatch`.

func NewListFileMembersBatchArg 

func NewListFileMembersBatchArg(Files []string) *ListFileMembersBatchArg

NewListFileMembersBatchArg returns a new ListFileMembersBatchArg instance

type ListFileMembersBatchResult 

type ListFileMembersBatchResult struct {
	// File : This is the input file identifier, whether an ID or a path.
	File string `json:"file"`
	// Result : The result for this particular file.
	Result *ListFileMembersIndividualResult `json:"result"`
}

ListFileMembersBatchResult : Per-file result for `listFileMembersBatch`.

func NewListFileMembersBatchResult 

func NewListFileMembersBatchResult(File string, Result *ListFileMembersIndividualResult) *ListFileMembersBatchResult

NewListFileMembersBatchResult returns a new ListFileMembersBatchResult instance

type ListFileMembersContinueAPIError 

type ListFileMembersContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFileMembersContinueError `json:"error"`
}

ListFileMembersContinueAPIError is an error-wrapper for the list_file_members/continue route

type ListFileMembersContinueArg 

type ListFileMembersContinueArg struct {
	// Cursor : The cursor returned by your last call to `listFileMembers`,
	// `listFileMembersContinue`, or `listFileMembersBatch`.
	Cursor string `json:"cursor"`
}

ListFileMembersContinueArg : Arguments for `listFileMembersContinue`.

func NewListFileMembersContinueArg 

func NewListFileMembersContinueArg(Cursor string) *ListFileMembersContinueArg

NewListFileMembersContinueArg returns a new ListFileMembersContinueArg instance

type ListFileMembersContinueError 

type ListFileMembersContinueError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

ListFileMembersContinueError : Error for `listFileMembersContinue`.

func (*ListFileMembersContinueError) UnmarshalJSON 

func (u *ListFileMembersContinueError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListFileMembersContinueError instance

type ListFileMembersCountResult 

type ListFileMembersCountResult struct {
	// Members : A list of members on this file.
	Members *SharedFileMembers `json:"members"`
	// MemberCount : The number of members on this file. This does not include
	// inherited members.
	MemberCount uint32 `json:"member_count"`
}

ListFileMembersCountResult : has no documentation (yet)

func NewListFileMembersCountResult 

func NewListFileMembersCountResult(Members *SharedFileMembers, MemberCount uint32) *ListFileMembersCountResult

NewListFileMembersCountResult returns a new ListFileMembersCountResult instance

type ListFileMembersError 

type ListFileMembersError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

ListFileMembersError : Error for `listFileMembers`.

func (*ListFileMembersError) UnmarshalJSON 

func (u *ListFileMembersError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListFileMembersError instance

type ListFileMembersIndividualResult 

type ListFileMembersIndividualResult struct {
	dropbox.Tagged
	// Result : The results of the query for this file if it was successful.
	Result *ListFileMembersCountResult `json:"result,omitempty"`
	// AccessError : The result of the query for this file if it was an error.
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

ListFileMembersIndividualResult : has no documentation (yet)

func (*ListFileMembersIndividualResult) UnmarshalJSON 

func (u *ListFileMembersIndividualResult) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListFileMembersIndividualResult instance

type ListFilesArg 

type ListFilesArg struct {
	// Limit : Number of files to return max per query. Defaults to 100 if no
	// limit is specified.
	Limit uint32 `json:"limit"`
	// Actions : A list of `FileAction`s corresponding to `FilePermission`s that
	// should appear in the  response's `SharedFileMetadata.permissions` field
	// describing the actions the  authenticated user can perform on the file.
	Actions []*FileAction `json:"actions,omitempty"`
}

ListFilesArg : Arguments for `listReceivedFiles`.

func NewListFilesArg 

func NewListFilesArg() *ListFilesArg

NewListFilesArg returns a new ListFilesArg instance

type ListFilesContinueArg 

type ListFilesContinueArg struct {
	// Cursor : Cursor in `ListFilesResult.cursor`.
	Cursor string `json:"cursor"`
}

ListFilesContinueArg : Arguments for `listReceivedFilesContinue`.

func NewListFilesContinueArg 

func NewListFilesContinueArg(Cursor string) *ListFilesContinueArg

NewListFilesContinueArg returns a new ListFilesContinueArg instance

type ListFilesContinueError 

type ListFilesContinueError struct {
	dropbox.Tagged
	// UserError : User account had a problem.
	UserError *SharingUserError `json:"user_error,omitempty"`
}

ListFilesContinueError : Error results for `listReceivedFilesContinue`.

func (*ListFilesContinueError) UnmarshalJSON 

func (u *ListFilesContinueError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListFilesContinueError instance

type ListFilesResult 

type ListFilesResult struct {
	// Entries : Information about the files shared with current user.
	Entries []*SharedFileMetadata `json:"entries"`
	// Cursor : Cursor used to obtain additional shared files.
	Cursor string `json:"cursor,omitempty"`
}

ListFilesResult : Success results for `listReceivedFiles`.

func NewListFilesResult 

func NewListFilesResult(Entries []*SharedFileMetadata) *ListFilesResult

NewListFilesResult returns a new ListFilesResult instance

type ListFolderMembersAPIError 

type ListFolderMembersAPIError struct {
	dropbox.APIError
	EndpointError *SharedFolderAccessError `json:"error"`
}

ListFolderMembersAPIError is an error-wrapper for the list_folder_members route

type ListFolderMembersArgs 

type ListFolderMembersArgs struct {
	ListFolderMembersCursorArg
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
}

ListFolderMembersArgs : has no documentation (yet)

func NewListFolderMembersArgs 

func NewListFolderMembersArgs(SharedFolderId string) *ListFolderMembersArgs

NewListFolderMembersArgs returns a new ListFolderMembersArgs instance

type ListFolderMembersContinueAPIError 

type ListFolderMembersContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFolderMembersContinueError `json:"error"`
}

ListFolderMembersContinueAPIError is an error-wrapper for the list_folder_members/continue route

type ListFolderMembersContinueArg 

type ListFolderMembersContinueArg struct {
	// Cursor : The cursor returned by your last call to `listFolderMembers` or
	// `listFolderMembersContinue`.
	Cursor string `json:"cursor"`
}

ListFolderMembersContinueArg : has no documentation (yet)

func NewListFolderMembersContinueArg 

func NewListFolderMembersContinueArg(Cursor string) *ListFolderMembersContinueArg

NewListFolderMembersContinueArg returns a new ListFolderMembersContinueArg instance

type ListFolderMembersContinueError 

type ListFolderMembersContinueError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

ListFolderMembersContinueError : has no documentation (yet)

func (*ListFolderMembersContinueError) UnmarshalJSON 

func (u *ListFolderMembersContinueError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListFolderMembersContinueError instance

type ListFolderMembersCursorArg 

type ListFolderMembersCursorArg struct {
	// Actions : This is a list indicating whether each returned member will
	// include a boolean value `MemberPermission.allow` that describes whether
	// the current user can perform the MemberAction on the member.
	Actions []*MemberAction `json:"actions,omitempty"`
	// Limit : The maximum number of results that include members, groups and
	// invitees to return per request.
	Limit uint32 `json:"limit"`
}

ListFolderMembersCursorArg : has no documentation (yet)

func NewListFolderMembersCursorArg 

func NewListFolderMembersCursorArg() *ListFolderMembersCursorArg

NewListFolderMembersCursorArg returns a new ListFolderMembersCursorArg instance

type ListFoldersAPIError 

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

ListFoldersAPIError is an error-wrapper for the list_folders route

type ListFoldersArgs 

type ListFoldersArgs struct {
	// Limit : The maximum number of results to return per request.
	Limit uint32 `json:"limit"`
	// Actions : A list of `FolderAction`s corresponding to `FolderPermission`s
	// that should appear in the  response's `SharedFolderMetadata.permissions`
	// field describing the actions the  authenticated user can perform on the
	// folder.
	Actions []*FolderAction `json:"actions,omitempty"`
}

ListFoldersArgs : has no documentation (yet)

func NewListFoldersArgs 

func NewListFoldersArgs() *ListFoldersArgs

NewListFoldersArgs returns a new ListFoldersArgs instance

type ListFoldersContinueAPIError 

type ListFoldersContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFoldersContinueError `json:"error"`
}

ListFoldersContinueAPIError is an error-wrapper for the list_folders/continue route

type ListFoldersContinueArg 

type ListFoldersContinueArg struct {
	// Cursor : The cursor returned by the previous API call specified in the
	// endpoint description.
	Cursor string `json:"cursor"`
}

ListFoldersContinueArg : has no documentation (yet)

func NewListFoldersContinueArg 

func NewListFoldersContinueArg(Cursor string) *ListFoldersContinueArg

NewListFoldersContinueArg returns a new ListFoldersContinueArg instance

type ListFoldersContinueError 

type ListFoldersContinueError struct {
	dropbox.Tagged
}

ListFoldersContinueError : has no documentation (yet)

type ListFoldersResult 

type ListFoldersResult struct {
	// Entries : List of all shared folders the authenticated user has access
	// to.
	Entries []*SharedFolderMetadata `json:"entries"`
	// Cursor : Present if there are additional shared folders that have not
	// been returned yet. Pass the cursor into the corresponding continue
	// endpoint (either `listFoldersContinue` or `listMountableFoldersContinue`)
	// to list additional folders.
	Cursor string `json:"cursor,omitempty"`
}

ListFoldersResult : Result for `listFolders` or `listMountableFolders`, depending on which endpoint was requested. Unmounted shared folders can be identified by the absence of `SharedFolderMetadata.path_lower`.

func NewListFoldersResult 

func NewListFoldersResult(Entries []*SharedFolderMetadata) *ListFoldersResult

NewListFoldersResult returns a new ListFoldersResult instance

type ListMountableFoldersAPIError 

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

ListMountableFoldersAPIError is an error-wrapper for the list_mountable_folders route

type ListMountableFoldersContinueAPIError 

type ListMountableFoldersContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFoldersContinueError `json:"error"`
}

ListMountableFoldersContinueAPIError is an error-wrapper for the list_mountable_folders/continue route

type ListReceivedFilesAPIError 

type ListReceivedFilesAPIError struct {
	dropbox.APIError
	EndpointError *SharingUserError `json:"error"`
}

ListReceivedFilesAPIError is an error-wrapper for the list_received_files route

type ListReceivedFilesContinueAPIError 

type ListReceivedFilesContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFilesContinueError `json:"error"`
}

ListReceivedFilesContinueAPIError is an error-wrapper for the list_received_files/continue route

type ListSharedLinksAPIError 

type ListSharedLinksAPIError struct {
	dropbox.APIError
	EndpointError *ListSharedLinksError `json:"error"`
}

ListSharedLinksAPIError is an error-wrapper for the list_shared_links route

type ListSharedLinksArg 

type ListSharedLinksArg struct {
	// Path : See `listSharedLinks` description.
	Path string `json:"path,omitempty"`
	// Cursor : The cursor returned by your last call to `listSharedLinks`.
	Cursor string `json:"cursor,omitempty"`
	// DirectOnly : See `listSharedLinks` description.
	DirectOnly bool `json:"direct_only,omitempty"`
}

ListSharedLinksArg : has no documentation (yet)

func NewListSharedLinksArg 

func NewListSharedLinksArg() *ListSharedLinksArg

NewListSharedLinksArg returns a new ListSharedLinksArg instance

type ListSharedLinksError 

type ListSharedLinksError struct {
	dropbox.Tagged
	// Path : has no documentation (yet)
	Path *files.LookupError `json:"path,omitempty"`
}

ListSharedLinksError : has no documentation (yet)

func (*ListSharedLinksError) UnmarshalJSON 

func (u *ListSharedLinksError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ListSharedLinksError instance

type ListSharedLinksResult 

type ListSharedLinksResult struct {
	// Links : Shared links applicable to the path argument.
	Links []IsSharedLinkMetadata `json:"links"`
	// HasMore : Is true if there are additional shared links that have not been
	// returned yet. Pass the cursor into `listSharedLinks` to retrieve them.
	HasMore bool `json:"has_more"`
	// Cursor : Pass the cursor into `listSharedLinks` to obtain the additional
	// links. Cursor is returned only if no path is given.
	Cursor string `json:"cursor,omitempty"`
}

ListSharedLinksResult : has no documentation (yet)

func NewListSharedLinksResult 

func NewListSharedLinksResult(Links []IsSharedLinkMetadata, HasMore bool) *ListSharedLinksResult

NewListSharedLinksResult returns a new ListSharedLinksResult instance

func (*ListSharedLinksResult) UnmarshalJSON 

func (u *ListSharedLinksResult) UnmarshalJSON(b []byte) error

UnmarshalJSON deserializes into a ListSharedLinksResult instance

type MemberAccessLevelResult 

type MemberAccessLevelResult struct {
	// AccessLevel : The member still has this level of access to the content
	// through a parent folder.
	AccessLevel *AccessLevel `json:"access_level,omitempty"`
	// Warning : A localized string with additional information about why the
	// user has this access level to the content.
	Warning string `json:"warning,omitempty"`
	// AccessDetails : The parent folders that a member has access to. The field
	// is present if the user has access to the first parent folder where the
	// member gains access.
	AccessDetails []*ParentFolderAccessInfo `json:"access_details,omitempty"`
}

MemberAccessLevelResult : Contains information about a member's access level to content after an operation.

func NewMemberAccessLevelResult 

func NewMemberAccessLevelResult() *MemberAccessLevelResult

NewMemberAccessLevelResult returns a new MemberAccessLevelResult instance

type MemberAction 

type MemberAction struct {
	dropbox.Tagged
}

MemberAction : Actions that may be taken on members of a shared folder.

type MemberPermission 

type MemberPermission struct {
	// Action : The action that the user may wish to take on the member.
	Action *MemberAction `json:"action"`
	// Allow : True if the user is allowed to take the action.
	Allow bool `json:"allow"`
	// Reason : The reason why the user is denied the permission. Not present if
	// the action is allowed.
	Reason *PermissionDeniedReason `json:"reason,omitempty"`
}

MemberPermission : Whether the user is allowed to take the action on the associated member.

func NewMemberPermission 

func NewMemberPermission(Action *MemberAction, Allow bool) *MemberPermission

NewMemberPermission returns a new MemberPermission instance

type MemberPolicy 

type MemberPolicy struct {
	dropbox.Tagged
}

MemberPolicy : Policy governing who can be a member of a shared folder. Only applicable to folders owned by a user on a team.

type MemberSelector 

type MemberSelector struct {
	dropbox.Tagged
	// DropboxId : Dropbox account, team member, or group ID of member.
	DropboxId string `json:"dropbox_id,omitempty"`
	// Email : E-mail address of member.
	Email string `json:"email,omitempty"`
}

MemberSelector : Includes different ways to identify a member of a shared folder.

func (*MemberSelector) UnmarshalJSON 

func (u *MemberSelector) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a MemberSelector instance

type MembershipInfo 

type MembershipInfo struct {
	// AccessType : The access type for this member. It contains inherited
	// access type from parent folder, and acquired access type from this
	// folder.
	AccessType *AccessLevel `json:"access_type"`
	// Permissions : The permissions that requesting user has on this member.
	// The set of permissions corresponds to the MemberActions in the request.
	Permissions []*MemberPermission `json:"permissions,omitempty"`
	// Initials : Never set.
	Initials string `json:"initials,omitempty"`
	// IsInherited : True if the member has access from a parent folder.
	IsInherited bool `json:"is_inherited"`
}

MembershipInfo : The information about a member of the shared content.

func NewMembershipInfo 

func NewMembershipInfo(AccessType *AccessLevel) *MembershipInfo

NewMembershipInfo returns a new MembershipInfo instance

type ModifySharedLinkSettingsAPIError 

type ModifySharedLinkSettingsAPIError struct {
	dropbox.APIError
	EndpointError *ModifySharedLinkSettingsError `json:"error"`
}

ModifySharedLinkSettingsAPIError is an error-wrapper for the modify_shared_link_settings route

type ModifySharedLinkSettingsArgs 

type ModifySharedLinkSettingsArgs struct {
	// Url : URL of the shared link to change its settings.
	Url string `json:"url"`
	// Settings : Set of settings for the shared link.
	Settings *SharedLinkSettings `json:"settings"`
	// RemoveExpiration : If set to true, removes the expiration of the shared
	// link.
	RemoveExpiration bool `json:"remove_expiration"`
}

ModifySharedLinkSettingsArgs : has no documentation (yet)

func NewModifySharedLinkSettingsArgs 

func NewModifySharedLinkSettingsArgs(Url string, Settings *SharedLinkSettings) *ModifySharedLinkSettingsArgs

NewModifySharedLinkSettingsArgs returns a new ModifySharedLinkSettingsArgs instance

type ModifySharedLinkSettingsError 

type ModifySharedLinkSettingsError struct {
	dropbox.Tagged
	// SettingsError : There is an error with the given settings.
	SettingsError *SharedLinkSettingsError `json:"settings_error,omitempty"`
}

ModifySharedLinkSettingsError : has no documentation (yet)

func (*ModifySharedLinkSettingsError) UnmarshalJSON 

func (u *ModifySharedLinkSettingsError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ModifySharedLinkSettingsError instance

type MountFolderAPIError 

type MountFolderAPIError struct {
	dropbox.APIError
	EndpointError *MountFolderError `json:"error"`
}

MountFolderAPIError is an error-wrapper for the mount_folder route

type MountFolderArg 

type MountFolderArg struct {
	// SharedFolderId : The ID of the shared folder to mount.
	SharedFolderId string `json:"shared_folder_id"`
}

MountFolderArg : has no documentation (yet)

func NewMountFolderArg 

func NewMountFolderArg(SharedFolderId string) *MountFolderArg

NewMountFolderArg returns a new MountFolderArg instance

type MountFolderError 

type MountFolderError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
	// InsufficientQuota : The current user does not have enough space to mount
	// the shared folder.
	InsufficientQuota *InsufficientQuotaAmounts `json:"insufficient_quota,omitempty"`
}

MountFolderError : has no documentation (yet)

func (*MountFolderError) UnmarshalJSON 

func (u *MountFolderError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a MountFolderError instance

type ParentFolderAccessInfo 

type ParentFolderAccessInfo struct {
	// FolderName : Display name for the folder.
	FolderName string `json:"folder_name"`
	// SharedFolderId : The identifier of the parent shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Permissions : The user's permissions for the parent shared folder.
	Permissions []*MemberPermission `json:"permissions"`
	// Path : The full path to the parent shared folder relative to the acting
	// user's root.
	Path string `json:"path"`
}

ParentFolderAccessInfo : Contains information about a parent folder that a member has access to.

func NewParentFolderAccessInfo 

func NewParentFolderAccessInfo(FolderName string, SharedFolderId string, Permissions []*MemberPermission, Path string) *ParentFolderAccessInfo

NewParentFolderAccessInfo returns a new ParentFolderAccessInfo instance

type PathLinkMetadata 

type PathLinkMetadata struct {
	LinkMetadata
	// Path : Path in user's Dropbox.
	Path string `json:"path"`
}

PathLinkMetadata : Metadata for a path-based shared link.

func NewPathLinkMetadata 

func NewPathLinkMetadata(Url string, Visibility *Visibility, Path string) *PathLinkMetadata

NewPathLinkMetadata returns a new PathLinkMetadata instance

type PendingUploadMode 

type PendingUploadMode struct {
	dropbox.Tagged
}

PendingUploadMode : Flag to indicate pending upload default (for linking to not-yet-existing paths).

type PermissionDeniedReason 

type PermissionDeniedReason struct {
	dropbox.Tagged
	// InsufficientPlan : has no documentation (yet)
	InsufficientPlan *InsufficientPlan `json:"insufficient_plan,omitempty"`
}

PermissionDeniedReason : Possible reasons the user is denied a permission.

func (*PermissionDeniedReason) UnmarshalJSON 

func (u *PermissionDeniedReason) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a PermissionDeniedReason instance

type RelinquishFileMembershipAPIError 

type RelinquishFileMembershipAPIError struct {
	dropbox.APIError
	EndpointError *RelinquishFileMembershipError `json:"error"`
}

RelinquishFileMembershipAPIError is an error-wrapper for the relinquish_file_membership route

type RelinquishFileMembershipArg 

type RelinquishFileMembershipArg struct {
	// File : The path or id for the file.
	File string `json:"file"`
}

RelinquishFileMembershipArg : has no documentation (yet)

func NewRelinquishFileMembershipArg 

func NewRelinquishFileMembershipArg(File string) *RelinquishFileMembershipArg

NewRelinquishFileMembershipArg returns a new RelinquishFileMembershipArg instance

type RelinquishFileMembershipError 

type RelinquishFileMembershipError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

RelinquishFileMembershipError : has no documentation (yet)

func (*RelinquishFileMembershipError) UnmarshalJSON 

func (u *RelinquishFileMembershipError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a RelinquishFileMembershipError instance

type RelinquishFolderMembershipAPIError 

type RelinquishFolderMembershipAPIError struct {
	dropbox.APIError
	EndpointError *RelinquishFolderMembershipError `json:"error"`
}

RelinquishFolderMembershipAPIError is an error-wrapper for the relinquish_folder_membership route

type RelinquishFolderMembershipArg 

type RelinquishFolderMembershipArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// LeaveACopy : Keep a copy of the folder's contents upon relinquishing
	// membership.
	LeaveACopy bool `json:"leave_a_copy"`
}

RelinquishFolderMembershipArg : has no documentation (yet)

func NewRelinquishFolderMembershipArg 

func NewRelinquishFolderMembershipArg(SharedFolderId string) *RelinquishFolderMembershipArg

NewRelinquishFolderMembershipArg returns a new RelinquishFolderMembershipArg instance

type RelinquishFolderMembershipError 

type RelinquishFolderMembershipError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

RelinquishFolderMembershipError : has no documentation (yet)

func (*RelinquishFolderMembershipError) UnmarshalJSON 

func (u *RelinquishFolderMembershipError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a RelinquishFolderMembershipError instance

type RemoveFileMember2APIError 

type RemoveFileMember2APIError struct {
	dropbox.APIError
	EndpointError *RemoveFileMemberError `json:"error"`
}

RemoveFileMember2APIError is an error-wrapper for the remove_file_member_2 route

type RemoveFileMemberAPIError 

type RemoveFileMemberAPIError struct {
	dropbox.APIError
	EndpointError *RemoveFileMemberError `json:"error"`
}

RemoveFileMemberAPIError is an error-wrapper for the remove_file_member route

type RemoveFileMemberArg 

type RemoveFileMemberArg struct {
	// File : File from which to remove members.
	File string `json:"file"`
	// Member : Member to remove from this file. Note that even if an email is
	// specified, it may result in the removal of a user (not an invitee) if the
	// user's main account corresponds to that email address.
	Member *MemberSelector `json:"member"`
}

RemoveFileMemberArg : Arguments for `removeFileMember2`.

func NewRemoveFileMemberArg 

func NewRemoveFileMemberArg(File string, Member *MemberSelector) *RemoveFileMemberArg

NewRemoveFileMemberArg returns a new RemoveFileMemberArg instance

type RemoveFileMemberError 

type RemoveFileMemberError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
	// NoExplicitAccess : This member does not have explicit access to the file
	// and therefore cannot be removed. The return value is the access that a
	// user might have to the file from a parent folder.
	NoExplicitAccess *MemberAccessLevelResult `json:"no_explicit_access,omitempty"`
}

RemoveFileMemberError : Errors for `removeFileMember2`.

func (*RemoveFileMemberError) UnmarshalJSON 

func (u *RemoveFileMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a RemoveFileMemberError instance

type RemoveFolderMemberAPIError 

type RemoveFolderMemberAPIError struct {
	dropbox.APIError
	EndpointError *RemoveFolderMemberError `json:"error"`
}

RemoveFolderMemberAPIError is an error-wrapper for the remove_folder_member route

type RemoveFolderMemberArg 

type RemoveFolderMemberArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Member : The member to remove from the folder.
	Member *MemberSelector `json:"member"`
	// LeaveACopy : If true, the removed user will keep their copy of the folder
	// after it's unshared, assuming it was mounted. Otherwise, it will be
	// removed from their Dropbox. Also, this must be set to false when kicking
	// a group.
	LeaveACopy bool `json:"leave_a_copy"`
}

RemoveFolderMemberArg : has no documentation (yet)

func NewRemoveFolderMemberArg 

func NewRemoveFolderMemberArg(SharedFolderId string, Member *MemberSelector, LeaveACopy bool) *RemoveFolderMemberArg

NewRemoveFolderMemberArg returns a new RemoveFolderMemberArg instance

type RemoveFolderMemberError 

type RemoveFolderMemberError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
	// MemberError : has no documentation (yet)
	MemberError *SharedFolderMemberError `json:"member_error,omitempty"`
}

RemoveFolderMemberError : has no documentation (yet)

func (*RemoveFolderMemberError) UnmarshalJSON 

func (u *RemoveFolderMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a RemoveFolderMemberError instance

type RemoveMemberJobStatus 

type RemoveMemberJobStatus struct {
	dropbox.Tagged
	// Complete : Removing the folder member has finished. The value is
	// information about whether the member has another form of access.
	Complete *MemberAccessLevelResult `json:"complete,omitempty"`
	// Failed : has no documentation (yet)
	Failed *RemoveFolderMemberError `json:"failed,omitempty"`
}

RemoveMemberJobStatus : has no documentation (yet)

func (*RemoveMemberJobStatus) UnmarshalJSON 

func (u *RemoveMemberJobStatus) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a RemoveMemberJobStatus instance

type RequestedLinkAccessLevel 

type RequestedLinkAccessLevel struct {
	dropbox.Tagged
}

RequestedLinkAccessLevel : has no documentation (yet)

type RequestedVisibility 

type RequestedVisibility struct {
	dropbox.Tagged
}

RequestedVisibility : The access permission that can be requested by the caller for the shared link. Note that the final resolved visibility of the shared link takes into account other aspects, such as team and shared folder settings. Check the `ResolvedVisibility` for more info on the possible resolved visibility values of shared links.

type ResolvedVisibility 

type ResolvedVisibility struct {
	dropbox.Tagged
}

ResolvedVisibility : The actual access permissions values of shared links after taking into account user preferences and the team and shared folder settings. Check the `RequestedVisibility` for more info on the possible visibility values that can be set by the shared link's owner.

type RevokeSharedLinkAPIError 

type RevokeSharedLinkAPIError struct {
	dropbox.APIError
	EndpointError *RevokeSharedLinkError `json:"error"`
}

RevokeSharedLinkAPIError is an error-wrapper for the revoke_shared_link route

type RevokeSharedLinkArg 

type RevokeSharedLinkArg struct {
	// Url : URL of the shared link.
	Url string `json:"url"`
}

RevokeSharedLinkArg : has no documentation (yet)

func NewRevokeSharedLinkArg 

func NewRevokeSharedLinkArg(Url string) *RevokeSharedLinkArg

NewRevokeSharedLinkArg returns a new RevokeSharedLinkArg instance

type RevokeSharedLinkError 

type RevokeSharedLinkError struct {
	dropbox.Tagged
}

RevokeSharedLinkError : has no documentation (yet)

type SetAccessInheritanceAPIError 

type SetAccessInheritanceAPIError struct {
	dropbox.APIError
	EndpointError *SetAccessInheritanceError `json:"error"`
}

SetAccessInheritanceAPIError is an error-wrapper for the set_access_inheritance route

type SetAccessInheritanceArg 

type SetAccessInheritanceArg struct {
	// AccessInheritance : The access inheritance settings for the folder.
	AccessInheritance *AccessInheritance `json:"access_inheritance"`
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
}

SetAccessInheritanceArg : has no documentation (yet)

func NewSetAccessInheritanceArg 

func NewSetAccessInheritanceArg(SharedFolderId string) *SetAccessInheritanceArg

NewSetAccessInheritanceArg returns a new SetAccessInheritanceArg instance

type SetAccessInheritanceError 

type SetAccessInheritanceError struct {
	dropbox.Tagged
	// AccessError : Unable to access shared folder.
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

SetAccessInheritanceError : has no documentation (yet)

func (*SetAccessInheritanceError) UnmarshalJSON 

func (u *SetAccessInheritanceError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a SetAccessInheritanceError instance

type ShareFolderAPIError 

type ShareFolderAPIError struct {
	dropbox.APIError
	EndpointError *ShareFolderError `json:"error"`
}

ShareFolderAPIError is an error-wrapper for the share_folder route

type ShareFolderArg 

type ShareFolderArg struct {
	ShareFolderArgBase
	// Actions : A list of `FolderAction`s corresponding to `FolderPermission`s
	// that should appear in the  response's `SharedFolderMetadata.permissions`
	// field describing the actions the  authenticated user can perform on the
	// folder.
	Actions []*FolderAction `json:"actions,omitempty"`
	// LinkSettings : Settings on the link for this folder.
	LinkSettings *LinkSettings `json:"link_settings,omitempty"`
}

ShareFolderArg : has no documentation (yet)

func NewShareFolderArg 

func NewShareFolderArg(Path string) *ShareFolderArg

NewShareFolderArg returns a new ShareFolderArg instance

type ShareFolderArgBase 

type ShareFolderArgBase struct {
	// AclUpdatePolicy : Who can add and remove members of this shared folder.
	AclUpdatePolicy *AclUpdatePolicy `json:"acl_update_policy,omitempty"`
	// ForceAsync : Whether to force the share to happen asynchronously.
	ForceAsync bool `json:"force_async"`
	// MemberPolicy : Who can be a member of this shared folder. Only applicable
	// if the current user is on a team.
	MemberPolicy *MemberPolicy `json:"member_policy,omitempty"`
	// Path : The path to the folder to share. If it does not exist, then a new
	// one is created.
	Path string `json:"path"`
	// SharedLinkPolicy : The policy to apply to shared links created for
	// content inside this shared folder.  The current user must be on a team to
	// set this policy to `SharedLinkPolicy.members`.
	SharedLinkPolicy *SharedLinkPolicy `json:"shared_link_policy,omitempty"`
	// ViewerInfoPolicy : Who can enable/disable viewer info for this shared
	// folder.
	ViewerInfoPolicy *ViewerInfoPolicy `json:"viewer_info_policy,omitempty"`
	// AccessInheritance : The access inheritance settings for the folder.
	AccessInheritance *AccessInheritance `json:"access_inheritance"`
}

ShareFolderArgBase : has no documentation (yet)

func NewShareFolderArgBase 

func NewShareFolderArgBase(Path string) *ShareFolderArgBase

NewShareFolderArgBase returns a new ShareFolderArgBase instance

type ShareFolderError 

type ShareFolderError struct {
	dropbox.Tagged
	// BadPath : `ShareFolderArg.path` is invalid.
	BadPath *SharePathError `json:"bad_path,omitempty"`
}

ShareFolderError : has no documentation (yet)

func (*ShareFolderError) UnmarshalJSON 

func (u *ShareFolderError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ShareFolderError instance

type ShareFolderErrorBase 

type ShareFolderErrorBase struct {
	dropbox.Tagged
	// BadPath : `ShareFolderArg.path` is invalid.
	BadPath *SharePathError `json:"bad_path,omitempty"`
}

ShareFolderErrorBase : has no documentation (yet)

func (*ShareFolderErrorBase) UnmarshalJSON 

func (u *ShareFolderErrorBase) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ShareFolderErrorBase instance

type ShareFolderJobStatus 

type ShareFolderJobStatus struct {
	dropbox.Tagged
	// Complete : The share job has finished. The value is the metadata for the
	// folder.
	Complete *SharedFolderMetadata `json:"complete,omitempty"`
	// Failed : has no documentation (yet)
	Failed *ShareFolderError `json:"failed,omitempty"`
}

ShareFolderJobStatus : has no documentation (yet)

func (*ShareFolderJobStatus) UnmarshalJSON 

func (u *ShareFolderJobStatus) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ShareFolderJobStatus instance

type ShareFolderLaunch 

type ShareFolderLaunch 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 *SharedFolderMetadata `json:"complete,omitempty"`
}

ShareFolderLaunch : has no documentation (yet)

func (*ShareFolderLaunch) UnmarshalJSON 

func (u *ShareFolderLaunch) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a ShareFolderLaunch instance

type SharePathError 

type SharePathError struct {
	dropbox.Tagged
	// AlreadyShared : Folder is already shared. Contains metadata about the
	// existing shared folder.
	AlreadyShared *SharedFolderMetadata `json:"already_shared,omitempty"`
}

SharePathError : has no documentation (yet)

func (*SharePathError) UnmarshalJSON 

func (u *SharePathError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a SharePathError instance

type SharedContentLinkMetadata 

type SharedContentLinkMetadata struct {
	SharedContentLinkMetadataBase
	// AudienceExceptions : The content inside this folder with link audience
	// different than this folder's. This is only returned when an endpoint that
	// returns metadata for a single shared folder is called, e.g.
	// /get_folder_metadata.
	AudienceExceptions *AudienceExceptions `json:"audience_exceptions,omitempty"`
	// Url : The URL of the link.
	Url string `json:"url"`
}

SharedContentLinkMetadata : Metadata of a shared link for a file or folder.

func NewSharedContentLinkMetadata 

func NewSharedContentLinkMetadata(AudienceOptions []*LinkAudience, CurrentAudience *LinkAudience, LinkPermissions []*LinkPermission, PasswordProtected bool, Url string) *SharedContentLinkMetadata

NewSharedContentLinkMetadata returns a new SharedContentLinkMetadata instance

type SharedContentLinkMetadataBase 

type SharedContentLinkMetadataBase struct {
	// AccessLevel : The access level on the link for this file.
	AccessLevel *AccessLevel `json:"access_level,omitempty"`
	// AudienceOptions : The audience options that are available for the
	// content. Some audience options may be unavailable. For example, team_only
	// may be unavailable if the content is not owned by a user on a team. The
	// 'default' audience option is always available if the user can modify link
	// settings.
	AudienceOptions []*LinkAudience `json:"audience_options"`
	// AudienceRestrictingSharedFolder : The shared folder that prevents the
	// link audience for this link from being more restrictive.
	AudienceRestrictingSharedFolder *AudienceRestrictingSharedFolder `json:"audience_restricting_shared_folder,omitempty"`
	// CurrentAudience : The current audience of the link.
	CurrentAudience *LinkAudience `json:"current_audience"`
	// Expiry : Whether the link has an expiry set on it. A link with an expiry
	// will have its  audience changed to members when the expiry is reached.
	Expiry time.Time `json:"expiry,omitempty"`
	// LinkPermissions : A list of permissions for actions you can perform on
	// the link.
	LinkPermissions []*LinkPermission `json:"link_permissions"`
	// PasswordProtected : Whether the link is protected by a password.
	PasswordProtected bool `json:"password_protected"`
}

SharedContentLinkMetadataBase : has no documentation (yet)

func NewSharedContentLinkMetadataBase 

func NewSharedContentLinkMetadataBase(AudienceOptions []*LinkAudience, CurrentAudience *LinkAudience, LinkPermissions []*LinkPermission, PasswordProtected bool) *SharedContentLinkMetadataBase

NewSharedContentLinkMetadataBase returns a new SharedContentLinkMetadataBase instance

type SharedFileMembers 

type SharedFileMembers struct {
	// Users : The list of user members of the shared file.
	Users []*UserFileMembershipInfo `json:"users"`
	// Groups : The list of group members of the shared file.
	Groups []*GroupMembershipInfo `json:"groups"`
	// Invitees : The list of invited members of a file, but have not logged in
	// and claimed this.
	Invitees []*InviteeMembershipInfo `json:"invitees"`
	// Cursor : Present if there are additional shared file members that have
	// not been returned yet. Pass the cursor into `listFileMembersContinue` to
	// list additional members.
	Cursor string `json:"cursor,omitempty"`
}

SharedFileMembers : Shared file user, group, and invitee membership. Used for the results of `listFileMembers` and `listFileMembersContinue`, and used as part of the results for `listFileMembersBatch`.

func NewSharedFileMembers 

func NewSharedFileMembers(Users []*UserFileMembershipInfo, Groups []*GroupMembershipInfo, Invitees []*InviteeMembershipInfo) *SharedFileMembers

NewSharedFileMembers returns a new SharedFileMembers instance

type SharedFileMetadata 

type SharedFileMetadata struct {
	// AccessType : The current user's access level for this shared file.
	AccessType *AccessLevel `json:"access_type,omitempty"`
	// Id : The ID of the file.
	Id string `json:"id"`
	// ExpectedLinkMetadata : The expected metadata of the link associated for
	// the file when it is first shared. Absent if the link already exists. This
	// is for an unreleased feature so it may not be returned yet.
	ExpectedLinkMetadata *ExpectedSharedContentLinkMetadata `json:"expected_link_metadata,omitempty"`
	// LinkMetadata : The metadata of the link associated for the file. This is
	// for an unreleased feature so it may not be returned yet.
	LinkMetadata *SharedContentLinkMetadata `json:"link_metadata,omitempty"`
	// Name : The name of this file.
	Name string `json:"name"`
	// OwnerDisplayNames : The display names of the users that own the file. If
	// the file is part of a team folder, the display names of the team admins
	// are also included. Absent if the owner display names cannot be fetched.
	OwnerDisplayNames []string `json:"owner_display_names,omitempty"`
	// OwnerTeam : The team that owns the file. This field is not present if the
	// file is not owned by a team.
	OwnerTeam *users.Team `json:"owner_team,omitempty"`
	// ParentSharedFolderId : The ID of the parent shared folder. This field is
	// present only if the file is contained within a shared folder.
	ParentSharedFolderId string `json:"parent_shared_folder_id,omitempty"`
	// PathDisplay : The cased path to be used for display purposes only. In
	// rare instances the casing will not correctly match the user's filesystem,
	// but this behavior will match the path provided in the Core API v1. Absent
	// for unmounted files.
	PathDisplay string `json:"path_display,omitempty"`
	// PathLower : The lower-case full path of this file. Absent for unmounted
	// files.
	PathLower string `json:"path_lower,omitempty"`
	// Permissions : The sharing permissions that requesting user has on this
	// file. This corresponds to the entries given in
	// `GetFileMetadataBatchArg.actions` or `GetFileMetadataArg.actions`.
	Permissions []*FilePermission `json:"permissions,omitempty"`
	// Policy : Policies governing this shared file.
	Policy *FolderPolicy `json:"policy"`
	// PreviewUrl : URL for displaying a web preview of the shared file.
	PreviewUrl string `json:"preview_url"`
	// TimeInvited : Timestamp indicating when the current user was invited to
	// this shared file. If the user was not invited to the shared file, the
	// timestamp will indicate when the user was invited to the parent shared
	// folder. This value may be absent.
	TimeInvited time.Time `json:"time_invited,omitempty"`
}

SharedFileMetadata : Properties of the shared file.

func NewSharedFileMetadata 

func NewSharedFileMetadata(Id string, Name string, Policy *FolderPolicy, PreviewUrl string) *SharedFileMetadata

NewSharedFileMetadata returns a new SharedFileMetadata instance

type SharedFolderAccessError 

type SharedFolderAccessError struct {
	dropbox.Tagged
}

SharedFolderAccessError : There is an error accessing the shared folder.

type SharedFolderMemberError 

type SharedFolderMemberError struct {
	dropbox.Tagged
	// NoExplicitAccess : The target member only has inherited access to the
	// shared folder.
	NoExplicitAccess *MemberAccessLevelResult `json:"no_explicit_access,omitempty"`
}

SharedFolderMemberError : has no documentation (yet)

func (*SharedFolderMemberError) UnmarshalJSON 

func (u *SharedFolderMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a SharedFolderMemberError instance

type SharedFolderMembers 

type SharedFolderMembers struct {
	// Users : The list of user members of the shared folder.
	Users []*UserMembershipInfo `json:"users"`
	// Groups : The list of group members of the shared folder.
	Groups []*GroupMembershipInfo `json:"groups"`
	// Invitees : The list of invitees to the shared folder.
	Invitees []*InviteeMembershipInfo `json:"invitees"`
	// Cursor : Present if there are additional shared folder members that have
	// not been returned yet. Pass the cursor into `listFolderMembersContinue`
	// to list additional members.
	Cursor string `json:"cursor,omitempty"`
}

SharedFolderMembers : Shared folder user and group membership.

func NewSharedFolderMembers 

func NewSharedFolderMembers(Users []*UserMembershipInfo, Groups []*GroupMembershipInfo, Invitees []*InviteeMembershipInfo) *SharedFolderMembers

NewSharedFolderMembers returns a new SharedFolderMembers instance

type SharedFolderMetadata 

type SharedFolderMetadata struct {
	SharedFolderMetadataBase
	// LinkMetadata : The metadata of the shared content link to this shared
	// folder. Absent if there is no link on the folder. This is for an
	// unreleased feature so it may not be returned yet.
	LinkMetadata *SharedContentLinkMetadata `json:"link_metadata,omitempty"`
	// Name : The name of the this shared folder.
	Name string `json:"name"`
	// Permissions : Actions the current user may perform on the folder and its
	// contents. The set of permissions corresponds to the FolderActions in the
	// request.
	Permissions []*FolderPermission `json:"permissions,omitempty"`
	// Policy : Policies governing this shared folder.
	Policy *FolderPolicy `json:"policy"`
	// PreviewUrl : URL for displaying a web preview of the shared folder.
	PreviewUrl string `json:"preview_url"`
	// SharedFolderId : The ID of the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// TimeInvited : Timestamp indicating when the current user was invited to
	// this shared folder.
	TimeInvited time.Time `json:"time_invited"`
	// AccessInheritance : Whether the folder inherits its members from its
	// parent.
	AccessInheritance *AccessInheritance `json:"access_inheritance"`
}

SharedFolderMetadata : The metadata which includes basic information about the shared folder.

func NewSharedFolderMetadata 

func NewSharedFolderMetadata(AccessType *AccessLevel, IsInsideTeamFolder bool, IsTeamFolder bool, Name string, Policy *FolderPolicy, PreviewUrl string, SharedFolderId string, TimeInvited time.Time) *SharedFolderMetadata

NewSharedFolderMetadata returns a new SharedFolderMetadata instance

type SharedFolderMetadataBase 

type SharedFolderMetadataBase struct {
	// AccessType : The current user's access level for this shared folder.
	AccessType *AccessLevel `json:"access_type"`
	// IsInsideTeamFolder : Whether this folder is inside of a team folder.
	IsInsideTeamFolder bool `json:"is_inside_team_folder"`
	// IsTeamFolder : Whether this folder is a `team folder`
	// <https://www.dropbox.com/en/help/986>.
	IsTeamFolder bool `json:"is_team_folder"`
	// OwnerDisplayNames : The display names of the users that own the folder.
	// If the folder is part of a team folder, the display names of the team
	// admins are also included. Absent if the owner display names cannot be
	// fetched.
	OwnerDisplayNames []string `json:"owner_display_names,omitempty"`
	// OwnerTeam : The team that owns the folder. This field is not present if
	// the folder is not owned by a team.
	OwnerTeam *users.Team `json:"owner_team,omitempty"`
	// ParentSharedFolderId : The ID of the parent shared folder. This field is
	// present only if the folder is contained within another shared folder.
	ParentSharedFolderId string `json:"parent_shared_folder_id,omitempty"`
	// PathLower : The lower-cased full path of this shared folder. Absent for
	// unmounted folders.
	PathLower string `json:"path_lower,omitempty"`
}

SharedFolderMetadataBase : Properties of the shared folder.

func NewSharedFolderMetadataBase 

func NewSharedFolderMetadataBase(AccessType *AccessLevel, IsInsideTeamFolder bool, IsTeamFolder bool) *SharedFolderMetadataBase

NewSharedFolderMetadataBase returns a new SharedFolderMetadataBase instance

type SharedLinkAccessFailureReason 

type SharedLinkAccessFailureReason struct {
	dropbox.Tagged
}

SharedLinkAccessFailureReason : has no documentation (yet)

type SharedLinkAlreadyExistsMetadata 

type SharedLinkAlreadyExistsMetadata struct {
	dropbox.Tagged
	// Metadata : Metadata of the shared link that already exists.
	Metadata IsSharedLinkMetadata `json:"metadata,omitempty"`
}

SharedLinkAlreadyExistsMetadata : has no documentation (yet)

func (*SharedLinkAlreadyExistsMetadata) UnmarshalJSON 

func (u *SharedLinkAlreadyExistsMetadata) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a SharedLinkAlreadyExistsMetadata instance

type SharedLinkError 

type SharedLinkError struct {
	dropbox.Tagged
}

SharedLinkError : has no documentation (yet)

type SharedLinkMetadata 

type SharedLinkMetadata struct {
	// Url : URL of the shared link.
	Url string `json:"url"`
	// Id : A unique identifier for the linked file.
	Id string `json:"id,omitempty"`
	// Name : The linked file name (including extension). This never contains a
	// slash.
	Name string `json:"name"`
	// Expires : Expiration time, if set. By default the link won't expire.
	Expires time.Time `json:"expires,omitempty"`
	// PathLower : The lowercased full path in the user's Dropbox. This always
	// starts with a slash. This field will only be present only if the linked
	// file is in the authenticated user's  dropbox.
	PathLower string `json:"path_lower,omitempty"`
	// LinkPermissions : The link's access permissions.
	LinkPermissions *LinkPermissions `json:"link_permissions"`
	// TeamMemberInfo : The team membership information of the link's owner.
	// This field will only be present  if the link's owner is a team member.
	TeamMemberInfo *TeamMemberInfo `json:"team_member_info,omitempty"`
	// ContentOwnerTeamInfo : The team information of the content's owner. This
	// field will only be present if the content's owner is a team member and
	// the content's owner team is different from the link's owner team.
	ContentOwnerTeamInfo *users.Team `json:"content_owner_team_info,omitempty"`
}

SharedLinkMetadata : The metadata of a shared link.

func NewSharedLinkMetadata 

func NewSharedLinkMetadata(Url string, Name string, LinkPermissions *LinkPermissions) *SharedLinkMetadata

NewSharedLinkMetadata returns a new SharedLinkMetadata instance

func (*SharedLinkMetadata) IsSharedLinkMetadata 

func (u *SharedLinkMetadata) IsSharedLinkMetadata()

IsSharedLinkMetadata implements the IsSharedLinkMetadata interface

type SharedLinkPolicy 

type SharedLinkPolicy struct {
	dropbox.Tagged
}

SharedLinkPolicy : Who can view shared links in this folder.

type SharedLinkSettings 

type SharedLinkSettings struct {
	// RequestedVisibility : The requested access for this shared link.
	RequestedVisibility *RequestedVisibility `json:"requested_visibility,omitempty"`
	// LinkPassword : If `requested_visibility` is
	// `RequestedVisibility.password` this is needed to specify the password to
	// access the link.
	LinkPassword string `json:"link_password,omitempty"`
	// Expires : Expiration time of the shared link. By default the link won't
	// expire.
	Expires time.Time `json:"expires,omitempty"`
	// Audience : The new audience who can benefit from the access level
	// specified by the link's access level specified in the `link_access_level`
	// field of `LinkPermissions`. This is used in conjunction with team
	// policies and shared folder policies to determine the final effective
	// audience type in the `effective_audience` field of `LinkPermissions.
	Audience *LinkAudience `json:"audience,omitempty"`
	// Access : Requested access level you want the audience to gain from this
	// link.
	Access *RequestedLinkAccessLevel `json:"access,omitempty"`
}

SharedLinkSettings : has no documentation (yet)

func NewSharedLinkSettings 

func NewSharedLinkSettings() *SharedLinkSettings

NewSharedLinkSettings returns a new SharedLinkSettings instance

type SharedLinkSettingsError 

type SharedLinkSettingsError struct {
	dropbox.Tagged
}

SharedLinkSettingsError : has no documentation (yet)

type SharingFileAccessError 

type SharingFileAccessError struct {
	dropbox.Tagged
}

SharingFileAccessError : User could not access this file.

type SharingUserError 

type SharingUserError struct {
	dropbox.Tagged
}

SharingUserError : User account had a problem preventing this action.

type TeamMemberInfo 

type TeamMemberInfo struct {
	// TeamInfo : Information about the member's team.
	TeamInfo *users.Team `json:"team_info"`
	// DisplayName : The display name of the user.
	DisplayName string `json:"display_name"`
	// MemberId : ID of user as a member of a team. This field will only be
	// present if the member is in the same team as current user.
	MemberId string `json:"member_id,omitempty"`
}

TeamMemberInfo : Information about a team member.

func NewTeamMemberInfo 

func NewTeamMemberInfo(TeamInfo *users.Team, DisplayName string) *TeamMemberInfo

NewTeamMemberInfo returns a new TeamMemberInfo instance

type TransferFolderAPIError 

type TransferFolderAPIError struct {
	dropbox.APIError
	EndpointError *TransferFolderError `json:"error"`
}

TransferFolderAPIError is an error-wrapper for the transfer_folder route

type TransferFolderArg 

type TransferFolderArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// ToDropboxId : A account or team member ID to transfer ownership to.
	ToDropboxId string `json:"to_dropbox_id"`
}

TransferFolderArg : has no documentation (yet)

func NewTransferFolderArg 

func NewTransferFolderArg(SharedFolderId string, ToDropboxId string) *TransferFolderArg

NewTransferFolderArg returns a new TransferFolderArg instance

type TransferFolderError 

type TransferFolderError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

TransferFolderError : has no documentation (yet)

func (*TransferFolderError) UnmarshalJSON 

func (u *TransferFolderError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a TransferFolderError instance

type UnmountFolderAPIError 

type UnmountFolderAPIError struct {
	dropbox.APIError
	EndpointError *UnmountFolderError `json:"error"`
}

UnmountFolderAPIError is an error-wrapper for the unmount_folder route

type UnmountFolderArg 

type UnmountFolderArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
}

UnmountFolderArg : has no documentation (yet)

func NewUnmountFolderArg 

func NewUnmountFolderArg(SharedFolderId string) *UnmountFolderArg

NewUnmountFolderArg returns a new UnmountFolderArg instance

type UnmountFolderError 

type UnmountFolderError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

UnmountFolderError : has no documentation (yet)

func (*UnmountFolderError) UnmarshalJSON 

func (u *UnmountFolderError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a UnmountFolderError instance

type UnshareFileAPIError 

type UnshareFileAPIError struct {
	dropbox.APIError
	EndpointError *UnshareFileError `json:"error"`
}

UnshareFileAPIError is an error-wrapper for the unshare_file route

type UnshareFileArg 

type UnshareFileArg struct {
	// File : The file to unshare.
	File string `json:"file"`
}

UnshareFileArg : Arguments for `unshareFile`.

func NewUnshareFileArg 

func NewUnshareFileArg(File string) *UnshareFileArg

NewUnshareFileArg returns a new UnshareFileArg instance

type UnshareFileError 

type UnshareFileError struct {
	dropbox.Tagged
	// UserError : has no documentation (yet)
	UserError *SharingUserError `json:"user_error,omitempty"`
	// AccessError : has no documentation (yet)
	AccessError *SharingFileAccessError `json:"access_error,omitempty"`
}

UnshareFileError : Error result for `unshareFile`.

func (*UnshareFileError) UnmarshalJSON 

func (u *UnshareFileError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a UnshareFileError instance

type UnshareFolderAPIError 

type UnshareFolderAPIError struct {
	dropbox.APIError
	EndpointError *UnshareFolderError `json:"error"`
}

UnshareFolderAPIError is an error-wrapper for the unshare_folder route

type UnshareFolderArg 

type UnshareFolderArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// LeaveACopy : If true, members of this shared folder will get a copy of
	// this folder after it's unshared. Otherwise, it will be removed from their
	// Dropbox. The current user, who is an owner, will always retain their
	// copy.
	LeaveACopy bool `json:"leave_a_copy"`
}

UnshareFolderArg : has no documentation (yet)

func NewUnshareFolderArg 

func NewUnshareFolderArg(SharedFolderId string) *UnshareFolderArg

NewUnshareFolderArg returns a new UnshareFolderArg instance

type UnshareFolderError 

type UnshareFolderError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

UnshareFolderError : has no documentation (yet)

func (*UnshareFolderError) UnmarshalJSON 

func (u *UnshareFolderError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a UnshareFolderError instance

type UpdateFileMemberAPIError 

type UpdateFileMemberAPIError struct {
	dropbox.APIError
	EndpointError *FileMemberActionError `json:"error"`
}

UpdateFileMemberAPIError is an error-wrapper for the update_file_member route

type UpdateFileMemberArgs 

type UpdateFileMemberArgs struct {
	ChangeFileMemberAccessArgs
}

UpdateFileMemberArgs : Arguments for `updateFileMember`.

func NewUpdateFileMemberArgs 

func NewUpdateFileMemberArgs(File string, Member *MemberSelector, AccessLevel *AccessLevel) *UpdateFileMemberArgs

NewUpdateFileMemberArgs returns a new UpdateFileMemberArgs instance

type UpdateFolderMemberAPIError 

type UpdateFolderMemberAPIError struct {
	dropbox.APIError
	EndpointError *UpdateFolderMemberError `json:"error"`
}

UpdateFolderMemberAPIError is an error-wrapper for the update_folder_member route

type UpdateFolderMemberArg 

type UpdateFolderMemberArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// Member : The member of the shared folder to update.  Only the
	// `MemberSelector.dropbox_id` may be set at this time.
	Member *MemberSelector `json:"member"`
	// AccessLevel : The new access level for `member`. `AccessLevel.owner` is
	// disallowed.
	AccessLevel *AccessLevel `json:"access_level"`
}

UpdateFolderMemberArg : has no documentation (yet)

func NewUpdateFolderMemberArg 

func NewUpdateFolderMemberArg(SharedFolderId string, Member *MemberSelector, AccessLevel *AccessLevel) *UpdateFolderMemberArg

NewUpdateFolderMemberArg returns a new UpdateFolderMemberArg instance

type UpdateFolderMemberError 

type UpdateFolderMemberError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
	// MemberError : has no documentation (yet)
	MemberError *SharedFolderMemberError `json:"member_error,omitempty"`
	// NoExplicitAccess : If updating the access type required the member to be
	// added to the shared folder and there was an error when adding the member.
	NoExplicitAccess *AddFolderMemberError `json:"no_explicit_access,omitempty"`
}

UpdateFolderMemberError : has no documentation (yet)

func (*UpdateFolderMemberError) UnmarshalJSON 

func (u *UpdateFolderMemberError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a UpdateFolderMemberError instance

type UpdateFolderPolicyAPIError 

type UpdateFolderPolicyAPIError struct {
	dropbox.APIError
	EndpointError *UpdateFolderPolicyError `json:"error"`
}

UpdateFolderPolicyAPIError is an error-wrapper for the update_folder_policy route

type UpdateFolderPolicyArg 

type UpdateFolderPolicyArg struct {
	// SharedFolderId : The ID for the shared folder.
	SharedFolderId string `json:"shared_folder_id"`
	// MemberPolicy : Who can be a member of this shared folder. Only applicable
	// if the current user is on a team.
	MemberPolicy *MemberPolicy `json:"member_policy,omitempty"`
	// AclUpdatePolicy : Who can add and remove members of this shared folder.
	AclUpdatePolicy *AclUpdatePolicy `json:"acl_update_policy,omitempty"`
	// ViewerInfoPolicy : Who can enable/disable viewer info for this shared
	// folder.
	ViewerInfoPolicy *ViewerInfoPolicy `json:"viewer_info_policy,omitempty"`
	// SharedLinkPolicy : The policy to apply to shared links created for
	// content inside this shared folder. The current user must be on a team to
	// set this policy to `SharedLinkPolicy.members`.
	SharedLinkPolicy *SharedLinkPolicy `json:"shared_link_policy,omitempty"`
	// LinkSettings : Settings on the link for this folder.
	LinkSettings *LinkSettings `json:"link_settings,omitempty"`
	// Actions : A list of `FolderAction`s corresponding to `FolderPermission`s
	// that should appear in the  response's `SharedFolderMetadata.permissions`
	// field describing the actions the  authenticated user can perform on the
	// folder.
	Actions []*FolderAction `json:"actions,omitempty"`
}

UpdateFolderPolicyArg : If any of the policies are unset, then they retain their current setting.

func NewUpdateFolderPolicyArg 

func NewUpdateFolderPolicyArg(SharedFolderId string) *UpdateFolderPolicyArg

NewUpdateFolderPolicyArg returns a new UpdateFolderPolicyArg instance

type UpdateFolderPolicyError 

type UpdateFolderPolicyError struct {
	dropbox.Tagged
	// AccessError : has no documentation (yet)
	AccessError *SharedFolderAccessError `json:"access_error,omitempty"`
}

UpdateFolderPolicyError : has no documentation (yet)

func (*UpdateFolderPolicyError) UnmarshalJSON 

func (u *UpdateFolderPolicyError) UnmarshalJSON(body []byte) error

UnmarshalJSON deserializes into a UpdateFolderPolicyError instance

type UserFileMembershipInfo 

type UserFileMembershipInfo struct {
	UserMembershipInfo
	// TimeLastSeen : The UTC timestamp of when the user has last seen the
	// content, if they have.
	TimeLastSeen time.Time `json:"time_last_seen,omitempty"`
	// PlatformType : The platform on which the user has last seen the content,
	// or unknown.
	PlatformType *seen_state.PlatformType `json:"platform_type,omitempty"`
}

UserFileMembershipInfo : The information about a user member of the shared content with an appended last seen timestamp.

func NewUserFileMembershipInfo 

func NewUserFileMembershipInfo(AccessType *AccessLevel, User *UserInfo) *UserFileMembershipInfo

NewUserFileMembershipInfo returns a new UserFileMembershipInfo instance

type UserInfo 

type UserInfo struct {
	// AccountId : The account ID of the user.
	AccountId string `json:"account_id"`
	// Email : Email address of user.
	Email string `json:"email"`
	// DisplayName : The display name of the user.
	DisplayName string `json:"display_name"`
	// SameTeam : If the user is in the same team as current user.
	SameTeam bool `json:"same_team"`
	// TeamMemberId : The team member ID of the shared folder member. Only
	// present if `same_team` is true.
	TeamMemberId string `json:"team_member_id,omitempty"`
}

UserInfo : Basic information about a user. Use `usersAccount` and `usersAccountBatch` to obtain more detailed information.

func NewUserInfo 

func NewUserInfo(AccountId string, Email string, DisplayName string, SameTeam bool) *UserInfo

NewUserInfo returns a new UserInfo instance

type UserMembershipInfo 

type UserMembershipInfo struct {
	MembershipInfo
	// User : The account information for the membership user.
	User *UserInfo `json:"user"`
}

UserMembershipInfo : The information about a user member of the shared content.

func NewUserMembershipInfo 

func NewUserMembershipInfo(AccessType *AccessLevel, User *UserInfo) *UserMembershipInfo

NewUserMembershipInfo returns a new UserMembershipInfo instance

type ViewerInfoPolicy 

type ViewerInfoPolicy struct {
	dropbox.Tagged
}

ViewerInfoPolicy : has no documentation (yet)

type Visibility 

type Visibility struct {
	dropbox.Tagged
}

Visibility : Who can access a shared link. The most open visibility is `public`. The default depends on many aspects, such as team and user preferences and shared folder settings.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.