files

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: 11 Imported by: 0

Documentation

Overview

Package files : This namespace contains endpoints and data types for basic file operations.

Index

Constants

View Source 
const (
	AlphaGetMetadataErrorPath            = "path"
	AlphaGetMetadataErrorPropertiesError = "properties_error"
)

Valid tag values for AlphaGetMetadataError

View Source 
const (
	CreateFolderBatchErrorTooManyFiles = "too_many_files"
	CreateFolderBatchErrorOther        = "other"
)

Valid tag values for CreateFolderBatchError

View Source 
const (
	CreateFolderBatchJobStatusInProgress = "in_progress"
	CreateFolderBatchJobStatusComplete   = "complete"
	CreateFolderBatchJobStatusFailed     = "failed"
	CreateFolderBatchJobStatusOther      = "other"
)

Valid tag values for CreateFolderBatchJobStatus

View Source 
const (
	CreateFolderBatchLaunchAsyncJobId = "async_job_id"
	CreateFolderBatchLaunchComplete   = "complete"
	CreateFolderBatchLaunchOther      = "other"
)

Valid tag values for CreateFolderBatchLaunch

View Source 
const (
	CreateFolderBatchResultEntrySuccess = "success"
	CreateFolderBatchResultEntryFailure = "failure"
)

Valid tag values for CreateFolderBatchResultEntry

View Source 
const (
	CreateFolderEntryErrorPath  = "path"
	CreateFolderEntryErrorOther = "other"
)

Valid tag values for CreateFolderEntryError

View Source 
const (
	DeleteBatchErrorTooManyWriteOperations = "too_many_write_operations"
	DeleteBatchErrorOther                  = "other"
)

Valid tag values for DeleteBatchError

View Source 
const (
	DeleteBatchJobStatusInProgress = "in_progress"
	DeleteBatchJobStatusComplete   = "complete"
	DeleteBatchJobStatusFailed     = "failed"
	DeleteBatchJobStatusOther      = "other"
)

Valid tag values for DeleteBatchJobStatus

View Source 
const (
	DeleteBatchLaunchAsyncJobId = "async_job_id"
	DeleteBatchLaunchComplete   = "complete"
	DeleteBatchLaunchOther      = "other"
)

Valid tag values for DeleteBatchLaunch

View Source 
const (
	DeleteBatchResultEntrySuccess = "success"
	DeleteBatchResultEntryFailure = "failure"
)

Valid tag values for DeleteBatchResultEntry

View Source 
const (
	DeleteErrorPathLookup             = "path_lookup"
	DeleteErrorPathWrite              = "path_write"
	DeleteErrorTooManyWriteOperations = "too_many_write_operations"
	DeleteErrorTooManyFiles           = "too_many_files"
	DeleteErrorOther                  = "other"
)

Valid tag values for DeleteError

View Source 
const (
	MetadataFile    = "file"
	MetadataFolder  = "folder"
	MetadataDeleted = "deleted"
)

Valid tag values for Metadata

View Source 
const (
	DownloadErrorPath            = "path"
	DownloadErrorUnsupportedFile = "unsupported_file"
	DownloadErrorOther           = "other"
)

Valid tag values for DownloadError

View Source 
const (
	DownloadZipErrorPath         = "path"
	DownloadZipErrorTooLarge     = "too_large"
	DownloadZipErrorTooManyFiles = "too_many_files"
	DownloadZipErrorOther        = "other"
)

Valid tag values for DownloadZipError

View Source 
const (
	ExportErrorPath          = "path"
	ExportErrorNonExportable = "non_exportable"
	ExportErrorOther         = "other"
)

Valid tag values for ExportError

View Source 
const (
	GetCopyReferenceErrorPath  = "path"
	GetCopyReferenceErrorOther = "other"
)

Valid tag values for GetCopyReferenceError

View Source 
const (
	GetTemporaryLinkErrorPath             = "path"
	GetTemporaryLinkErrorEmailNotVerified = "email_not_verified"
	GetTemporaryLinkErrorUnsupportedFile  = "unsupported_file"
	GetTemporaryLinkErrorOther            = "other"
)

Valid tag values for GetTemporaryLinkError

View Source 
const (
	GetThumbnailBatchErrorTooManyFiles = "too_many_files"
	GetThumbnailBatchErrorOther        = "other"
)

Valid tag values for GetThumbnailBatchError

View Source 
const (
	GetThumbnailBatchResultEntrySuccess = "success"
	GetThumbnailBatchResultEntryFailure = "failure"
	GetThumbnailBatchResultEntryOther   = "other"
)

Valid tag values for GetThumbnailBatchResultEntry

View Source 
const (
	ListFolderContinueErrorPath  = "path"
	ListFolderContinueErrorReset = "reset"
	ListFolderContinueErrorOther = "other"
)

Valid tag values for ListFolderContinueError

View Source 
const (
	ListFolderErrorPath  = "path"
	ListFolderErrorOther = "other"
)

Valid tag values for ListFolderError

View Source 
const (
	ListFolderLongpollErrorReset = "reset"
	ListFolderLongpollErrorOther = "other"
)

Valid tag values for ListFolderLongpollError

View Source 
const (
	ListRevisionsErrorPath  = "path"
	ListRevisionsErrorOther = "other"
)

Valid tag values for ListRevisionsError

View Source 
const (
	ListRevisionsModePath  = "path"
	ListRevisionsModeId    = "id"
	ListRevisionsModeOther = "other"
)

Valid tag values for ListRevisionsMode

View Source 
const (
	LookupErrorMalformedPath          = "malformed_path"
	LookupErrorNotFound               = "not_found"
	LookupErrorNotFile                = "not_file"
	LookupErrorNotFolder              = "not_folder"
	LookupErrorRestrictedContent      = "restricted_content"
	LookupErrorUnsupportedContentType = "unsupported_content_type"
	LookupErrorOther                  = "other"
)

Valid tag values for LookupError

View Source 
const (
	MediaInfoPending  = "pending"
	MediaInfoMetadata = "metadata"
)

Valid tag values for MediaInfo

View Source 
const (
	MediaMetadataPhoto = "photo"
	MediaMetadataVideo = "video"
)

Valid tag values for MediaMetadata

View Source 
const (
	PreviewErrorPath                 = "path"
	PreviewErrorInProgress           = "in_progress"
	PreviewErrorUnsupportedExtension = "unsupported_extension"
	PreviewErrorUnsupportedContent   = "unsupported_content"
)

Valid tag values for PreviewError

View Source 
const (
	RelocationErrorFromLookup               = "from_lookup"
	RelocationErrorFromWrite                = "from_write"
	RelocationErrorTo                       = "to"
	RelocationErrorCantCopySharedFolder     = "cant_copy_shared_folder"
	RelocationErrorCantNestSharedFolder     = "cant_nest_shared_folder"
	RelocationErrorCantMoveFolderIntoItself = "cant_move_folder_into_itself"
	RelocationErrorTooManyFiles             = "too_many_files"
	RelocationErrorDuplicatedOrNestedPaths  = "duplicated_or_nested_paths"
	RelocationErrorCantTransferOwnership    = "cant_transfer_ownership"
	RelocationErrorInsufficientQuota        = "insufficient_quota"
	RelocationErrorInternalError            = "internal_error"
	RelocationErrorCantMoveSharedFolder     = "cant_move_shared_folder"
	RelocationErrorOther                    = "other"
)

Valid tag values for RelocationError

View Source 
const (
	RelocationBatchErrorFromLookup               = "from_lookup"
	RelocationBatchErrorFromWrite                = "from_write"
	RelocationBatchErrorTo                       = "to"
	RelocationBatchErrorCantCopySharedFolder     = "cant_copy_shared_folder"
	RelocationBatchErrorCantNestSharedFolder     = "cant_nest_shared_folder"
	RelocationBatchErrorCantMoveFolderIntoItself = "cant_move_folder_into_itself"
	RelocationBatchErrorTooManyFiles             = "too_many_files"
	RelocationBatchErrorDuplicatedOrNestedPaths  = "duplicated_or_nested_paths"
	RelocationBatchErrorCantTransferOwnership    = "cant_transfer_ownership"
	RelocationBatchErrorInsufficientQuota        = "insufficient_quota"
	RelocationBatchErrorInternalError            = "internal_error"
	RelocationBatchErrorCantMoveSharedFolder     = "cant_move_shared_folder"
	RelocationBatchErrorOther                    = "other"
	RelocationBatchErrorTooManyWriteOperations   = "too_many_write_operations"
)

Valid tag values for RelocationBatchError

View Source 
const (
	RelocationBatchErrorEntryRelocationError        = "relocation_error"
	RelocationBatchErrorEntryInternalError          = "internal_error"
	RelocationBatchErrorEntryTooManyWriteOperations = "too_many_write_operations"
	RelocationBatchErrorEntryOther                  = "other"
)

Valid tag values for RelocationBatchErrorEntry

View Source 
const (
	RelocationBatchJobStatusInProgress = "in_progress"
	RelocationBatchJobStatusComplete   = "complete"
	RelocationBatchJobStatusFailed     = "failed"
)

Valid tag values for RelocationBatchJobStatus

View Source 
const (
	RelocationBatchLaunchAsyncJobId = "async_job_id"
	RelocationBatchLaunchComplete   = "complete"
	RelocationBatchLaunchOther      = "other"
)

Valid tag values for RelocationBatchLaunch

View Source 
const (
	RelocationBatchResultEntrySuccess = "success"
	RelocationBatchResultEntryFailure = "failure"
	RelocationBatchResultEntryOther   = "other"
)

Valid tag values for RelocationBatchResultEntry

View Source 
const (
	RelocationBatchV2JobStatusInProgress = "in_progress"
	RelocationBatchV2JobStatusComplete   = "complete"
)

Valid tag values for RelocationBatchV2JobStatus

View Source 
const (
	RelocationBatchV2LaunchAsyncJobId = "async_job_id"
	RelocationBatchV2LaunchComplete   = "complete"
)

Valid tag values for RelocationBatchV2Launch

View Source 
const (
	RestoreErrorPathLookup      = "path_lookup"
	RestoreErrorPathWrite       = "path_write"
	RestoreErrorInvalidRevision = "invalid_revision"
	RestoreErrorOther           = "other"
)

Valid tag values for RestoreError

View Source 
const (
	SaveCopyReferenceErrorPath                 = "path"
	SaveCopyReferenceErrorInvalidCopyReference = "invalid_copy_reference"
	SaveCopyReferenceErrorNoPermission         = "no_permission"
	SaveCopyReferenceErrorNotFound             = "not_found"
	SaveCopyReferenceErrorTooManyFiles         = "too_many_files"
	SaveCopyReferenceErrorOther                = "other"
)

Valid tag values for SaveCopyReferenceError

View Source 
const (
	SaveUrlErrorPath           = "path"
	SaveUrlErrorDownloadFailed = "download_failed"
	SaveUrlErrorInvalidUrl     = "invalid_url"
	SaveUrlErrorNotFound       = "not_found"
	SaveUrlErrorOther          = "other"
)

Valid tag values for SaveUrlError

View Source 
const (
	SaveUrlJobStatusInProgress = "in_progress"
	SaveUrlJobStatusComplete   = "complete"
	SaveUrlJobStatusFailed     = "failed"
)

Valid tag values for SaveUrlJobStatus

View Source 
const (
	SaveUrlResultAsyncJobId = "async_job_id"
	SaveUrlResultComplete   = "complete"
)

Valid tag values for SaveUrlResult

View Source 
const (
	SearchErrorPath  = "path"
	SearchErrorOther = "other"
)

Valid tag values for SearchError

View Source 
const (
	SearchMatchTypeFilename = "filename"
	SearchMatchTypeContent  = "content"
	SearchMatchTypeBoth     = "both"
)

Valid tag values for SearchMatchType

View Source 
const (
	SearchModeFilename           = "filename"
	SearchModeFilenameAndContent = "filename_and_content"
	SearchModeDeletedFilename    = "deleted_filename"
)

Valid tag values for SearchMode

View Source 
const (
	SyncSettingDefault           = "default"
	SyncSettingNotSynced         = "not_synced"
	SyncSettingNotSyncedInactive = "not_synced_inactive"
	SyncSettingOther             = "other"
)

Valid tag values for SyncSetting

View Source 
const (
	SyncSettingArgDefault   = "default"
	SyncSettingArgNotSynced = "not_synced"
	SyncSettingArgOther     = "other"
)

Valid tag values for SyncSettingArg

View Source 
const (
	SyncSettingsErrorPath                     = "path"
	SyncSettingsErrorUnsupportedCombination   = "unsupported_combination"
	SyncSettingsErrorUnsupportedConfiguration = "unsupported_configuration"
	SyncSettingsErrorOther                    = "other"
)

Valid tag values for SyncSettingsError

View Source 
const (
	ThumbnailErrorPath                 = "path"
	ThumbnailErrorUnsupportedExtension = "unsupported_extension"
	ThumbnailErrorUnsupportedImage     = "unsupported_image"
	ThumbnailErrorConversionError      = "conversion_error"
)

Valid tag values for ThumbnailError

View Source 
const (
	ThumbnailFormatJpeg = "jpeg"
	ThumbnailFormatPng  = "png"
)

Valid tag values for ThumbnailFormat

View Source 
const (
	ThumbnailModeStrict        = "strict"
	ThumbnailModeBestfit       = "bestfit"
	ThumbnailModeFitoneBestfit = "fitone_bestfit"
)

Valid tag values for ThumbnailMode

View Source 
const (
	ThumbnailSizeW32h32     = "w32h32"
	ThumbnailSizeW64h64     = "w64h64"
	ThumbnailSizeW128h128   = "w128h128"
	ThumbnailSizeW256h256   = "w256h256"
	ThumbnailSizeW480h320   = "w480h320"
	ThumbnailSizeW640h480   = "w640h480"
	ThumbnailSizeW960h640   = "w960h640"
	ThumbnailSizeW1024h768  = "w1024h768"
	ThumbnailSizeW2048h1536 = "w2048h1536"
)

Valid tag values for ThumbnailSize

View Source 
const (
	UploadErrorPath            = "path"
	UploadErrorPropertiesError = "properties_error"
	UploadErrorOther           = "other"
)

Valid tag values for UploadError

View Source 
const (
	UploadErrorWithPropertiesPath            = "path"
	UploadErrorWithPropertiesPropertiesError = "properties_error"
	UploadErrorWithPropertiesOther           = "other"
)

Valid tag values for UploadErrorWithProperties

View Source 
const (
	UploadSessionFinishBatchJobStatusInProgress = "in_progress"
	UploadSessionFinishBatchJobStatusComplete   = "complete"
)

Valid tag values for UploadSessionFinishBatchJobStatus

View Source 
const (
	UploadSessionFinishBatchLaunchAsyncJobId = "async_job_id"
	UploadSessionFinishBatchLaunchComplete   = "complete"
	UploadSessionFinishBatchLaunchOther      = "other"
)

Valid tag values for UploadSessionFinishBatchLaunch

View Source 
const (
	UploadSessionFinishBatchResultEntrySuccess = "success"
	UploadSessionFinishBatchResultEntryFailure = "failure"
)

Valid tag values for UploadSessionFinishBatchResultEntry

View Source 
const (
	UploadSessionFinishErrorLookupFailed               = "lookup_failed"
	UploadSessionFinishErrorPath                       = "path"
	UploadSessionFinishErrorPropertiesError            = "properties_error"
	UploadSessionFinishErrorTooManySharedFolderTargets = "too_many_shared_folder_targets"
	UploadSessionFinishErrorTooManyWriteOperations     = "too_many_write_operations"
	UploadSessionFinishErrorOther                      = "other"
)

Valid tag values for UploadSessionFinishError

View Source 
const (
	UploadSessionLookupErrorNotFound        = "not_found"
	UploadSessionLookupErrorIncorrectOffset = "incorrect_offset"
	UploadSessionLookupErrorClosed          = "closed"
	UploadSessionLookupErrorNotClosed       = "not_closed"
	UploadSessionLookupErrorTooLarge        = "too_large"
	UploadSessionLookupErrorOther           = "other"
)

Valid tag values for UploadSessionLookupError

View Source 
const (
	WriteConflictErrorFile         = "file"
	WriteConflictErrorFolder       = "folder"
	WriteConflictErrorFileAncestor = "file_ancestor"
	WriteConflictErrorOther        = "other"
)

Valid tag values for WriteConflictError

View Source 
const (
	WriteErrorMalformedPath          = "malformed_path"
	WriteErrorConflict               = "conflict"
	WriteErrorNoWritePermission      = "no_write_permission"
	WriteErrorInsufficientSpace      = "insufficient_space"
	WriteErrorDisallowedName         = "disallowed_name"
	WriteErrorTeamFolder             = "team_folder"
	WriteErrorTooManyWriteOperations = "too_many_write_operations"
	WriteErrorOther                  = "other"
)

Valid tag values for WriteError

View Source 
const (
	WriteModeAdd       = "add"
	WriteModeOverwrite = "overwrite"
	WriteModeUpdate    = "update"
)

Valid tag values for WriteMode

View Source 
const (
	CreateFolderErrorPath = "path"
)

Valid tag values for CreateFolderError

View Source 
const (
	GetMetadataErrorPath = "path"
)

Valid tag values for GetMetadataError

Variables

This section is empty.

Functions

This section is empty.

Types

type AlphaGetMetadataAPIError 

type AlphaGetMetadataAPIError struct {
	dropbox.APIError
	EndpointError *AlphaGetMetadataError `json:"error"`
}

AlphaGetMetadataAPIError is an error-wrapper for the alpha/get_metadata route

type AlphaGetMetadataArg 

type AlphaGetMetadataArg struct {
	GetMetadataArg
	// IncludePropertyTemplates : If set to a valid list of template IDs,
	// `FileMetadata.property_groups` is set for files with custom properties.
	IncludePropertyTemplates []string `json:"include_property_templates,omitempty"`
}

AlphaGetMetadataArg : has no documentation (yet)

func NewAlphaGetMetadataArg 

func NewAlphaGetMetadataArg(Path string) *AlphaGetMetadataArg

NewAlphaGetMetadataArg returns a new AlphaGetMetadataArg instance

type AlphaGetMetadataError 

type AlphaGetMetadataError struct {
	dropbox.Tagged
	// Path : has no documentation (yet)
	Path *LookupError `json:"path,omitempty"`
	// PropertiesError : has no documentation (yet)
	PropertiesError *file_properties.LookUpPropertiesError `json:"properties_error,omitempty"`
}

AlphaGetMetadataError : has no documentation (yet)

func (*AlphaGetMetadataError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a AlphaGetMetadataError instance

type AlphaUploadAPIError 

type AlphaUploadAPIError struct {
	dropbox.APIError
	EndpointError *UploadErrorWithProperties `json:"error"`
}

AlphaUploadAPIError is an error-wrapper for the alpha/upload route

type Client 

type Client interface {
	// AlphaGetMetadata : Returns the metadata for a file or folder. This is an
	// alpha endpoint compatible with the properties API. Note: Metadata for the
	// root folder is unsupported.
	// Deprecated: Use `GetMetadata` instead
	AlphaGetMetadata(arg *AlphaGetMetadataArg) (res IsMetadata, err error)
	// AlphaUpload : Create a new file with the contents provided in the
	// request. Note that this endpoint is part of the properties API alpha and
	// is slightly different from `upload`. Do not use this to upload a file
	// larger than 150 MB. Instead, create an upload session with
	// `uploadSessionStart`.
	// Deprecated: Use `AlphaUpload` instead
	AlphaUpload(arg *CommitInfoWithProperties, content io.Reader) (res *FileMetadata, err error)
	// Copy : Copy a file or folder to a different location in the user's
	// Dropbox. If the source path is a folder all its contents will be copied.
	CopyV2(arg *RelocationArg) (res *RelocationResult, err error)
	// Copy : Copy a file or folder to a different location in the user's
	// Dropbox. If the source path is a folder all its contents will be copied.
	// Deprecated: Use `CopyV2` instead
	Copy(arg *RelocationArg) (res IsMetadata, err error)
	// CopyBatch : Copy multiple files or folders to different locations at once
	// in the user's Dropbox. This route will replace `copyBatch`. The main
	// difference is this route will return status for each entry, while
	// `copyBatch` raises failure if any entry fails. This route will either
	// finish synchronously, or return a job ID and do the async copy job in
	// background. Please use `copyBatchCheck` to check the job status.
	CopyBatchV2(arg *RelocationBatchArgBase) (res *RelocationBatchV2Launch, err error)
	// CopyBatch : Copy multiple files or folders to different locations at once
	// in the user's Dropbox. If `RelocationBatchArg.allow_shared_folder` is
	// false, this route is atomic. If one entry fails, the whole transaction
	// will abort. If `RelocationBatchArg.allow_shared_folder` is true,
	// atomicity is not guaranteed, but it allows you to copy the contents of
	// shared folders to new locations. This route will return job ID
	// immediately and do the async copy job in background. Please use
	// `copyBatchCheck` to check the job status.
	// Deprecated: Use `CopyBatchV2` instead
	CopyBatch(arg *RelocationBatchArg) (res *RelocationBatchLaunch, err error)
	// CopyBatchCheck : Returns the status of an asynchronous job for
	// `copyBatch`. It returns list of results for each entry.
	CopyBatchCheckV2(arg *async.PollArg) (res *RelocationBatchV2JobStatus, err error)
	// CopyBatchCheck : Returns the status of an asynchronous job for
	// `copyBatch`. If success, it returns list of results for each entry.
	// Deprecated: Use `CopyBatchCheckV2` instead
	CopyBatchCheck(arg *async.PollArg) (res *RelocationBatchJobStatus, err error)
	// CopyReferenceGet : Get a copy reference to a file or folder. This
	// reference string can be used to save that file or folder to another
	// user's Dropbox by passing it to `copyReferenceSave`.
	CopyReferenceGet(arg *GetCopyReferenceArg) (res *GetCopyReferenceResult, err error)
	// CopyReferenceSave : Save a copy reference returned by `copyReferenceGet`
	// to the user's Dropbox.
	CopyReferenceSave(arg *SaveCopyReferenceArg) (res *SaveCopyReferenceResult, err error)
	// CreateFolder : Create a folder at a given path.
	CreateFolderV2(arg *CreateFolderArg) (res *CreateFolderResult, err error)
	// CreateFolder : Create a folder at a given path.
	// Deprecated: Use `CreateFolderV2` instead
	CreateFolder(arg *CreateFolderArg) (res *FolderMetadata, err error)
	// CreateFolderBatch : Create multiple folders at once. This route is
	// asynchronous for large batches, which returns a job ID immediately and
	// runs the create folder batch asynchronously. Otherwise, creates the
	// folders and returns the result synchronously for smaller inputs. You can
	// force asynchronous behaviour by using the
	// `CreateFolderBatchArg.force_async` flag.  Use `createFolderBatchCheck` to
	// check the job status.
	CreateFolderBatch(arg *CreateFolderBatchArg) (res *CreateFolderBatchLaunch, err error)
	// CreateFolderBatchCheck : Returns the status of an asynchronous job for
	// `createFolderBatch`. If success, it returns list of result for each
	// entry.
	CreateFolderBatchCheck(arg *async.PollArg) (res *CreateFolderBatchJobStatus, err error)
	// Delete : Delete the file or folder at a given path. If the path is a
	// folder, all its contents will be deleted too. A successful response
	// indicates that the file or folder was deleted. The returned metadata will
	// be the corresponding `FileMetadata` or `FolderMetadata` for the item at
	// time of deletion, and not a `DeletedMetadata` object.
	DeleteV2(arg *DeleteArg) (res *DeleteResult, err error)
	// Delete : Delete the file or folder at a given path. If the path is a
	// folder, all its contents will be deleted too. A successful response
	// indicates that the file or folder was deleted. The returned metadata will
	// be the corresponding `FileMetadata` or `FolderMetadata` for the item at
	// time of deletion, and not a `DeletedMetadata` object.
	// Deprecated: Use `DeleteV2` instead
	Delete(arg *DeleteArg) (res IsMetadata, err error)
	// DeleteBatch : Delete multiple files/folders at once. This route is
	// asynchronous, which returns a job ID immediately and runs the delete
	// batch asynchronously. Use `deleteBatchCheck` to check the job status.
	DeleteBatch(arg *DeleteBatchArg) (res *DeleteBatchLaunch, err error)
	// DeleteBatchCheck : Returns the status of an asynchronous job for
	// `deleteBatch`. If success, it returns list of result for each entry.
	DeleteBatchCheck(arg *async.PollArg) (res *DeleteBatchJobStatus, err error)
	// Download : Download a file from a user's Dropbox.
	Download(arg *DownloadArg) (res *FileMetadata, content io.ReadCloser, err error)
	// DownloadZip : Download a folder from the user's Dropbox, as a zip file.
	// The folder must be less than 20 GB in size and have fewer than 10,000
	// total files. The input cannot be a single file. Any single file must be
	// less than 4GB in size.
	DownloadZip(arg *DownloadZipArg) (res *DownloadZipResult, content io.ReadCloser, err error)
	// Export : Export a file from a user's Dropbox. This route only supports
	// exporting files that cannot be downloaded directly  and whose
	// `ExportResult.file_metadata` has `ExportInfo.export_as` populated.
	Export(arg *ExportArg) (res *ExportResult, content io.ReadCloser, err error)
	// GetMetadata : Returns the metadata for a file or folder. Note: Metadata
	// for the root folder is unsupported.
	GetMetadata(arg *GetMetadataArg) (res IsMetadata, err error)
	// GetPreview : Get a preview for a file. Currently, PDF previews are
	// generated for files with the following extensions: .ai, .doc, .docm,
	// .docx, .eps, .gdoc, .gslides, .odp, .odt, .pps, .ppsm, .ppsx, .ppt,
	// .pptm, .pptx, .rtf. HTML previews are generated for files with the
	// following extensions: .csv, .ods, .xls, .xlsm, .gsheet, .xlsx. Other
	// formats will return an unsupported extension error.
	GetPreview(arg *PreviewArg) (res *FileMetadata, content io.ReadCloser, err error)
	// GetTemporaryLink : Get a temporary link to stream content of a file. This
	// link will expire in four hours and afterwards you will get 410 Gone. This
	// URL should not be used to display content directly in the browser. The
	// Content-Type of the link is determined automatically by the file's mime
	// type.
	GetTemporaryLink(arg *GetTemporaryLinkArg) (res *GetTemporaryLinkResult, err error)
	// GetTemporaryUploadLink : Get a one-time use temporary upload link to
	// upload a file to a Dropbox location.  This endpoint acts as a delayed
	// `upload`. The returned temporary upload link may be used to make a POST
	// request with the data to be uploaded. The upload will then be perfomed
	// with the `CommitInfo` previously provided to `getTemporaryUploadLink` but
	// evaluated only upon consumption. Hence, errors stemming from invalid
	// `CommitInfo` with respect to the state of the user's Dropbox will only be
	// communicated at consumption time. Additionally, these errors are surfaced
	// as generic HTTP 409 Conflict responses, potentially hiding issue details.
	// The maximum temporary upload link duration is 4 hours. Upon consumption
	// or expiration, a new link will have to be generated. Multiple links may
	// exist for a specific upload path at any given time.  The POST request on
	// the temporary upload link must have its Content-Type set to
	// "application/octet-stream".  Example temporary upload link consumption
	// request:  curl -X POST
	// https://dl.dropboxusercontent.com/apitul/1/bNi2uIYF51cVBND --header
	// "Content-Type: application/octet-stream" --data-binary @local_file.txt  A
	// successful temporary upload link consumption request returns the content
	// hash of the uploaded data in JSON format.  Example succesful temporary
	// upload link consumption response: {"content-hash":
	// "599d71033d700ac892a0e48fa61b125d2f5994"}  An unsuccessful temporary
	// upload link consumption request returns any of the following status
	// codes:  HTTP 400 Bad Request: Content-Type is not one of
	// application/octet-stream and text/plain or request is invalid. HTTP 409
	// Conflict: The temporary upload link does not exist or is currently
	// unavailable, the upload failed, or another error happened. HTTP 410 Gone:
	// The temporary upload link is expired or consumed.  Example unsuccessful
	// temporary upload link consumption response: Temporary upload link has
	// been recently consumed.
	GetTemporaryUploadLink(arg *GetTemporaryUploadLinkArg) (res *GetTemporaryUploadLinkResult, err error)
	// GetThumbnail : Get a thumbnail for an image. This method currently
	// supports files with the following file extensions: jpg, jpeg, png, tiff,
	// tif, gif and bmp. Photos that are larger than 20MB in size won't be
	// converted to a thumbnail.
	GetThumbnail(arg *ThumbnailArg) (res *FileMetadata, content io.ReadCloser, err error)
	// GetThumbnailBatch : Get thumbnails for a list of images. We allow up to
	// 25 thumbnails in a single batch. This method currently supports files
	// with the following file extensions: jpg, jpeg, png, tiff, tif, gif and
	// bmp. Photos that are larger than 20MB in size won't be converted to a
	// thumbnail.
	GetThumbnailBatch(arg *GetThumbnailBatchArg) (res *GetThumbnailBatchResult, err error)
	// ListFolder : Starts returning the contents of a folder. If the result's
	// `ListFolderResult.has_more` field is true, call `listFolderContinue` with
	// the returned `ListFolderResult.cursor` to retrieve more entries. If
	// you're using `ListFolderArg.recursive` set to true to keep a local cache
	// of the contents of a Dropbox account, iterate through each entry in order
	// and process them as follows to keep your local state in sync: For each
	// `FileMetadata`, store the new entry at the given path in your local
	// state. If the required parent folders don't exist yet, create them. If
	// there's already something else at the given path, replace it and remove
	// all its children. For each `FolderMetadata`, store the new entry at the
	// given path in your local state. If the required parent folders don't
	// exist yet, create them. If there's already something else at the given
	// path, replace it but leave the children as they are. Check the new
	// entry's `FolderSharingInfo.read_only` and set all its children's
	// read-only statuses to match. For each `DeletedMetadata`, if your local
	// state has something at the given path, remove it and all its children. If
	// there's nothing at the given path, ignore this entry. Note:
	// `auth.RateLimitError` may be returned if multiple `listFolder` or
	// `listFolderContinue` calls with same parameters are made simultaneously
	// by same API app for same user. If your app implements retry logic, please
	// hold off the retry until the previous request finishes.
	ListFolder(arg *ListFolderArg) (res *ListFolderResult, err error)
	// ListFolderContinue : Once a cursor has been retrieved from `listFolder`,
	// use this to paginate through all files and retrieve updates to the
	// folder, following the same rules as documented for `listFolder`.
	ListFolderContinue(arg *ListFolderContinueArg) (res *ListFolderResult, err error)
	// ListFolderGetLatestCursor : A way to quickly get a cursor for the
	// folder's state. Unlike `listFolder`, `listFolderGetLatestCursor` doesn't
	// return any entries. This endpoint is for app which only needs to know
	// about new files and modifications and doesn't need to know about files
	// that already exist in Dropbox.
	ListFolderGetLatestCursor(arg *ListFolderArg) (res *ListFolderGetLatestCursorResult, err error)
	// ListFolderLongpoll : A longpoll endpoint to wait for changes on an
	// account. In conjunction with `listFolderContinue`, this call gives you a
	// low-latency way to monitor an account for file changes. The connection
	// will block until there are changes available or a timeout occurs. This
	// endpoint is useful mostly for client-side apps. If you're looking for
	// server-side notifications, check out our `webhooks documentation`
	// <https://www.dropbox.com/developers/reference/webhooks>.
	ListFolderLongpoll(arg *ListFolderLongpollArg) (res *ListFolderLongpollResult, err error)
	// ListRevisions : Returns revisions for files based on a file path or a
	// file id. The file path or file id is identified from the latest file
	// entry at the given file path or id. This end point allows your app to
	// query either by file path or file id by setting the mode parameter
	// appropriately. In the `ListRevisionsMode.path` (default) mode, all
	// revisions at the same file path as the latest file entry are returned. If
	// revisions with the same file id are desired, then mode must be set to
	// `ListRevisionsMode.id`. The `ListRevisionsMode.id` mode is useful to
	// retrieve revisions for a given file across moves or renames.
	ListRevisions(arg *ListRevisionsArg) (res *ListRevisionsResult, err error)
	// Move : Move a file or folder to a different location in the user's
	// Dropbox. If the source path is a folder all its contents will be moved.
	MoveV2(arg *RelocationArg) (res *RelocationResult, err error)
	// Move : Move a file or folder to a different location in the user's
	// Dropbox. If the source path is a folder all its contents will be moved.
	// Deprecated: Use `MoveV2` instead
	Move(arg *RelocationArg) (res IsMetadata, err error)
	// MoveBatch : Move multiple files or folders to different locations at once
	// in the user's Dropbox. This route will replace `moveBatch`. The main
	// difference is this route will return status for each entry, while
	// `moveBatch` raises failure if any entry fails. This route will either
	// finish synchronously, or return a job ID and do the async move job in
	// background. Please use `moveBatchCheck` to check the job status.
	MoveBatchV2(arg *MoveBatchArg) (res *RelocationBatchV2Launch, err error)
	// MoveBatch : Move multiple files or folders to different locations at once
	// in the user's Dropbox. This route is 'all or nothing', which means if one
	// entry fails, the whole transaction will abort. This route will return job
	// ID immediately and do the async moving job in background. Please use
	// `moveBatchCheck` to check the job status.
	MoveBatch(arg *RelocationBatchArg) (res *RelocationBatchLaunch, err error)
	// MoveBatchCheck : Returns the status of an asynchronous job for
	// `moveBatch`. It returns list of results for each entry.
	MoveBatchCheckV2(arg *async.PollArg) (res *RelocationBatchV2JobStatus, err error)
	// MoveBatchCheck : Returns the status of an asynchronous job for
	// `moveBatch`. If success, it returns list of results for each entry.
	MoveBatchCheck(arg *async.PollArg) (res *RelocationBatchJobStatus, err error)
	// PermanentlyDelete : Permanently delete the file or folder at a given path
	// (see https://www.dropbox.com/en/help/40). Note: This endpoint is only
	// available for Dropbox Business apps.
	PermanentlyDelete(arg *DeleteArg) (err error)
	// PropertiesAdd : has no documentation (yet)
	// Deprecated:
	PropertiesAdd(arg *file_properties.AddPropertiesArg) (err error)
	// PropertiesOverwrite : has no documentation (yet)
	// Deprecated:
	PropertiesOverwrite(arg *file_properties.OverwritePropertyGroupArg) (err error)
	// PropertiesRemove : has no documentation (yet)
	// Deprecated:
	PropertiesRemove(arg *file_properties.RemovePropertiesArg) (err error)
	// PropertiesTemplateGet : has no documentation (yet)
	// Deprecated:
	PropertiesTemplateGet(arg *file_properties.GetTemplateArg) (res *file_properties.GetTemplateResult, err error)
	// PropertiesTemplateList : has no documentation (yet)
	// Deprecated:
	PropertiesTemplateList() (res *file_properties.ListTemplateResult, err error)
	// PropertiesUpdate : has no documentation (yet)
	// Deprecated:
	PropertiesUpdate(arg *file_properties.UpdatePropertiesArg) (err error)
	// Restore : Restore a specific revision of a file to the given path.
	Restore(arg *RestoreArg) (res *FileMetadata, err error)
	// SaveUrl : Save the data from a specified URL into a file in user's
	// Dropbox. Note that the transfer from the URL must complete within 5
	// minutes, or the operation will time out and the job will fail. If the
	// given path already exists, the file will be renamed to avoid the conflict
	// (e.g. myfile (1).txt).
	SaveUrl(arg *SaveUrlArg) (res *SaveUrlResult, err error)
	// SaveUrlCheckJobStatus : Check the status of a `saveUrl` job.
	SaveUrlCheckJobStatus(arg *async.PollArg) (res *SaveUrlJobStatus, err error)
	// Search : Searches for files and folders. Note: Recent changes may not
	// immediately be reflected in search results due to a short delay in
	// indexing.
	Search(arg *SearchArg) (res *SearchResult, err error)
	// Upload : Create a new file with the contents provided in the request. Do
	// not use this to upload a file larger than 150 MB. Instead, create an
	// upload session with `uploadSessionStart`. Calls to this endpoint will
	// count as data transport calls for any Dropbox Business teams with a limit
	// on the number of data transport calls allowed per month. For more
	// information, see the `Data transport limit page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	Upload(arg *CommitInfo, content io.Reader) (res *FileMetadata, err error)
	// UploadSessionAppend : Append more data to an upload session. When the
	// parameter close is set, this call will close the session. A single
	// request should not upload more than 150 MB. The maximum size of a file
	// one can upload to an upload session is 350 GB. Calls to this endpoint
	// will count as data transport calls for any Dropbox Business teams with a
	// limit on the number of data transport calls allowed per month. For more
	// information, see the `Data transport limit page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	UploadSessionAppendV2(arg *UploadSessionAppendArg, content io.Reader) (err error)
	// UploadSessionAppend : Append more data to an upload session. A single
	// request should not upload more than 150 MB. The maximum size of a file
	// one can upload to an upload session is 350 GB. Calls to this endpoint
	// will count as data transport calls for any Dropbox Business teams with a
	// limit on the number of data transport calls allowed per month. For more
	// information, see the `Data transport limit page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	// Deprecated: Use `UploadSessionAppendV2` instead
	UploadSessionAppend(arg *UploadSessionCursor, content io.Reader) (err error)
	// UploadSessionFinish : Finish an upload session and save the uploaded data
	// to the given file path. A single request should not upload more than 150
	// MB. The maximum size of a file one can upload to an upload session is 350
	// GB. Calls to this endpoint will count as data transport calls for any
	// Dropbox Business teams with a limit on the number of data transport calls
	// allowed per month. For more information, see the `Data transport limit
	// page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	UploadSessionFinish(arg *UploadSessionFinishArg, content io.Reader) (res *FileMetadata, err error)
	// UploadSessionFinishBatch : This route helps you commit many files at once
	// into a user's Dropbox. Use `uploadSessionStart` and `uploadSessionAppend`
	// to upload file contents. We recommend uploading many files in parallel to
	// increase throughput. Once the file contents have been uploaded, rather
	// than calling `uploadSessionFinish`, use this route to finish all your
	// upload sessions in a single request. `UploadSessionStartArg.close` or
	// `UploadSessionAppendArg.close` needs to be true for the last
	// `uploadSessionStart` or `uploadSessionAppend` call. The maximum size of a
	// file one can upload to an upload session is 350 GB. This route will
	// return a job_id immediately and do the async commit job in background.
	// Use `uploadSessionFinishBatchCheck` to check the job status. For the same
	// account, this route should be executed serially. That means you should
	// not start the next job before current job finishes. We allow up to 1000
	// entries in a single request. Calls to this endpoint will count as data
	// transport calls for any Dropbox Business teams with a limit on the number
	// of data transport calls allowed per month. For more information, see the
	// `Data transport limit page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	UploadSessionFinishBatch(arg *UploadSessionFinishBatchArg) (res *UploadSessionFinishBatchLaunch, err error)
	// UploadSessionFinishBatchCheck : Returns the status of an asynchronous job
	// for `uploadSessionFinishBatch`. If success, it returns list of result for
	// each entry.
	UploadSessionFinishBatchCheck(arg *async.PollArg) (res *UploadSessionFinishBatchJobStatus, err error)
	// UploadSessionStart : Upload sessions allow you to upload a single file in
	// one or more requests, for example where the size of the file is greater
	// than 150 MB.  This call starts a new upload session with the given data.
	// You can then use `uploadSessionAppend` to add more data and
	// `uploadSessionFinish` to save all the data to a file in Dropbox. A single
	// request should not upload more than 150 MB. The maximum size of a file
	// one can upload to an upload session is 350 GB. An upload session can be
	// used for a maximum of 48 hours. Attempting to use an
	// `UploadSessionStartResult.session_id` with `uploadSessionAppend` or
	// `uploadSessionFinish` more than 48 hours after its creation will return a
	// `UploadSessionLookupError.not_found`. Calls to this endpoint will count
	// as data transport calls for any Dropbox Business teams with a limit on
	// the number of data transport calls allowed per month. For more
	// information, see the `Data transport limit page`
	// <https://www.dropbox.com/developers/reference/data-transport-limit>.
	UploadSessionStart(arg *UploadSessionStartArg, content io.Reader) (res *UploadSessionStartResult, 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 CommitInfo 

type CommitInfo struct {
	// Path : Path in the user's Dropbox to save the file.
	Path string `json:"path"`
	// Mode : Selects what to do if the file already exists.
	Mode *WriteMode `json:"mode"`
	// Autorename : If there's a conflict, as determined by `mode`, have the
	// Dropbox server try to autorename the file to avoid conflict.
	Autorename bool `json:"autorename"`
	// ClientModified : The value to store as the `client_modified` timestamp.
	// Dropbox automatically records the time at which the file was written to
	// the Dropbox servers. It can also record an additional timestamp, provided
	// by Dropbox desktop clients, mobile clients, and API apps of when the file
	// was actually created or modified.
	ClientModified time.Time `json:"client_modified,omitempty"`
	// Mute : Normally, users are made aware of any file modifications in their
	// Dropbox account via notifications in the client software. If true, this
	// tells the clients that this modification shouldn't result in a user
	// notification.
	Mute bool `json:"mute"`
	// PropertyGroups : List of custom properties to add to file.
	PropertyGroups []*file_properties.PropertyGroup `json:"property_groups,omitempty"`
	// StrictConflict : Be more strict about how each `WriteMode` detects
	// conflict. For example, always return a conflict error when `mode` =
	// `WriteMode.update` and the given "rev" doesn't match the existing file's
	// "rev", even if the existing file has been deleted.
	StrictConflict bool `json:"strict_conflict"`
}

CommitInfo : has no documentation (yet)

func NewCommitInfo 

func NewCommitInfo(Path string) *CommitInfo

NewCommitInfo returns a new CommitInfo instance

type CommitInfoWithProperties 

type CommitInfoWithProperties struct {
	CommitInfo
}

CommitInfoWithProperties : has no documentation (yet)

func NewCommitInfoWithProperties 

func NewCommitInfoWithProperties(Path string) *CommitInfoWithProperties

NewCommitInfoWithProperties returns a new CommitInfoWithProperties instance

type ContentSyncSetting 

type ContentSyncSetting struct {
	// Id : Id of the item this setting is applied to.
	Id string `json:"id"`
	// SyncSetting : Setting for this item.
	SyncSetting *SyncSetting `json:"sync_setting"`
}

ContentSyncSetting : has no documentation (yet)

func NewContentSyncSetting 

func NewContentSyncSetting(Id string, SyncSetting *SyncSetting) *ContentSyncSetting

NewContentSyncSetting returns a new ContentSyncSetting instance

type ContentSyncSettingArg 

type ContentSyncSettingArg struct {
	// Id : Id of the item this setting is applied to.
	Id string `json:"id"`
	// SyncSetting : Setting for this item.
	SyncSetting *SyncSettingArg `json:"sync_setting"`
}

ContentSyncSettingArg : has no documentation (yet)

func NewContentSyncSettingArg 

func NewContentSyncSettingArg(Id string, SyncSetting *SyncSettingArg) *ContentSyncSettingArg

NewContentSyncSettingArg returns a new ContentSyncSettingArg instance

type CopyAPIError 

type CopyAPIError struct {
	dropbox.APIError
	EndpointError *RelocationError `json:"error"`
}

CopyAPIError is an error-wrapper for the copy route

type CopyBatchAPIError 

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

CopyBatchAPIError is an error-wrapper for the copy_batch route

type CopyBatchCheckAPIError 

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

CopyBatchCheckAPIError is an error-wrapper for the copy_batch/check route

type CopyBatchCheckV2APIError 

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

CopyBatchCheckV2APIError is an error-wrapper for the copy_batch/check route

type CopyBatchV2APIError 

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

CopyBatchV2APIError is an error-wrapper for the copy_batch route

type CopyReferenceGetAPIError 

type CopyReferenceGetAPIError struct {
	dropbox.APIError
	EndpointError *GetCopyReferenceError `json:"error"`
}

CopyReferenceGetAPIError is an error-wrapper for the copy_reference/get route

type CopyReferenceSaveAPIError 

type CopyReferenceSaveAPIError struct {
	dropbox.APIError
	EndpointError *SaveCopyReferenceError `json:"error"`
}

CopyReferenceSaveAPIError is an error-wrapper for the copy_reference/save route

type CopyV2APIError 

type CopyV2APIError struct {
	dropbox.APIError
	EndpointError *RelocationError `json:"error"`
}

CopyV2APIError is an error-wrapper for the copy route

type CreateFolderAPIError 

type CreateFolderAPIError struct {
	dropbox.APIError
	EndpointError *CreateFolderError `json:"error"`
}

CreateFolderAPIError is an error-wrapper for the create_folder route

type CreateFolderArg 

type CreateFolderArg struct {
	// Path : Path in the user's Dropbox to create.
	Path string `json:"path"`
	// Autorename : If there's a conflict, have the Dropbox server try to
	// autorename the folder to avoid the conflict.
	Autorename bool `json:"autorename"`
}

CreateFolderArg : has no documentation (yet)

func NewCreateFolderArg 

func NewCreateFolderArg(Path string) *CreateFolderArg

NewCreateFolderArg returns a new CreateFolderArg instance

type CreateFolderBatchAPIError 

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

CreateFolderBatchAPIError is an error-wrapper for the create_folder_batch route

type CreateFolderBatchArg 

type CreateFolderBatchArg struct {
	// Paths : List of paths to be created in the user's Dropbox. Duplicate path
	// arguments in the batch are considered only once.
	Paths []string `json:"paths"`
	// Autorename : If there's a conflict, have the Dropbox server try to
	// autorename the folder to avoid the conflict.
	Autorename bool `json:"autorename"`
	// ForceAsync : Whether to force the create to happen asynchronously.
	ForceAsync bool `json:"force_async"`
}

CreateFolderBatchArg : has no documentation (yet)

func NewCreateFolderBatchArg 

func NewCreateFolderBatchArg(Paths []string) *CreateFolderBatchArg

NewCreateFolderBatchArg returns a new CreateFolderBatchArg instance

type CreateFolderBatchCheckAPIError 

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

CreateFolderBatchCheckAPIError is an error-wrapper for the create_folder_batch/check route

type CreateFolderBatchError 

type CreateFolderBatchError struct {
	dropbox.Tagged
}

CreateFolderBatchError : has no documentation (yet)

type CreateFolderBatchJobStatus 

type CreateFolderBatchJobStatus struct {
	dropbox.Tagged
	// Complete : The batch create folder has finished.
	Complete *CreateFolderBatchResult `json:"complete,omitempty"`
	// Failed : The batch create folder has failed.
	Failed *CreateFolderBatchError `json:"failed,omitempty"`
}

CreateFolderBatchJobStatus : has no documentation (yet)

func (*CreateFolderBatchJobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a CreateFolderBatchJobStatus instance

type CreateFolderBatchLaunch 

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

CreateFolderBatchLaunch : Result returned by `createFolderBatch` that may either launch an asynchronous job or complete synchronously.

func (*CreateFolderBatchLaunch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a CreateFolderBatchLaunch instance

type CreateFolderBatchResult 

type CreateFolderBatchResult struct {
	FileOpsResult
	// Entries : Each entry in `CreateFolderBatchArg.paths` will appear at the
	// same position inside `CreateFolderBatchResult.entries`.
	Entries []*CreateFolderBatchResultEntry `json:"entries"`
}

CreateFolderBatchResult : has no documentation (yet)

func NewCreateFolderBatchResult 

func NewCreateFolderBatchResult(Entries []*CreateFolderBatchResultEntry) *CreateFolderBatchResult

NewCreateFolderBatchResult returns a new CreateFolderBatchResult instance

type CreateFolderBatchResultEntry 

type CreateFolderBatchResultEntry struct {
	dropbox.Tagged
	// Success : has no documentation (yet)
	Success *CreateFolderEntryResult `json:"success,omitempty"`
	// Failure : has no documentation (yet)
	Failure *CreateFolderEntryError `json:"failure,omitempty"`
}

CreateFolderBatchResultEntry : has no documentation (yet)

func (*CreateFolderBatchResultEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a CreateFolderBatchResultEntry instance

type CreateFolderEntryError 

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

CreateFolderEntryError : has no documentation (yet)

func (*CreateFolderEntryError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a CreateFolderEntryError instance

type CreateFolderEntryResult 

type CreateFolderEntryResult struct {
	// Metadata : Metadata of the created folder.
	Metadata *FolderMetadata `json:"metadata"`
}

CreateFolderEntryResult : has no documentation (yet)

func NewCreateFolderEntryResult 

func NewCreateFolderEntryResult(Metadata *FolderMetadata) *CreateFolderEntryResult

NewCreateFolderEntryResult returns a new CreateFolderEntryResult instance

type CreateFolderError 

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

CreateFolderError : has no documentation (yet)

func (*CreateFolderError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a CreateFolderError instance

type CreateFolderResult 

type CreateFolderResult struct {
	FileOpsResult
	// Metadata : Metadata of the created folder.
	Metadata *FolderMetadata `json:"metadata"`
}

CreateFolderResult : has no documentation (yet)

func NewCreateFolderResult 

func NewCreateFolderResult(Metadata *FolderMetadata) *CreateFolderResult

NewCreateFolderResult returns a new CreateFolderResult instance

type CreateFolderV2APIError 

type CreateFolderV2APIError struct {
	dropbox.APIError
	EndpointError *CreateFolderError `json:"error"`
}

CreateFolderV2APIError is an error-wrapper for the create_folder route

type DeleteAPIError 

type DeleteAPIError struct {
	dropbox.APIError
	EndpointError *DeleteError `json:"error"`
}

DeleteAPIError is an error-wrapper for the delete route

type DeleteArg 

type DeleteArg struct {
	// Path : Path in the user's Dropbox to delete.
	Path string `json:"path"`
	// ParentRev : Perform delete if given "rev" matches the existing file's
	// latest "rev". This field does not support deleting a folder.
	ParentRev string `json:"parent_rev,omitempty"`
}

DeleteArg : has no documentation (yet)

func NewDeleteArg 

func NewDeleteArg(Path string) *DeleteArg

NewDeleteArg returns a new DeleteArg instance

type DeleteBatchAPIError 

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

DeleteBatchAPIError is an error-wrapper for the delete_batch route

type DeleteBatchArg 

type DeleteBatchArg struct {
	// Entries : has no documentation (yet)
	Entries []*DeleteArg `json:"entries"`
}

DeleteBatchArg : has no documentation (yet)

func NewDeleteBatchArg 

func NewDeleteBatchArg(Entries []*DeleteArg) *DeleteBatchArg

NewDeleteBatchArg returns a new DeleteBatchArg instance

type DeleteBatchCheckAPIError 

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

DeleteBatchCheckAPIError is an error-wrapper for the delete_batch/check route

type DeleteBatchError 

type DeleteBatchError struct {
	dropbox.Tagged
}

DeleteBatchError : has no documentation (yet)

type DeleteBatchJobStatus 

type DeleteBatchJobStatus struct {
	dropbox.Tagged
	// Complete : The batch delete has finished.
	Complete *DeleteBatchResult `json:"complete,omitempty"`
	// Failed : The batch delete has failed.
	Failed *DeleteBatchError `json:"failed,omitempty"`
}

DeleteBatchJobStatus : has no documentation (yet)

func (*DeleteBatchJobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteBatchJobStatus instance

type DeleteBatchLaunch 

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

DeleteBatchLaunch : Result returned by `deleteBatch` that may either launch an asynchronous job or complete synchronously.

func (*DeleteBatchLaunch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteBatchLaunch instance

type DeleteBatchResult 

type DeleteBatchResult struct {
	FileOpsResult
	// Entries : Each entry in `DeleteBatchArg.entries` will appear at the same
	// position inside `DeleteBatchResult.entries`.
	Entries []*DeleteBatchResultEntry `json:"entries"`
}

DeleteBatchResult : has no documentation (yet)

func NewDeleteBatchResult 

func NewDeleteBatchResult(Entries []*DeleteBatchResultEntry) *DeleteBatchResult

NewDeleteBatchResult returns a new DeleteBatchResult instance

type DeleteBatchResultData 

type DeleteBatchResultData struct {
	// Metadata : Metadata of the deleted object.
	Metadata IsMetadata `json:"metadata"`
}

DeleteBatchResultData : has no documentation (yet)

func NewDeleteBatchResultData 

func NewDeleteBatchResultData(Metadata IsMetadata) *DeleteBatchResultData

NewDeleteBatchResultData returns a new DeleteBatchResultData instance

func (*DeleteBatchResultData) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteBatchResultData instance

type DeleteBatchResultEntry 

type DeleteBatchResultEntry struct {
	dropbox.Tagged
	// Success : has no documentation (yet)
	Success *DeleteBatchResultData `json:"success,omitempty"`
	// Failure : has no documentation (yet)
	Failure *DeleteError `json:"failure,omitempty"`
}

DeleteBatchResultEntry : has no documentation (yet)

func (*DeleteBatchResultEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteBatchResultEntry instance

type DeleteError 

type DeleteError struct {
	dropbox.Tagged
	// PathLookup : has no documentation (yet)
	PathLookup *LookupError `json:"path_lookup,omitempty"`
	// PathWrite : has no documentation (yet)
	PathWrite *WriteError `json:"path_write,omitempty"`
}

DeleteError : has no documentation (yet)

func (*DeleteError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteError instance

type DeleteResult 

type DeleteResult struct {
	FileOpsResult
	// Metadata : Metadata of the deleted object.
	Metadata IsMetadata `json:"metadata"`
}

DeleteResult : has no documentation (yet)

func NewDeleteResult 

func NewDeleteResult(Metadata IsMetadata) *DeleteResult

NewDeleteResult returns a new DeleteResult instance

func (*DeleteResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DeleteResult instance

type DeleteV2APIError 

type DeleteV2APIError struct {
	dropbox.APIError
	EndpointError *DeleteError `json:"error"`
}

DeleteV2APIError is an error-wrapper for the delete route

type DeletedMetadata 

type DeletedMetadata struct {
	Metadata
}

DeletedMetadata : Indicates that there used to be a file or folder at this path, but it no longer exists.

func NewDeletedMetadata 

func NewDeletedMetadata(Name string) *DeletedMetadata

NewDeletedMetadata returns a new DeletedMetadata instance

type Dimensions 

type Dimensions struct {
	// Height : Height of the photo/video.
	Height uint64 `json:"height"`
	// Width : Width of the photo/video.
	Width uint64 `json:"width"`
}

Dimensions : Dimensions for a photo or video.

func NewDimensions 

func NewDimensions(Height uint64, Width uint64) *Dimensions

NewDimensions returns a new Dimensions instance

type DownloadAPIError 

type DownloadAPIError struct {
	dropbox.APIError
	EndpointError *DownloadError `json:"error"`
}

DownloadAPIError is an error-wrapper for the download route

type DownloadArg 

type DownloadArg struct {
	// Path : The path of the file to download.
	Path string `json:"path"`
	// Rev : Please specify revision in `path` instead.
	Rev string `json:"rev,omitempty"`
	// ExtraHeaders can be used to pass Range, If-None-Match headers
	ExtraHeaders map[string]string `json:"-"`
}

DownloadArg : has no documentation (yet)

func NewDownloadArg 

func NewDownloadArg(Path string) *DownloadArg

NewDownloadArg returns a new DownloadArg instance

type DownloadError 

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

DownloadError : has no documentation (yet)

func (*DownloadError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DownloadError instance

type DownloadZipAPIError 

type DownloadZipAPIError struct {
	dropbox.APIError
	EndpointError *DownloadZipError `json:"error"`
}

DownloadZipAPIError is an error-wrapper for the download_zip route

type DownloadZipArg 

type DownloadZipArg struct {
	// Path : The path of the folder to download.
	Path string `json:"path"`
}

DownloadZipArg : has no documentation (yet)

func NewDownloadZipArg 

func NewDownloadZipArg(Path string) *DownloadZipArg

NewDownloadZipArg returns a new DownloadZipArg instance

type DownloadZipError 

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

DownloadZipError : has no documentation (yet)

func (*DownloadZipError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a DownloadZipError instance

type DownloadZipResult 

type DownloadZipResult struct {
	// Metadata : has no documentation (yet)
	Metadata *FolderMetadata `json:"metadata"`
}

DownloadZipResult : has no documentation (yet)

func NewDownloadZipResult 

func NewDownloadZipResult(Metadata *FolderMetadata) *DownloadZipResult

NewDownloadZipResult returns a new DownloadZipResult instance

type ExportAPIError 

type ExportAPIError struct {
	dropbox.APIError
	EndpointError *ExportError `json:"error"`
}

ExportAPIError is an error-wrapper for the export route

type ExportArg 

type ExportArg struct {
	// Path : The path of the file to be exported.
	Path string `json:"path"`
}

ExportArg : has no documentation (yet)

func NewExportArg 

func NewExportArg(Path string) *ExportArg

NewExportArg returns a new ExportArg instance

type ExportError 

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

ExportError : has no documentation (yet)

func (*ExportError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ExportError instance

type ExportInfo 

type ExportInfo struct {
	// ExportAs : Format to which the file can be exported to.
	ExportAs string `json:"export_as,omitempty"`
}

ExportInfo : Export information for a file.

func NewExportInfo 

func NewExportInfo() *ExportInfo

NewExportInfo returns a new ExportInfo instance

type ExportMetadata 

type ExportMetadata struct {
	// Name : The last component of the path (including extension). This never
	// contains a slash.
	Name string `json:"name"`
	// Size : The file size in bytes.
	Size uint64 `json:"size"`
	// ExportHash : A hash based on the exported file content. This field can be
	// used to verify data integrity. Similar to content hash. For more
	// information see our `Content hash`
	// <https://www.dropbox.com/developers/reference/content-hash> page.
	ExportHash string `json:"export_hash,omitempty"`
}

ExportMetadata : has no documentation (yet)

func NewExportMetadata 

func NewExportMetadata(Name string, Size uint64) *ExportMetadata

NewExportMetadata returns a new ExportMetadata instance

type ExportResult 

type ExportResult struct {
	// ExportMetadata : Metadata for the exported version of the file.
	ExportMetadata *ExportMetadata `json:"export_metadata"`
	// FileMetadata : Metadata for the original file.
	FileMetadata *FileMetadata `json:"file_metadata"`
}

ExportResult : has no documentation (yet)

func NewExportResult 

func NewExportResult(ExportMetadata *ExportMetadata, FileMetadata *FileMetadata) *ExportResult

NewExportResult returns a new ExportResult instance

type FileMetadata 

type FileMetadata struct {
	Metadata
	// Id : A unique identifier for the file.
	Id string `json:"id"`
	// ClientModified : For files, this is 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"`
	// MediaInfo : Additional information if the file is a photo or video. This
	// field will not be set on entries returned by `listFolder`,
	// `listFolderContinue`, or `getThumbnailBatch`, starting December 2, 2019.
	MediaInfo *MediaInfo `json:"media_info,omitempty"`
	// SymlinkInfo : Set if this file is a symlink.
	SymlinkInfo *SymlinkInfo `json:"symlink_info,omitempty"`
	// SharingInfo : Set if this file is contained in a shared folder.
	SharingInfo *FileSharingInfo `json:"sharing_info,omitempty"`
	// IsDownloadable : If true, file can be downloaded directly; else the file
	// must be exported.
	IsDownloadable bool `json:"is_downloadable"`
	// ExportInfo : Information about format this file can be exported to. This
	// filed must be set if `is_downloadable` is set to false.
	ExportInfo *ExportInfo `json:"export_info,omitempty"`
	// PropertyGroups : Additional information if the file has custom properties
	// with the property template specified.
	PropertyGroups []*file_properties.PropertyGroup `json:"property_groups,omitempty"`
	// HasExplicitSharedMembers : This flag will only be present if
	// include_has_explicit_shared_members  is true in `listFolder` or
	// `getMetadata`. If this  flag is present, it will be true if this file has
	// any explicit shared  members. This is different from sharing_info in that
	// this could be true  in the case where a file has explicit members but is
	// not contained within  a shared folder.
	HasExplicitSharedMembers bool `json:"has_explicit_shared_members,omitempty"`
	// ContentHash : A hash of the file content. This field can be used to
	// verify data integrity. For more information see our `Content hash`
	// <https://www.dropbox.com/developers/reference/content-hash> page.
	ContentHash string `json:"content_hash,omitempty"`
}

FileMetadata : has no documentation (yet)

func NewFileMetadata 

func NewFileMetadata(Name string, Id string, ClientModified time.Time, ServerModified time.Time, Rev string, Size uint64) *FileMetadata

NewFileMetadata returns a new FileMetadata instance

type FileOpsResult 

type FileOpsResult struct {
}

FileOpsResult : has no documentation (yet)

func NewFileOpsResult 

func NewFileOpsResult() *FileOpsResult

NewFileOpsResult returns a new FileOpsResult instance

type FileSharingInfo 

type FileSharingInfo struct {
	SharingInfo
	// ParentSharedFolderId : ID of shared folder that holds this file.
	ParentSharedFolderId string `json:"parent_shared_folder_id"`
	// ModifiedBy : The last user who modified the file. This field will be null
	// if the user's account has been deleted.
	ModifiedBy string `json:"modified_by,omitempty"`
}

FileSharingInfo : Sharing info for a file which is contained by a shared folder.

func NewFileSharingInfo 

func NewFileSharingInfo(ReadOnly bool, ParentSharedFolderId string) *FileSharingInfo

NewFileSharingInfo returns a new FileSharingInfo instance

type FolderMetadata 

type FolderMetadata struct {
	Metadata
	// Id : A unique identifier for the folder.
	Id string `json:"id"`
	// SharedFolderId : Please use `sharing_info` instead.
	SharedFolderId string `json:"shared_folder_id,omitempty"`
	// SharingInfo : Set if the folder is contained in a shared folder or is a
	// shared folder mount point.
	SharingInfo *FolderSharingInfo `json:"sharing_info,omitempty"`
	// PropertyGroups : Additional information if the file has custom properties
	// with the property template specified. Note that only properties
	// associated with user-owned templates, not team-owned templates, can be
	// attached to folders.
	PropertyGroups []*file_properties.PropertyGroup `json:"property_groups,omitempty"`
}

FolderMetadata : has no documentation (yet)

func NewFolderMetadata 

func NewFolderMetadata(Name string, Id string) *FolderMetadata

NewFolderMetadata returns a new FolderMetadata instance

type FolderSharingInfo 

type FolderSharingInfo struct {
	SharingInfo
	// ParentSharedFolderId : Set if the folder is contained by a shared folder.
	ParentSharedFolderId string `json:"parent_shared_folder_id,omitempty"`
	// SharedFolderId : If this folder is a shared folder mount point, the ID of
	// the shared folder mounted at this location.
	SharedFolderId string `json:"shared_folder_id,omitempty"`
	// TraverseOnly : Specifies that the folder can only be traversed and the
	// user can only see a limited subset of the contents of this folder because
	// they don't have read access to this folder. They do, however, have access
	// to some sub folder.
	TraverseOnly bool `json:"traverse_only"`
	// NoAccess : Specifies that the folder cannot be accessed by the user.
	NoAccess bool `json:"no_access"`
}

FolderSharingInfo : Sharing info for a folder which is contained in a shared folder or is a shared folder mount point.

func NewFolderSharingInfo 

func NewFolderSharingInfo(ReadOnly bool) *FolderSharingInfo

NewFolderSharingInfo returns a new FolderSharingInfo instance

type GetCopyReferenceArg 

type GetCopyReferenceArg struct {
	// Path : The path to the file or folder you want to get a copy reference
	// to.
	Path string `json:"path"`
}

GetCopyReferenceArg : has no documentation (yet)

func NewGetCopyReferenceArg 

func NewGetCopyReferenceArg(Path string) *GetCopyReferenceArg

NewGetCopyReferenceArg returns a new GetCopyReferenceArg instance

type GetCopyReferenceError 

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

GetCopyReferenceError : has no documentation (yet)

func (*GetCopyReferenceError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a GetCopyReferenceError instance

type GetCopyReferenceResult 

type GetCopyReferenceResult struct {
	// Metadata : Metadata of the file or folder.
	Metadata IsMetadata `json:"metadata"`
	// CopyReference : A copy reference to the file or folder.
	CopyReference string `json:"copy_reference"`
	// Expires : The expiration date of the copy reference. This value is
	// currently set to be far enough in the future so that expiration is
	// effectively not an issue.
	Expires time.Time `json:"expires"`
}

GetCopyReferenceResult : has no documentation (yet)

func NewGetCopyReferenceResult 

func NewGetCopyReferenceResult(Metadata IsMetadata, CopyReference string, Expires time.Time) *GetCopyReferenceResult

NewGetCopyReferenceResult returns a new GetCopyReferenceResult instance

func (*GetCopyReferenceResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a GetCopyReferenceResult instance

type GetMetadataAPIError 

type GetMetadataAPIError struct {
	dropbox.APIError
	EndpointError *GetMetadataError `json:"error"`
}

GetMetadataAPIError is an error-wrapper for the get_metadata route

type GetMetadataArg 

type GetMetadataArg struct {
	// Path : The path of a file or folder on Dropbox.
	Path string `json:"path"`
	// IncludeMediaInfo : If true, `FileMetadata.media_info` is set for photo
	// and video.
	IncludeMediaInfo bool `json:"include_media_info"`
	// IncludeDeleted : If true, `DeletedMetadata` will be returned for deleted
	// file or folder, otherwise `LookupError.not_found` will be returned.
	IncludeDeleted bool `json:"include_deleted"`
	// IncludeHasExplicitSharedMembers : If true, the results will include a
	// flag for each file indicating whether or not  that file has any explicit
	// members.
	IncludeHasExplicitSharedMembers bool `json:"include_has_explicit_shared_members"`
	// IncludePropertyGroups : If set to a valid list of template IDs,
	// `FileMetadata.property_groups` is set if there exists property data
	// associated with the file and each of the listed templates.
	IncludePropertyGroups *file_properties.TemplateFilterBase `json:"include_property_groups,omitempty"`
}

GetMetadataArg : has no documentation (yet)

func NewGetMetadataArg 

func NewGetMetadataArg(Path string) *GetMetadataArg

NewGetMetadataArg returns a new GetMetadataArg instance

type GetMetadataError 

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

GetMetadataError : has no documentation (yet)

func (*GetMetadataError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a GetMetadataError instance

type GetPreviewAPIError 

type GetPreviewAPIError struct {
	dropbox.APIError
	EndpointError *PreviewError `json:"error"`
}

GetPreviewAPIError is an error-wrapper for the get_preview route

type GetTemporaryLinkAPIError 

type GetTemporaryLinkAPIError struct {
	dropbox.APIError
	EndpointError *GetTemporaryLinkError `json:"error"`
}

GetTemporaryLinkAPIError is an error-wrapper for the get_temporary_link route

type GetTemporaryLinkArg 

type GetTemporaryLinkArg struct {
	// Path : The path to the file you want a temporary link to.
	Path string `json:"path"`
}

GetTemporaryLinkArg : has no documentation (yet)

func NewGetTemporaryLinkArg 

func NewGetTemporaryLinkArg(Path string) *GetTemporaryLinkArg

NewGetTemporaryLinkArg returns a new GetTemporaryLinkArg instance

type GetTemporaryLinkError 

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

GetTemporaryLinkError : has no documentation (yet)

func (*GetTemporaryLinkError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a GetTemporaryLinkError instance

type GetTemporaryLinkResult 

type GetTemporaryLinkResult struct {
	// Metadata : Metadata of the file.
	Metadata *FileMetadata `json:"metadata"`
	// Link : The temporary link which can be used to stream content the file.
	Link string `json:"link"`
}

GetTemporaryLinkResult : has no documentation (yet)

func NewGetTemporaryLinkResult 

func NewGetTemporaryLinkResult(Metadata *FileMetadata, Link string) *GetTemporaryLinkResult

NewGetTemporaryLinkResult returns a new GetTemporaryLinkResult instance

type GetTemporaryUploadLinkAPIError 

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

GetTemporaryUploadLinkAPIError is an error-wrapper for the get_temporary_upload_link route

type GetTemporaryUploadLinkArg 

type GetTemporaryUploadLinkArg struct {
	// CommitInfo : Contains the path and other optional modifiers for the
	// future upload commit. Equivalent to the parameters provided to `upload`.
	CommitInfo *CommitInfo `json:"commit_info"`
	// Duration : How long before this link expires, in seconds.  Attempting to
	// start an upload with this link longer than this period  of time after
	// link creation will result in an error.
	Duration float64 `json:"duration"`
}

GetTemporaryUploadLinkArg : has no documentation (yet)

func NewGetTemporaryUploadLinkArg 

func NewGetTemporaryUploadLinkArg(CommitInfo *CommitInfo) *GetTemporaryUploadLinkArg

NewGetTemporaryUploadLinkArg returns a new GetTemporaryUploadLinkArg instance

type GetTemporaryUploadLinkResult 

type GetTemporaryUploadLinkResult struct {
	// Link : The temporary link which can be used to stream a file to a Dropbox
	// location.
	Link string `json:"link"`
}

GetTemporaryUploadLinkResult : has no documentation (yet)

func NewGetTemporaryUploadLinkResult 

func NewGetTemporaryUploadLinkResult(Link string) *GetTemporaryUploadLinkResult

NewGetTemporaryUploadLinkResult returns a new GetTemporaryUploadLinkResult instance

type GetThumbnailAPIError 

type GetThumbnailAPIError struct {
	dropbox.APIError
	EndpointError *ThumbnailError `json:"error"`
}

GetThumbnailAPIError is an error-wrapper for the get_thumbnail route

type GetThumbnailBatchAPIError 

type GetThumbnailBatchAPIError struct {
	dropbox.APIError
	EndpointError *GetThumbnailBatchError `json:"error"`
}

GetThumbnailBatchAPIError is an error-wrapper for the get_thumbnail_batch route

type GetThumbnailBatchArg 

type GetThumbnailBatchArg struct {
	// Entries : List of files to get thumbnails.
	Entries []*ThumbnailArg `json:"entries"`
}

GetThumbnailBatchArg : Arguments for `getThumbnailBatch`.

func NewGetThumbnailBatchArg 

func NewGetThumbnailBatchArg(Entries []*ThumbnailArg) *GetThumbnailBatchArg

NewGetThumbnailBatchArg returns a new GetThumbnailBatchArg instance

type GetThumbnailBatchError 

type GetThumbnailBatchError struct {
	dropbox.Tagged
}

GetThumbnailBatchError : has no documentation (yet)

type GetThumbnailBatchResult 

type GetThumbnailBatchResult struct {
	// Entries : List of files and their thumbnails.
	Entries []*GetThumbnailBatchResultEntry `json:"entries"`
}

GetThumbnailBatchResult : has no documentation (yet)

func NewGetThumbnailBatchResult 

func NewGetThumbnailBatchResult(Entries []*GetThumbnailBatchResultEntry) *GetThumbnailBatchResult

NewGetThumbnailBatchResult returns a new GetThumbnailBatchResult instance

type GetThumbnailBatchResultData 

type GetThumbnailBatchResultData struct {
	// Metadata : has no documentation (yet)
	Metadata *FileMetadata `json:"metadata"`
	// Thumbnail : A string containing the base64-encoded thumbnail data for
	// this file.
	Thumbnail string `json:"thumbnail"`
}

GetThumbnailBatchResultData : has no documentation (yet)

func NewGetThumbnailBatchResultData 

func NewGetThumbnailBatchResultData(Metadata *FileMetadata, Thumbnail string) *GetThumbnailBatchResultData

NewGetThumbnailBatchResultData returns a new GetThumbnailBatchResultData instance

type GetThumbnailBatchResultEntry 

type GetThumbnailBatchResultEntry struct {
	dropbox.Tagged
	// Success : has no documentation (yet)
	Success *GetThumbnailBatchResultData `json:"success,omitempty"`
	// Failure : The result for this file if it was an error.
	Failure *ThumbnailError `json:"failure,omitempty"`
}

GetThumbnailBatchResultEntry : has no documentation (yet)

func (*GetThumbnailBatchResultEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a GetThumbnailBatchResultEntry instance

type GpsCoordinates 

type GpsCoordinates struct {
	// Latitude : Latitude of the GPS coordinates.
	Latitude float64 `json:"latitude"`
	// Longitude : Longitude of the GPS coordinates.
	Longitude float64 `json:"longitude"`
}

GpsCoordinates : GPS coordinates for a photo or video.

func NewGpsCoordinates 

func NewGpsCoordinates(Latitude float64, Longitude float64) *GpsCoordinates

NewGpsCoordinates returns a new GpsCoordinates instance

type IsMediaMetadata 

type IsMediaMetadata interface {
	IsMediaMetadata()
}

IsMediaMetadata is the interface type for MediaMetadata and its subtypes

func IsMediaMetadataFromJSON 

func IsMediaMetadataFromJSON(data []byte) (IsMediaMetadata, error)

IsMediaMetadataFromJSON converts JSON to a concrete IsMediaMetadata instance

type IsMetadata 

type IsMetadata interface {
	IsMetadata()
}

IsMetadata is the interface type for Metadata and its subtypes

func IsMetadataFromJSON 

func IsMetadataFromJSON(data []byte) (IsMetadata, error)

IsMetadataFromJSON converts JSON to a concrete IsMetadata instance

type ListFolderAPIError 

type ListFolderAPIError struct {
	dropbox.APIError
	EndpointError *ListFolderError `json:"error"`
}

ListFolderAPIError is an error-wrapper for the list_folder route

type ListFolderArg 

type ListFolderArg struct {
	// Path : A unique identifier for the file.
	Path string `json:"path"`
	// Recursive : If true, the list folder operation will be applied
	// recursively to all subfolders and the response will contain contents of
	// all subfolders.
	Recursive bool `json:"recursive"`
	// IncludeMediaInfo : If true, `FileMetadata.media_info` is set for photo
	// and video. This parameter will no longer have an effect starting December
	// 2, 2019.
	IncludeMediaInfo bool `json:"include_media_info"`
	// IncludeDeleted : If true, the results will include entries for files and
	// folders that used to exist but were deleted.
	IncludeDeleted bool `json:"include_deleted"`
	// IncludeHasExplicitSharedMembers : If true, the results will include a
	// flag for each file indicating whether or not  that file has any explicit
	// members.
	IncludeHasExplicitSharedMembers bool `json:"include_has_explicit_shared_members"`
	// IncludeMountedFolders : If true, the results will include entries under
	// mounted folders which includes app folder, shared folder and team folder.
	IncludeMountedFolders bool `json:"include_mounted_folders"`
	// Limit : The maximum number of results to return per request. Note: This
	// is an approximate number and there can be slightly more entries returned
	// in some cases.
	Limit uint32 `json:"limit,omitempty"`
	// SharedLink : A shared link to list the contents of. If the link is
	// password-protected, the password must be provided. If this field is
	// present, `ListFolderArg.path` will be relative to root of the shared
	// link. Only non-recursive mode is supported for shared link.
	SharedLink *SharedLink `json:"shared_link,omitempty"`
	// IncludePropertyGroups : If set to a valid list of template IDs,
	// `FileMetadata.property_groups` is set if there exists property data
	// associated with the file and each of the listed templates.
	IncludePropertyGroups *file_properties.TemplateFilterBase `json:"include_property_groups,omitempty"`
	// IncludeNonDownloadableFiles : If true, include files that are not
	// downloadable, i.e. Google Docs.
	IncludeNonDownloadableFiles bool `json:"include_non_downloadable_files"`
}

ListFolderArg : has no documentation (yet)

func NewListFolderArg 

func NewListFolderArg(Path string) *ListFolderArg

NewListFolderArg returns a new ListFolderArg instance

type ListFolderContinueAPIError 

type ListFolderContinueAPIError struct {
	dropbox.APIError
	EndpointError *ListFolderContinueError `json:"error"`
}

ListFolderContinueAPIError is an error-wrapper for the list_folder/continue route

type ListFolderContinueArg 

type ListFolderContinueArg struct {
	// Cursor : The cursor returned by your last call to `listFolder` or
	// `listFolderContinue`.
	Cursor string `json:"cursor"`
}

ListFolderContinueArg : has no documentation (yet)

func NewListFolderContinueArg 

func NewListFolderContinueArg(Cursor string) *ListFolderContinueArg

NewListFolderContinueArg returns a new ListFolderContinueArg instance

type ListFolderContinueError 

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

ListFolderContinueError : has no documentation (yet)

func (*ListFolderContinueError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ListFolderContinueError instance

type ListFolderError 

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

ListFolderError : has no documentation (yet)

func (*ListFolderError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ListFolderError instance

type ListFolderGetLatestCursorAPIError 

type ListFolderGetLatestCursorAPIError struct {
	dropbox.APIError
	EndpointError *ListFolderError `json:"error"`
}

ListFolderGetLatestCursorAPIError is an error-wrapper for the list_folder/get_latest_cursor route

type ListFolderGetLatestCursorResult 

type ListFolderGetLatestCursorResult struct {
	// Cursor : Pass the cursor into `listFolderContinue` to see what's changed
	// in the folder since your previous query.
	Cursor string `json:"cursor"`
}

ListFolderGetLatestCursorResult : has no documentation (yet)

func NewListFolderGetLatestCursorResult 

func NewListFolderGetLatestCursorResult(Cursor string) *ListFolderGetLatestCursorResult

NewListFolderGetLatestCursorResult returns a new ListFolderGetLatestCursorResult instance

type ListFolderLongpollAPIError 

type ListFolderLongpollAPIError struct {
	dropbox.APIError
	EndpointError *ListFolderLongpollError `json:"error"`
}

ListFolderLongpollAPIError is an error-wrapper for the list_folder/longpoll route

type ListFolderLongpollArg 

type ListFolderLongpollArg struct {
	// Cursor : A cursor as returned by `listFolder` or `listFolderContinue`.
	// Cursors retrieved by setting `ListFolderArg.include_media_info` to true
	// are not supported.
	Cursor string `json:"cursor"`
	// Timeout : A timeout in seconds. The request will block for at most this
	// length of time, plus up to 90 seconds of random jitter added to avoid the
	// thundering herd problem. Care should be taken when using this parameter,
	// as some network infrastructure does not support long timeouts.
	Timeout uint64 `json:"timeout"`
}

ListFolderLongpollArg : has no documentation (yet)

func NewListFolderLongpollArg 

func NewListFolderLongpollArg(Cursor string) *ListFolderLongpollArg

NewListFolderLongpollArg returns a new ListFolderLongpollArg instance

type ListFolderLongpollError 

type ListFolderLongpollError struct {
	dropbox.Tagged
}

ListFolderLongpollError : has no documentation (yet)

type ListFolderLongpollResult 

type ListFolderLongpollResult struct {
	// Changes : Indicates whether new changes are available. If true, call
	// `listFolderContinue` to retrieve the changes.
	Changes bool `json:"changes"`
	// Backoff : If present, backoff for at least this many seconds before
	// calling `listFolderLongpoll` again.
	Backoff uint64 `json:"backoff,omitempty"`
}

ListFolderLongpollResult : has no documentation (yet)

func NewListFolderLongpollResult 

func NewListFolderLongpollResult(Changes bool) *ListFolderLongpollResult

NewListFolderLongpollResult returns a new ListFolderLongpollResult instance

type ListFolderResult 

type ListFolderResult struct {
	// Entries : The files and (direct) subfolders in the folder.
	Entries []IsMetadata `json:"entries"`
	// Cursor : Pass the cursor into `listFolderContinue` to see what's changed
	// in the folder since your previous query.
	Cursor string `json:"cursor"`
	// HasMore : If true, then there are more entries available. Pass the cursor
	// to `listFolderContinue` to retrieve the rest.
	HasMore bool `json:"has_more"`
}

ListFolderResult : has no documentation (yet)

func NewListFolderResult 

func NewListFolderResult(Entries []IsMetadata, Cursor string, HasMore bool) *ListFolderResult

NewListFolderResult returns a new ListFolderResult instance

func (*ListFolderResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ListFolderResult instance

type ListRevisionsAPIError 

type ListRevisionsAPIError struct {
	dropbox.APIError
	EndpointError *ListRevisionsError `json:"error"`
}

ListRevisionsAPIError is an error-wrapper for the list_revisions route

type ListRevisionsArg 

type ListRevisionsArg struct {
	// Path : The path to the file you want to see the revisions of.
	Path string `json:"path"`
	// Mode : Determines the behavior of the API in listing the revisions for a
	// given file path or id.
	Mode *ListRevisionsMode `json:"mode"`
	// Limit : The maximum number of revision entries returned.
	Limit uint64 `json:"limit"`
}

ListRevisionsArg : has no documentation (yet)

func NewListRevisionsArg 

func NewListRevisionsArg(Path string) *ListRevisionsArg

NewListRevisionsArg returns a new ListRevisionsArg instance

type ListRevisionsError 

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

ListRevisionsError : has no documentation (yet)

func (*ListRevisionsError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ListRevisionsError instance

type ListRevisionsMode 

type ListRevisionsMode struct {
	dropbox.Tagged
}

ListRevisionsMode : has no documentation (yet)

type ListRevisionsResult 

type ListRevisionsResult struct {
	// IsDeleted : If the file identified by the latest revision in the response
	// is either deleted or moved.
	IsDeleted bool `json:"is_deleted"`
	// ServerDeleted : The time of deletion if the file was deleted.
	ServerDeleted time.Time `json:"server_deleted,omitempty"`
	// Entries : The revisions for the file. Only revisions that are not deleted
	// will show up here.
	Entries []*FileMetadata `json:"entries"`
}

ListRevisionsResult : has no documentation (yet)

func NewListRevisionsResult 

func NewListRevisionsResult(IsDeleted bool, Entries []*FileMetadata) *ListRevisionsResult

NewListRevisionsResult returns a new ListRevisionsResult instance

type LookupError 

type LookupError struct {
	dropbox.Tagged
	// MalformedPath : The given path does not satisfy the required path format.
	// Please refer to the `Path formats documentation`
	// <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>
	// for more information.
	MalformedPath string `json:"malformed_path,omitempty"`
}

LookupError : has no documentation (yet)

func (*LookupError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a LookupError instance

type MediaInfo 

type MediaInfo struct {
	dropbox.Tagged
	// Metadata : The metadata for the photo/video.
	Metadata IsMediaMetadata `json:"metadata,omitempty"`
}

MediaInfo : has no documentation (yet)

func (*MediaInfo) UnmarshalJSON 

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

UnmarshalJSON deserializes into a MediaInfo instance

type MediaMetadata 

type MediaMetadata struct {
	// Dimensions : Dimension of the photo/video.
	Dimensions *Dimensions `json:"dimensions,omitempty"`
	// Location : The GPS coordinate of the photo/video.
	Location *GpsCoordinates `json:"location,omitempty"`
	// TimeTaken : The timestamp when the photo/video is taken.
	TimeTaken time.Time `json:"time_taken,omitempty"`
}

MediaMetadata : Metadata for a photo or video.

func NewMediaMetadata 

func NewMediaMetadata() *MediaMetadata

NewMediaMetadata returns a new MediaMetadata instance

func (*MediaMetadata) IsMediaMetadata 

func (u *MediaMetadata) IsMediaMetadata()

IsMediaMetadata implements the IsMediaMetadata interface

type Metadata 

type Metadata struct {
	// Name : The last component of the path (including extension). This never
	// contains a slash.
	Name string `json:"name"`
	// PathLower : The lowercased full path in the user's Dropbox. This always
	// starts with a slash. This field will be null if the file or folder is not
	// mounted.
	PathLower string `json:"path_lower,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, and at
	// least the last path component will have the correct casing. Changes to
	// only the casing of paths won't be returned by `listFolderContinue`. This
	// field will be null if the file or folder is not mounted.
	PathDisplay string `json:"path_display,omitempty"`
	// ParentSharedFolderId : Please use
	// `FileSharingInfo.parent_shared_folder_id` or
	// `FolderSharingInfo.parent_shared_folder_id` instead.
	ParentSharedFolderId string `json:"parent_shared_folder_id,omitempty"`
}

Metadata : Metadata for a file or folder.

func NewMetadata 

func NewMetadata(Name string) *Metadata

NewMetadata returns a new Metadata instance

func (*Metadata) IsMetadata 

func (u *Metadata) IsMetadata()

IsMetadata implements the IsMetadata interface

type MoveAPIError 

type MoveAPIError struct {
	dropbox.APIError
	EndpointError *RelocationError `json:"error"`
}

MoveAPIError is an error-wrapper for the move route

type MoveBatchAPIError 

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

MoveBatchAPIError is an error-wrapper for the move_batch route

type MoveBatchArg 

type MoveBatchArg struct {
	RelocationBatchArgBase
	// AllowOwnershipTransfer : Allow moves by owner even if it would result in
	// an ownership transfer for the content being moved. This does not apply to
	// copies.
	AllowOwnershipTransfer bool `json:"allow_ownership_transfer"`
}

MoveBatchArg : has no documentation (yet)

func NewMoveBatchArg 

func NewMoveBatchArg(Entries []*RelocationPath) *MoveBatchArg

NewMoveBatchArg returns a new MoveBatchArg instance

type MoveBatchCheckAPIError 

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

MoveBatchCheckAPIError is an error-wrapper for the move_batch/check route

type MoveBatchCheckV2APIError 

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

MoveBatchCheckV2APIError is an error-wrapper for the move_batch/check route

type MoveBatchV2APIError 

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

MoveBatchV2APIError is an error-wrapper for the move_batch route

type MoveV2APIError 

type MoveV2APIError struct {
	dropbox.APIError
	EndpointError *RelocationError `json:"error"`
}

MoveV2APIError is an error-wrapper for the move route

type PermanentlyDeleteAPIError 

type PermanentlyDeleteAPIError struct {
	dropbox.APIError
	EndpointError *DeleteError `json:"error"`
}

PermanentlyDeleteAPIError is an error-wrapper for the permanently_delete route

type PhotoMetadata 

type PhotoMetadata struct {
	MediaMetadata
}

PhotoMetadata : Metadata for a photo.

func NewPhotoMetadata 

func NewPhotoMetadata() *PhotoMetadata

NewPhotoMetadata returns a new PhotoMetadata instance

type PreviewArg 

type PreviewArg struct {
	// Path : The path of the file to preview.
	Path string `json:"path"`
	// Rev : Please specify revision in `path` instead.
	Rev string `json:"rev,omitempty"`
}

PreviewArg : has no documentation (yet)

func NewPreviewArg 

func NewPreviewArg(Path string) *PreviewArg

NewPreviewArg returns a new PreviewArg instance

type PreviewError 

type PreviewError struct {
	dropbox.Tagged
	// Path : An error occurs when downloading metadata for the file.
	Path *LookupError `json:"path,omitempty"`
}

PreviewError : has no documentation (yet)

func (*PreviewError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a PreviewError instance

type PropertiesAddAPIError 

type PropertiesAddAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.AddPropertiesError `json:"error"`
}

PropertiesAddAPIError is an error-wrapper for the properties/add route

type PropertiesOverwriteAPIError 

type PropertiesOverwriteAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.InvalidPropertyGroupError `json:"error"`
}

PropertiesOverwriteAPIError is an error-wrapper for the properties/overwrite route

type PropertiesRemoveAPIError 

type PropertiesRemoveAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.RemovePropertiesError `json:"error"`
}

PropertiesRemoveAPIError is an error-wrapper for the properties/remove route

type PropertiesTemplateGetAPIError 

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

PropertiesTemplateGetAPIError is an error-wrapper for the properties/template/get route

type PropertiesTemplateListAPIError 

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

PropertiesTemplateListAPIError is an error-wrapper for the properties/template/list route

type PropertiesUpdateAPIError 

type PropertiesUpdateAPIError struct {
	dropbox.APIError
	EndpointError *file_properties.UpdatePropertiesError `json:"error"`
}

PropertiesUpdateAPIError is an error-wrapper for the properties/update route

type RelocationArg 

type RelocationArg struct {
	RelocationPath
	// AllowSharedFolder : If true, `copy` will copy contents in shared folder,
	// otherwise `RelocationError.cant_copy_shared_folder` will be returned if
	// `from_path` contains shared folder. This field is always true for `move`.
	AllowSharedFolder bool `json:"allow_shared_folder"`
	// Autorename : If there's a conflict, have the Dropbox server try to
	// autorename the file to avoid the conflict.
	Autorename bool `json:"autorename"`
	// AllowOwnershipTransfer : Allow moves by owner even if it would result in
	// an ownership transfer for the content being moved. This does not apply to
	// copies.
	AllowOwnershipTransfer bool `json:"allow_ownership_transfer"`
}

RelocationArg : has no documentation (yet)

func NewRelocationArg 

func NewRelocationArg(FromPath string, ToPath string) *RelocationArg

NewRelocationArg returns a new RelocationArg instance

type RelocationBatchArg 

type RelocationBatchArg struct {
	RelocationBatchArgBase
	// AllowSharedFolder : If true, `copyBatch` will copy contents in shared
	// folder, otherwise `RelocationError.cant_copy_shared_folder` will be
	// returned if `RelocationPath.from_path` contains shared folder. This field
	// is always true for `moveBatch`.
	AllowSharedFolder bool `json:"allow_shared_folder"`
	// AllowOwnershipTransfer : Allow moves by owner even if it would result in
	// an ownership transfer for the content being moved. This does not apply to
	// copies.
	AllowOwnershipTransfer bool `json:"allow_ownership_transfer"`
}

RelocationBatchArg : has no documentation (yet)

func NewRelocationBatchArg 

func NewRelocationBatchArg(Entries []*RelocationPath) *RelocationBatchArg

NewRelocationBatchArg returns a new RelocationBatchArg instance

type RelocationBatchArgBase 

type RelocationBatchArgBase struct {
	// Entries : List of entries to be moved or copied. Each entry is
	// `RelocationPath`.
	Entries []*RelocationPath `json:"entries"`
	// Autorename : If there's a conflict with any file, have the Dropbox server
	// try to autorename that file to avoid the conflict.
	Autorename bool `json:"autorename"`
}

RelocationBatchArgBase : has no documentation (yet)

func NewRelocationBatchArgBase 

func NewRelocationBatchArgBase(Entries []*RelocationPath) *RelocationBatchArgBase

NewRelocationBatchArgBase returns a new RelocationBatchArgBase instance

type RelocationBatchError 

type RelocationBatchError struct {
	dropbox.Tagged
	// FromLookup : has no documentation (yet)
	FromLookup *LookupError `json:"from_lookup,omitempty"`
	// FromWrite : has no documentation (yet)
	FromWrite *WriteError `json:"from_write,omitempty"`
	// To : has no documentation (yet)
	To *WriteError `json:"to,omitempty"`
}

RelocationBatchError : has no documentation (yet)

func (*RelocationBatchError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchError instance

type RelocationBatchErrorEntry 

type RelocationBatchErrorEntry struct {
	dropbox.Tagged
	// RelocationError : User errors that retry won't help.
	RelocationError *RelocationError `json:"relocation_error,omitempty"`
}

RelocationBatchErrorEntry : has no documentation (yet)

func (*RelocationBatchErrorEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchErrorEntry instance

type RelocationBatchJobStatus 

type RelocationBatchJobStatus struct {
	dropbox.Tagged
	// Complete : The copy or move batch job has finished.
	Complete *RelocationBatchResult `json:"complete,omitempty"`
	// Failed : The copy or move batch job has failed with exception.
	Failed *RelocationBatchError `json:"failed,omitempty"`
}

RelocationBatchJobStatus : has no documentation (yet)

func (*RelocationBatchJobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchJobStatus instance

type RelocationBatchLaunch 

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

RelocationBatchLaunch : Result returned by `copyBatch` or `moveBatch` that may either launch an asynchronous job or complete synchronously.

func (*RelocationBatchLaunch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchLaunch instance

type RelocationBatchResult 

type RelocationBatchResult struct {
	FileOpsResult
	// Entries : has no documentation (yet)
	Entries []*RelocationBatchResultData `json:"entries"`
}

RelocationBatchResult : has no documentation (yet)

func NewRelocationBatchResult 

func NewRelocationBatchResult(Entries []*RelocationBatchResultData) *RelocationBatchResult

NewRelocationBatchResult returns a new RelocationBatchResult instance

type RelocationBatchResultData 

type RelocationBatchResultData struct {
	// Metadata : Metadata of the relocated object.
	Metadata IsMetadata `json:"metadata"`
}

RelocationBatchResultData : has no documentation (yet)

func NewRelocationBatchResultData 

func NewRelocationBatchResultData(Metadata IsMetadata) *RelocationBatchResultData

NewRelocationBatchResultData returns a new RelocationBatchResultData instance

func (*RelocationBatchResultData) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchResultData instance

type RelocationBatchResultEntry 

type RelocationBatchResultEntry struct {
	dropbox.Tagged
	// Success : has no documentation (yet)
	Success IsMetadata `json:"success,omitempty"`
	// Failure : has no documentation (yet)
	Failure *RelocationBatchErrorEntry `json:"failure,omitempty"`
}

RelocationBatchResultEntry : has no documentation (yet)

func (*RelocationBatchResultEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchResultEntry instance

type RelocationBatchV2JobStatus 

type RelocationBatchV2JobStatus struct {
	dropbox.Tagged
	// Complete : The copy or move batch job has finished.
	Complete *RelocationBatchV2Result `json:"complete,omitempty"`
}

RelocationBatchV2JobStatus : Result returned by `copyBatchCheck` or `moveBatchCheck` that may either be in progress or completed with result for each entry.

func (*RelocationBatchV2JobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchV2JobStatus instance

type RelocationBatchV2Launch 

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

RelocationBatchV2Launch : Result returned by `copyBatch` or `moveBatch` that may either launch an asynchronous job or complete synchronously.

func (*RelocationBatchV2Launch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationBatchV2Launch instance

type RelocationBatchV2Result 

type RelocationBatchV2Result struct {
	FileOpsResult
	// Entries : Each entry in CopyBatchArg.entries or `MoveBatchArg.entries`
	// will appear at the same position inside
	// `RelocationBatchV2Result.entries`.
	Entries []*RelocationBatchResultEntry `json:"entries"`
}

RelocationBatchV2Result : has no documentation (yet)

func NewRelocationBatchV2Result 

func NewRelocationBatchV2Result(Entries []*RelocationBatchResultEntry) *RelocationBatchV2Result

NewRelocationBatchV2Result returns a new RelocationBatchV2Result instance

type RelocationError 

type RelocationError struct {
	dropbox.Tagged
	// FromLookup : has no documentation (yet)
	FromLookup *LookupError `json:"from_lookup,omitempty"`
	// FromWrite : has no documentation (yet)
	FromWrite *WriteError `json:"from_write,omitempty"`
	// To : has no documentation (yet)
	To *WriteError `json:"to,omitempty"`
}

RelocationError : has no documentation (yet)

func (*RelocationError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationError instance

type RelocationPath 

type RelocationPath struct {
	// FromPath : Path in the user's Dropbox to be copied or moved.
	FromPath string `json:"from_path"`
	// ToPath : Path in the user's Dropbox that is the destination.
	ToPath string `json:"to_path"`
}

RelocationPath : has no documentation (yet)

func NewRelocationPath 

func NewRelocationPath(FromPath string, ToPath string) *RelocationPath

NewRelocationPath returns a new RelocationPath instance

type RelocationResult 

type RelocationResult struct {
	FileOpsResult
	// Metadata : Metadata of the relocated object.
	Metadata IsMetadata `json:"metadata"`
}

RelocationResult : has no documentation (yet)

func NewRelocationResult 

func NewRelocationResult(Metadata IsMetadata) *RelocationResult

NewRelocationResult returns a new RelocationResult instance

func (*RelocationResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RelocationResult instance

type RestoreAPIError 

type RestoreAPIError struct {
	dropbox.APIError
	EndpointError *RestoreError `json:"error"`
}

RestoreAPIError is an error-wrapper for the restore route

type RestoreArg 

type RestoreArg struct {
	// Path : The path to save the restored file.
	Path string `json:"path"`
	// Rev : The revision to restore.
	Rev string `json:"rev"`
}

RestoreArg : has no documentation (yet)

func NewRestoreArg 

func NewRestoreArg(Path string, Rev string) *RestoreArg

NewRestoreArg returns a new RestoreArg instance

type RestoreError 

type RestoreError struct {
	dropbox.Tagged
	// PathLookup : An error occurs when downloading metadata for the file.
	PathLookup *LookupError `json:"path_lookup,omitempty"`
	// PathWrite : An error occurs when trying to restore the file to that path.
	PathWrite *WriteError `json:"path_write,omitempty"`
}

RestoreError : has no documentation (yet)

func (*RestoreError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a RestoreError instance

type SaveCopyReferenceArg 

type SaveCopyReferenceArg struct {
	// CopyReference : A copy reference returned by `copyReferenceGet`.
	CopyReference string `json:"copy_reference"`
	// Path : Path in the user's Dropbox that is the destination.
	Path string `json:"path"`
}

SaveCopyReferenceArg : has no documentation (yet)

func NewSaveCopyReferenceArg 

func NewSaveCopyReferenceArg(CopyReference string, Path string) *SaveCopyReferenceArg

NewSaveCopyReferenceArg returns a new SaveCopyReferenceArg instance

type SaveCopyReferenceError 

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

SaveCopyReferenceError : has no documentation (yet)

func (*SaveCopyReferenceError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SaveCopyReferenceError instance

type SaveCopyReferenceResult 

type SaveCopyReferenceResult struct {
	// Metadata : The metadata of the saved file or folder in the user's
	// Dropbox.
	Metadata IsMetadata `json:"metadata"`
}

SaveCopyReferenceResult : has no documentation (yet)

func NewSaveCopyReferenceResult 

func NewSaveCopyReferenceResult(Metadata IsMetadata) *SaveCopyReferenceResult

NewSaveCopyReferenceResult returns a new SaveCopyReferenceResult instance

func (*SaveCopyReferenceResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SaveCopyReferenceResult instance

type SaveUrlAPIError 

type SaveUrlAPIError struct {
	dropbox.APIError
	EndpointError *SaveUrlError `json:"error"`
}

SaveUrlAPIError is an error-wrapper for the save_url route

type SaveUrlArg 

type SaveUrlArg struct {
	// Path : The path in Dropbox where the URL will be saved to.
	Path string `json:"path"`
	// Url : The URL to be saved.
	Url string `json:"url"`
}

SaveUrlArg : has no documentation (yet)

func NewSaveUrlArg 

func NewSaveUrlArg(Path string, Url string) *SaveUrlArg

NewSaveUrlArg returns a new SaveUrlArg instance

type SaveUrlCheckJobStatusAPIError 

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

SaveUrlCheckJobStatusAPIError is an error-wrapper for the save_url/check_job_status route

type SaveUrlError 

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

SaveUrlError : has no documentation (yet)

func (*SaveUrlError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SaveUrlError instance

type SaveUrlJobStatus 

type SaveUrlJobStatus struct {
	dropbox.Tagged
	// Complete : Metadata of the file where the URL is saved to.
	Complete *FileMetadata `json:"complete,omitempty"`
	// Failed : has no documentation (yet)
	Failed *SaveUrlError `json:"failed,omitempty"`
}

SaveUrlJobStatus : has no documentation (yet)

func (*SaveUrlJobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SaveUrlJobStatus instance

type SaveUrlResult 

type SaveUrlResult 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 : Metadata of the file where the URL is saved to.
	Complete *FileMetadata `json:"complete,omitempty"`
}

SaveUrlResult : has no documentation (yet)

func (*SaveUrlResult) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SaveUrlResult instance

type SearchAPIError 

type SearchAPIError struct {
	dropbox.APIError
	EndpointError *SearchError `json:"error"`
}

SearchAPIError is an error-wrapper for the search route

type SearchArg 

type SearchArg struct {
	// Path : The path in the user's Dropbox to search. Should probably be a
	// folder.
	Path string `json:"path"`
	// Query : The string to search for. The search string is split on spaces
	// into multiple tokens. For file name searching, the last token is used for
	// prefix matching (i.e. "bat c" matches "bat cave" but not "batman car").
	Query string `json:"query"`
	// Start : The starting index within the search results (used for paging).
	Start uint64 `json:"start"`
	// MaxResults : The maximum number of search results to return.
	MaxResults uint64 `json:"max_results"`
	// Mode : The search mode (filename, filename_and_content, or
	// deleted_filename). Note that searching file content is only available for
	// Dropbox Business accounts.
	Mode *SearchMode `json:"mode"`
}

SearchArg : has no documentation (yet)

func NewSearchArg 

func NewSearchArg(Path string, Query string) *SearchArg

NewSearchArg returns a new SearchArg instance

type SearchError 

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

SearchError : has no documentation (yet)

func (*SearchError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SearchError instance

type SearchMatch 

type SearchMatch struct {
	// MatchType : The type of the match.
	MatchType *SearchMatchType `json:"match_type"`
	// Metadata : The metadata for the matched file or folder.
	Metadata IsMetadata `json:"metadata"`
}

SearchMatch : has no documentation (yet)

func NewSearchMatch 

func NewSearchMatch(MatchType *SearchMatchType, Metadata IsMetadata) *SearchMatch

NewSearchMatch returns a new SearchMatch instance

func (*SearchMatch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SearchMatch instance

type SearchMatchType 

type SearchMatchType struct {
	dropbox.Tagged
}

SearchMatchType : Indicates what type of match was found for a given item.

type SearchMode 

type SearchMode struct {
	dropbox.Tagged
}

SearchMode : has no documentation (yet)

type SearchResult 

type SearchResult struct {
	// Matches : A list (possibly empty) of matches for the query.
	Matches []*SearchMatch `json:"matches"`
	// More : Used for paging. If true, indicates there is another page of
	// results available that can be fetched by calling `search` again.
	More bool `json:"more"`
	// Start : Used for paging. Value to set the start argument to when calling
	// `search` to fetch the next page of results.
	Start uint64 `json:"start"`
}

SearchResult : has no documentation (yet)

func NewSearchResult 

func NewSearchResult(Matches []*SearchMatch, More bool, Start uint64) *SearchResult

NewSearchResult returns a new SearchResult instance 

type SharedLink struct {
	// Url : Shared link url.
	Url string `json:"url"`
	// Password : Password for the shared link.
	Password string `json:"password,omitempty"`
}

SharedLink : has no documentation (yet) 

func NewSharedLink(Url string) *SharedLink

NewSharedLink returns a new SharedLink instance

type SharingInfo 

type SharingInfo struct {
	// ReadOnly : True if the file or folder is inside a read-only shared
	// folder.
	ReadOnly bool `json:"read_only"`
}

SharingInfo : Sharing info for a file or folder.

func NewSharingInfo 

func NewSharingInfo(ReadOnly bool) *SharingInfo

NewSharingInfo returns a new SharingInfo instance

type SymlinkInfo 

type SymlinkInfo struct {
	// Target : The target this symlink points to.
	Target string `json:"target"`
}

SymlinkInfo : has no documentation (yet)

func NewSymlinkInfo 

func NewSymlinkInfo(Target string) *SymlinkInfo

NewSymlinkInfo returns a new SymlinkInfo instance

type SyncSetting 

type SyncSetting struct {
	dropbox.Tagged
}

SyncSetting : has no documentation (yet)

type SyncSettingArg 

type SyncSettingArg struct {
	dropbox.Tagged
}

SyncSettingArg : has no documentation (yet)

type SyncSettingsError 

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

SyncSettingsError : has no documentation (yet)

func (*SyncSettingsError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a SyncSettingsError instance

type ThumbnailArg 

type ThumbnailArg struct {
	// Path : The path to the image file you want to thumbnail.
	Path string `json:"path"`
	// Format : The format for the thumbnail image, jpeg (default) or png. For
	// images that are photos, jpeg should be preferred, while png is  better
	// for screenshots and digital arts.
	Format *ThumbnailFormat `json:"format"`
	// Size : The size for the thumbnail image.
	Size *ThumbnailSize `json:"size"`
	// Mode : How to resize and crop the image to achieve the desired size.
	Mode *ThumbnailMode `json:"mode"`
}

ThumbnailArg : has no documentation (yet)

func NewThumbnailArg 

func NewThumbnailArg(Path string) *ThumbnailArg

NewThumbnailArg returns a new ThumbnailArg instance

type ThumbnailError 

type ThumbnailError struct {
	dropbox.Tagged
	// Path : An error occurs when downloading metadata for the image.
	Path *LookupError `json:"path,omitempty"`
}

ThumbnailError : has no documentation (yet)

func (*ThumbnailError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a ThumbnailError instance

type ThumbnailFormat 

type ThumbnailFormat struct {
	dropbox.Tagged
}

ThumbnailFormat : has no documentation (yet)

type ThumbnailMode 

type ThumbnailMode struct {
	dropbox.Tagged
}

ThumbnailMode : has no documentation (yet)

type ThumbnailSize 

type ThumbnailSize struct {
	dropbox.Tagged
}

ThumbnailSize : has no documentation (yet)

type UploadAPIError 

type UploadAPIError struct {
	dropbox.APIError
	EndpointError *UploadError `json:"error"`
}

UploadAPIError is an error-wrapper for the upload route

type UploadError 

type UploadError struct {
	dropbox.Tagged
	// Path : Unable to save the uploaded contents to a file.
	Path *UploadWriteFailed `json:"path,omitempty"`
	// PropertiesError : The supplied property group is invalid. The file has
	// uploaded without property groups.
	PropertiesError *file_properties.InvalidPropertyGroupError `json:"properties_error,omitempty"`
}

UploadError : has no documentation (yet)

func (*UploadError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadError instance

type UploadErrorWithProperties 

type UploadErrorWithProperties struct {
	dropbox.Tagged
	// Path : Unable to save the uploaded contents to a file.
	Path *UploadWriteFailed `json:"path,omitempty"`
	// PropertiesError : The supplied property group is invalid. The file has
	// uploaded without property groups.
	PropertiesError *file_properties.InvalidPropertyGroupError `json:"properties_error,omitempty"`
}

UploadErrorWithProperties : has no documentation (yet)

func (*UploadErrorWithProperties) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadErrorWithProperties instance

type UploadSessionAppendAPIError 

type UploadSessionAppendAPIError struct {
	dropbox.APIError
	EndpointError *UploadSessionLookupError `json:"error"`
}

UploadSessionAppendAPIError is an error-wrapper for the upload_session/append route

type UploadSessionAppendArg 

type UploadSessionAppendArg struct {
	// Cursor : Contains the upload session ID and the offset.
	Cursor *UploadSessionCursor `json:"cursor"`
	// Close : If true, the current session will be closed, at which point you
	// won't be able to call `uploadSessionAppend` anymore with the current
	// session.
	Close bool `json:"close"`
}

UploadSessionAppendArg : has no documentation (yet)

func NewUploadSessionAppendArg 

func NewUploadSessionAppendArg(Cursor *UploadSessionCursor) *UploadSessionAppendArg

NewUploadSessionAppendArg returns a new UploadSessionAppendArg instance

type UploadSessionAppendV2APIError 

type UploadSessionAppendV2APIError struct {
	dropbox.APIError
	EndpointError *UploadSessionLookupError `json:"error"`
}

UploadSessionAppendV2APIError is an error-wrapper for the upload_session/append route

type UploadSessionCursor 

type UploadSessionCursor struct {
	// SessionId : The upload session ID (returned by `uploadSessionStart`).
	SessionId string `json:"session_id"`
	// Offset : The amount of data that has been uploaded so far. We use this to
	// make sure upload data isn't lost or duplicated in the event of a network
	// error.
	Offset uint64 `json:"offset"`
}

UploadSessionCursor : has no documentation (yet)

func NewUploadSessionCursor 

func NewUploadSessionCursor(SessionId string, Offset uint64) *UploadSessionCursor

NewUploadSessionCursor returns a new UploadSessionCursor instance

type UploadSessionFinishAPIError 

type UploadSessionFinishAPIError struct {
	dropbox.APIError
	EndpointError *UploadSessionFinishError `json:"error"`
}

UploadSessionFinishAPIError is an error-wrapper for the upload_session/finish route

type UploadSessionFinishArg 

type UploadSessionFinishArg struct {
	// Cursor : Contains the upload session ID and the offset.
	Cursor *UploadSessionCursor `json:"cursor"`
	// Commit : Contains the path and other optional modifiers for the commit.
	Commit *CommitInfo `json:"commit"`
}

UploadSessionFinishArg : has no documentation (yet)

func NewUploadSessionFinishArg 

func NewUploadSessionFinishArg(Cursor *UploadSessionCursor, Commit *CommitInfo) *UploadSessionFinishArg

NewUploadSessionFinishArg returns a new UploadSessionFinishArg instance

type UploadSessionFinishBatchAPIError 

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

UploadSessionFinishBatchAPIError is an error-wrapper for the upload_session/finish_batch route

type UploadSessionFinishBatchArg 

type UploadSessionFinishBatchArg struct {
	// Entries : Commit information for each file in the batch.
	Entries []*UploadSessionFinishArg `json:"entries"`
}

UploadSessionFinishBatchArg : has no documentation (yet)

func NewUploadSessionFinishBatchArg 

func NewUploadSessionFinishBatchArg(Entries []*UploadSessionFinishArg) *UploadSessionFinishBatchArg

NewUploadSessionFinishBatchArg returns a new UploadSessionFinishBatchArg instance

type UploadSessionFinishBatchCheckAPIError 

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

UploadSessionFinishBatchCheckAPIError is an error-wrapper for the upload_session/finish_batch/check route

type UploadSessionFinishBatchJobStatus 

type UploadSessionFinishBatchJobStatus struct {
	dropbox.Tagged
	// Complete : The `uploadSessionFinishBatch` has finished.
	Complete *UploadSessionFinishBatchResult `json:"complete,omitempty"`
}

UploadSessionFinishBatchJobStatus : has no documentation (yet)

func (*UploadSessionFinishBatchJobStatus) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadSessionFinishBatchJobStatus instance

type UploadSessionFinishBatchLaunch 

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

UploadSessionFinishBatchLaunch : Result returned by `uploadSessionFinishBatch` that may either launch an asynchronous job or complete synchronously.

func (*UploadSessionFinishBatchLaunch) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadSessionFinishBatchLaunch instance

type UploadSessionFinishBatchResult 

type UploadSessionFinishBatchResult struct {
	// Entries : Each entry in `UploadSessionFinishBatchArg.entries` will appear
	// at the same position inside `UploadSessionFinishBatchResult.entries`.
	Entries []*UploadSessionFinishBatchResultEntry `json:"entries"`
}

UploadSessionFinishBatchResult : has no documentation (yet)

func NewUploadSessionFinishBatchResult 

func NewUploadSessionFinishBatchResult(Entries []*UploadSessionFinishBatchResultEntry) *UploadSessionFinishBatchResult

NewUploadSessionFinishBatchResult returns a new UploadSessionFinishBatchResult instance

type UploadSessionFinishBatchResultEntry 

type UploadSessionFinishBatchResultEntry struct {
	dropbox.Tagged
	// Success : has no documentation (yet)
	Success *FileMetadata `json:"success,omitempty"`
	// Failure : has no documentation (yet)
	Failure *UploadSessionFinishError `json:"failure,omitempty"`
}

UploadSessionFinishBatchResultEntry : has no documentation (yet)

func (*UploadSessionFinishBatchResultEntry) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadSessionFinishBatchResultEntry instance

type UploadSessionFinishError 

type UploadSessionFinishError struct {
	dropbox.Tagged
	// LookupFailed : The session arguments are incorrect; the value explains
	// the reason.
	LookupFailed *UploadSessionLookupError `json:"lookup_failed,omitempty"`
	// Path : Unable to save the uploaded contents to a file. Data has already
	// been appended to the upload session. Please retry with empty data body
	// and updated offset.
	Path *WriteError `json:"path,omitempty"`
	// PropertiesError : The supplied property group is invalid. The file has
	// uploaded without property groups.
	PropertiesError *file_properties.InvalidPropertyGroupError `json:"properties_error,omitempty"`
}

UploadSessionFinishError : has no documentation (yet)

func (*UploadSessionFinishError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadSessionFinishError instance

type UploadSessionLookupError 

type UploadSessionLookupError struct {
	dropbox.Tagged
	// IncorrectOffset : The specified offset was incorrect. See the value for
	// the correct offset. This error may occur when a previous request was
	// received and processed successfully but the client did not receive the
	// response, e.g. due to a network error.
	IncorrectOffset *UploadSessionOffsetError `json:"incorrect_offset,omitempty"`
}

UploadSessionLookupError : has no documentation (yet)

func (*UploadSessionLookupError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a UploadSessionLookupError instance

type UploadSessionOffsetError 

type UploadSessionOffsetError struct {
	// CorrectOffset : The offset up to which data has been collected.
	CorrectOffset uint64 `json:"correct_offset"`
}

UploadSessionOffsetError : has no documentation (yet)

func NewUploadSessionOffsetError 

func NewUploadSessionOffsetError(CorrectOffset uint64) *UploadSessionOffsetError

NewUploadSessionOffsetError returns a new UploadSessionOffsetError instance

type UploadSessionStartAPIError 

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

UploadSessionStartAPIError is an error-wrapper for the upload_session/start route

type UploadSessionStartArg 

type UploadSessionStartArg struct {
	// Close : If true, the current session will be closed, at which point you
	// won't be able to call `uploadSessionAppend` anymore with the current
	// session.
	Close bool `json:"close"`
}

UploadSessionStartArg : has no documentation (yet)

func NewUploadSessionStartArg 

func NewUploadSessionStartArg() *UploadSessionStartArg

NewUploadSessionStartArg returns a new UploadSessionStartArg instance

type UploadSessionStartResult 

type UploadSessionStartResult struct {
	// SessionId : A unique identifier for the upload session. Pass this to
	// `uploadSessionAppend` and `uploadSessionFinish`.
	SessionId string `json:"session_id"`
}

UploadSessionStartResult : has no documentation (yet)

func NewUploadSessionStartResult 

func NewUploadSessionStartResult(SessionId string) *UploadSessionStartResult

NewUploadSessionStartResult returns a new UploadSessionStartResult instance

type UploadWriteFailed 

type UploadWriteFailed struct {
	// Reason : The reason why the file couldn't be saved.
	Reason *WriteError `json:"reason"`
	// UploadSessionId : The upload session ID; data has already been uploaded
	// to the corresponding upload session and this ID may be used to retry the
	// commit with `uploadSessionFinish`.
	UploadSessionId string `json:"upload_session_id"`
}

UploadWriteFailed : has no documentation (yet)

func NewUploadWriteFailed 

func NewUploadWriteFailed(Reason *WriteError, UploadSessionId string) *UploadWriteFailed

NewUploadWriteFailed returns a new UploadWriteFailed instance

type VideoMetadata 

type VideoMetadata struct {
	MediaMetadata
	// Duration : The duration of the video in milliseconds.
	Duration uint64 `json:"duration,omitempty"`
}

VideoMetadata : Metadata for a video.

func NewVideoMetadata 

func NewVideoMetadata() *VideoMetadata

NewVideoMetadata returns a new VideoMetadata instance

type WriteConflictError 

type WriteConflictError struct {
	dropbox.Tagged
}

WriteConflictError : has no documentation (yet)

type WriteError 

type WriteError struct {
	dropbox.Tagged
	// MalformedPath : The given path does not satisfy the required path format.
	// Please refer to the `Path formats documentation`
	// <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>
	// for more information.
	MalformedPath string `json:"malformed_path,omitempty"`
	// Conflict : Couldn't write to the target path because there was something
	// in the way.
	Conflict *WriteConflictError `json:"conflict,omitempty"`
}

WriteError : has no documentation (yet)

func (*WriteError) UnmarshalJSON 

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

UnmarshalJSON deserializes into a WriteError instance

type WriteMode 

type WriteMode struct {
	dropbox.Tagged
	// Update : Overwrite if the given "rev" matches the existing file's "rev".
	// The autorename strategy is to append the string "conflicted copy" to the
	// file name. For example, "document.txt" might become "document (conflicted
	// copy).txt" or "document (Panda's conflicted copy).txt".
	Update string `json:"update,omitempty"`
}

WriteMode : Your intent when writing a file to some path. This is used to determine what constitutes a conflict and what the autorename strategy is. In some situations, the conflict behavior is identical: (a) If the target path doesn't refer to anything, the file is always written; no conflict. (b) If the target path refers to a folder, it's always a conflict. (c) If the target path refers to a file with identical contents, nothing gets written; no conflict. The conflict checking differs in the case where there's a file at the target path with contents different from the contents you're trying to write.

func (*WriteMode) UnmarshalJSON 

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

UnmarshalJSON deserializes into a WriteMode instance

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.