/**@class android.content.SyncResult
 implements android.os.Parcelable

@extends java.lang.Object

 This class is used to communicate the results of a sync operation to the SyncManager.
 Based on the values here the SyncManager will determine the disposition of the
 sync and whether or not a new sync operation needs to be scheduled in the future.

*/
var SyncResult = {

/** Used to indicate that the SyncAdapter is already performing a sync operation, though
 not necessarily for the requested account and authority and that it wasn't able to
 process this request. The SyncManager will reschedule the request to run later.
*/
syncAlreadyInProgress : "null",
/** Used to indicate that the SyncAdapter determined that it would need to issue
 too many delete operations to the server in order to satisfy the request
 (as defined by the SyncAdapter). The SyncManager will record
 that the sync request failed and will cause a System Notification to be created
 asking the user what they want to do about this. It will give the user a chance to
 choose between (1) go ahead even with those deletes, (2) revert the deletes,
 or (3) take no action. If the user decides (1) or (2) the SyncManager will issue another
 sync request with either {@link android.content.ContentResolver#SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS}
 or {@link android.content.ContentResolver#SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS} set in the extras.
 It is then up to the SyncAdapter to decide how to honor that request.
*/
tooManyDeletions : "null",
/** Used to indicate that the SyncAdapter experienced a hard error due to trying the same
 operation too many times (as defined by the SyncAdapter). The SyncManager will record
 that the sync request failed and it will not reschedule the request.
*/
tooManyRetries : "null",
/** Used to indicate that the SyncAdapter experienced a hard error due to an error it
 received from interacting with the storage layer. The SyncManager will record that
 the sync request failed and it will not reschedule the request.
*/
databaseError : "null",
/** If set the SyncManager will request an immediate sync with the same Account and authority
 (but empty extras Bundle) as was used in the sync request.
*/
fullSyncRequested : "null",
/** This field is ignored by the SyncManager.
*/
partialSyncUnavailable : "null",
/** This field is ignored by the SyncManager.
*/
moreRecordsToGet : "null",
/** Used to indicate to the SyncManager that future sync requests that match the request's
 Account and authority should be delayed at least this many seconds.
*/
delayUntil : "null",
/** Used to hold extras statistics about the sync operation. Some of these indicate that
 the sync request resulted in a hard or soft error, others are for purely informational
 purposes.
*/
stats : "null",
/** This instance of a SyncResult is returned by the SyncAdapter in response to a
 sync request when a sync is already underway. The SyncManager will reschedule the
 sync request to try again later.
*/
ALREADY_IN_PROGRESS : "null",
/***/
CREATOR : "null",
/**Convenience method for determining if the SyncResult indicates that a hard error
 occurred. See {@link #SyncResult}() for an explanation of what the SyncManager does
 when it sees a hard error.
 <p>
 A hard error is indicated when any of the following is true:
 <ul>
 <li> {@link android.content.SyncStats#numParseExceptions} > 0
 <li> {@link android.content.SyncStats#numConflictDetectedExceptions} > 0
 <li> {@link android.content.SyncStats#numAuthExceptions} > 0
 <li> {@link #tooManyDeletions}
 <li> {@link #tooManyRetries}
 <li> {@link #databaseError}
@return {Boolean} true if a hard error is indicated
*/
hasHardError : function(  ) {},

/**Convenience method for determining if the SyncResult indicates that a soft error
 occurred. See {@link #SyncResult}() for an explanation of what the SyncManager does
 when it sees a soft error.
 <p>
 A soft error is indicated when any of the following is true:
 <ul>
 <li> {@link android.content.SyncStats#numIoExceptions} > 0
 <li> {@link #syncAlreadyInProgress}
 </ul>
@return {Boolean} true if a soft error is indicated
*/
hasSoftError : function(  ) {},

/**A convenience method for determining of the SyncResult indicates that an error occurred.
@return {Boolean} true if either a soft or hard error occurred
*/
hasError : function(  ) {},

/**Convenience method for determining if the Sync should be rescheduled after failing for some
 reason.
@return {Boolean} true if the SyncManager should reschedule this sync.
*/
madeSomeProgress : function(  ) {},

/**Clears the SyncResult to a clean state. Throws an {@link UnsupportedOperationException}
 if this is called when {@link #syncAlreadyInProgress} is set.
*/
clear : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**
*/
toString : function(  ) {},

/**Generates a debugging string indicating the status.
 The string consist of a sequence of code letter followed by the count.
 Code letters are f - fullSyncRequested, r - partialSyncUnavailable,
 X - hardError, e - numParseExceptions, c - numConflictDetectedExceptions,
 a - numAuthExceptions, D - tooManyDeletions, R - tooManyRetries,
 b - databaseError, x - softError, l - syncAlreadyInProgress,
 I - numIoExceptions
@return {String} debugging string.
*/
toDebugString : function(  ) {},


};