security

type AllDataScope struct{}

type AuthManager interface {
	// Authenticate finds a suitable authenticator and validates the credentials.
	Authenticate(ctx context.Context, authentication Authentication) (*Principal, error)
}

type AuthTokens struct {
	AccessToken  string `json:"accessToken"`
	RefreshToken string `json:"refreshToken"`
}

type Authentication struct {
	Type        string `json:"type"`
	Principal   string `json:"principal"`
	Credentials any    `json:"credentials"`
}

type Authenticator interface {
	// Supports returns true if this authenticator can handle the given authentication type.
	Supports(authType string) bool
	// Authenticate validates the credentials and returns the authenticated Principal.
	Authenticate(ctx context.Context, authentication Authentication) (*Principal, error)
}

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

type ChallengeProvider interface {
	// Type returns the unique challenge type identifier (e.g. "totp", "select_department").
	Type() string
	// Order returns the evaluation priority. Lower values are evaluated first.
	Order() int
	// Evaluate checks whether this challenge applies to the given principal.
	// Return nil to indicate the challenge is not needed.
	Evaluate(ctx context.Context, principal *Principal) (*LoginChallenge, error)
	// Resolve validates the user's response and returns an optionally updated Principal.
	Resolve(ctx context.Context, principal *Principal, response any) (*Principal, error)
}

type ChallengeState struct {
	Principal *Principal
	Pending   []string
	Resolved  []string
}

type ChallengeTokenStore interface {
	// Generate creates a challenge token encoding the principal and challenge state.
	Generate(principal *Principal, pending, resolved []string) (string, error)
	// Parse retrieves the challenge state from a token.
	Parse(token string) (*ChallengeState, error)
}

type DataPermissionApplier interface {
	// Apply adds data permission filters to the query based on the current context.
	Apply(query orm.SelectQuery) error
}

type DataPermissionResolver interface {
	// ResolveDataScope returns the DataScope that should be applied for the permission.
	ResolveDataScope(ctx context.Context, principal *Principal, permToken string) (DataScope, error)
}

type DataScope interface {
	// Key returns a unique identifier for this data scope type.
	Key() string
	// Priority determines the order when multiple scopes apply (lower = higher priority).
	Priority() int
	// Supports returns true if this scope applies to the given Principal and table.
	Supports(principal *Principal, table *orm.Table) bool
	// Apply modifies the query to enforce the data scope restrictions.
	Apply(principal *Principal, query orm.SelectQuery) error
}

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

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

type DepartmentLoader interface {
	// LoadDepartments returns the departments available to the user.
	// Return nil or an empty slice to skip the challenge.
	LoadDepartments(ctx context.Context, principal *Principal) ([]DepartmentOption, error)
}

type DepartmentOption struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type DepartmentSelectionChallengeData struct {
	Departments []DepartmentOption `json:"departments"`
	Meta        map[string]any     `json:"meta,omitempty"`
}

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

type DepartmentSelector interface {
	// SelectDepartment validates the department choice and returns an enriched principal.
	SelectDepartment(ctx context.Context, principal *Principal, departmentID string) (*Principal, error)
}

type ExternalAppConfig struct {
	Enabled     bool   `json:"enabled"`
	IPWhitelist string `json:"ipWhitelist"`
}

type ExternalAppLoader interface {
	// LoadByID retrieves an external app by its ID, returning the Principal,
	// secret key for signature verification, and any error.
	LoadByID(ctx context.Context, id string) (*Principal, string, error)
}

type Gender string

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

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

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

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

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

type JWTConfig struct {
	Secret   string `config:"secret"`   // Secret key for JWT signing
	Audience string `config:"audience"` // JWT audience
}

type LoginChallenge struct {
	Type     string `json:"type"`
	Data     any    `json:"data,omitempty"`
	Required bool   `json:"required"`
}

type LoginEvent struct {
	event.BaseEvent

	AuthType   string  `json:"authType"`
	UserID     *string `json:"userId"` // Populated on success
	Username   string  `json:"username"`
	LoginIP    string  `json:"loginIp"`
	UserAgent  string  `json:"userAgent"`
	TraceID    string  `json:"traceId"`
	IsOk       bool    `json:"isOk"`
	FailReason string  `json:"failReason"` // Populated on failure
	ErrorCode  int     `json:"errorCode"`
}

type LoginEventParams struct {
	AuthType   string
	UserID     *string
	Username   string
	LoginIP    string
	UserAgent  string
	TraceID    string
	IsOk       bool
	FailReason string
	ErrorCode  int
}

type LoginResult struct {
	Tokens         *AuthTokens     `json:"tokens,omitempty"`
	ChallengeToken string          `json:"challengeToken,omitempty"`
	Challenge      *LoginChallenge `json:"challenge,omitempty"`
}

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

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

type NonceStore interface {
	// StoreIfAbsent atomically stores a nonce only when it does not already exist.
	// It returns true when the nonce was newly stored, false when the nonce already existed.
	// The TTL should be slightly longer than timestamp tolerance to ensure
	// nonces remain valid while their corresponding timestamps are accepted.
	StoreIfAbsent(ctx context.Context, appID, nonce string, ttl time.Duration) (bool, error)
}

type OTPChallengeData struct {
	Destination string         `json:"destination"`
	Meta        map[string]any `json:"meta,omitempty"`
}

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

type OTPChallengeProviderConfig struct {
	ChallengeType  string          // Required, unique identifier (e.g. "totp", "sms_otp").
	ChallengeOrder int             // Evaluation priority; lower values are evaluated first.
	Evaluator      OTPEvaluator    // Required.
	Sender         OTPCodeSender   // Optional; nil skips the send step.
	Verifier       OTPCodeVerifier // Required.
}

type OTPCodeDelivery interface {
	// Deliver sends the given OTP code to the principal via the configured channel.
	Deliver(ctx context.Context, principal *Principal, code string) error
}

type OTPCodeSender interface {
	// Send triggers the delivery of an OTP code to the given principal.
	Send(ctx context.Context, principal *Principal) error
}

type OTPCodeStore interface {
	// Generate creates a new OTP code, stores it, and returns the generated code.
	Generate(ctx context.Context, principal *Principal) (string, error)
	// Verify checks whether the submitted code matches the stored code.
	Verify(ctx context.Context, principal *Principal, code string) (bool, error)
}

type OTPCodeVerifier interface {
	// Verify checks whether the submitted code is valid for the given principal.
	Verify(ctx context.Context, principal *Principal, code string) (bool, error)
}

type OTPEvaluator interface {
	// Evaluate checks the principal and returns challenge data if OTP is required.
	// Return nil to skip the challenge; non-nil triggers a challenge.
	Evaluate(ctx context.Context, principal *Principal) (*OTPChallengeData, error)
}

type PasswordChangeChallengeData struct {
	Reason string         `json:"reason"`
	Meta   map[string]any `json:"meta,omitempty"`
}

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

type PasswordChangeChecker interface {
	// Check returns challenge data (including reason) if a password change is required,
	// or nil if no change is needed.
	Check(ctx context.Context, principal *Principal) (*PasswordChangeChallengeData, error)
}

type PasswordChanger interface {
	// ChangePassword validates password strength and persists the new password.
	ChangePassword(ctx context.Context, principal *Principal, newPassword string) error
}

type PasswordDecryptor interface {
	// Decrypt transforms an encrypted password back to plaintext for verification.
	Decrypt(encryptedPassword string) (string, error)
}

type PermissionChecker interface {
	// HasPermission returns true if the Principal has the specified permission token.
	HasPermission(ctx context.Context, principal *Principal, permToken string) (bool, error)
}

type Principal struct {
	// Type is the type of the principal.
	Type PrincipalType `json:"type"`
	// ID is the id of the user.
	ID string `json:"id"`
	// Name is the name of the user.
	Name string `json:"name"`
	// Roles is the roles of the user.
	Roles []string `json:"roles"`
	// Details is the details of the user.
	Details any `json:"details"`
}

type PrincipalType string

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

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

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

type RolePermissionsChangedEvent struct {
	event.BaseEvent

	Roles []string `json:"roles"` // Affected role names (empty means all roles)
}

type RolePermissionsLoader interface {
	// LoadPermissions returns a map of permission tokens to their DataScope for a role.
	LoadPermissions(ctx context.Context, role string) (map[string]DataScope, error)
}

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

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

type SignatureAlgorithm string

type SignatureCredentials struct {
	// Timestamp is the Unix timestamp (seconds) when the request was created.
	Timestamp int64

	// Nonce is a random string to prevent replay attacks.
	Nonce string

	// Signature is the HMAC signature in hex encoding.
	Signature string
}

type SignatureOption func(*Signature)

type SignatureResult struct {
	AppID     string
	Timestamp int64
	Nonce     string
	Signature string
}

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

type TOTPOption func(*TOTPEvaluator)

type TOTPSecretLoader interface {
	// LoadSecret returns the base32-encoded TOTP secret for the given principal.
	// An empty string means the user has not configured TOTP.
	LoadSecret(ctx context.Context, principal *Principal) (string, error)
}

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

type TokenGenerator interface {
	// Generate creates a new token pair for the given Principal.
	Generate(principal *Principal) (*AuthTokens, error)
}

type UserInfo struct {
	ID         string      `json:"id"`
	Name       string      `json:"name"`
	Gender     Gender      `json:"gender"`
	Avatar     null.String `json:"avatar"`
	PermTokens []string    `json:"permTokens"`
	Menus      []UserMenu  `json:"menus"`
	Details    any         `json:"details,omitempty"`
}

type UserInfoLoader interface {
	// LoadUserInfo retrieves detailed user information based on the Principal and parameters.
	LoadUserInfo(ctx context.Context, principal *Principal, params map[string]any) (*UserInfo, error)
}

type UserLoader interface {
	// LoadByUsername retrieves a user by username, returning the Principal,
	// hashed password, and any error. Used for password-based authentication.
	LoadByUsername(ctx context.Context, username string) (*Principal, string, error)
	// LoadByID retrieves a user by their unique identifier.
	// Used for token refresh and session validation.
	LoadByID(ctx context.Context, id string) (*Principal, error)
}

type UserMenu struct {
	Type     UserMenuType   `json:"type"`
	Path     string         `json:"path"`
	Name     string         `json:"name"`
	Icon     null.String    `json:"icon"`
	Meta     map[string]any `json:"metadata,omitempty"`
	Children []UserMenu     `json:"children,omitempty"`
}

type UserMenuType string