parse

type ACL interface {
	// Returns whether public read access is enabled on this ACL
	PublicReadAccess() bool

	// Returns whether public write access is enabled on this ACL
	PublicWriteAccess() bool

	// Returns whether read access is enabled on this ACL for the
	// given role
	RoleReadAccess(role string) bool

	// Returns whether write access is enabled on this ACL for the
	// given role
	RoleWriteAccess(role string) bool

	// Returns whether read access is enabled on this ACL for the
	// given user
	ReadAccess(userId string) bool

	// Returns whether write access is enabled on this ACL for the
	// given user
	WriteAccess(userId string) bool

	// Allow the object to which this ACL is attached be read
	// by anyone
	SetPublicReadAccess(allowed bool) ACL

	// Allow the object to which this ACL is attached to be
	// updated by anyone
	SetPublicWriteAccess(allowed bool) ACL

	// Allow the object to which this ACL is attached to be
	// read by the provided role
	SetRoleReadAccess(role string, allowed bool) ACL

	// Allow the object to which this ACL is attached to be
	// updated by the provided role
	SetRoleWriteAccess(role string, allowed bool) ACL

	// Allow the object to which this ACL is attached to be
	// read by the provided user
	SetReadAccess(userId string, allowed bool) ACL

	// Allow the object to which this ACL is attached to be
	// updated by the provided user
	SetWriteAccess(userId string, allowed bool) ACL
}

type AnonymousAuthData struct {
	Id string `json:"id"`
}

type AuthData struct {
	Twitter   *TwitterAuthData   `json:"twitter,omitempty"`
	Facebook  *FacebookAuthData  `json:"facebook,omitempty"`
	Anonymous *AnonymousAuthData `json:"anonymous,omitempty"`
}

type Base struct {
	Id        string                 `parse:"objectId"`
	CreatedAt time.Time              `parse:"-"`
	UpdatedAt time.Time              `parse:"-"`
	ACL       ACL                    `parse:"ACL,omitempty"`
	Extra     map[string]interface{} `parse:"-"`
}

type Config map[string]interface{}

type Date time.Time

type Error interface {
	error
	Code() int
	Message() string
	StatusCode() int
	RequestMethod() string
	RequestURL() string
	RequestHeaders() []string
	RequestBody() string
	ResponseBody() string
}

type FacebookAuthData struct {
	Id             string
	AccessToken    string    `parse:"access_token"`
	ExpirationDate time.Time `parse:"expiration_date"`
}

type File struct {
	Name string `json:"name"`
	Url  string `json:"url"`
}

type GeoPoint struct {
	Latitude  float64
	Longitude float64
}

type Installation struct {
	Base
	Badge          int      `parse:",omitempty"`
	Channels       []string `parse:",omitempty"`
	TimeZone       string
	DeviceType     string
	PushType       string `parse:",omitempty"`
	GCMSenderId    string `parse:",omitempty"`
	InstallationId string
	DeviceToken    string   `parse:",omitempty"`
	ChannelUris    []string `parse:",omitempty"`
	AppName        string
	AppVersion     string
	ParseVersion   string
	AppIdentifier  string
}

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

type Params map[string]interface{}

type Pointer struct {
	Id        string
	ClassName string
}

type PushNotification interface {
	// Set the query for advanced targeting
	//
	// use parse.NewPushQuery to create a new query
	Where(q Query) PushNotification

	// Set the channels to target
	Channels(c ...string) PushNotification

	// Specify a specific time to send this push
	PushTime(t time.Time) PushNotification

	// Set the time this push notification should expire if it can't be immediately sent
	ExpirationTime(t time.Time) PushNotification

	// Set the duration after which this push notification should expire if it can't be immediately sent
	ExpirationInterval(d time.Duration) PushNotification

	// Set the payload for this push notification
	Data(d map[string]interface{}) PushNotification

	// Send the push notification
	Send() error
}

type Query interface {

	// Use the Master Key for the given request.
	UseMasterKey() Query

	// Get retrieves the instance of the type pointed to by v and
	// identified by id, and stores the result in v.
	Get(id string) error

	// Set the sort order for the query. The first argument sets the primary
	// sort order. Subsequent arguments will set secondary sort orders. Results
	// will be sorted in ascending order by default. Prefix field names with a
	// '-' to sort in descending order. E.g.: q.OrderBy("-createdAt") will sort
	// by the createdAt field in descending order.
	OrderBy(fs ...string) Query

	// Set the number of results to retrieve
	Limit(l int) Query

	// Set the number of results to skip before returning any results
	Skip(s int) Query

	// Specify nested fields to retrieve within the primary object. Use
	// dot notation to retrieve further nested fields. E.g.:
	// q.Include("user") or q.Include("user.location")
	Include(fs ...string) Query

	// Only retrieve the specified fields
	Keys(fs ...string) Query

	// Add a constraint requiring the field specified by f be equal to the
	// value represented by v
	EqualTo(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f not be equal to the
	// value represented by v
	NotEqualTo(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f be greater than the
	// value represented by v
	GreaterThan(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f be greater than or
	// or equal to the value represented by v
	GreaterThanOrEqual(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f be less than the
	// value represented by v
	LessThan(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f be less than or
	// or equal to the value represented by v
	LessThanOrEqual(f string, v interface{}) Query

	// Add a constraint requiring the field specified by f be equal to one
	// of the values specified
	In(f string, vs ...interface{}) Query

	// Add a constraint requiring the field specified by f not be equal to any
	// of the values specified
	NotIn(f string, vs ...interface{}) Query

	// Add a constraint requiring returned objects contain the field specified by f
	Exists(f string) Query

	// Add a constraint requiring returned objects do not contain the field specified by f
	DoesNotExist(f string) Query

	// Add a constraint requiring the field specified by f contain all
	// of the values specified
	All(f string, vs ...interface{}) Query

	// Add a constraint requiring the string field specified by f contain
	// the substring specified by v
	Contains(f string, v string) Query

	// Add a constraint requiring the string field specified by f start with
	// the substring specified by v
	StartsWith(f string, v string) Query

	// Add a constraint requiring the string field specified by f end with
	// the substring specified by v
	EndsWith(f string, v string) Query

	// Add a constraint requiring the string field specified by f match the
	// regular expression v
	Matches(f string, v string, ignoreCase bool, multiLine bool) Query

	// Add a constraint requiring the location of GeoPoint field specified by f be
	// within the rectangular geographic bounding box with a southwest corner
	// represented by sw and a northeast corner represented by ne
	WithinGeoBox(f string, sw GeoPoint, ne GeoPoint) Query

	// Add a constraint requiring the location of GeoPoint field specified by f
	// be near the point represented by g
	Near(f string, g GeoPoint) Query

	// Add a constraint requiring the location of GeoPoint field specified by f
	// be near the point represented by g with a maximum distance in miles
	// represented by m
	WithinMiles(f string, g GeoPoint, m float64) Query

	// Add a constraint requiring the location of GeoPoint field specified by f
	// be near the point represented by g with a maximum distance in kilometers
	// represented by m
	WithinKilometers(f string, g GeoPoint, k float64) Query

	// Add a constraint requiring the location of GeoPoint field specified by f
	// be near the point represented by g with a maximum distance in radians
	// represented by m
	WithinRadians(f string, g GeoPoint, r float64) Query

	// Add a constraint requiring the value of the field specified by f be equal
	// to the field named qk in the result of the subquery sq
	MatchesKeyInQuery(f string, qk string, sq Query) Query

	// Add a constraint requiring the value of the field specified by f not match
	// the field named qk in the result of the subquery sq
	DoesNotMatchKeyInQuery(f string, qk string, sq Query) Query

	// Add a constraint requiring the field specified by f contain the object
	// returned by Parse query q
	MatchesQuery(f string, q Query) Query

	// Add a constraint requiring the field specified by f not contain the object
	// returned by the Parse query q
	DoesNotMatchQuery(f string, q Query) Query

	// Convenience method for duplicating a query
	Clone() Query

	// Convenience method for building a subquery for use with Query.Or
	Sub() Query

	// Constructs a query where each result must satisfy one of the given
	// subueries
	//
	// E.g.:
	//
	// q, _ := parse.NewQuery(&parse.User{})
	//
	// sq1 := q.Sub().EqualTo("city", "Chicago")
	//
	// sq2 := q.Sub().GreaterThan("age", 30)
	//
	// sq3 := q.Sub().In("occupation", []string{"engineer", "developer"})
	//
	// q.Or(sq1, sq2, sq3)
	// q.Each(...)
	Or(qs ...Query) Query

	// Fetch all results for a query, sending each result to the provided
	// channel rc. The element type of rc should match that of the query,
	// otherwise an error will be returned.
	//
	// Errors are passed to the channel ec. If an error occurns during iteration,
	// iteration will stop
	//
	// The third argument is a channel which may be used for cancelling
	// iteration. Simply send an empty struct value to the channel,
	// and iteration will discontinue. This argument may be nil.
	Each(rc interface{}) (*Iterator, error)

	SetBatchSize(size uint) Query

	// Retrieves a list of objects that satisfy the given query. The results
	// are assigned to the slice provided to NewQuery.
	//
	// E.g.:
	//
	// users := make([]parse.User)
	// q, _ := parse.NewQuery(&users)
	// q.EqualTo("city", "Chicago")
	// q.OrderBy("-createdAt")
	// q.Limit(20)
	// q.Find() // Retrieve the 20 newest users in Chicago
	Find() error

	// Retrieves the first result that satisfies the given query. The result
	// is assigned to the value provided to NewQuery.
	//
	// E.g.:
	// u := parse.User{}
	// q, _ := parse.NewQuery(&u)
	// q.EqualTo("city", "Chicago")
	// q.OrderBy("-createdAt")
	// q.First() // Retrieve the newest user in Chicago
	First() error

	// Retrieve the number of results that satisfy the given query
	Count() (int64, error)
	// contains filtered or unexported methods
}

type Session interface {
	User() interface{}
	NewQuery(v interface{}) (Query, error)
	NewUpdate(v interface{}) (Update, error)
	Create(v interface{}) error
	Delete(v interface{}) error
	CallFunction(name string, params Params, resp interface{}) error
}

type TwitterAuthData struct {
	Id              string `json:"id"`
	ScreenName      string `json:"screen_name" parse:"screen_name"`
	ConsumerKey     string `json:"consumer_key" parse:"consumer_key"`
	ConsumerSecret  string `json:"consumer_secret" parse:"consumer_secret"`
	AuthToken       string `json:"auth_token" parse:"auth_token"`
	AuthTokenSecret string `json:"auth_token_secret" parse:"auth_token_secret"`
}

type Update interface {

	//Set the field specified by f to the value of v
	Set(f string, v interface{}) Update

	// Increment the field specified by f by the amount specified by v.
	// v should be a numeric type
	Increment(f string, v interface{}) Update

	// Delete the field specified by f from the instance being updated
	Delete(f string) Update

	// Append the values provided to the Array field specified by f. This operation
	// is atomic
	Add(f string, vs ...interface{}) Update

	// Add any values provided that were not alread present to the Array field
	// specified by f. This operation is atomic
	AddUnique(f string, vs ...interface{}) Update

	// Remove the provided values from the array field specified by f
	Remove(f string, vs ...interface{}) Update

	// Update the ACL on the given object
	SetACL(a ACL) Update

	// Use the Master Key for this update request
	UseMasterKey() Update

	// Execute this update. This method also updates the proper fields
	// on the provided value with their repective new values
	Execute() error
	// contains filtered or unexported methods
}

type User struct {
	Base
	Username      string
	Email         string
	EmailVerified bool `json:"-" parse:"-"`
}