cloudy

type AfterInterceptor[T any] interface {
	AfterAction(ctx context.Context, item *T) (*T, error)
}

type Attachment struct {
	Name   string
	Path   string
	Data   []byte
	Reader io.Reader
}

type BeforeInterceptor[T any] interface {
	BeforeAction(ctx context.Context, item *T) (*T, error)
}

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

type CachedEnvironment struct {
	Source EnvironmentService
	// contains filtered or unexported fields
}

type DuplicateUserMode int

type Email struct {
	To      []string
	CC      []string
	BCC     []string
	From    string
	Body    string
	HTML    bool
	Subject string

	Attachments []Attachment
}

type Emailer interface {
	Send(ctx context.Context, message *gomail.Message) error
}

type Environment struct {
	EnvSvc EnvironmentService
}

type EnvironmentService interface {
	Get(name string) (string, error)
}

type FirstDotLastUsernameStrategy struct{}

type FirstInitialLastUsernameStrategy struct{}

type GroupManager interface {

	// List all the groups available
	ListGroups(ctx context.Context) ([]*models.Group, error)

	// Get a specific group by id
	GetGroup(ctx context.Context, id string) (*models.Group, error)

	// Get all the groups for a single user
	GetUserGroups(ctx context.Context, uid string) ([]*models.Group, error)

	// Create a new Group
	NewGroup(ctx context.Context, grp *models.Group) (*models.Group, error)

	// Update a group. This is generally just the name of the group.
	UpdateGroup(ctx context.Context, grp *models.Group) (bool, error)

	// Get all the members of a group. This returns partial users only,
	// typically just the user id, name and email fields
	GetGroupMembers(ctx context.Context, grpId string) ([]*models.User, error)

	// Remove members from a group
	RemoveMembers(ctx context.Context, groupId string, userIds []string) error

	// Add member(s) to a group
	AddMembers(ctx context.Context, groupId string, userIds []string) error

	DeleteGroup(ctx context.Context, groupId string) error
}

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

type Logs struct {
	Info   *log.Logger
	Warn   *log.Logger
	Error  *log.Logger
	Buffer *bytes.Buffer
}

type Mailer struct {
	Before  []BeforeInterceptor[Email]
	After   []AfterInterceptor[Email]
	Emailer Emailer
}

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

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

type PasswordOptions struct {
	Length int

	MinUpperCase   int
	MinNum         int
	MinSpecialChar int

	HasUpperCase   bool
	HasNum         bool
	HasSpecialChar bool
}

type ProviderFactory[T any] interface {
	Create(cfg interface{}) (T, error)
	FromEnv(env *Environment) (interface{}, error)
}

type ProvidersRegistry[T any] struct {
	Providers map[string]ProviderFactory[T]
}

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

type Storage interface {
}

type SystemEnvironmentVariables struct{}

type SystemEnvironmentVariablesFactory struct{}

type TemplatedEmail struct {
	Email
	BodyTemplate    *template.Template
	SubjectTemplate *template.Template
	InlineStyles    bool
}

type TestEnvFileFactory struct{}

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

type UserJWT struct {
	EXP               int64                  `json:"exp"`
	IAT               int64                  `json:"iat"`
	AuthTime          int64                  `json:"auth_time"`
	JTI               string                 `json:"jti"`
	ISS               string                 `json:"iss"`
	AUD               string                 `json:"aud"`
	TYP               string                 `json:"typ"`
	AZP               string                 `json:"azp"`
	Nonce             string                 `json:"nonce"`
	SessionState      string                 `json:"session_state"`
	ACR               string                 `json:"acr"`
	AllowedOrigins    []string               `json:"allowed-origins"`
	RealmAccess       *UserJWTRealmAccess    `json:"realm_access"`
	ResourceAccess    *UserJWTResourceAccess `json:"resource_access"`
	Scope             string                 `json:"scope"`
	EmailVerified     bool                   `json:"email_verified"`
	Name              string                 `json:"name"`
	PreferredUserName string                 `json:"preferred_username"`
	GivenName         string                 `json:"given_name"`
	FamilyName        string                 `json:"family_name"`
	Email             string                 `json:"email"`
	UPN               string                 `json:"upn"`
	Groups            []string               `json:"groups"`
}

type UserJWTRealmAccess struct {
	Roles []string `json:"roles"`
}

type UserJWTResourceAccess struct {
	Account *UserJWTResourceAccessAccount `json:"account"`
}

type UserJWTResourceAccessAccount struct {
	Roles []string `json:"roles"`
}

type UserManager interface {
	// ForceUserName takes a proposed user name, validates it and transforms it.
	// Then it checks to see if it is a real user
	// Returns: string - updated user name, bool - if the user exists, error - if an error is encountered
	ForceUserName(ctx context.Context, name string) (string, bool, error)

	ListUsers(ctx context.Context, page interface{}, filter interface{}) ([]*models.User, interface{}, error)

	// Retrieves a specific user.
	GetUser(ctx context.Context, uid string) (*models.User, error)

	// NewUser creates a new user with the given information and returns the new user with any additional
	// fields populated
	NewUser(ctx context.Context, newUser *models.User) (*models.User, error)

	UpdateUser(ctx context.Context, usr *models.User) error

	Enable(ctx context.Context, uid string) error

	Disable(ctx context.Context, uid string) error

	DeleteUser(ctx context.Context, uid string) error
}

type UsernameStrategy interface {
	// GuessUsername provides the best username for a given user object. The pattern should contain
	GuessUsername(ctx context.Context, user *models.User, mode DuplicateUserMode, manager UserManager) (string, error)
}