handler

type AccessTokenIssuer interface {
	EncodeAccessToken(client *config.OAuthClientConfig, grant *oauth.AccessGrant, userID string, token string) (string, error)
}

type AnonymousIdentityProvider interface {
	List(userID string) ([]*identity.Anonymous, error)
}

type AnonymousUserHandler struct {
	AppID       config.AppID
	OAuthConfig *config.OAuthConfig
	Logger      AnonymousUserHandlerLogger

	Graphs              GraphService
	Authorizations      AuthorizationService
	Clock               clock.Clock
	TokenService        TokenService
	UserProvider        UserProvider
	AnonymousIdentities AnonymousIdentityProvider
	PromotionCodes      PromotionCodeStore
	OAuthClientResolver OAuthClientResolver
}

type AnonymousUserHandlerLogger struct{ *log.Logger }

type App2AppService interface {
	ParseTokenUnverified(requestJWT string) (t *app2app.Request, err error)
	ParseToken(requestJWT string, key jwk.Key) (*app2app.Request, error)
}

type AppSessionTokenService interface {
	Handle(input oauth.AppSessionTokenInput) (httputil.Result, error)
}

type AuthenticationInfoService interface {
	Get(entryID string) (*authenticationinfo.Entry, error)
	Delete(entryID string) error
}

type AuthorizationHandler struct {
	Context    context.Context
	AppID      config.AppID
	Config     *config.OAuthConfig
	HTTPConfig *config.HTTPConfig
	HTTPProto  httputil.HTTPProto
	HTTPOrigin httputil.HTTPOrigin
	AppDomains config.AppDomains
	Logger     AuthorizationHandlerLogger

	UIURLBuilder               UIURLBuilder
	UIInfoResolver             UIInfoResolver
	Authorizations             AuthorizationService
	ValidateScopes             ScopesValidator
	AppSessionTokenService     AppSessionTokenService
	AuthenticationInfoService  AuthenticationInfoService
	Clock                      clock.Clock
	Cookies                    CookieManager
	OAuthSessionService        OAuthSessionService
	CodeGrantService           CodeGrantService
	SettingsActionGrantService SettingsActionGrantService
	ClientResolver             OAuthClientResolver
}

type AuthorizationHandlerLogger struct{ *log.Logger }

type AuthorizationService interface {
	GetByID(id string) (*oauth.Authorization, error)
	CheckAndGrant(
		clientID string,
		userID string,
		scopes []string,
	) (*oauth.Authorization, error)
	Check(
		clientID string,
		userID string,
		scopes []string,
	) (*oauth.Authorization, error)
}

type ChallengeProvider interface {
	Consume(token string) (*challenge.Purpose, error)
}

type CodeGrantService struct {
	AppID         config.AppID
	CodeGenerator TokenGenerator
	Clock         clock.Clock

	CodeGrants oauth.CodeGrantStore
}

type ConsentRequired struct {
	UserID string
	Scopes []string
	Client *config.OAuthClientConfig
}

type CookieManager interface {
	GetCookie(r *http.Request, def *httputil.CookieDef) (*http.Cookie, error)
	ValueCookie(def *httputil.CookieDef, value string) *http.Cookie
	ClearCookie(def *httputil.CookieDef) *http.Cookie
}

type CookiesGetter interface {
	GetCookies() []*http.Cookie
}

type CreateCodeGrantOptions struct {
	Authorization        *oauth.Authorization
	IDPSessionID         string
	AuthenticationInfo   authenticationinfo.T
	IDTokenHintSID       string
	RedirectURI          string
	AuthorizationRequest protocol.AuthorizationRequest
}

type CreateSettingsActionGrantOptions struct {
	Authorization        *oauth.Authorization
	IDPSessionID         string
	AuthenticationInfo   authenticationinfo.T
	IDTokenHintSID       string
	RedirectURI          string
	AuthorizationRequest protocol.AuthorizationRequest
}

type EventService interface {
	DispatchEventOnCommit(payload event.Payload) error
}

type GraphService interface {
	NewGraph(ctx *interaction.Context, intent interaction.Intent) (*interaction.Graph, error)
	DryRun(contextValue interaction.ContextValues, fn func(*interaction.Context) (*interaction.Graph, error)) error
	Run(contextValue interaction.ContextValues, graph *interaction.Graph) error
	Accept(ctx *interaction.Context, graph *interaction.Graph, input interface{}) (*interaction.Graph, []interaction.Edge, error)
}

type IDTokenIssuer interface {
	IssueIDToken(opts oidc.IssueIDTokenOptions) (token string, err error)
}

type IssueOfflineGrantOptions struct {
	AuthenticationInfo authenticationinfo.T
	Scopes             []string
	AuthorizationID    string
	IDPSessionID       string
	DeviceInfo         map[string]interface{}
	IdentityID         string
	SSOEnabled         bool
	App2AppDeviceKey   jwk.Key
}

type OAuthClientResolver interface {
	ResolveClient(clientID string) *config.OAuthClientConfig
}

type OAuthSessionService interface {
	Save(entry *oauthsession.Entry) (err error)
	Get(entryID string) (*oauthsession.Entry, error)
	Delete(entryID string) error
}

type PromotionCodeStore interface {
	CreatePromotionCode(code *anonymous.PromotionCode) error
}

type ProxyRedirectHandler struct {
	OAuthConfig *config.OAuthConfig
	HTTPOrigin  httputil.HTTPOrigin
	HTTPProto   httputil.HTTPProto
	AppDomains  config.AppDomains
}

type RevokeHandler struct {
	SessionManager SessionManager
	OfflineGrants  oauth.OfflineGrantStore
	AccessGrants   oauth.AccessGrantStore
}

type ScopesValidator func(client *config.OAuthClientConfig, scopes []string) error

type SessionManager interface {
	RevokeWithEvent(session session.Session, isTermination bool, isAdminAPI bool) error
	RevokeWithoutEvent(session session.Session) error
}

type SettingsActionGrantService struct {
	AppID         config.AppID
	CodeGenerator TokenGenerator
	Clock         clock.Clock

	SettingsActionGrants oauth.SettingsActionGrantStore
}

type SignupAnonymousUserResult struct {
	TokenResponse interface{}
	Cookies       []*http.Cookie
}

type TokenGenerator func() string

type TokenHandler struct {
	Context                context.Context
	AppID                  config.AppID
	Config                 *config.OAuthConfig
	AppDomains             config.AppDomains
	HTTPProto              httputil.HTTPProto
	HTTPOrigin             httputil.HTTPOrigin
	OAuthFeatureConfig     *config.OAuthFeatureConfig
	IdentityFeatureConfig  *config.IdentityFeatureConfig
	OAuthClientCredentials *config.OAuthClientCredentials
	Logger                 TokenHandlerLogger

	Authorizations           AuthorizationService
	CodeGrants               oauth.CodeGrantStore
	SettingsActionGrantStore oauth.SettingsActionGrantStore
	OfflineGrants            oauth.OfflineGrantStore
	AppSessionTokens         oauth.AppSessionTokenStore
	OfflineGrantService      oauth.OfflineGrantService
	Graphs                   GraphService
	IDTokenIssuer            IDTokenIssuer
	Clock                    clock.Clock
	TokenService             TokenService
	Events                   EventService
	SessionManager           SessionManager
	App2App                  App2AppService
	Challenges               ChallengeProvider
	CodeGrantService         CodeGrantService
	ClientResolver           OAuthClientResolver
	UIInfoResolver           UIInfoResolver
}

type TokenHandlerLogger struct{ *log.Logger }

type TokenHandlerUserFacade interface {
	GetRaw(id string) (*user.User, error)
}

type TokenService struct {
	RemoteIP        httputil.RemoteIP
	UserAgentString httputil.UserAgentString
	AppID           config.AppID
	Config          *config.OAuthConfig

	Authorizations      oauth.AuthorizationStore
	OfflineGrants       oauth.OfflineGrantStore
	AccessGrants        oauth.AccessGrantStore
	OfflineGrantService oauth.OfflineGrantService
	AccessEvents        *access.EventProvider
	AccessTokenIssuer   AccessTokenIssuer
	GenerateToken       TokenGenerator
	Clock               clock.Clock
	Users               TokenHandlerUserFacade
}

type UIInfoResolver interface {
	ResolveForAuthorizationEndpoint(client *config.OAuthClientConfig, req protocol.AuthorizationRequest) (*oidc.UIInfo, *oidc.UIInfoByProduct, error)
	GetAuthenticationInfoID(req *http.Request) (string, bool)
}

type UIURLBuilder interface {
	BuildAuthenticationURL(client *config.OAuthClientConfig, r protocol.AuthorizationRequest, e *oauthsession.Entry) (*url.URL, error)
	BuildSettingsActionURL(client *config.OAuthClientConfig, r protocol.AuthorizationRequest, e *oauthsession.Entry, redirectURI *url.URL) (*url.URL, error)
}

type UserProvider interface {
	Get(id string, role accesscontrol.Role) (*model.User, error)
}

type WebSessionType string