webapp

type AdvanceOptions struct {
	// Treat the next screen as the extend of the taken branch
	// Allowing alternative branches to be selected based on the current state
	InheritTakenBranchState bool
}

type AppStaticAssetsHandler struct {
	Resources ResourceManager
}

type AuthEntryPointMiddleware struct {
	BaseViewModel       *viewmodels.BaseViewModeler
	Renderer            Renderer
	AppHostSuffixes     config.AppHostSuffixes
	TrustProxy          config.TrustProxy
	OAuthConfig         *config.OAuthConfig
	UIConfig            *config.UIConfig
	OAuthClientResolver WebappOAuthClientResolver
}

type AuthflowController struct {
	TesterEndpointsProvider tester.EndpointsProvider
	TrustProxy              config.TrustProxy
	Clock                   clock.Clock

	Cookies        AuthflowControllerCookieManager
	Sessions       AuthflowControllerSessionStore
	SessionCookie  webapp.SessionCookieDef
	SignedUpCookie webapp.SignedUpCookieDef
	Endpoints      AuthflowEndpoints

	Authflows AuthflowControllerAuthflowService

	OAuthSessions  AuthflowControllerOAuthSessionService
	SAMLSessions   AuthflowControllerSAMLSessionService
	UIInfoResolver AuthflowControllerUIInfoResolver

	UIConfig            *config.UIConfig
	OAuthClientResolver AuthflowControllerOAuthClientResolver

	Navigator     AuthflowNavigator
	ErrorRenderer *ErrorRenderer
}

type AuthflowControllerAuthflowService interface {
	CreateNewFlow(ctx context.Context, intent authflow.PublicFlow, sessionOptions *authflow.SessionOptions) (*authflow.ServiceOutput, error)
	Get(ctx context.Context, stateToken string) (*authflow.ServiceOutput, error)
	FeedInput(ctx context.Context, stateToken string, rawMessage json.RawMessage) (*authflow.ServiceOutput, error)
}

type AuthflowControllerCookieManager 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 AuthflowControllerErrorHandler func(ctx context.Context, w http.ResponseWriter, r *http.Request, err error) error

type AuthflowControllerHandler func(ctx context.Context, s *webapp.Session, screen *webapp.AuthflowScreenWithFlowResponse) error

type AuthflowControllerHandlers struct {
	GetHandler           AuthflowControllerHandler
	PostHandlers         map[string]AuthflowControllerHandler
	InlinePreviewHandler AuthflowControllerInlinePreviewHandler
}

type AuthflowControllerInlinePreviewHandler func(ctx context.Context, w http.ResponseWriter, r *http.Request) error

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

type AuthflowControllerOAuthSessionService interface {
	Get(ctx context.Context, entryID string) (*oauthsession.Entry, error)
}

type AuthflowControllerSAMLSessionService interface {
	Get(ctx context.Context, entryID string) (*samlsession.SAMLSession, error)
}

type AuthflowControllerSessionStore interface {
	Get(ctx context.Context, id string) (*webapp.Session, error)
	Create(ctx context.Context, session *webapp.Session) (err error)
	Update(ctx context.Context, session *webapp.Session) (err error)
	Delete(ctx context.Context, id string) (err error)
}

type AuthflowControllerUIInfoResolver interface {
	ResolveForUI(ctx context.Context, r protocol.AuthorizationRequest) (*oidc.UIInfo, error)
	LooksLikeOriginallyTriggeredByOIDCOrSaml(r *http.Request) bool
}

type AuthflowEndpoints interface {
	SSOCallbackURL(alias string) *url.URL
	SharedSSOCallbackURL() *url.URL
}

type AuthflowNavigator interface {
	Navigate(ctx context.Context, screen *webapp.AuthflowScreenWithFlowResponse, r *http.Request, webSessionID string, result *webapp.Result)
	NavigateSelectAccount(result *webapp.Result)
	NavigateResetPasswordSuccessPage() string
	NavigateVerifyBotProtection(result *webapp.Result)
	NavigateOAuthProviderDemoCredentialPage(screen *webapp.AuthflowScreen, r *http.Request) *webapp.Result
}

type AuthflowOAuthCallbackResponse struct {
	Query string
	State *webappoauth.WebappOAuthState
}

type CSRFErrorInstructionHandler struct {
	Controller    *AuthflowController
	BaseViewModel *viewmodels.BaseViewModeler
	Renderer      Renderer
}

type CSRFMiddleware struct {
	TrustProxy              config.TrustProxy
	BaseViewModel           *viewmodels.BaseViewModeler
	Renderer                Renderer
	UIImplementationService CSRFMiddlewareUIImplementationService
	EnvironmentConfig       *config.EnvironmentConfig
}

type CSRFMiddlewareUIImplementationService interface {
	GetUIImplementation() config.UIImplementation
}

type Controller struct {
	ControllerDeps
	// contains filtered or unexported fields
}

type ControllerAuthenticationInfoService interface {
	Get(ctx context.Context, entryID string) (entry *authenticationinfo.Entry, err error)
	Save(ctx context.Context, entry *authenticationinfo.Entry) (err error)
}

type ControllerDeps struct {
	Database                  *appdb.Handle
	RedisHandle               *appredis.Handle
	AppID                     config.AppID
	Page                      PageService
	BaseViewModel             *viewmodels.BaseViewModeler
	Renderer                  Renderer
	Publisher                 *Publisher
	Clock                     clock.Clock
	TesterEndpointsProvider   tester.EndpointsProvider
	ErrorRenderer             *ErrorRenderer
	UIInfoResolver            ControllerUIInfoResolver
	AuthenticationInfoService ControllerAuthenticationInfoService
	Sessions                  ControllerSessionStore
	OAuthSessions             ControllerOAuthSessionService

	TrustProxy config.TrustProxy
}

type ControllerFactory struct {
	ControllerDeps
}

type ControllerOAuthSessionService interface {
	Get(ctx context.Context, entryID string) (*oauthsession.Entry, error)
	Save(ctx context.Context, entry *oauthsession.Entry) error
}

type ControllerSessionStore interface {
	Get(ctx context.Context, id string) (*webapp.Session, error)
	Create(ctx context.Context, session *webapp.Session) (err error)
	Update(ctx context.Context, session *webapp.Session) (err error)
	Delete(ctx context.Context, id string) (err error)
}

type ControllerUIInfoResolver interface {
	SetAuthenticationInfoInQuery(redirectURI string, e *authenticationinfo.Entry) string
}

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 ErrorRenderer struct {
	ErrorService            *webapp.ErrorService
	UIImplementationService ErrorRendererUIImplementationService
	Renderer                Renderer
	BaseViewModel           *viewmodels.BaseViewModeler

	AuthflowV2Navigator ErrorRendererAuthflowV2Navigator
}

type ErrorRendererAuthflowV2Navigator interface {
	NavigateNonRecoverableError(r *http.Request, u *url.URL, e error)
}

type ErrorRendererUIImplementationService interface {
	GetUIImplementation() config.UIImplementation
}

type FeatureDisabledHandler struct {
	ControllerFactory ControllerFactory
	BaseViewModel     *viewmodels.BaseViewModeler
	Renderer          Renderer
}

type FormPrefiller struct {
	LoginID *config.LoginIDConfig
	UI      *config.UIConfig
}

type GeneratedStaticAssetsHandler struct {
	EmbeddedResources GlobalEmbeddedResourceManager
}

type GlobalEmbeddedResourceManager interface {
	Open(name string) (http.File, error)
}

type GlobalSessionService struct {
	SessionStore SessionStore
	Publisher    *Publisher
	Clock        clock.Clock
}

type GlobalSessionServiceFactory struct {
	Clock       clock.Clock
	RedisHandle *appredis.Handle
}

type HTMLResult struct {
	Renderer Renderer
	Template *template.HTML
	Data     interface{}
}

type ImplementationSwitcherHandler struct {
	AuthflowV2 http.Handler
}

type ImplementationSwitcherMiddleware struct {
	UIImplementationService ImplementationSwitcherMiddlewareUIImplementationService
}

type ImplementationSwitcherMiddlewareUIImplementationService interface {
	GetUIImplementation() config.UIImplementation
}

type InputAuthOOB struct {
	Code        string
	DeviceToken bool
}

type InputAuthPassword struct {
	Stage       string
	Password    string
	DeviceToken bool
}

type InputAuthRecoveryCode struct {
	Code        string
	DeviceToken bool
}

type InputAuthTOTP struct {
	Code        string
	DeviceToken bool
}

type InputChangePassword struct {
	AuthenticationStage authn.AuthenticationStage
	OldPassword         string
	NewPassword         string
}

type InputConfirmTerminateOtherSessions struct {
	IsConfirm bool
}

type InputConfirmWeb3AccountRequest struct {
	Message   string
	Signature string
}

type InputCreateAuthenticator struct{}

type InputNewLoginID struct {
	LoginIDType  string
	LoginIDKey   string
	LoginIDValue string
}

type InputOAuthCallback struct {
	ProviderAlias string
	Query         string
}

type InputPasskeyAssertionResponse struct {
	Stage             string
	AssertionResponse []byte
}

type InputPasskeyAttestationResponse struct {
	Stage               string
	AttestationResponse []byte
}

type InputPromptCreatePasskeyAttestationResponse struct {
	Skipped             bool
	AttestationResponse []byte
}

type InputRemoveAuthenticator struct {
	Type model.AuthenticatorType
	ID   string
}

type InputRemoveIdentity struct {
	Type model.IdentityType
	ID   string
}

type InputResendCode struct{}

type InputResetPassword struct {
	Code     string
	Password string
}

type InputSelectLoginLink struct{}

type InputSelectOOB struct{}

type InputSelectTOTP struct{}

type InputSelectVerifyIdentityViaOOBOTP struct{}

type InputSelectVerifyIdentityViaWhatsapp struct{}

type InputSelectWhatsappOTP struct{}

type InputSetupLoginLinkOTP struct {
	InputType string
	Target    string
}

type InputSetupOOB struct {
	InputType string
	Target    string
}

type InputSetupPassword struct {
	Stage    string
	Password string
}

type InputSetupRecoveryCode struct{}

type InputSetupTOTP struct {
	Code        string
	DisplayName string
}

type InputSetupWhatsappOTP struct {
	Phone string
}

type InputTriggerLoginLink struct {
	AuthenticatorIndex int
}

type InputTriggerOOB struct {
	AuthenticatorType  string
	AuthenticatorIndex int
}

type InputTriggerWhatsApp struct {
	AuthenticatorIndex int
}

type InputUseLoginID struct {
	LoginIDKey string
	LoginID    string
}

type InputUseOAuth struct {
	ProviderAlias    string
	ErrorRedirectURI string
	Prompt           []string
}

type InputVerificationCode struct {
	Code string
}

type InputVerifyLoginLinkOTP struct {
	DeviceToken bool
}

type InputVerifyWhatsappOTP struct {
	DeviceToken bool
	WhatsappOTP string
}

type LoginLinkOTPPageQueryState string

type LogoutHandler struct {
	ControllerFactory     ControllerFactory
	Database              *appdb.Handle
	TrustProxy            config.TrustProxy
	OAuth                 *config.OAuthConfig
	UIConfig              *config.UIConfig
	SAMLConfig            *config.SAMLConfig
	SessionManager        LogoutSessionManager
	BaseViewModel         *viewmodels.BaseViewModeler
	Renderer              Renderer
	OAuthClientResolver   WebappOAuthClientResolver
	SAMLSLOSessionService SAMLSLOSessionService
	SAMLSLOService        SAMLSLOService
}

type LogoutSessionManager interface {
	Logout(ctx context.Context, s session.SessionBase, w http.ResponseWriter) ([]session.ListableSession, error)
}

type NoProjectSSOCallbackHandler struct {
	ConfigSource    *configsource.ConfigSource
	OAuthStateStore NoProjectSSOCallbackHandlerOAuthStateStore
}

type NoProjectSSOCallbackHandlerOAuthStateStore interface {
	RecoverState(ctx context.Context, stateToken string) (state *webappoauth.WebappOAuthState, err error)
}

type OAuthEntrypointEndpointsProvider interface {
	SelectAccountEndpointURL() *url.URL
}

type OAuthEntrypointHandler struct {
	Endpoints OAuthEntrypointEndpointsProvider
}

type OTPCodeService interface {
	VerifyOTP(ctx context.Context, kind otp.Kind, target string, otp string, opts *otp.VerifyOptions) error
	InspectState(ctx context.Context, kind otp.Kind, target string) (*otp.State, error)

	LookupCode(ctx context.Context, purpose otp.Purpose, code string) (target string, err error)
	SetSubmittedCode(ctx context.Context, kind otp.Kind, target string, code string) (*otp.State, error)
}

type PageService interface {
	UpdateSession(ctx context.Context, session *webapp.Session) error
	DeleteSession(ctx context.Context, id string) error
	PeekUncommittedChanges(ctx context.Context, session *webapp.Session, fn func(graph *interaction.Graph) error) error
	Get(ctx context.Context, session *webapp.Session) (*interaction.Graph, error)
	GetSession(ctx context.Context, id string) (*webapp.Session, error)
	GetWithIntent(ctx context.Context, session *webapp.Session, intent interaction.Intent) (*interaction.Graph, error)
	PostWithIntent(
		ctx context.Context,
		session *webapp.Session,
		intent interaction.Intent,
		inputFn func() (interface{}, error),
	) (result *webapp.Result, err error)
	PostWithInput(
		ctx context.Context,
		session *webapp.Session,
		inputFn func() (interface{}, error),
	) (result *webapp.Result, err error)
}

type PanicMiddleware struct {
	ErrorService            *webapp.ErrorService
	BaseViewModel           *viewmodels.BaseViewModeler
	Renderer                Renderer
	Endpoints               PanicMiddlewareEndpointsProvider
	UIImplementationService PanicMiddlewareUIImplementationService
}

type PanicMiddlewareEndpointsProvider interface {
	ErrorEndpointURL() *url.URL
}

type PanicMiddlewareUIImplementationService interface {
	GetUIImplementation() config.UIImplementation
}

type PasskeyCreationOptionsHandler struct {
	Page     PageService
	Database *appdb.Handle
	Passkey  PasskeyCreationOptionsService
}

type PasskeyCreationOptionsService interface {
	MakeCreationOptions(ctx context.Context, userID string) (*model.WebAuthnCreationOptions, error)
}

type PasskeyRequestOptionsHandler struct {
	Page     PageService
	Database *appdb.Handle
	Passkey  PasskeyRequestOptionsService
}

type PasskeyRequestOptionsService interface {
	MakeConditionalRequestOptions(ctx context.Context) (*model.WebAuthnRequestOptions, error)
	MakeModalRequestOptions(ctx context.Context) (*model.WebAuthnRequestOptions, error)
	MakeModalRequestOptionsWithUser(ctx context.Context, userID string) (*model.WebAuthnRequestOptions, error)
}

type Publisher struct {
	AppID       config.AppID
	RedisHandle *appredis.Handle
	Publisher   *pubsub.Publisher
}

type Renderer interface {
	// Render renders the template into response body.
	Render(w http.ResponseWriter, r *http.Request, tpl template.Resource, data interface{})
	// RenderHTML is a shorthand of Render that renders HTML.
	RenderHTML(w http.ResponseWriter, r *http.Request, tpl *template.HTML, data interface{})
	RenderStatus(w http.ResponseWriter, req *http.Request, status int, tpl template.Resource, data interface{})
	RenderHTMLStatus(w http.ResponseWriter, r *http.Request, status int, tpl *template.HTML, data interface{})
}

type ResourceManager interface {
	Read(ctx context.Context, desc resource.Descriptor, view resource.View) (interface{}, error)
	Resolve(path string) (resource.Descriptor, bool)
}

type ResponseRenderer struct {
	TemplateEngine *template.Engine
}

type ResponseWriter struct {
	Renderer Renderer
}

type ReturnHandler struct {
	ControllerFactory ControllerFactory
	BaseViewModel     *viewmodels.BaseViewModeler
	Renderer          Renderer
}

type RobotsTXTHandler struct {
	Renderer Renderer
}

type RootHandler struct {
	AuthenticationConfig *config.AuthenticationConfig
	Cookies              CookieManager
	SignedUpCookie       webapp.SignedUpCookieDef
}

type SAMLSLOService interface {
	SendSLORequest(
		ctx context.Context,
		rw http.ResponseWriter,
		r *http.Request,
		sloSession *samlslosession.SAMLSLOSession,
		sp *config.SAMLServiceProviderConfig,
	) error
}

type SAMLSLOSessionService interface {
	Get(ctx context.Context, sessionID string) (entry *samlslosession.SAMLSLOSession, err error)
	Save(ctx context.Context, session *samlslosession.SAMLSLOSession) (err error)
}

type SSOCallbackHandler struct {
	AuthflowController *AuthflowController
	ErrorRenderer      *ErrorRenderer
	OAuthStateStore    SSOCallbackHandlerOAuthStateStore
	AccountManagement  *accountmanagement.Service
}

type SSOCallbackHandlerOAuthStateStore interface {
	PopAndRecoverState(ctx context.Context, stateToken string) (state *webappoauth.WebappOAuthState, err error)
}

type SessionStore interface {
	Get(ctx context.Context, id string) (session *webapp.Session, err error)
	Update(ctx context.Context, session *webapp.Session) (err error)
}

type SettingsImplementationSwitcherHandler struct {
	SettingV2 http.Handler
}

type SettingsImplementationSwitcherMiddleware struct {
	UIImplementationService SettingsImplementationSwitcherMiddlewareUIImplementationService
}

type SettingsImplementationSwitcherMiddlewareUIImplementationService interface {
	GetSettingsUIImplementation() config.SettingsUIImplementation
}

type TesterAppSessionTokenService interface {
	Exchange(ctx context.Context, appSessionToken string) (string, error)
}

type TesterAuthTokensIssuer interface {
	IssueTokensForAuthorizationCode(
		ctx context.Context,
		client *config.OAuthClientConfig,
		r protocol.TokenRequest,
	) (*oauthhandler.HandleResult, error)
	IssueAppSessionToken(ctx context.Context, refreshToken string) (string, *oauth.AppSessionToken, error)
}

type TesterCookieManager interface {
	ValueCookie(def *httputil.CookieDef, value string) *http.Cookie
}

type TesterHandler struct {
	AppID                   config.AppID
	ControllerFactory       ControllerFactory
	OauthEndpointsProvider  oauth.EndpointsProvider
	TesterEndpointsProvider tester.EndpointsProvider
	TesterService           TesterService
	TesterTokenIssuer       TesterAuthTokensIssuer
	OAuthClientResolver     *oauthclient.Resolver
	AppSessionTokenService  TesterAppSessionTokenService
	CookieManager           TesterCookieManager
	Renderer                Renderer
	BaseViewModel           *viewmodels.BaseViewModeler
	UserInfoProvider        TesterUserInfoProvider
	OfflineGrants           TesterOfflineGrantService
}

type TesterOfflineGrantService interface {
	GetOfflineGrant(ctx context.Context, id string) (*oauth.OfflineGrant, error)
}

type TesterService interface {
	GetToken(
		ctx context.Context,
		appID config.AppID,
		tokenID string,
		consume bool,
	) (*tester.TesterToken, error)
	CreateResult(
		ctx context.Context,
		appID config.AppID,
		result *tester.TesterResult,
	) (*tester.TesterResult, error)
	GetResult(
		ctx context.Context,
		appID config.AppID,
		resultID string,
	) (*tester.TesterResult, error)
}

type TesterState struct {
	Token string `json:"token"`
}

type TesterUserInfoProvider interface {
	GetUserInfo(ctx context.Context, userID string, clientLike *oauth.ClientLike) (map[string]interface{}, error)
}

type TesterViewModel struct {
	ReturnURI    string
	UserInfoJson string
}

type UserProfile map[string]interface{}

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

type WebsocketHandler struct {
	AppID       config.AppID
	RedisHandle *appredis.Handle
	Publisher   *Publisher
}

type WebsocketMessage struct {
	Kind WebsocketMessageKind `json:"kind"`
}

type WebsocketMessageKind string

type WechatCallbackHandler struct {
	ControllerFactory ControllerFactory
	BaseViewModel     *viewmodels.BaseViewModeler
	OAuthStateStore   WechatCallbackHandlerOAuthStateStore
}

type WechatCallbackHandlerOAuthStateStore interface {
	PopAndRecoverState(ctx context.Context, stateToken string) (state *webappoauth.WebappOAuthState, err error)
}

type WhatsappCloudAPIWebhookHandler struct {
	AppID           config.AppID
	WhatsappService WhatsappCloudAPIWebhookWhatsappService
	Credentials     *config.WhatsappCloudAPICredentials
	AppHostSuffixes config.AppHostSuffixes
}

type WhatsappCloudAPIWebhookWhatsappService interface {
	UpdateMessageStatus(ctx context.Context, messageID string, status whatsapp.WhatsappMessageStatus, errors []whatsapp.WhatsappStatusError) error
}