/* eslint-disable */
//@ts-nocheck
import type { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
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; }
  DateTime: { input: string; output: string; }
  UUID: { input: any; output: any; }
};

export type ActionLogType = {
  id: Scalars['ID']['output'];
  readReceipt: Maybe<Scalars['DateTime']['output']>;
};

export type DefinitionChannelType = {
  id: Scalars['ID']['output'];
  readReceipt: Array<TeamChannelReceipt>;
};

export type EmailType = {
  id: Scalars['ID']['output'];
  readReceipt: Maybe<Scalars['DateTime']['output']>;
};

export type Mutation = {
  setIsUnreadChannel: Maybe<DefinitionChannelType>;
  writeReadReceipt: Maybe<ActionLogType>;
  writeReadReceiptEmail: Maybe<EmailType>;
};


export type MutationSetIsUnreadChannelArgs = {
  channelId: Scalars['ID']['input'];
  isUnread: Scalars['Boolean']['input'];
  teamId: Scalars['ID']['input'];
};


export type MutationWriteReadReceiptArgs = {
  actionLogId: Scalars['ID']['input'];
};


export type MutationWriteReadReceiptEmailArgs = {
  emailId: Scalars['ID']['input'];
};

export type Query = {
  channelId: Maybe<DefinitionChannelType>;
  email: Maybe<EmailType>;
  readReceipt: Maybe<ActionLogType>;
};


export type QueryChannelIdArgs = {
  channelId: Scalars['ID']['input'];
};


export type QueryEmailArgs = {
  id: Scalars['ID']['input'];
};


export type QueryReadReceiptArgs = {
  id: Scalars['ID']['input'];
};

export type TeamChannelReceipt = UnreadReceipt & {
  id: Scalars['ID']['output'];
  isUnread: Maybe<Scalars['Boolean']['output']>;
  teamId: Scalars['ID']['output'];
};

export type UnreadReceipt = {
  id: Scalars['ID']['output'];
  isUnread: Maybe<Scalars['Boolean']['output']>;
  teamId: Scalars['ID']['output'];
};



export type ResolverTypeWrapper<T> = Promise<T> | T;


export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<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 of interface types */
export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
  UnreadReceipt: ( TeamChannelReceipt );
};

/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = {
  ActionLogType: ResolverTypeWrapper<ActionLogType>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
  DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>;
  DefinitionChannelType: ResolverTypeWrapper<DefinitionChannelType>;
  EmailType: ResolverTypeWrapper<EmailType>;
  ID: ResolverTypeWrapper<Scalars['ID']['output']>;
  Mutation: ResolverTypeWrapper<{}>;
  Query: ResolverTypeWrapper<{}>;
  String: ResolverTypeWrapper<Scalars['String']['output']>;
  TeamChannelReceipt: ResolverTypeWrapper<TeamChannelReceipt>;
  UUID: ResolverTypeWrapper<Scalars['UUID']['output']>;
  UnreadReceipt: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['UnreadReceipt']>;
};

/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = {
  ActionLogType: ActionLogType;
  Boolean: Scalars['Boolean']['output'];
  DateTime: Scalars['DateTime']['output'];
  DefinitionChannelType: DefinitionChannelType;
  EmailType: EmailType;
  ID: Scalars['ID']['output'];
  Mutation: {};
  Query: {};
  String: Scalars['String']['output'];
  TeamChannelReceipt: TeamChannelReceipt;
  UUID: Scalars['UUID']['output'];
  UnreadReceipt: ResolversInterfaceTypes<ResolversParentTypes>['UnreadReceipt'];
};

export type ActionLogTypeResolvers<ContextType = any, ParentType extends ResolversParentTypes['ActionLogType'] = ResolversParentTypes['ActionLogType']> = {
  id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  readReceipt: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
  name: 'DateTime';
}

export type DefinitionChannelTypeResolvers<ContextType = any, ParentType extends ResolversParentTypes['DefinitionChannelType'] = ResolversParentTypes['DefinitionChannelType']> = {
  id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  readReceipt: Resolver<Array<ResolversTypes['TeamChannelReceipt']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type EmailTypeResolvers<ContextType = any, ParentType extends ResolversParentTypes['EmailType'] = ResolversParentTypes['EmailType']> = {
  id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  readReceipt: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
  setIsUnreadChannel: Resolver<Maybe<ResolversTypes['DefinitionChannelType']>, ParentType, ContextType, RequireFields<MutationSetIsUnreadChannelArgs, 'channelId' | 'isUnread' | 'teamId'>>;
  writeReadReceipt: Resolver<Maybe<ResolversTypes['ActionLogType']>, ParentType, ContextType, RequireFields<MutationWriteReadReceiptArgs, 'actionLogId'>>;
  writeReadReceiptEmail: Resolver<Maybe<ResolversTypes['EmailType']>, ParentType, ContextType, RequireFields<MutationWriteReadReceiptEmailArgs, 'emailId'>>;
};

export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
  channelId: Resolver<Maybe<ResolversTypes['DefinitionChannelType']>, ParentType, ContextType, RequireFields<QueryChannelIdArgs, 'channelId'>>;
  email: Resolver<Maybe<ResolversTypes['EmailType']>, ParentType, ContextType, RequireFields<QueryEmailArgs, 'id'>>;
  readReceipt: Resolver<Maybe<ResolversTypes['ActionLogType']>, ParentType, ContextType, RequireFields<QueryReadReceiptArgs, 'id'>>;
};

export type TeamChannelReceiptResolvers<ContextType = any, ParentType extends ResolversParentTypes['TeamChannelReceipt'] = ResolversParentTypes['TeamChannelReceipt']> = {
  id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  isUnread: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  teamId: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface UuidScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['UUID'], any> {
  name: 'UUID';
}

export type UnreadReceiptResolvers<ContextType = any, ParentType extends ResolversParentTypes['UnreadReceipt'] = ResolversParentTypes['UnreadReceipt']> = {
  __resolveType: TypeResolveFn<'TeamChannelReceipt', ParentType, ContextType>;
  id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  isUnread: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  teamId: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
};

export type Resolvers<ContextType = any> = {
  ActionLogType: ActionLogTypeResolvers<ContextType>;
  DateTime: GraphQLScalarType;
  DefinitionChannelType: DefinitionChannelTypeResolvers<ContextType>;
  EmailType: EmailTypeResolvers<ContextType>;
  Mutation: MutationResolvers<ContextType>;
  Query: QueryResolvers<ContextType>;
  TeamChannelReceipt: TeamChannelReceiptResolvers<ContextType>;
  UUID: GraphQLScalarType;
  UnreadReceipt: UnreadReceiptResolvers<ContextType>;
};

