api

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

type EmailGetModel struct {
	Email string `json:'email'`
}

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

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

type EmailVerifyPostModel struct {
	Email string `json:"email"`
}

type EmailVerifyPutModel struct {
	Secret string `json:"secret"`
}

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

type Emailer struct {
	Auth smtp.Auth

	// The SMTP server to use (with port)
	Server string

	// The service's domain name. E.g., 'example.com'
	Domain string

	// EmailVerificationTemplate may contain the following substrings:
	// '{{secret}}' -- replaced with the verification secret
	// '{{name}}' -- replaced with the user's name
	// '{{domain}}' -- replaced with the domain name
	EmailVerificationTemplate []byte

	// PasswordRecoveryTemplate may contain the following substrings:
	// '{{secret}}' -- replaced with the verification secret
	// '{{name}}' -- replaced with the user's name
	// '{{domain}}' -- replaced with the domain name
	PasswordRecoveryTemplate []byte
}

type EmailerModel interface {
	// Send an email with a secret key to verify that the email exists and is
	// valid.
	SendEmailVerification(email string, name, secret []byte) error
	// Send a password recovery email to reset an account's password.
	SendPasswordRecovery(email string, name, secret []byte) error
}

type Endpoint struct {
	Path    string
	Methods []string
	// The handler is the function that turns the HTTP request into a struct or
	// other data type to be passed to the processors.
	Handler Handler
	// Processors are executed in sequence, passing the output of the one into
	// the input of the next one, starting with the output returned from the
	// handler. Processors can validate input, make database calls, etc.
	Processors []Processor
	// The writer takes the output of the last processor and turns it into a byte
	// array to return to the client.
	Writer Writer
}

type Handler func(*http.Request) (interface{}, *HttpError)

type HttpError struct {
	Message string
	Status  int
}

type JsonHandler struct {
	// The target interface to fit JSON into. Pass in a factory function
	// which creates a new empty struct pointer to fill with values.
	Target func() interface{}
}

type JsonHandlerWithAuth struct {
	Target      func() interface{}
	User        int
	Permissions PermissionSet
	// contains filtered or unexported fields
}

type NotificationModel struct {
	ID         int                 `json:"id" db:"id"`
	Issued     time.Time           `json:"issued" db:"issued"`
	Read       *NullTime           `json:"read" db:"read"`
	Dismissed  *NullTime           `json:"dismissed" db:"dismissed"`
	Type       string              `json:"type" db:"type"`
	Parameters *types.NullJSONText `json:"parameters" db:"parameters"`
}

type NotificationsGetModel struct {
}

type NotificationsPutModel struct {
	Notifications []int `json:"notifications"`
	Read          bool  `json:"read"`
	Dismissed     bool  `json:"dismissed"`
}

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

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

type NullTime pq.NullTime

type Password struct {
	User   int    `db:"user"`
	Method string `db:"method"`
	Hash   string `db:"hash"`
	Salt   string `db:"salt"`
}

type PasswordHasher struct {
	RandReader io.Reader
}

type PasswordPutModel struct {
	Old string `json:"old"`
	New string `json:"new"`
}

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

type PasswordRecoverPostModel struct {
	Email string `json:"email"`
}

type PasswordRecoverPutModel struct {
	Secret   string `json:"secret"`
	Password string `json:"password"`
}

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

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

type PermissionSet []string

type Processor func(interface{}) (interface{}, *HttpError)

type Profile struct {
	Id           int    `json:"-" `
	Bio          string `json:"bio" db:"bio"`
	Organization string `json:"organization" db:"organization"`
	Location     string `json:"location" db:"location"`
	Website      string `json:"website" db:"website"`
	Github       string `json:"github" db:"github"`
}

type Recaptcha struct {
	RecaptchaUrl    string
	RecaptchaSecret string
}

type RecaptchaModel interface {
	// Verify that the token sent from the user is valid with the app secret.
	Verify(token string) (bool, error)
}

type SecretGenerator struct {
	RandReader io.Reader
}

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

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

type SessionModel interface {
	GetUserId(string) (int, error)
	GetPermissions(string) (PermissionSet, error)
}

type SessionPostModel struct {
	Email    string `json:"email"`
	Password string `json:"password"`
}

type SessionPostResponse struct {
	User    int       `json:"user"`
	Secret  string    `json:"secret"`
	Expires time.Time `json:"expiration"`
}

type SessionPutModel struct {
	Secret string `json:"secret"`
}

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

type URLPathHandler struct {
	// The target interface to fit URL parameters into. Pass in a factory function
	// which creates a new empty struct pointer to fill with values.
	Target func() interface{}
}

type URLPathHandlerWithAuth struct {
	Target      func() interface{}
	User        int
	Permissions PermissionSet
	// contains filtered or unexported fields
}

type User struct {
	Id            int       `json:"id" db:"id"`
	Name          string    `json:"name" db:"name"`
	Email         string    `json:"-" db:"email"`
	Joined        time.Time `json:"joined" db:"joined"`
	PermissionSet string    `json:"permission_set" db:"permission_set"`

	Permissions PermissionSet `json:"permissions"`
	Profile     *Profile      `json:"profile"`
}

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

type UserIdSelectModel struct {
	Id string `json:'id'`
}

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

type UserPasswordPostModel struct {
	Name     string `json:'name'`
	Password string `json:'password'`
	Email    string `json:'email'`
	Captcha  string `json:'captcha'`
}

type Writer func(interface{}) ([]byte, *HttpError)