import { GraphQLResolveInfo } from 'graphql';
import { AccountsContextGraphQLModules } from './';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
export type RequireFields<T, K extends keyof T> = Omit<T, K> & {
    [P in K]-?: NonNullable<T[P]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
};
export type 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>;
};
export type EmailRecord = {
    __typename?: 'EmailRecord';
    address?: Maybe<Scalars['String']['output']>;
    verified?: Maybe<Scalars['Boolean']['output']>;
};
export type ImpersonateReturn = {
    __typename?: 'ImpersonateReturn';
    authorized?: Maybe<Scalars['Boolean']['output']>;
    tokens?: Maybe<Tokens>;
    user?: Maybe<User>;
};
export type ImpersonationUserIdentityInput = {
    email?: InputMaybe<Scalars['String']['input']>;
    userId?: InputMaybe<Scalars['String']['input']>;
    username?: InputMaybe<Scalars['String']['input']>;
};
export type LoginResult = {
    __typename?: 'LoginResult';
    sessionId?: Maybe<Scalars['String']['output']>;
    tokens?: Maybe<Tokens>;
    user?: Maybe<User>;
};
export type Mutation = {
    __typename?: 'Mutation';
    authenticate?: Maybe<LoginResult>;
    impersonate?: Maybe<ImpersonateReturn>;
    logout?: Maybe<Scalars['Boolean']['output']>;
    refreshTokens?: Maybe<LoginResult>;
    verifyAuthentication?: Maybe<Scalars['Boolean']['output']>;
};
export type MutationAuthenticateArgs = {
    params: AuthenticateParamsInput;
    serviceName: Scalars['String']['input'];
};
export type MutationImpersonateArgs = {
    accessToken: Scalars['String']['input'];
    impersonated: ImpersonationUserIdentityInput;
};
export type MutationRefreshTokensArgs = {
    accessToken: Scalars['String']['input'];
    refreshToken: Scalars['String']['input'];
};
export type MutationVerifyAuthenticationArgs = {
    params: AuthenticateParamsInput;
    serviceName: Scalars['String']['input'];
};
export type Query = {
    __typename?: 'Query';
    getUser?: Maybe<User>;
};
export type Tokens = {
    __typename?: 'Tokens';
    accessToken?: Maybe<Scalars['String']['output']>;
    refreshToken?: Maybe<Scalars['String']['output']>;
};
export type User = {
    __typename?: 'User';
    emails?: Maybe<Array<EmailRecord>>;
    id: Scalars['ID']['output'];
    username?: Maybe<Scalars['String']['output']>;
};
export type UserInput = {
    email?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['ID']['input']>;
    username?: InputMaybe<Scalars['String']['input']>;
};
export type ResolverTypeWrapper<T> = Promise<T> | T;
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs>;
export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<{
        [key in TKey]: TResult;
    }, TParent, TContext, TArgs>;
    resolve?: SubscriptionResolveFn<TResult, {
        [key in TKey]: TResult;
    }, TContext, TArgs>;
}
export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
    resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}
export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
export type NextResolverFn<T> = () => Promise<T>;
export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = {
    AuthenticateParamsInput: AuthenticateParamsInput;
    Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
    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>;
    User: ResolverTypeWrapper<User>;
    UserInput: UserInput;
};
/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = {
    AuthenticateParamsInput: AuthenticateParamsInput;
    Boolean: Scalars['Boolean']['output'];
    EmailRecord: EmailRecord;
    ID: Scalars['ID']['output'];
    ImpersonateReturn: ImpersonateReturn;
    ImpersonationUserIdentityInput: ImpersonationUserIdentityInput;
    LoginResult: LoginResult;
    Mutation: {};
    Query: {};
    String: Scalars['String']['output'];
    Tokens: Tokens;
    User: User;
    UserInput: UserInput;
};
export type EmailRecordResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['EmailRecord'] = ResolversParentTypes['EmailRecord']> = {
    address?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    verified?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ImpersonateReturnResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['ImpersonateReturn'] = ResolversParentTypes['ImpersonateReturn']> = {
    authorized?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
    tokens?: Resolver<Maybe<ResolversTypes['Tokens']>, ParentType, ContextType>;
    user?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type LoginResultResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['LoginResult'] = ResolversParentTypes['LoginResult']> = {
    sessionId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    tokens?: Resolver<Maybe<ResolversTypes['Tokens']>, ParentType, ContextType>;
    user?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type MutationResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
    authenticate?: Resolver<Maybe<ResolversTypes['LoginResult']>, ParentType, ContextType, RequireFields<MutationAuthenticateArgs, 'params' | 'serviceName'>>;
    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'>>;
    verifyAuthentication?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<MutationVerifyAuthenticationArgs, 'params' | 'serviceName'>>;
};
export type QueryResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
    getUser?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
};
export type TokensResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['Tokens'] = ResolversParentTypes['Tokens']> = {
    accessToken?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    refreshToken?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type UserResolvers<ContextType = AccountsContextGraphQLModules, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']> = {
    emails?: Resolver<Maybe<Array<ResolversTypes['EmailRecord']>>, ParentType, ContextType>;
    id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
    username?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type Resolvers<ContextType = AccountsContextGraphQLModules> = {
    EmailRecord?: EmailRecordResolvers<ContextType>;
    ImpersonateReturn?: ImpersonateReturnResolvers<ContextType>;
    LoginResult?: LoginResultResolvers<ContextType>;
    Mutation?: MutationResolvers<ContextType>;
    Query?: QueryResolvers<ContextType>;
    Tokens?: TokensResolvers<ContextType>;
    User?: UserResolvers<ContextType>;
};