wonderwall

type Action struct {
	Action   string `json:"action"`
	Node     Node   `json:"node"`
	Original *Node  `json:"original"`
}

type CollabConfig struct {
	Debug     bool
	Workers   int
	Queue     int
	IOTimeout time.Duration
}

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

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

type Config struct {
	Debug  bool
	Store  StoreConfig
	Server ServerConfig
	Email  EmailConfig
}

type CreateRegistration interface {
	CreateRegistration(*Txn, Email, Password) (*Registration, error)
}

type CreateSession interface {
	CreateSession(*Txn, string) (*Session, error)
}

type CreateUser interface{ CreateUser(*Txn, *User) error }

type CreateWall interface {
	CreateWall(*Txn, string, Key) (*Wall, error)
}

type DeleteUser interface{ DeleteUser(*Txn, *User) error }

type DeleteWall interface{ DeleteWall(*Txn, *Wall) error }

type Email string

type EmailClient struct {
	Conf      EmailConfig
	SendMail  SendMailFunc
	Templates map[string]template.Template
}

type EmailConfig struct {
	SenderAddr string
	Username   string
	Password   string
	ServerHost string
	ServerPort string
	Origin     string
}

type EmailForm struct{ Email Email }

type Error struct {
	ID    int    `json:"id"`
	Error Object `json:"error"`
}

type ErrorResult struct {
	Message string
}

type FindRegistrationByEmail interface {
	FindRegistrationByEmail(*Txn, Email) (*Registration, error)
}

type FindRegistrationByID interface {
	FindRegistrationByID(*Txn, Token) (*Registration, error)
}

type FindUserByEmail interface {
	FindUserByEmail(*Txn, Email) (*User, error)
}

type FindUserById interface {
	FindUserById(*Txn, xid.ID) (*User, error)
}

type FindWallById interface {
	FindWallById(*Txn, xid.ID) (*Wall, error)
}

type ForgotPasswordForm struct {
	Email Email `json:"email"`
}

type Index struct{ Primary, Secondary Key }

type JsonResult struct{}

type Key []byte

type LogConfig struct {
}

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

type Node struct {
	ID        string
	ClassName string                 `json:"className"`
	Attrs     map[string]interface{} `json:"attrs"`
}

type Object map[string]interface{}

type Password string

type PasswordForm struct {
	Password Password
}

type PasswordHash []byte

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

type RawResult struct{}

type Readable interface{ Deserialize([]byte) error }

type Registration struct {
	ID           Token
	Email        Email
	PasswordHash PasswordHash
	CreatedAt    time.Time
	VerifiedAt   *time.Time
}

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

type RegistrationService interface {
	CreateUser
	FindRegistrationByID
	FindRegistrationByEmail
}

type Registrations struct{ DB *Store }

type Request struct {
	ID     int    `json:"id"`
	Method string `json:"method"`
	Params Object `json:"params"`
}

type Response struct {
	ID     int    `json:"id"`
	Result Object `json:"result"`
}

type Result interface {
	MarshalJSON() ([]byte, error)
	ContentType() string
}

type Result2 struct {
	Result   []interface{}
	Previous *string
	Next     *string
	Error    error `json:"error"`
}

type SendEmail interface {
	SendEmail(name string, email Email, i interface{}) error
}

type SendMailFunc func(string, smtp.Auth, string, []string, []byte) error

type ServerConfig struct {
	Addr string
}

type Session struct {
	ID        Token
	UserID    string
	CreatedAt time.Time
}

type Sessions struct{}

type State struct {
	Image *[]Node `json:"image"`
	Text  *[]Node `json:"text"`
	Pen   *[]Node `json:"pen"`
}

type Store struct {
	*badger.DB
	Index bleve.Index
}

type StoreConfig struct {
	Path       string
	InMemoryDB bool
}

type Token []byte

type Txn = badger.Txn

type UpdateWall interface{ UpdateWall(*Txn, *Wall) error }

type User struct {
	ID           xid.ID
	Email        Email
	PasswordHash PasswordHash
	Name         string
	Roles        []Role
}

type UserService interface {
	CreateUser
	DeleteUser
	FindUserById
	FindUserByEmail
}

type Users struct {
	DB *Store
}

type Verification struct{ Token Token }

type Wall struct {
	ID         xid.ID        `json:"id"`
	Title      string        `json:"title"`
	Owner      Key           `json:"owner"`
	CreatedAt  time.Time     `json:"createdAt"`
	ModifiedAt time.Time     `json:"modifiedAt"`
	AllowList  []Key         `json:"allowList"`
	Content    []interface{} `json:"content"`
}

type Walls struct {
	DB *Store
}

type Writable interface {
	Serialize() ([]byte, error)
	Key() Key
}