Skip to main content

@accounts/module-password

Index

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

CreateUserInput

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

Type declaration

CreateUserResult

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

Type declaration

CreateUserResultResolvers

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

Type parameters

Type declaration

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

Type declaration

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

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

Type declaration

ImpersonationUserIdentityInput

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

Type declaration

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

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

Type declaration

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

MutationAddEmailArgs

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

Type declaration

MutationAuthenticateArgs

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

Type declaration

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

MutationImpersonateArgs

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

Type declaration

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

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

Type declaration

MutationSendResetPasswordEmailArgs

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

Type declaration

MutationSendVerificationEmailArgs

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

Type declaration

MutationTwoFactorSetArgs

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

Type declaration

MutationTwoFactorUnsetArgs

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

Type declaration

MutationVerifyAuthenticationArgs

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

Type declaration

MutationVerifyEmailArgs

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

Type declaration

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

QueryResolvers

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

Type parameters

Type declaration

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

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

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

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

Type declaration

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

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

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

Type declaration

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

UserInput

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

Type declaration

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

Type declaration