@accounts/module-password

Index

Functions

• createAccountsPasswordModule

Interfaces

• AccountsPasswordModuleConfig
• SubscriptionResolverObject
• SubscriptionSubscriberObject

Type Aliases

• AuthenticateParamsInput
• CreateUserInput
• CreateUserResult
• CreateUserResultResolvers
• DirectiveResolverFn
• EmailRecord
• EmailRecordResolvers
• Exact
• ImpersonateReturn
• ImpersonateReturnResolvers
• ImpersonationUserIdentityInput
• Incremental
• InputMaybe
• IsTypeOfResolverFn
• LoginResult
• LoginResultResolvers
• MakeEmpty
• MakeMaybe
• MakeOptional
• Maybe
• Mutation
• MutationAddEmailArgs
• MutationAuthenticateArgs
• MutationChangePasswordArgs
• MutationCreateUserArgs
• MutationImpersonateArgs
• MutationRefreshTokensArgs
• MutationResetPasswordArgs
• MutationResolvers
• MutationSendResetPasswordEmailArgs
• MutationSendVerificationEmailArgs
• MutationTwoFactorSetArgs
• MutationTwoFactorUnsetArgs
• MutationVerifyAuthenticationArgs
• MutationVerifyEmailArgs
• NextResolverFn
• Query
• QueryResolvers
• RequireFields
• Resolver
• ResolverFn
• ResolverTypeWrapper
• Resolvers
• ResolversParentTypes
• ResolversTypes
• Scalars
• SubscriptionObject
• SubscriptionResolveFn
• SubscriptionResolver
• SubscriptionSubscribeFn
• Tokens
• TokensResolvers
• TwoFactorSecretKey
• TwoFactorSecretKeyInput
• TwoFactorSecretKeyResolvers
• TypeResolveFn
• User
• UserInput
• UserResolvers

Type Aliases

AuthenticateParamsInput

AuthenticateParamsInput: { access_token?: InputMaybe<Scalars[String][input]>; access_token_secret?: InputMaybe<Scalars[String][input]>; code?: InputMaybe<Scalars[String][input]>; password?: InputMaybe<Scalars[String][input]>; provider?: InputMaybe<Scalars[String][input]>; token?: InputMaybe<Scalars[String][input]>; user?: InputMaybe<UserInput> }

Type declaration

• optionalaccess_token?: InputMaybe<Scalars[String][input]>

• optionalaccess_token_secret?: InputMaybe<Scalars[String][input]>

• optionalcode?: InputMaybe<Scalars[String][input]>

• optionalpassword?: InputMaybe<Scalars[String][input]>

• optionalprovider?: InputMaybe<Scalars[String][input]>

• optionaltoken?: InputMaybe<Scalars[String][input]>

• optionaluser?: InputMaybe<UserInput>

CreateUserInput

CreateUserInput: { email?: InputMaybe<Scalars[String][input]>; password?: InputMaybe<Scalars[String][input]>; username?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalemail?: InputMaybe<Scalars[String][input]>

• optionalpassword?: InputMaybe<Scalars[String][input]>

• optionalusername?: InputMaybe<Scalars[String][input]>

CreateUserResult

CreateUserResult: { __typename?: CreateUserResult; loginResult?: Maybe<LoginResult>; userId?: Maybe<Scalars[ID][output]> }

Type declaration

• optional__typename?: CreateUserResult

• optionalloginResult?: Maybe<LoginResult>

• optionaluserId?: Maybe<Scalars[ID][output]>

CreateUserResultResolvers

CreateUserResultResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; loginResult?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType>; userId?: Resolver<Maybe<ResolversTypes[ID]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[CreateUserResult] = ResolversParentTypes[CreateUserResult]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalloginResult?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType>

• optionaluserId?: Resolver<Maybe<ResolversTypes[ID]>, ParentType, ContextType>

DirectiveResolverFn

DirectiveResolverFn<TResult, TParent, TContext, TArgs>: (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>

Type parameters

• TResult = {}
• TParent = {}
• TContext = {}
• TArgs = {}

Type declaration

• • (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): TResult | Promise<TResult>

  • Parameters

    • next: NextResolverFn<TResult>

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns TResult | Promise<TResult>

EmailRecord

EmailRecord: { __typename?: EmailRecord; address?: Maybe<Scalars[String][output]>; verified?: Maybe<Scalars[Boolean][output]> }

Type declaration

• optional__typename?: EmailRecord

• optionaladdress?: Maybe<Scalars[String][output]>

• optionalverified?: Maybe<Scalars[Boolean][output]>

EmailRecordResolvers

EmailRecordResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; address?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; verified?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[EmailRecord] = ResolversParentTypes[EmailRecord]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionaladdress?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalverified?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

Exact

Exact<T>: { [ K in keyof T ]: T[K] }

Type parameters

• T: {}

ImpersonateReturn

ImpersonateReturn: { __typename?: ImpersonateReturn; authorized?: Maybe<Scalars[Boolean][output]>; tokens?: Maybe<Tokens>; user?: Maybe<User> }

Type declaration

• optional__typename?: ImpersonateReturn

• optionalauthorized?: Maybe<Scalars[Boolean][output]>

• optionaltokens?: Maybe<Tokens>

• optionaluser?: Maybe<User>

ImpersonateReturnResolvers

ImpersonateReturnResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; authorized?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>; tokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>; user?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[ImpersonateReturn] = ResolversParentTypes[ImpersonateReturn]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalauthorized?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

• optionaltokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>

• optionaluser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

ImpersonationUserIdentityInput

ImpersonationUserIdentityInput: { email?: InputMaybe<Scalars[String][input]>; userId?: InputMaybe<Scalars[String][input]>; username?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalemail?: InputMaybe<Scalars[String][input]>

• optionaluserId?: InputMaybe<Scalars[String][input]>

• optionalusername?: InputMaybe<Scalars[String][input]>

Incremental

Incremental<T>: T | { [ P in keyof T ]?: P extends $fragmentName | __typename ? T[P] : never }

Type parameters

• T

InputMaybe

InputMaybe<T>: Maybe<T>

Type parameters

• T

IsTypeOfResolverFn

IsTypeOfResolverFn<T, TContext>: (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>

Type parameters

• T = {}
• TContext = {}

Type declaration

• • (obj: T, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>

  • Parameters

    • obj: T

    • context: TContext

    • info: GraphQLResolveInfo

    Returns boolean | Promise<boolean>

LoginResult

LoginResult: { __typename?: LoginResult; sessionId?: Maybe<Scalars[String][output]>; tokens?: Maybe<Tokens>; user?: Maybe<User> }

Type declaration

• optional__typename?: LoginResult

• optionalsessionId?: Maybe<Scalars[String][output]>

• optionaltokens?: Maybe<Tokens>

• optionaluser?: Maybe<User>

LoginResultResolvers

LoginResultResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; sessionId?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; tokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>; user?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[LoginResult] = ResolversParentTypes[LoginResult]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalsessionId?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionaltokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>

• optionaluser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

MakeEmpty

MakeEmpty<T, K>: { [ _ in K ]?: never }

Type parameters

• T: {}
• K: keyof T

MakeMaybe

MakeMaybe<T, K>: Omit<T, K> & { [ SubKey in K ]: Maybe<T[SubKey]> }

Type parameters

• T
• K: keyof T

MakeOptional

MakeOptional<T, K>: Omit<T, K> & { [ SubKey in K ]?: Maybe<T[SubKey]> }

Type parameters

• T
• K: keyof T

Maybe

Maybe<T>: T | null

Type parameters

• T

Mutation

Mutation: { __typename?: Mutation; addEmail?: Maybe<Scalars[Boolean][output]>; authenticate?: Maybe<LoginResult>; changePassword?: Maybe<Scalars[Boolean][output]>; createUser?: Maybe<CreateUserResult>; impersonate?: Maybe<ImpersonateReturn>; logout?: Maybe<Scalars[Boolean][output]>; refreshTokens?: Maybe<LoginResult>; resetPassword?: Maybe<LoginResult>; sendResetPasswordEmail?: Maybe<Scalars[Boolean][output]>; sendVerificationEmail?: Maybe<Scalars[Boolean][output]>; twoFactorSet?: Maybe<Scalars[Boolean][output]>; twoFactorUnset?: Maybe<Scalars[Boolean][output]>; verifyAuthentication?: Maybe<Scalars[Boolean][output]>; verifyEmail?: Maybe<Scalars[Boolean][output]> }

Type declaration

• optional__typename?: Mutation

• optionaladdEmail?: Maybe<Scalars[Boolean][output]>

• optionalauthenticate?: Maybe<LoginResult>

• optionalchangePassword?: Maybe<Scalars[Boolean][output]>

• optionalcreateUser?: Maybe<CreateUserResult>

• optionalimpersonate?: Maybe<ImpersonateReturn>

• optionallogout?: Maybe<Scalars[Boolean][output]>

• optionalrefreshTokens?: Maybe<LoginResult>

• optionalresetPassword?: Maybe<LoginResult>

• optionalsendResetPasswordEmail?: Maybe<Scalars[Boolean][output]>

• optionalsendVerificationEmail?: Maybe<Scalars[Boolean][output]>

• optionaltwoFactorSet?: Maybe<Scalars[Boolean][output]>

• optionaltwoFactorUnset?: Maybe<Scalars[Boolean][output]>

• optionalverifyAuthentication?: Maybe<Scalars[Boolean][output]>

• optionalverifyEmail?: Maybe<Scalars[Boolean][output]>

MutationAddEmailArgs

MutationAddEmailArgs: { newEmail: Scalars[String][input] }

Type declaration

• newEmail: Scalars[String][input]

MutationAuthenticateArgs

MutationAuthenticateArgs: { params: AuthenticateParamsInput; serviceName: Scalars[String][input] }

Type declaration

• params: AuthenticateParamsInput

• serviceName: Scalars[String][input]

MutationChangePasswordArgs

MutationChangePasswordArgs: { newPassword: Scalars[String][input]; oldPassword: Scalars[String][input] }

Type declaration

• newPassword: Scalars[String][input]

• oldPassword: Scalars[String][input]

MutationCreateUserArgs

MutationCreateUserArgs: { user: CreateUserInput }

Type declaration

• user: CreateUserInput

MutationImpersonateArgs

MutationImpersonateArgs: { accessToken: Scalars[String][input]; impersonated: ImpersonationUserIdentityInput }

Type declaration

• accessToken: Scalars[String][input]

• impersonated: ImpersonationUserIdentityInput

MutationRefreshTokensArgs

MutationRefreshTokensArgs: { accessToken: Scalars[String][input]; refreshToken: Scalars[String][input] }

Type declaration

• accessToken: Scalars[String][input]

• refreshToken: Scalars[String][input]

MutationResetPasswordArgs

MutationResetPasswordArgs: { newPassword: Scalars[String][input]; token: Scalars[String][input] }

Type declaration

• newPassword: Scalars[String][input]

• token: Scalars[String][input]

MutationResolvers

MutationResolvers<ContextType, ParentType>: { addEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationAddEmailArgs, newEmail>>; authenticate?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationAuthenticateArgs, params | serviceName>>; changePassword?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationChangePasswordArgs, newPassword | oldPassword>>; createUser?: Resolver<Maybe<ResolversTypes[CreateUserResult]>, ParentType, ContextType, RequireFields<MutationCreateUserArgs, user>>; impersonate?: Resolver<Maybe<ResolversTypes[ImpersonateReturn]>, ParentType, ContextType, RequireFields<MutationImpersonateArgs, accessToken | impersonated>>; logout?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>; refreshTokens?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationRefreshTokensArgs, accessToken | refreshToken>>; resetPassword?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationResetPasswordArgs, newPassword | token>>; sendResetPasswordEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationSendResetPasswordEmailArgs, email>>; sendVerificationEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationSendVerificationEmailArgs, email>>; twoFactorSet?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationTwoFactorSetArgs, code | secret>>; twoFactorUnset?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationTwoFactorUnsetArgs, code>>; verifyAuthentication?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyAuthenticationArgs, params | serviceName>>; verifyEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyEmailArgs, token>> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Mutation] = ResolversParentTypes[Mutation]

Type declaration

• optionaladdEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationAddEmailArgs, newEmail>>

• optionalauthenticate?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationAuthenticateArgs, params | serviceName>>

• optionalchangePassword?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationChangePasswordArgs, newPassword | oldPassword>>

• optionalcreateUser?: Resolver<Maybe<ResolversTypes[CreateUserResult]>, ParentType, ContextType, RequireFields<MutationCreateUserArgs, user>>

• optionalimpersonate?: Resolver<Maybe<ResolversTypes[ImpersonateReturn]>, ParentType, ContextType, RequireFields<MutationImpersonateArgs, accessToken | impersonated>>

• optionallogout?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

• optionalrefreshTokens?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationRefreshTokensArgs, accessToken | refreshToken>>

• optionalresetPassword?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationResetPasswordArgs, newPassword | token>>

• optionalsendResetPasswordEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationSendResetPasswordEmailArgs, email>>

• optionalsendVerificationEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationSendVerificationEmailArgs, email>>

• optionaltwoFactorSet?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationTwoFactorSetArgs, code | secret>>

• optionaltwoFactorUnset?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationTwoFactorUnsetArgs, code>>

• optionalverifyAuthentication?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyAuthenticationArgs, params | serviceName>>

• optionalverifyEmail?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyEmailArgs, token>>

MutationSendResetPasswordEmailArgs

MutationSendResetPasswordEmailArgs: { email: Scalars[String][input] }

Type declaration

• email: Scalars[String][input]

MutationSendVerificationEmailArgs

MutationSendVerificationEmailArgs: { email: Scalars[String][input] }

Type declaration

• email: Scalars[String][input]

MutationTwoFactorSetArgs

MutationTwoFactorSetArgs: { code: Scalars[String][input]; secret: TwoFactorSecretKeyInput }

Type declaration

• code: Scalars[String][input]

• secret: TwoFactorSecretKeyInput

MutationTwoFactorUnsetArgs

MutationTwoFactorUnsetArgs: { code: Scalars[String][input] }

Type declaration

• code: Scalars[String][input]

MutationVerifyAuthenticationArgs

MutationVerifyAuthenticationArgs: { params: AuthenticateParamsInput; serviceName: Scalars[String][input] }

Type declaration

• params: AuthenticateParamsInput

• serviceName: Scalars[String][input]

MutationVerifyEmailArgs

MutationVerifyEmailArgs: { token: Scalars[String][input] }

Type declaration

• token: Scalars[String][input]

NextResolverFn

NextResolverFn<T>: () => Promise<T>

Type parameters

• T

Type declaration

• • (): Promise<T>

  • Returns Promise<T>

Query

Query: { __typename?: Query; getUser?: Maybe<User>; twoFactorSecret?: Maybe<TwoFactorSecretKey> }

Type declaration

• optional__typename?: Query

• optionalgetUser?: Maybe<User>

• optionaltwoFactorSecret?: Maybe<TwoFactorSecretKey>

QueryResolvers

QueryResolvers<ContextType, ParentType>: { getUser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>; twoFactorSecret?: Resolver<Maybe<ResolversTypes[TwoFactorSecretKey]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Query] = ResolversParentTypes[Query]

Type declaration

• optionalgetUser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

• optionaltwoFactorSecret?: Resolver<Maybe<ResolversTypes[TwoFactorSecretKey]>, ParentType, ContextType>

RequireFields

RequireFields<T, K>: Omit<T, K> & { [ P in K ]-?: NonNullable<T[P]> }

Type parameters

• T
• K: keyof T

Resolver

Resolver<TResult, TParent, TContext, TArgs>: ResolverFn<TResult, TParent, TContext, TArgs>

Type parameters

• TResult
• TParent = {}
• TContext = {}
• TArgs = {}

ResolverFn

ResolverFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): Promise<TResult> | TResult

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns Promise<TResult> | TResult

ResolverTypeWrapper

ResolverTypeWrapper<T>: Promise<T> | T

Type parameters

• T

Resolvers

Resolvers<ContextType>: { CreateUserResult?: CreateUserResultResolvers<ContextType>; EmailRecord?: EmailRecordResolvers<ContextType>; ImpersonateReturn?: ImpersonateReturnResolvers<ContextType>; LoginResult?: LoginResultResolvers<ContextType>; Mutation?: MutationResolvers<ContextType>; Query?: QueryResolvers<ContextType>; Tokens?: TokensResolvers<ContextType>; TwoFactorSecretKey?: TwoFactorSecretKeyResolvers<ContextType>; User?: UserResolvers<ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules

Type declaration

• optionalCreateUserResult?: CreateUserResultResolvers<ContextType>

• optionalEmailRecord?: EmailRecordResolvers<ContextType>

• optionalImpersonateReturn?: ImpersonateReturnResolvers<ContextType>

• optionalLoginResult?: LoginResultResolvers<ContextType>

• optionalMutation?: MutationResolvers<ContextType>

• optionalQuery?: QueryResolvers<ContextType>

• optionalTokens?: TokensResolvers<ContextType>

• optionalTwoFactorSecretKey?: TwoFactorSecretKeyResolvers<ContextType>

• optionalUser?: UserResolvers<ContextType>

ResolversParentTypes

ResolversParentTypes: { AuthenticateParamsInput: AuthenticateParamsInput; Boolean: Scalars[Boolean][output]; CreateUserInput: CreateUserInput; CreateUserResult: CreateUserResult; EmailRecord: EmailRecord; ID: Scalars[ID][output]; ImpersonateReturn: ImpersonateReturn; ImpersonationUserIdentityInput: ImpersonationUserIdentityInput; LoginResult: LoginResult; Mutation: {}; Query: {}; String: Scalars[String][output]; Tokens: Tokens; TwoFactorSecretKey: TwoFactorSecretKey; TwoFactorSecretKeyInput: TwoFactorSecretKeyInput; User: User; UserInput: UserInput }

Mapping between all available schema types and the resolvers parents

---

Type declaration

• AuthenticateParamsInput: AuthenticateParamsInput

• Boolean: Scalars[Boolean][output]

• CreateUserInput: CreateUserInput

• CreateUserResult: CreateUserResult

• EmailRecord: EmailRecord

• ID: Scalars[ID][output]

• ImpersonateReturn: ImpersonateReturn

• ImpersonationUserIdentityInput: ImpersonationUserIdentityInput

• LoginResult: LoginResult

• Mutation: {}

• Query: {}

• String: Scalars[String][output]

• Tokens: Tokens

• TwoFactorSecretKey: TwoFactorSecretKey

• TwoFactorSecretKeyInput: TwoFactorSecretKeyInput

• User: User

• UserInput: UserInput

ResolversTypes

ResolversTypes: { AuthenticateParamsInput: AuthenticateParamsInput; Boolean: ResolverTypeWrapper<Scalars[Boolean][output]>; CreateUserInput: CreateUserInput; CreateUserResult: ResolverTypeWrapper<CreateUserResult>; EmailRecord: ResolverTypeWrapper<EmailRecord>; ID: ResolverTypeWrapper<Scalars[ID][output]>; ImpersonateReturn: ResolverTypeWrapper<ImpersonateReturn>; ImpersonationUserIdentityInput: ImpersonationUserIdentityInput; LoginResult: ResolverTypeWrapper<LoginResult>; Mutation: ResolverTypeWrapper<{}>; Query: ResolverTypeWrapper<{}>; String: ResolverTypeWrapper<Scalars[String][output]>; Tokens: ResolverTypeWrapper<Tokens>; TwoFactorSecretKey: ResolverTypeWrapper<TwoFactorSecretKey>; TwoFactorSecretKeyInput: TwoFactorSecretKeyInput; User: ResolverTypeWrapper<User>; UserInput: UserInput }

Mapping between all available schema types and the resolvers types

---

Type declaration

• AuthenticateParamsInput: AuthenticateParamsInput

• Boolean: ResolverTypeWrapper<Scalars[Boolean][output]>

• CreateUserInput: CreateUserInput

• CreateUserResult: ResolverTypeWrapper<CreateUserResult>

• EmailRecord: ResolverTypeWrapper<EmailRecord>

• ID: ResolverTypeWrapper<Scalars[ID][output]>

• ImpersonateReturn: ResolverTypeWrapper<ImpersonateReturn>

• ImpersonationUserIdentityInput: ImpersonationUserIdentityInput

• LoginResult: ResolverTypeWrapper<LoginResult>

• Mutation: ResolverTypeWrapper<{}>

• Query: ResolverTypeWrapper<{}>

• String: ResolverTypeWrapper<Scalars[String][output]>

• Tokens: ResolverTypeWrapper<Tokens>

• TwoFactorSecretKey: ResolverTypeWrapper<TwoFactorSecretKey>

• TwoFactorSecretKeyInput: TwoFactorSecretKeyInput

• User: ResolverTypeWrapper<User>

• UserInput: UserInput

Scalars

Scalars: { Boolean: { input: boolean; output: boolean }; Float: { input: number; output: number }; ID: { input: string; output: string }; Int: { input: number; output: number }; String: { input: string; output: string } }

All built-in and custom scalars, mapped to their actual values

---

Type declaration

• Boolean: { input: boolean; output: boolean }

  • input: boolean

  • output: boolean

• Float: { input: number; output: number }

  • input: number

  • output: number

• ID: { input: string; output: string }

  • input: string

  • output: string

• Int: { input: number; output: number }

  • input: number

  • output: number

• String: { input: string; output: string }

  • input: string

  • output: string

SubscriptionObject

SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>: SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>

Type parameters

• TResult
• TKey: string
• TParent
• TContext
• TArgs

SubscriptionResolveFn

SubscriptionResolveFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): TResult | Promise<TResult>

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns TResult | Promise<TResult>

SubscriptionResolver

SubscriptionResolver<TResult, TKey, TParent, TContext, TArgs>: (...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>

Type parameters

• TResult
• TKey: string
• TParent = {}
• TContext = {}
• TArgs = {}

SubscriptionSubscribeFn

SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

Tokens

Tokens: { __typename?: Tokens; accessToken?: Maybe<Scalars[String][output]>; refreshToken?: Maybe<Scalars[String][output]> }

Type declaration

• optional__typename?: Tokens

• optionalaccessToken?: Maybe<Scalars[String][output]>

• optionalrefreshToken?: Maybe<Scalars[String][output]>

TokensResolvers

TokensResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; accessToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; refreshToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Tokens] = ResolversParentTypes[Tokens]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalaccessToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalrefreshToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

TwoFactorSecretKey

TwoFactorSecretKey: { __typename?: TwoFactorSecretKey; ascii?: Maybe<Scalars[String][output]>; base32?: Maybe<Scalars[String][output]>; google_auth_qr?: Maybe<Scalars[String][output]>; hex?: Maybe<Scalars[String][output]>; otpauth_url?: Maybe<Scalars[String][output]>; qr_code_ascii?: Maybe<Scalars[String][output]>; qr_code_base32?: Maybe<Scalars[String][output]>; qr_code_hex?: Maybe<Scalars[String][output]> }

Type declaration

• optional__typename?: TwoFactorSecretKey

• optionalascii?: Maybe<Scalars[String][output]>

• optionalbase32?: Maybe<Scalars[String][output]>

• optionalgoogle_auth_qr?: Maybe<Scalars[String][output]>

• optionalhex?: Maybe<Scalars[String][output]>

• optionalotpauth_url?: Maybe<Scalars[String][output]>

• optionalqr_code_ascii?: Maybe<Scalars[String][output]>

• optionalqr_code_base32?: Maybe<Scalars[String][output]>

• optionalqr_code_hex?: Maybe<Scalars[String][output]>

TwoFactorSecretKeyInput

TwoFactorSecretKeyInput: { ascii?: InputMaybe<Scalars[String][input]>; base32?: InputMaybe<Scalars[String][input]>; google_auth_qr?: InputMaybe<Scalars[String][input]>; hex?: InputMaybe<Scalars[String][input]>; otpauth_url?: InputMaybe<Scalars[String][input]>; qr_code_ascii?: InputMaybe<Scalars[String][input]>; qr_code_base32?: InputMaybe<Scalars[String][input]>; qr_code_hex?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalascii?: InputMaybe<Scalars[String][input]>

• optionalbase32?: InputMaybe<Scalars[String][input]>

• optionalgoogle_auth_qr?: InputMaybe<Scalars[String][input]>

• optionalhex?: InputMaybe<Scalars[String][input]>

• optionalotpauth_url?: InputMaybe<Scalars[String][input]>

• optionalqr_code_ascii?: InputMaybe<Scalars[String][input]>

• optionalqr_code_base32?: InputMaybe<Scalars[String][input]>

• optionalqr_code_hex?: InputMaybe<Scalars[String][input]>

TwoFactorSecretKeyResolvers

TwoFactorSecretKeyResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ascii?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; base32?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; google_auth_qr?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; hex?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; otpauth_url?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; qr_code_ascii?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; qr_code_base32?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; qr_code_hex?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[TwoFactorSecretKey] = ResolversParentTypes[TwoFactorSecretKey]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalascii?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalbase32?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalgoogle_auth_qr?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalhex?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalotpauth_url?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalqr_code_ascii?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalqr_code_base32?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalqr_code_hex?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

TypeResolveFn

TypeResolveFn<TTypes, TParent, TContext>: (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>

Type parameters

• TTypes
• TParent = {}
• TContext = {}

Type declaration

• • (parent: TParent, context: TContext, info: GraphQLResolveInfo): Maybe<TTypes> | Promise<Maybe<TTypes>>

  • Parameters

    • parent: TParent

    • context: TContext

    • info: GraphQLResolveInfo

    Returns Maybe<TTypes> | Promise<Maybe<TTypes>>

User

User: { __typename?: User; emails?: Maybe<EmailRecord[]>; id: Scalars[ID][output]; username?: Maybe<Scalars[String][output]> }

Type declaration

• optional__typename?: User

• optionalemails?: Maybe<EmailRecord[]>

• id: Scalars[ID][output]

• optionalusername?: Maybe<Scalars[String][output]>

UserInput

UserInput: { email?: InputMaybe<Scalars[String][input]>; id?: InputMaybe<Scalars[ID][input]>; username?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalemail?: InputMaybe<Scalars[String][input]>

• optionalid?: InputMaybe<Scalars[ID][input]>

• optionalusername?: InputMaybe<Scalars[String][input]>

UserResolvers

UserResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; emails?: Resolver<Maybe<ResolversTypes[EmailRecord][]>, ParentType, ContextType>; id?: Resolver<ResolversTypes[ID], ParentType, ContextType>; username?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[User] = ResolversParentTypes[User]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalemails?: Resolver<Maybe<ResolversTypes[EmailRecord][]>, ParentType, ContextType>

• optionalid?: Resolver<ResolversTypes[ID], ParentType, ContextType>

• optionalusername?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>