const (
    StatusMulti               = 207
    StatusUnprocessableEntity = 422
    StatusLocked              = 423
    StatusFailedDependency    = 424
    StatusInsufficientStorage = 507
)

var (
    // ErrConfirmationFailed is returned by a LockSystem's Confirm method.
    ErrConfirmationFailed = errors.New("webdav: confirmation failed")
    // ErrForbidden is returned by a LockSystem's Unlock method.
    ErrForbidden = errors.New("webdav: forbidden")
    // ErrLocked is returned by a LockSystem's Create, Refresh and Unlock methods.
    ErrLocked = errors.New("webdav: locked")
    // ErrNoSuchLock is returned by a LockSystem's Refresh and Unlock methods.
    ErrNoSuchLock = errors.New("webdav: no such lock")
)

type Condition struct {
    Not   bool
    Token string
    ETag  string
}

type DeadPropsHolder interface {
    // DeadProps returns a copy of the dead properties held.
    DeadProps() (map[xml.Name]Property, error)

    // Patch patches the dead properties held.
    //
    // Patching is atomic; either all or no patches succeed. It returns (nil,
    // non-nil) if an internal server error occurred, otherwise the Propstats
    // collectively contain one Property for each proposed patch Property. If
    // all patches succeed, Patch returns a slice of length one and a Propstat
    // element with a 200 OK HTTP status code. If none succeed, for reasons
    // other than an internal server error, no Propstat has status 200 OK.
    //
    // For more details on when various HTTP status codes apply, see
    // http://www.webdav.org/specs/rfc4918.html#PROPPATCH-status
    Patch([]Proppatch) ([]Propstat, error)
}

type Dir string

type File interface {
    http.File
    io.Writer
}

type FileSystem interface {
    Mkdir(name string, perm os.FileMode) error
    OpenFile(name string, flag int, perm os.FileMode) (File, error)
    RemoveAll(name string) error
    Rename(oldName, newName string) error
    Stat(name string) (os.FileInfo, error)
}

type Handler struct {
    // Prefix is the URL path prefix to strip from WebDAV resource paths.
    Prefix string
    // FileSystem is the virtual file system.
    FileSystem FileSystem
    // LockSystem is the lock management system.
    LockSystem LockSystem
    // Logger is an optional error logger. If non-nil, it will be called
    // for all HTTP requests.
    Logger func(*http.Request, error)
}

type LockDetails struct {
    // Root is the root resource name being locked. For a zero-depth lock, the
    // root is the only resource being locked.
    Root string
    // Duration is the lock timeout. A negative duration means infinite.
    Duration time.Duration
    // OwnerXML is the verbatim <owner> XML given in a LOCK HTTP request.
    //
    // TODO: does the "verbatim" nature play well with XML namespaces?
    // Does the OwnerXML field need to have more structure? See
    // https://codereview.appspot.com/175140043/#msg2
    OwnerXML string
    // ZeroDepth is whether the lock has zero depth. If it does not have zero
    // depth, it has infinite depth.
    ZeroDepth bool
}

type LockSystem interface {
    // Confirm confirms that the caller can claim all of the locks specified by
    // the given conditions, and that holding the union of all of those locks
    // gives exclusive access to all of the named resources. Up to two resources
    // can be named. Empty names are ignored.
    //
    // Exactly one of release and err will be non-nil. If release is non-nil,
    // all of the requested locks are held until release is called. Calling
    // release does not unlock the lock, in the WebDAV UNLOCK sense, but once
    // Confirm has confirmed that a lock claim is valid, that lock cannot be
    // Confirmed again until it has been released.
    //
    // If Confirm returns ErrConfirmationFailed then the Handler will continue
    // to try any other set of locks presented (a WebDAV HTTP request can
    // present more than one set of locks). If it returns any other non-nil
    // error, the Handler will write a "500 Internal Server Error" HTTP status.
    Confirm(now time.Time, name0, name1 string, conditions ...Condition) (release func(), err error)

    // Create creates a lock with the given depth, duration, owner and root
    // (name). The depth will either be negative (meaning infinite) or zero.
    //
    // If Create returns ErrLocked then the Handler will write a "423 Locked"
    // HTTP status. If it returns any other non-nil error, the Handler will
    // write a "500 Internal Server Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
    // when to use each error.
    //
    // The token returned identifies the created lock. It should be an absolute
    // URI as defined by RFC 3986, Section 4.3. In particular, it should not
    // contain whitespace.
    Create(now time.Time, details LockDetails) (token string, err error)

    // Refresh refreshes the lock with the given token.
    //
    // If Refresh returns ErrLocked then the Handler will write a "423 Locked"
    // HTTP Status. If Refresh returns ErrNoSuchLock then the Handler will write
    // a "412 Precondition Failed" HTTP Status. If it returns any other non-nil
    // error, the Handler will write a "500 Internal Server Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
    // when to use each error.
    Refresh(now time.Time, token string, duration time.Duration) (LockDetails, error)

    // Unlock unlocks the lock with the given token.
    //
    // If Unlock returns ErrForbidden then the Handler will write a "403
    // Forbidden" HTTP Status. If Unlock returns ErrLocked then the Handler
    // will write a "423 Locked" HTTP status. If Unlock returns ErrNoSuchLock
    // then the Handler will write a "409 Conflict" HTTP Status. If it returns
    // any other non-nil error, the Handler will write a "500 Internal Server
    // Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.11.1 for
    // when to use each error.
    Unlock(now time.Time, token string) error
}

type Property struct {
    // XMLName is the fully qualified name that identifies this property.
    XMLName xml.Name

    // Lang is an optional xml:lang attribute.
    Lang string `xml:"xml:lang,attr,omitempty"`

    // InnerXML contains the XML representation of the property value.
    // See http://www.webdav.org/specs/rfc4918.html#property_values
    //
    // Property values of complex type or mixed-content must have fully
    // expanded XML namespaces or be self-contained with according
    // XML namespace declarations. They must not rely on any XML
    // namespace declarations within the scope of the XML document,
    // even including the DAV: namespace.
    InnerXML []byte `xml:",innerxml"`
}

type Proppatch struct {
    // Remove specifies whether this patch removes properties. If it does not
    // remove them, it sets them.
    Remove bool
    // Props contains the properties to be set or removed.
    Props []Property
}

type Propstat struct {
    // Props contains the properties for which Status applies.
    Props []Property

    // Status defines the HTTP status code of the properties in Prop.
    // Allowed values include, but are not limited to the WebDAV status
    // code extensions for HTTP/1.1.
    // http://www.webdav.org/specs/rfc4918.html#status.code.extensions.to.http11
    Status int

    // XMLError contains the XML representation of the optional error element.
    // XML content within this field must not rely on any predefined
    // namespace declarations or prefixes. If empty, the XML error element
    // is omitted.
    XMLError string

    // ResponseDescription contains the contents of the optional
    // responsedescription field. If empty, the XML element is omitted.
    ResponseDescription string
}