internal

type ActiveLock struct {
	XMLName   xml.Name   `xml:"DAV: activelock"`
	LockScope LockScope  `xml:"lockscope"`
	LockType  LockType   `xml:"locktype"`
	Depth     Depth      `xml:"depth"`
	Owner     *Owner     `xml:"owner,omitempty"`
	Timeout   *Timeout   `xml:"timeout,omitempty"`
	LockToken *LockToken `xml:"locktoken,omitempty"`
	LockRoot  LockRoot   `xml:"lockroot"`
}

type Backend interface {
	Options(r *http.Request) (caps []string, allow []string, err error)
	HeadGet(w http.ResponseWriter, r *http.Request) error
	PropFind(r *http.Request, pf *PropFind, depth Depth) (*MultiStatus, error)
	PropPatch(r *http.Request, pu *PropertyUpdate) (*Response, error)
	Put(w http.ResponseWriter, r *http.Request) error
	Delete(r *http.Request) error
	Mkcol(r *http.Request) error
	Copy(r *http.Request, dest *Href, recursive, overwrite bool) (created bool, err error)
	Move(r *http.Request, dest *Href, overwrite bool) (created bool, err error)
	Lock(r *http.Request, depth Depth, timeout time.Duration, refreshToken string) (lock *Lock, created bool, err error)
	Unlock(r *http.Request, tokenHref string) error
}

type Client struct {
	// contains filtered or unexported fields
}

type Condition struct {
	Resource string
	Not      bool
	Token    string
	ETag     string
}

type CurrentUserPrincipal struct {
	XMLName         xml.Name  `xml:"DAV: current-user-principal"`
	Href            Href      `xml:"href,omitempty"`
	Unauthenticated *struct{} `xml:"unauthenticated,omitempty"`
}

type Depth int

type DisplayName struct {
	XMLName xml.Name `xml:"DAV: displayname"`
	Name    string   `xml:",chardata"`
}

type ETag string

type Error struct {
	XMLName xml.Name      `xml:"DAV: error"`
	Raw     []RawXMLValue `xml:",any"`
}

type GetContentLength struct {
	XMLName xml.Name `xml:"DAV: getcontentlength"`
	Length  int64    `xml:",chardata"`
}

type GetContentType struct {
	XMLName xml.Name `xml:"DAV: getcontenttype"`
	Type    string   `xml:",chardata"`
}

type GetETag struct {
	XMLName xml.Name `xml:"DAV: getetag"`
	ETag    ETag     `xml:",chardata"`
}

type GetLastModified struct {
	XMLName      xml.Name `xml:"DAV: getlastmodified"`
	LastModified Time     `xml:",chardata"`
}

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
}

type HTTPError struct {
	Code int
	Err  error
}

type Handler struct {
	Backend Backend
}

type Href url.URL

type Include struct {
	XMLName xml.Name      `xml:"DAV: include"`
	Raw     []RawXMLValue `xml:",any"`
}

type Limit struct {
	XMLName  xml.Name `xml:"DAV: limit"`
	NResults uint     `xml:"nresults"`
}

type Location struct {
	XMLName xml.Name `xml:"DAV: location"`
	Href    Href     `xml:"href"`
}

type Lock struct {
	Href    string
	Root    string
	Timeout time.Duration
}

type LockDiscovery struct {
	XMLName    xml.Name     `xml:"DAV: lockdiscovery"`
	ActiveLock []ActiveLock `xml:"activelock,omitempty"`
}

type LockEntry struct {
	XMLName   xml.Name  `xml:"DAV: lockentry"`
	LockScope LockScope `xml:"lockscope"`
	LockType  LockType  `xml:"locktype"`
}

type LockInfo struct {
	XMLName   xml.Name  `xml:"DAV: lockinfo"`
	LockScope LockScope `xml:"lockscope"`
	LockType  LockType  `xml:"locktype"`
	Owner     *Owner    `xml:"owner,omitempty"`
}

type LockRoot struct {
	XMLName xml.Name `xml:"DAV: lockroot"`
	Href    string   `xml:"href"`
}

type LockScope struct {
	XMLName   xml.Name  `xml:"DAV: lockscope"`
	Exclusive *struct{} `xml:"exclusive"`
	Shared    *struct{} `xml:"shared"`
}

type LockToken struct {
	XMLName xml.Name `xml:"DAV: locktoken"`
	Href    string   `xml:"href"`
}

type LockType struct {
	XMLName xml.Name  `xml:"DAV: locktype"`
	Write   *struct{} `xml:"write"`
}

type MultiStatus struct {
	XMLName             xml.Name   `xml:"DAV: multistatus"`
	Responses           []Response `xml:"response"`
	ResponseDescription string     `xml:"responsedescription,omitempty"`
	SyncToken           string     `xml:"sync-token,omitempty"`
}

type Owner struct {
	XMLName xml.Name `xml:"DAV: owner"`
}

type Prop struct {
	XMLName xml.Name      `xml:"DAV: prop"`
	Raw     []RawXMLValue `xml:",any"`
}

type PropFind struct {
	XMLName  xml.Name  `xml:"DAV: propfind"`
	Prop     *Prop     `xml:"prop,omitempty"`
	AllProp  *struct{} `xml:"allprop,omitempty"`
	Include  *Include  `xml:"include,omitempty"`
	PropName *struct{} `xml:"propname,omitempty"`
}

type PropFindFunc func(raw *RawXMLValue) (interface{}, error)

type PropStat struct {
	XMLName             xml.Name `xml:"DAV: propstat"`
	Prop                Prop     `xml:"prop"`
	Status              Status   `xml:"status"`
	ResponseDescription string   `xml:"responsedescription,omitempty"`
	Error               *Error   `xml:"error,omitempty"`
}

type PropertyUpdate struct {
	XMLName xml.Name `xml:"DAV: propertyupdate"`
	Remove  []Remove `xml:"remove"`
	Set     []Set    `xml:"set"`
}

type RawXMLValue struct {
	// contains filtered or unexported fields
}

type Remove struct {
	XMLName xml.Name `xml:"DAV: remove"`
	Prop    Prop     `xml:"prop"`
}

type ResourceType struct {
	XMLName xml.Name      `xml:"DAV: resourcetype"`
	Raw     []RawXMLValue `xml:",any"`
}

type Response struct {
	XMLName             xml.Name   `xml:"DAV: response"`
	Hrefs               []Href     `xml:"href"`
	PropStats           []PropStat `xml:"propstat,omitempty"`
	ResponseDescription string     `xml:"responsedescription,omitempty"`
	Status              *Status    `xml:"status,omitempty"`
	Error               *Error     `xml:"error,omitempty"`
	Location            *Location  `xml:"location,omitempty"`
}

type Set struct {
	XMLName xml.Name `xml:"DAV: set"`
	Prop    Prop     `xml:"prop"`
}

type Status struct {
	Code int
	Text string
}

type SupportedLock struct {
	XMLName     xml.Name    `xml:"DAV: supportedlock"`
	LockEntries []LockEntry `xml:"lockentry"`
}

type SyncCollectionQuery struct {
	XMLName   xml.Name `xml:"DAV: sync-collection"`
	SyncToken string   `xml:"sync-token"`
	Limit     *Limit   `xml:"limit,omitempty"`
	SyncLevel string   `xml:"sync-level"`
	Prop      *Prop    `xml:"prop"`
}

type Time time.Time

type Timeout struct {
	Duration time.Duration
}