import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
export type Maybe<T> = T;
export type InputMaybe<T> = T | null;
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]> };
const defaultOptions = {} as const;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  /**
   * Implement the DateTime<FixedOffset> scalar
   *
   * The input/output is a string in RFC3339 format.
   */
  DateTime: any;
  /** A scalar that can represent any JSON value. */
  JSON: any;
  /**
   * A UUID is a unique 128-bit number, stored as 16 octets. UUIDs are parsed as
   * Strings within GraphQL. UUIDs are used to assign unique identifiers to
   * entities without requiring a central allocating authority.
   *
   * # References
   *
   * * [Wikipedia: Universally Unique Identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier)
   * * [RFC4122: A Universally Unique IDentifier (UUID) URN Namespace](http://tools.ietf.org/html/rfc4122)
   */
  UUID: any;
};

export type gql_Admin = {
  __typename?: 'Admin';
  createdAt: Scalars['DateTime'];
  email: Scalars['String'];
  firstName?: Maybe<Scalars['String']>;
  id: Scalars['UUID'];
  lastName?: Maybe<Scalars['String']>;
  phone?: Maybe<Scalars['String']>;
  updatedAt: Scalars['DateTime'];
};

export type gql_AdminConnection = {
  __typename?: 'AdminConnection';
  /** A list of edges. */
  edges: Array<gql_AdminEdge>;
  /** A list of nodes. */
  nodes: Array<gql_Admin>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_AdminEdge = {
  __typename?: 'AdminEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_Admin;
};

export type gql_AdminFilters = {
  email?: InputMaybe<Scalars['String']>;
  firstName?: InputMaybe<Scalars['String']>;
  lastName?: InputMaybe<Scalars['String']>;
  phone?: InputMaybe<Scalars['String']>;
};

export enum gql_AdminSortByKeys {
  Email = 'email',
  Id = 'id'
}

export type gql_App = {
  __typename?: 'App';
  active: Scalars['Boolean'];
  apiKeyCreatedAt?: Maybe<Scalars['DateTime']>;
  createdAt: Scalars['DateTime'];
  enabledOrigin?: Maybe<Scalars['String']>;
  hasApiKey: Scalars['Boolean'];
  hasVapidKeys: Scalars['Boolean'];
  id: Scalars['UUID'];
  name: Scalars['String'];
  updatedAt: Scalars['DateTime'];
  vapidKeysCreatedAt?: Maybe<Scalars['DateTime']>;
  vapidPublicKey?: Maybe<Scalars['String']>;
  vapidSignatureMailto?: Maybe<Scalars['String']>;
};

export type gql_AppChannel = {
  __typename?: 'AppChannel';
  appId: Scalars['UUID'];
  channel: gql_Channel;
  createdAt: Scalars['DateTime'];
  id: Scalars['UUID'];
  updatedAt: Scalars['DateTime'];
  value: Scalars['JSON'];
};

export type gql_AppConnection = {
  __typename?: 'AppConnection';
  /** A list of edges. */
  edges: Array<gql_AppEdge>;
  /** A list of nodes. */
  nodes: Array<gql_App>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_AppEdge = {
  __typename?: 'AppEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_App;
};

export type gql_AppFilters = {
  ids?: InputMaybe<Array<Scalars['UUID']>>;
  name?: InputMaybe<Scalars['String']>;
};

export enum gql_AppSortByKeys {
  Id = 'id',
  Name = 'name'
}

export enum gql_Channel {
  Email = 'EMAIL',
  Sms = 'SMS',
  WebPush = 'WEB_PUSH'
}

export type gql_CreateAdminData = {
  email: Scalars['String'];
  firstName?: InputMaybe<Scalars['String']>;
  lastName?: InputMaybe<Scalars['String']>;
  password: Scalars['String'];
  phone?: InputMaybe<Scalars['String']>;
};

export type gql_CreateAppData = {
  active?: InputMaybe<Scalars['Boolean']>;
  name: Scalars['String'];
};

export type gql_CreateNotificationData = {
  rawChannels?: InputMaybe<Array<gql_NotificationRawChannelInput>>;
  rawContent?: InputMaybe<gql_NotificationContent>;
  recipientIds?: InputMaybe<Array<Scalars['ID']>>;
  recipientRefIds?: InputMaybe<Array<Scalars['ID']>>;
  replacements?: InputMaybe<Scalars['JSON']>;
  scheduledFor?: InputMaybe<Scalars['DateTime']>;
  senderIcon?: InputMaybe<Scalars['String']>;
  senderId?: InputMaybe<Scalars['ID']>;
  senderName?: InputMaybe<Scalars['String']>;
  senderRefId?: InputMaybe<Scalars['ID']>;
  typeId?: InputMaybe<Scalars['ID']>;
  typeSlug?: InputMaybe<Scalars['String']>;
};

export type gql_CreateNotificationTypeData = {
  active?: InputMaybe<Scalars['Boolean']>;
  appId: Scalars['UUID'];
  description?: InputMaybe<Scalars['String']>;
  emailEnabled?: InputMaybe<Scalars['Boolean']>;
  emailTemplateSubject?: InputMaybe<Scalars['String']>;
  emailTemplateText?: InputMaybe<Scalars['String']>;
  name: Scalars['String'];
  notificationCenterBody?: InputMaybe<Scalars['String']>;
  notificationCenterClickUrl?: InputMaybe<Scalars['String']>;
  notificationCenterEnabled?: InputMaybe<Scalars['Boolean']>;
  notificationCenterIcon?: InputMaybe<Scalars['String']>;
  notificationCenterTitle?: InputMaybe<Scalars['String']>;
  slug: Scalars['String'];
  smsEnabled?: InputMaybe<Scalars['Boolean']>;
  smsTemplate?: InputMaybe<Scalars['String']>;
  tempEmailTemplateHtml?: InputMaybe<Scalars['String']>;
  webPushEnabled?: InputMaybe<Scalars['Boolean']>;
  webPushTemplate?: InputMaybe<Scalars['JSON']>;
};

export type gql_CreateUserChannelData = {
  active: Scalars['Boolean'];
  channel: gql_Channel;
  details: Scalars['JSON'];
  userId: Scalars['UUID'];
};

export type gql_CreateUserChannelInput = {
  active: Scalars['Boolean'];
  channel: gql_Channel;
  details: Scalars['JSON'];
};

export type gql_CreateUserData = {
  appId?: InputMaybe<Scalars['ID']>;
  channels: Array<gql_CreateUserChannelInput>;
  refId: Scalars['ID'];
};

export type gql_Credentials = {
  email: Scalars['String'];
  password: Scalars['String'];
};

export type gql_GeneratedApiKey = {
  __typename?: 'GeneratedApiKey';
  /** The private API key for the app visible only once */
  apiKey: Scalars['String'];
};

export type gql_GeneratedVapidKeys = {
  __typename?: 'GeneratedVapidKeys';
  /** The public VAPID key */
  publicKey: Scalars['String'];
};

export type gql_InboxFilters = {
  unreadOnly?: InputMaybe<Scalars['Boolean']>;
};

export enum gql_InboxSortByKeys {
  Id = 'id'
}

export type gql_LoginResult = {
  __typename?: 'LoginResult';
  user: gql_Admin;
};

export type gql_Mutation = {
  __typename?: 'Mutation';
  createAdmin: gql_Admin;
  createApp: gql_App;
  createNotification: gql_Notification;
  createNotificationType: gql_NotificationType;
  createUser: gql_User;
  createUserChannel: gql_UserChannel;
  deleteAdmin: Scalars['Boolean'];
  deleteApp: Scalars['Boolean'];
  deleteNotification: Scalars['Boolean'];
  deleteNotificationType: Scalars['Boolean'];
  deleteUser: Scalars['Boolean'];
  deleteUserChannel: Scalars['Boolean'];
  destroyApiKey: Scalars['Boolean'];
  destroyVapidKeys: Scalars['Boolean'];
  generateApiKey: gql_GeneratedApiKey;
  /**
   * * Generate a new user token to fetch notifications from client
   *      * * `appId` - Don't use this from a client
   *      * * `id` - Generate token by user id
   *      * * `refId` - Generate token by user ref_id
   */
  generateUserToken: Scalars['String'];
  generateVapidKeys: gql_GeneratedVapidKeys;
  hc_createChannel: gql_UserChannel;
  hc_deleteChannel: Scalars['Boolean'];
  hc_markAsRead: Scalars['Boolean'];
  hc_setChannel: gql_UserChannel;
  /** * Admin login */
  login: gql_LoginResult;
  /** * Admin logout */
  logout: Scalars['Boolean'];
  resetEnabledOrigin: Scalars['Boolean'];
  resetVapidSignatureMailto: Scalars['Boolean'];
  saveUser: gql_User;
  send: gql_Notification;
  setAppChannel: gql_AppChannel;
  setEnabledOrigin: Scalars['String'];
  setVapidSignatureMailto: Scalars['String'];
  updateAdmin: gql_Admin;
  updateApp: gql_App;
  updateNotificationType: gql_NotificationType;
  updateUser: gql_User;
  updateUserChannel: gql_UserChannel;
};


export type gql_MutationCreateAdminArgs = {
  data: gql_CreateAdminData;
};


export type gql_MutationCreateAppArgs = {
  data: gql_CreateAppData;
};


export type gql_MutationCreateNotificationArgs = {
  appId?: InputMaybe<Scalars['String']>;
  data: gql_CreateNotificationData;
};


export type gql_MutationCreateNotificationTypeArgs = {
  data: gql_CreateNotificationTypeData;
};


export type gql_MutationCreateUserArgs = {
  data: gql_CreateUserData;
};


export type gql_MutationCreateUserChannelArgs = {
  data: gql_CreateUserChannelData;
};


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


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


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


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


export type gql_MutationDeleteUserArgs = {
  appId?: InputMaybe<Scalars['ID']>;
  id?: InputMaybe<Scalars['ID']>;
  refId?: InputMaybe<Scalars['ID']>;
};


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


export type gql_MutationDestroyApiKeyArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationDestroyVapidKeysArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationGenerateApiKeyArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationGenerateUserTokenArgs = {
  appId?: InputMaybe<Scalars['ID']>;
  id?: InputMaybe<Scalars['ID']>;
  refId?: InputMaybe<Scalars['ID']>;
};


export type gql_MutationGenerateVapidKeysArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationHc_CreateChannelArgs = {
  active: Scalars['Boolean'];
  channel: gql_Channel;
  details: Scalars['JSON'];
};


export type gql_MutationHc_DeleteChannelArgs = {
  channel: gql_Channel;
};


export type gql_MutationHc_MarkAsReadArgs = {
  inboxIds: Array<Scalars['UUID']>;
};


export type gql_MutationHc_SetChannelArgs = {
  active: Scalars['Boolean'];
  channel: gql_Channel;
  details: Scalars['JSON'];
};


export type gql_MutationLoginArgs = {
  credentials: gql_Credentials;
};


export type gql_MutationResetEnabledOriginArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationResetVapidSignatureMailtoArgs = {
  appId: Scalars['ID'];
};


export type gql_MutationSaveUserArgs = {
  data: gql_SaveUserData;
  id?: InputMaybe<Scalars['ID']>;
  refId?: InputMaybe<Scalars['ID']>;
};


export type gql_MutationSendArgs = {
  appId?: InputMaybe<Scalars['ID']>;
  forceSend?: InputMaybe<Scalars['Boolean']>;
  notification?: InputMaybe<gql_CreateNotificationData>;
  notificationId?: InputMaybe<Scalars['ID']>;
};


export type gql_MutationSetAppChannelArgs = {
  appId: Scalars['ID'];
  channel: gql_Channel;
  value: Scalars['JSON'];
};


export type gql_MutationSetEnabledOriginArgs = {
  appId: Scalars['ID'];
  origin: Scalars['String'];
};


export type gql_MutationSetVapidSignatureMailtoArgs = {
  appId: Scalars['ID'];
  mailto: Scalars['String'];
};


export type gql_MutationUpdateAdminArgs = {
  data: gql_UpdateAdminData;
  id: Scalars['ID'];
};


export type gql_MutationUpdateAppArgs = {
  data: gql_UpdateAppData;
  id: Scalars['ID'];
};


export type gql_MutationUpdateNotificationTypeArgs = {
  data: gql_UpdateNotificationTypeData;
  id: Scalars['ID'];
};


export type gql_MutationUpdateUserArgs = {
  data: gql_UpdateUserData;
  id?: InputMaybe<Scalars['ID']>;
  refId?: InputMaybe<Scalars['ID']>;
};


export type gql_MutationUpdateUserChannelArgs = {
  data: gql_UpdateUserChannelData;
  id: Scalars['ID'];
};

export type gql_Notification = {
  __typename?: 'Notification';
  addedToQueueAt?: Maybe<Scalars['DateTime']>;
  appId: Scalars['UUID'];
  createdAt: Scalars['DateTime'];
  id: Scalars['UUID'];
  notificationType?: Maybe<gql_NotificationType>;
  rawChannels?: Maybe<Scalars['JSON']>;
  rawContent?: Maybe<Scalars['JSON']>;
  recipients: Array<gql_NotificationRecipient>;
  replacements?: Maybe<Scalars['JSON']>;
  scheduledFor?: Maybe<Scalars['DateTime']>;
  senderIcon?: Maybe<Scalars['String']>;
  senderId?: Maybe<Scalars['UUID']>;
  senderName?: Maybe<Scalars['String']>;
  typeId?: Maybe<Scalars['UUID']>;
  updatedAt: Scalars['DateTime'];
};

export type gql_NotificationConnection = {
  __typename?: 'NotificationConnection';
  /** A list of edges. */
  edges: Array<gql_NotificationEdge>;
  /** A list of nodes. */
  nodes: Array<gql_Notification>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

export type gql_NotificationContent = {
  emailEnabled?: InputMaybe<Scalars['Boolean']>;
  emailHtml?: InputMaybe<Scalars['String']>;
  emailSubject?: InputMaybe<Scalars['String']>;
  emailText?: InputMaybe<Scalars['String']>;
  notificationCenterBody?: InputMaybe<Scalars['String']>;
  notificationCenterClickUrl?: InputMaybe<Scalars['String']>;
  notificationCenterEnabled?: InputMaybe<Scalars['Boolean']>;
  notificationCenterIcon?: InputMaybe<Scalars['String']>;
  notificationCenterTitle?: InputMaybe<Scalars['String']>;
  smsEnabled?: InputMaybe<Scalars['Boolean']>;
  smsText?: InputMaybe<Scalars['String']>;
  webPushBadge?: InputMaybe<Scalars['String']>;
  webPushBody?: InputMaybe<Scalars['String']>;
  webPushClickUrl?: InputMaybe<Scalars['String']>;
  webPushData?: InputMaybe<Scalars['JSON']>;
  webPushDir?: InputMaybe<Scalars['String']>;
  webPushEnabled?: InputMaybe<Scalars['Boolean']>;
  webPushIcon?: InputMaybe<Scalars['String']>;
  webPushImage?: InputMaybe<Scalars['String']>;
  webPushLang?: InputMaybe<Scalars['String']>;
  webPushTag?: InputMaybe<Scalars['String']>;
  webPushTimestamp?: InputMaybe<Scalars['Int']>;
  webPushTitle?: InputMaybe<Scalars['String']>;
};

/** An edge in a connection. */
export type gql_NotificationEdge = {
  __typename?: 'NotificationEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_Notification;
};

export type gql_NotificationFilters = {
  addedToQueueAt?: InputMaybe<Scalars['DateTime']>;
  appId?: InputMaybe<Scalars['ID']>;
  createdAt?: InputMaybe<Scalars['DateTime']>;
  scheduledFor?: InputMaybe<Scalars['DateTime']>;
  senderId?: InputMaybe<Scalars['ID']>;
  typeId?: InputMaybe<Scalars['ID']>;
  updatedAt?: InputMaybe<Scalars['DateTime']>;
};

export type gql_NotificationInbox = {
  __typename?: 'NotificationInbox';
  createdAt: Scalars['DateTime'];
  id: Scalars['UUID'];
  notificationId: Scalars['UUID'];
  readAt?: Maybe<Scalars['DateTime']>;
  senderId?: Maybe<Scalars['UUID']>;
  updatedAt: Scalars['DateTime'];
  userId: Scalars['UUID'];
  value: Scalars['JSON'];
};

export type gql_NotificationInboxConnection = {
  __typename?: 'NotificationInboxConnection';
  /** A list of edges. */
  edges: Array<gql_NotificationInboxEdge>;
  /** A list of nodes. */
  nodes: Array<gql_NotificationInbox>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_NotificationInboxEdge = {
  __typename?: 'NotificationInboxEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_NotificationInbox;
};

export type gql_NotificationRawChannelInput = {
  channel: gql_Channel;
  value: Scalars['JSON'];
};

export type gql_NotificationRecipient = {
  __typename?: 'NotificationRecipient';
  createdAt: Scalars['DateTime'];
  id: Scalars['UUID'];
  notificationId?: Maybe<Scalars['UUID']>;
  readAt?: Maybe<Scalars['DateTime']>;
  sentAt?: Maybe<Scalars['DateTime']>;
  updatedAt: Scalars['DateTime'];
  userId?: Maybe<Scalars['UUID']>;
};

export enum gql_NotificationSortByKeys {
  Id = 'id'
}

export type gql_NotificationType = {
  __typename?: 'NotificationType';
  active: Scalars['Boolean'];
  app?: Maybe<gql_App>;
  appId: Scalars['UUID'];
  createdAt: Scalars['DateTime'];
  description: Scalars['String'];
  emailEnabled: Scalars['Boolean'];
  emailTemplateHtmlPath?: Maybe<Scalars['String']>;
  emailTemplateSubject?: Maybe<Scalars['String']>;
  emailTemplateText?: Maybe<Scalars['String']>;
  id: Scalars['UUID'];
  name: Scalars['String'];
  notificationCenterBody?: Maybe<Scalars['String']>;
  notificationCenterClickUrl?: Maybe<Scalars['String']>;
  notificationCenterEnabled: Scalars['Boolean'];
  notificationCenterIcon?: Maybe<Scalars['String']>;
  notificationCenterTitle?: Maybe<Scalars['String']>;
  slug: Scalars['String'];
  smsEnabled: Scalars['Boolean'];
  smsTemplate?: Maybe<Scalars['String']>;
  tempEmailTemplateHtml?: Maybe<Scalars['String']>;
  updatedAt: Scalars['DateTime'];
  webPushEnabled: Scalars['Boolean'];
  webPushTemplate?: Maybe<Scalars['JSON']>;
};

export type gql_NotificationTypeConnection = {
  __typename?: 'NotificationTypeConnection';
  /** A list of edges. */
  edges: Array<gql_NotificationTypeEdge>;
  /** A list of nodes. */
  nodes: Array<gql_NotificationType>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_NotificationTypeEdge = {
  __typename?: 'NotificationTypeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_NotificationType;
};

export type gql_NotificationTypeFilters = {
  appId?: InputMaybe<Scalars['UUID']>;
  ids?: InputMaybe<Array<Scalars['UUID']>>;
  name?: InputMaybe<Scalars['String']>;
};

export enum gql_NotificationTypeSortByKeys {
  CreatedAt = 'createdAt',
  Id = 'id',
  Name = 'name',
  UpdatedAt = 'updatedAt'
}

/** Information about pagination in a connection */
export type gql_PageInfo = {
  __typename?: 'PageInfo';
  /** When paginating forwards, the cursor to continue. */
  endCursor?: Maybe<Scalars['String']>;
  /** When paginating forwards, are there more items? */
  hasNextPage: Scalars['Boolean'];
  /** When paginating backwards, are there more items? */
  hasPreviousPage: Scalars['Boolean'];
  /** When paginating backwards, the cursor to continue. */
  startCursor?: Maybe<Scalars['String']>;
};

export type gql_Query = {
  __typename?: 'Query';
  admin?: Maybe<gql_Admin>;
  adminMe?: Maybe<gql_Admin>;
  admins: gql_AdminConnection;
  adminsCount: Scalars['Int'];
  app?: Maybe<gql_App>;
  appChannel?: Maybe<gql_AppChannel>;
  apps: gql_AppConnection;
  appsCount: Scalars['Int'];
  hc_inbox: gql_NotificationInboxConnection;
  hc_unreadCount: Scalars['Int'];
  hc_userMe?: Maybe<gql_User>;
  notification?: Maybe<gql_Notification>;
  notificationType?: Maybe<gql_NotificationType>;
  notificationTypes: gql_NotificationTypeConnection;
  notificationTypesCount: Scalars['Int'];
  notifications: gql_NotificationConnection;
  notificationsCount: Scalars['Int'];
  user?: Maybe<gql_User>;
  userChannel?: Maybe<gql_UserChannel>;
  userChannels: gql_UserChannelConnection;
  userChannelsCount: Scalars['Int'];
  users: gql_UserConnection;
  usersCount: Scalars['Int'];
};


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


export type gql_QueryAdminsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_AdminFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_AdminSortByKeys>;
};


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


export type gql_QueryAppChannelArgs = {
  appId: Scalars['ID'];
  channel: gql_Channel;
};


export type gql_QueryAppsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_AppFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_AppSortByKeys>;
};


export type gql_QueryHc_InboxArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_InboxFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_InboxSortByKeys>;
};


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


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


export type gql_QueryNotificationTypesArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_NotificationTypeFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_NotificationTypeSortByKeys>;
};


export type gql_QueryNotificationsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_NotificationFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_NotificationSortByKeys>;
};


export type gql_QueryUserArgs = {
  id?: InputMaybe<Scalars['ID']>;
  refId?: InputMaybe<Scalars['ID']>;
};


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


export type gql_QueryUserChannelsArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_UserChannelFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_UserChannelSortByKeys>;
};


export type gql_QueryUsersArgs = {
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<gql_UserFilters>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  revert?: InputMaybe<Scalars['Boolean']>;
  sortBy?: InputMaybe<gql_UserSortByKeys>;
};


export type gql_QueryUsersCountArgs = {
  filters?: InputMaybe<gql_UserFilters>;
};

export type gql_SaveUserData = {
  appId?: InputMaybe<Scalars['ID']>;
  channels?: InputMaybe<Array<gql_UpdateUserChannelInput>>;
  refId?: InputMaybe<Scalars['ID']>;
};

export type gql_UpdateAdminData = {
  email?: InputMaybe<Scalars['String']>;
  firstName?: InputMaybe<Scalars['String']>;
  lastName?: InputMaybe<Scalars['String']>;
  password?: InputMaybe<Scalars['String']>;
  phone?: InputMaybe<Scalars['String']>;
};

export type gql_UpdateAppData = {
  active?: InputMaybe<Scalars['Boolean']>;
  name?: InputMaybe<Scalars['String']>;
};

export type gql_UpdateNotificationTypeData = {
  active?: InputMaybe<Scalars['Boolean']>;
  description?: InputMaybe<Scalars['String']>;
  emailEnabled?: InputMaybe<Scalars['Boolean']>;
  emailTemplateSubject?: InputMaybe<Scalars['String']>;
  emailTemplateText?: InputMaybe<Scalars['String']>;
  name?: InputMaybe<Scalars['String']>;
  notificationCenterBody?: InputMaybe<Scalars['String']>;
  notificationCenterClickUrl?: InputMaybe<Scalars['String']>;
  notificationCenterEnabled?: InputMaybe<Scalars['Boolean']>;
  notificationCenterIcon?: InputMaybe<Scalars['String']>;
  notificationCenterTitle?: InputMaybe<Scalars['String']>;
  slug?: InputMaybe<Scalars['String']>;
  smsEnabled?: InputMaybe<Scalars['Boolean']>;
  smsTemplate?: InputMaybe<Scalars['String']>;
  tempEmailTemplateHtml?: InputMaybe<Scalars['String']>;
  webPushEnabled?: InputMaybe<Scalars['Boolean']>;
  webPushTemplate?: InputMaybe<Scalars['JSON']>;
};

export type gql_UpdateUserChannelData = {
  active?: InputMaybe<Scalars['Boolean']>;
  details?: InputMaybe<Scalars['JSON']>;
};

export type gql_UpdateUserChannelInput = {
  active?: InputMaybe<Scalars['Boolean']>;
  channel?: InputMaybe<gql_Channel>;
  details?: InputMaybe<Scalars['JSON']>;
  id?: InputMaybe<Scalars['ID']>;
  toDelete?: InputMaybe<Scalars['Boolean']>;
};

export type gql_UpdateUserData = {
  channels?: InputMaybe<Array<gql_UpdateUserChannelInput>>;
  refId?: InputMaybe<Scalars['ID']>;
};

export type gql_User = {
  __typename?: 'User';
  app?: Maybe<gql_App>;
  appId: Scalars['UUID'];
  channels: Array<gql_UserChannel>;
  createdAt: Scalars['DateTime'];
  id: Scalars['UUID'];
  refId: Scalars['String'];
  updatedAt: Scalars['DateTime'];
};

export type gql_UserChannel = {
  __typename?: 'UserChannel';
  active: Scalars['Boolean'];
  channel: gql_Channel;
  createdAt: Scalars['DateTime'];
  details: Scalars['JSON'];
  id: Scalars['UUID'];
  updatedAt: Scalars['DateTime'];
  userId: Scalars['UUID'];
};

export type gql_UserChannelConnection = {
  __typename?: 'UserChannelConnection';
  /** A list of edges. */
  edges: Array<gql_UserChannelEdge>;
  /** A list of nodes. */
  nodes: Array<gql_UserChannel>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_UserChannelEdge = {
  __typename?: 'UserChannelEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_UserChannel;
};

export type gql_UserChannelFilters = {
  active?: InputMaybe<Scalars['Boolean']>;
  channel?: InputMaybe<gql_Channel>;
  userId?: InputMaybe<Scalars['UUID']>;
};

export enum gql_UserChannelSortByKeys {
  CreatedAt = 'createdAt',
  Id = 'id'
}

export type gql_UserConnection = {
  __typename?: 'UserConnection';
  /** A list of edges. */
  edges: Array<gql_UserEdge>;
  /** A list of nodes. */
  nodes: Array<gql_User>;
  /** Information to aid in pagination. */
  pageInfo: gql_PageInfo;
};

/** An edge in a connection. */
export type gql_UserEdge = {
  __typename?: 'UserEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String'];
  /** The item at the end of the edge */
  node: gql_User;
};

export type gql_UserFilters = {
  appId?: InputMaybe<Scalars['UUID']>;
  refId?: InputMaybe<Scalars['ID']>;
};

export enum gql_UserSortByKeys {
  CreatedAt = 'createdAt',
  Id = 'id',
  RefId = 'refId'
}

export type gql_UnreadCountQueryQueryVariables = Exact<{ [key: string]: never; }>;


export type gql_UnreadCountQueryQuery = { __typename?: 'Query', unreadCount: number };

export type gql_SetWebPushChannelMutationMutationVariables = Exact<{
  details: Scalars['JSON'];
}>;


export type gql_SetWebPushChannelMutationMutation = { __typename?: 'Mutation', hc_setChannel: { __typename?: 'UserChannel', id: any, details: any, active: boolean } };

export type gql_CreateChannelMutationVariables = Exact<{
  channel: gql_Channel;
  details: Scalars['JSON'];
}>;


export type gql_CreateChannelMutation = { __typename?: 'Mutation', hc_createChannel: { __typename?: 'UserChannel', id: any, userId: any, active: boolean, createdAt: any } };


export const UnreadCountQueryDocument = gql`
    query UnreadCountQuery {
  unreadCount: hc_unreadCount
}
    `;

/**
 * __useUnreadCountQueryQuery__
 *
 * To run a query within a React component, call `useUnreadCountQueryQuery` and pass it any options that fit your needs.
 * When your component renders, `useUnreadCountQueryQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useUnreadCountQueryQuery({
 *   variables: {
 *   },
 * });
 */
export function useUnreadCountQueryQuery(baseOptions?: Apollo.QueryHookOptions<gql_UnreadCountQueryQuery, gql_UnreadCountQueryQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<gql_UnreadCountQueryQuery, gql_UnreadCountQueryQueryVariables>(UnreadCountQueryDocument, options);
      }
export function useUnreadCountQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<gql_UnreadCountQueryQuery, gql_UnreadCountQueryQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<gql_UnreadCountQueryQuery, gql_UnreadCountQueryQueryVariables>(UnreadCountQueryDocument, options);
        }
export type UnreadCountQueryQueryHookResult = ReturnType<typeof useUnreadCountQueryQuery>;
export type UnreadCountQueryLazyQueryHookResult = ReturnType<typeof useUnreadCountQueryLazyQuery>;
export type UnreadCountQueryQueryResult = Apollo.QueryResult<gql_UnreadCountQueryQuery, gql_UnreadCountQueryQueryVariables>;
export const SetWebPushChannelMutationDocument = gql`
    mutation SetWebPushChannelMutation($details: JSON!) {
  hc_setChannel(channel: WEB_PUSH, details: $details, active: true) {
    id
    details
    active
  }
}
    `;
export type gql_SetWebPushChannelMutationMutationFn = Apollo.MutationFunction<gql_SetWebPushChannelMutationMutation, gql_SetWebPushChannelMutationMutationVariables>;

/**
 * __useSetWebPushChannelMutationMutation__
 *
 * To run a mutation, you first call `useSetWebPushChannelMutationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetWebPushChannelMutationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [setWebPushChannelMutationMutation, { data, loading, error }] = useSetWebPushChannelMutationMutation({
 *   variables: {
 *      details: // value for 'details'
 *   },
 * });
 */
export function useSetWebPushChannelMutationMutation(baseOptions?: Apollo.MutationHookOptions<gql_SetWebPushChannelMutationMutation, gql_SetWebPushChannelMutationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<gql_SetWebPushChannelMutationMutation, gql_SetWebPushChannelMutationMutationVariables>(SetWebPushChannelMutationDocument, options);
      }
export type SetWebPushChannelMutationMutationHookResult = ReturnType<typeof useSetWebPushChannelMutationMutation>;
export type SetWebPushChannelMutationMutationResult = Apollo.MutationResult<gql_SetWebPushChannelMutationMutation>;
export type SetWebPushChannelMutationMutationOptions = Apollo.BaseMutationOptions<gql_SetWebPushChannelMutationMutation, gql_SetWebPushChannelMutationMutationVariables>;
export const CreateChannelDocument = gql`
    mutation CreateChannel($channel: Channel!, $details: JSON!) {
  hc_createChannel(channel: $channel, details: $details, active: true) {
    id
    userId
    active
    createdAt
  }
}
    `;
export type gql_CreateChannelMutationFn = Apollo.MutationFunction<gql_CreateChannelMutation, gql_CreateChannelMutationVariables>;

/**
 * __useCreateChannelMutation__
 *
 * To run a mutation, you first call `useCreateChannelMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateChannelMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createChannelMutation, { data, loading, error }] = useCreateChannelMutation({
 *   variables: {
 *      channel: // value for 'channel'
 *      details: // value for 'details'
 *   },
 * });
 */
export function useCreateChannelMutation(baseOptions?: Apollo.MutationHookOptions<gql_CreateChannelMutation, gql_CreateChannelMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<gql_CreateChannelMutation, gql_CreateChannelMutationVariables>(CreateChannelDocument, options);
      }
export type CreateChannelMutationHookResult = ReturnType<typeof useCreateChannelMutation>;
export type CreateChannelMutationResult = Apollo.MutationResult<gql_CreateChannelMutation>;
export type CreateChannelMutationOptions = Apollo.BaseMutationOptions<gql_CreateChannelMutation, gql_CreateChannelMutationVariables>;