// [autogen: artifact] AUTOMATICALLY GENERATED FILE. NOT DO EDIT BY HAND.

import { gql } from '@kazoohr/graphql';
import * as ApolloReactCommon from '@kazoohr/graphql/common';
import * as ApolloReactHooks from '@kazoohr/graphql/hooks';
export type Maybe<T> = T | undefined;
export type InputMaybe<T> = T | undefined;
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 interface Scalars {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  Upload: any;
  /** All dates within this schema are ISO-8601 strings without time or timezone. */
  Date: any;
  /** All date-times are supposed to be are ISO-8601 strings, but we do accept input in other formats.  That behavior will change and we will replace Date and DateTime's behavior with that of StrictDate. */
  DateTime: any;
  /** A datetime input and output type only accepts ISO-8601 dates. */
  StrictDateTimeInput: String;
  /** General-use Upload input scalar */
  FileToUpload: any;
  /** General-use scalar to use for fields of JSON data. See https://www.npmjs.com/package/graphql-type-json for more information. */
  JSONObject: any;
  /** Represents a rich text document in its native ProseMirror document format. This is a JSON object with a specific schema. Use a TipTap editor instance from the @kazoohr/richtext-components package to interact with this format. */
  RichTextDocument: any;
}

export interface Person {
  __typename?: 'Person';
  /** globally unique identifier. Kazoo-assigned. */
  id: Scalars['ID'];
  /**
   * An identifier that can be used to resolve references to this recognition via
   * either its Kazoo ID or its YEI ID, since subgraphs can normally only resolve
   * references to entities by a single key type.  Acceptable values are:
   * - `kazoo:uuid` for a Kazoo ID (`id`)
   * - `yei:uuid` for a YEI ID (`yeiRecognitionId`)
   */
  _federationKey?: Maybe<Scalars['ID']>;
  /** Company for which they work. */
  company?: Maybe<Company>;
  /** returns the registered identity id for this user. If a company uses employee_id, this is an employee_id. Emails, this is an email. */
  identifier: Scalars['String'];
  /** The email address of the person. This is only queryable in certain contexts (self, admin, directoryGateway). */
  email?: Maybe<Scalars['String']>;
  /** username - typically workspace/username e.g. comcast/aliceExample.  Mainly presentational since auth is part of identity accounts */
  username?: Maybe<Scalars['String']>;
  /** Accounts such as legacy Highground Id, legacy YouEarnedIt Id.  May extend to authentication provider account id later. */
  identities: Array<Identity>;
  /** Most people have a direct manager. */
  manager?: Maybe<Person>;
  /** Chain of managers and their managers extending upwards from this employee */
  reportsInto: PersonConnection;
  /** Filtered and paginated list of direct and indirect reports. */
  reports: PersonConnection;
  /** These are all group memberships that are not department or location, e.g. 2019 Interns or Team Bravo. Filters the groups by type.  Only administrators may request PRIVATE groups. */
  groups: Array<Group>;
  /** Department represents the administrative unit the person belongs to.  Goals, for instance, has Department Goals. */
  department?: Maybe<Department>;
  /** This can be as granular as desired. E.g. US, or Chicago, or 363 W Erie. */
  location?: Maybe<Location>;
  /** Information about the Country assigned to this person.  Not the same as Location necessarily.  Mainly used for tax reporting associated with rewards. */
  country: Country;
  /** Person's job title.  e.g. Account Executive, Customer Service Representative II */
  title?: Maybe<Scalars['String']>;
  /**
   * Tracks if they are active or inactive.  Paused indicates they plan on returning to work.
   * Changing the status of someone to ARCHIVE does not delete any of their relationships with any other table/entity
   */
  status: PersonStatus;
  /** The person's name. */
  name: Scalars['String'];
  /** Open text field for sharing bio, mission statement, shocking facts, likes, dislikes, pets, etc. */
  aboutMe?: Maybe<Scalars['String']>;
  /**
   * public url of their profile picture.
   * @deprecated use avatarUrl(format) instead
   */
  profileImageUrl?: Maybe<Scalars['String']>;
  /** Month and day of their birthday */
  birthday?: Maybe<MonthDay>;
  /** Full date of birth */
  dateOfBirth?: Maybe<Scalars['DateTime']>;
  /** Month and day of their work anniversary */
  workAnniversary?: Maybe<MonthDay>;
  /** Employment Start Date as ISO-8601 - may be used for anniversaries, managing rewards or 'grandfather' policies. */
  employmentStartDate?: Maybe<Scalars['DateTime']>;
  /** ISO 639-1 ISO 3316-1 language code e.g. en-US, es-MX. */
  locale: Scalars['String'];
  /** showBirthday, showAnniversary belong to on user profile */
  profileSettings?: Maybe<ProfileSettings>;
  /** When true, this person is exempt from being auto-archived through directory ingestion/import operations. */
  exemptFromAutoArchive: Scalars['Boolean'];
  /** list of departments, locations, and groups they own */
  ownerOf: PersonResponsibleFor;
  /** list of departments, locations, and groups they administer */
  administratorOf: PersonResponsibleFor;
  avatarUrl?: Maybe<Scalars['String']>;
  roles: Array<Role>;
  /**
   * This field returns an object containing information about what the context
   * can do on the resources that belong to the Person. The use-case for this
   * object is to allow other API's to figure out if a User can edit the resources
   * that belong to another User, as it would be the case for Users who are
   * administrators of Groups, Locations or Departments that contain the target User.
   *
   * It is highly encouraged to forward whatever context you already have when you
   * query this field instead of building one-off contexts. Do not query this field
   * with a Robot context, for example, as it would just automatically have most -if
   * not all- permissions granted, defeating the purpose of this object.
   * More succinctly, just call this resolver with whatever context is coming from
   * React-land, or whichever client is calling your API.
   */
  permissions: DirectoryPermissions;
  /**
   * Each module is a personSegment defined by our customer admins.
   * This field represents which modules include this particular Person.
   */
  enabledModules: Array<PeopleSegmentModule>;
  /** This field returns the segments this Person is a member of. */
  segments: Array<PeopleSegment>;
  /** Optional person who has access to review my performance modules (logic implemented in each api ie. for check-ins api/check-ins/entities/CheckIn.ts) */
  secondaryManager?: Maybe<Person>;
  /** Returns array of People for whom the subject Person is the secondary manager. */
  secondaryManagerOf: Array<Person>;
  /** This field is to identify if person is an admin */
  isAdmin?: Maybe<Scalars['Boolean']>;
  /** Internal date when the person record was created in the platform. Not a record of length of employment or any other employment markers. */
  createdAt: Scalars['Date'];
  /**
   * Returns all custom attributes EXCEPT private attributes.
   * Private attributes do not appear in this list when requested by users or administrators.
   */
  customAttributes: Array<CustomAttributeValue>;
  /** Returns the batch that this was created in, if it was created as part of a batch op. */
  createdInBatch?: Maybe<DirectoryBatch>;
  /** Returns data to be used in the UI for this person. These are non-canonical representations of the person's data. For actual points data, use queries to points api. */
  columnUiIndexes: DirectoryIndexes;
  assists: Array<PersonAssistant>;
  assistedBy: Array<PersonAssistant>;
  isManagerOfManagers: Scalars['Boolean'];
  phoneNumbers: Array<PhoneNumber>;
}


export interface PersonIdentitiesArgs {
  filter?: PersonIdentityFilterInput;
}


export interface PersonManagerArgs {
  skipIfInactive?: InputMaybe<Scalars['Boolean']>;
}


export interface PersonReportsIntoArgs {
  filter?: QueryPersonHierarchyInput;
  sort?: InputMaybe<Array<QueryPersonHierarchySortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface PersonReportsArgs {
  filter?: QueryPersonHierarchyInput;
  sort?: InputMaybe<Array<QueryPersonHierarchySortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface PersonGroupsArgs {
  type?: InputMaybe<Array<GroupType>>;
}


export interface PersonNameArgs {
  format?: InputMaybe<NameFormat>;
}


export interface PersonOwnerOfArgs {
  showInactive?: InputMaybe<Scalars['Boolean']>;
  hierarchyType?: InputMaybe<HierarchyType>;
}


export interface PersonAdministratorOfArgs {
  showInactive?: InputMaybe<Scalars['Boolean']>;
  hierarchyType?: InputMaybe<HierarchyType>;
}


export interface PersonAvatarUrlArgs {
  format?: InputMaybe<AvatarFormat>;
}


export interface PersonSecondaryManagerArgs {
  fallbackToPrimaryManager?: InputMaybe<Scalars['Boolean']>;
}


export interface PersonCustomAttributesArgs {
  includeArchived?: InputMaybe<Scalars['Boolean']>;
  includePrivate?: InputMaybe<Scalars['Boolean']>;
  includeUnmapped?: InputMaybe<Scalars['Boolean']>;
  category?: InputMaybe<CustomAttributeValuesCategory>;
  categories?: InputMaybe<Array<CustomAttributeValuesCategory>>;
}


export interface PersonPhoneNumbersArgs {
  type?: InputMaybe<Array<PersonPhoneNumberType>>;
}

export interface Mutation {
  __typename?: 'Mutation';
  /** Uploads a document to be used by the AI assistant */
  uploadAIAssistantDocument: UploadAiAssistantDocumentPayload;
  /** Updates an existing AI assistant document */
  updateAIAssistantDocument: UploadAiAssistantDocumentPayload;
  /** Deletes an existing AI assistant document */
  deleteAIAssistantDocument: DeleteAiAssistantDocumentPayload;
  /** Updates the AI assistant conversation settings */
  updateAIAssistantSettings: UpdateAiAssistantSettingsPayload;
  /** Appends a message in a conversation. If the conversation doesn't exist, it will be created. */
  appendMessage: AppendMessagePayload;
  /** Creates a new conversation. */
  createConversation: CreateConversationPayload;
  /** Deletes a conversation. */
  deleteConversation: DeleteConversationPayload;
  /** Updates a conversation title. */
  updateConversationTitle: UpdateConversationTitlePayload;
  /** Create or update a rating for an AI-generated response. If a rating already exists for this user + response, it will be updated. At least one of userRating or userComment must be provided. */
  createOrUpdateAiResponseRating: AiResponseRating;
  /** Deletes all GenAI response ratings for a specific workspace. Superadmin only. */
  deleteWorkspaceGenAIResponseRatings: DeleteWorkspaceGenAiResponseRatingsPayload;
  /** like it says on the box: it creates or updates a given person. */
  createOrUpdatePerson: CreateOrUpdateOperationPayload;
  /** like it says on the box: it creates or updates a given group. */
  createOrUpdateGroup: CreateOrUpdateOperationPayload;
  /** like it says on the box: it creates or updates a given department. */
  createOrUpdateDepartment: CreateOrUpdateOperationPayload;
  /** like it says on the box: it creates or updates a given location. */
  createOrUpdateLocation: CreateOrUpdateOperationPayload;
  createOrUpdateCompany: CreateOrUpdateOperationPayload;
  createOrUpdateCustomAttribute: CreateOrUpdateOperationPayload;
  stageAvatar: StagedAvatarPayload;
  updateCompanySettings: CreateOrUpdateOperationPayload;
  /** allows user to update their profile */
  updateUserProfile: CreateOrUpdateOperationPayload;
  updateActivationRequest: ActivationRequest;
  /** Used to modify segments that can control either module access or some other more granular api action. */
  createOrUpdatePeopleSegment: CreateOrUpdateOperationPayload;
  /**
   * Archives the people segment so it won't be updated anymore and
   * deletes the membership data we have stored for it.
   * Archived segments will simply return an empty list of members.
   * This is a destructive operation, it cannot be undone.
   */
  archivePeopleSegment: CreateOrUpdateOperationPayload;
  /** Clones the people segment so it can be modified without affecting the original. */
  clonePeopleSegment: ClonePeopleSegmentPayload;
  /** Used to enqueue task processing */
  enqueueLegacyEntities: ProcessLegacyEntitiesPayload;
  /** Used to map a Kazoo field to Pulse */
  createOrUpdateKazooFieldMappings: CreateOrUpdateOperationPayload;
  /** Archives anyone in the current workspace who was created|updated|errored|no-op in the batch. */
  archivePeopleNotInBatch: ArchivePeopleNotInBatchPayload;
  /** Temporary mutation that lets platform admins hard delete a field mapping between TW and Pulse. */
  purgePulseMapping: Scalars['Boolean'];
  /** Stages people IDs into a Redis cache to commit later in a single transaction. */
  stagePeopleForSegment: StagePeopleForSegmentPayload;
  /** Used to write/update data into the index tables */
  updateDirectoryIndex: UpdateDirectoryIndexPayload;
  /** Manually attempt to clean up archived directory events. Limited to platform administrators. */
  cleanDirectoryEvents: CleanDirectoryEventsPayload;
  /** Allows users who can manage other users in the admin UI to set the columns they'd like to appear on the users table. */
  setPersonUiColumns: Array<PersonUiColumn>;
  /** Allows platform admins only to insert a LegacyCdcYeiCompany into directory. Intended for use in automation tests only. */
  insertTestCdcCompany: LegacyCdcYeiCompany;
  /**
   * Some People are missing YEI Identities. Provide Person IDs regardless of workspace, and if they don't have YEI ids, they will be purged.
   * Each person ID will be processed in a separate job.
   *
   * Limited to 500 IDs at a time.
   */
  purgeUnlinkedPeople: PurgeUnlinkedPeopleResult;
  /**
   * Some People have YEI Identities, but they are not linked to the KW Person counterpart.
   * Provide Person IDs regardless of workspace, and their email or employee id will be used to find and link their YEI user.
   *
   * Limited to 250 IDs at a time.
   */
  linkPeopleIdentities: LinkPeopleIdentitiesResult;
  /**
   * Enqueues a task to create activity attributes for all active companies.
   * Limited to super admins only. Returns a job id
   */
  enqueueCreateCompanyActivityAttributesPerCompany: Scalars['String'];
  /**
   * Enqueues a task to create activity attributes for the current workspace.
   * Limited to super admins only. Returns a job id
   */
  enqueueCreateCompanyActivityAttributesForWorkspace: Scalars['String'];
  /**
   * Enqueues a task to clean up activity attributes that are not in the required list.
   * Limited to platform admins only. Returns a job ID.
   */
  cleanupActivityAttributes: Scalars['String'];
  /**
   * Enqueues a task to send activation emails for all the active people in the current workspace.
   * Limited to admins and platform admins. Returns a job ID.
   */
  enqueueActivationRequestForWorkspace: EnqueueActivationRequestForWorkspacePayload;
  apiPing: Scalars['String'];
}


export interface MutationUploadAiAssistantDocumentArgs {
  input: UploadAiAssistantDocumentInput;
}


export interface MutationUpdateAiAssistantDocumentArgs {
  input: UpdateAiAssistantDocumentInput;
}


export interface MutationDeleteAiAssistantDocumentArgs {
  input: DeleteAiAssistantDocumentInput;
}


export interface MutationUpdateAiAssistantSettingsArgs {
  input: UpdateAiAssistantSettingsInput;
}


export interface MutationAppendMessageArgs {
  input: AppendMessageInput;
}


export interface MutationCreateConversationArgs {
  input: CreateConversationInput;
}


export interface MutationDeleteConversationArgs {
  input: DeleteConversationInput;
}


export interface MutationUpdateConversationTitleArgs {
  input: UpdateConversationTitleInput;
}


export interface MutationCreateOrUpdateAiResponseRatingArgs {
  input: CreateAiResponseRatingInput;
}


export interface MutationDeleteWorkspaceGenAiResponseRatingsArgs {
  input: DeleteWorkspaceGenAiResponseRatingsInput;
}


export interface MutationCreateOrUpdatePersonArgs {
  input: CreateOrUpdatePersonInput;
}


export interface MutationCreateOrUpdateGroupArgs {
  input: CreateOrUpdateGroupInput;
}


export interface MutationCreateOrUpdateDepartmentArgs {
  input: CreateOrUpdateDepartmentInput;
}


export interface MutationCreateOrUpdateLocationArgs {
  input: CreateOrUpdateLocationInput;
}


export interface MutationCreateOrUpdateCompanyArgs {
  input: CreateOrUpdateCompanyInput;
}


export interface MutationCreateOrUpdateCustomAttributeArgs {
  input: CreateOrUpdateCustomAttributeInput;
}


export interface MutationStageAvatarArgs {
  file: Scalars['Upload'];
}


export interface MutationUpdateCompanySettingsArgs {
  input: UpdateCompanySettingsInput;
}


export interface MutationUpdateUserProfileArgs {
  input: UpdateUserProfileInput;
}


export interface MutationUpdateActivationRequestArgs {
  input: UpdateActivationRequestInput;
}


export interface MutationCreateOrUpdatePeopleSegmentArgs {
  input: CreateOrUpdatePeopleSegmentInput;
}


export interface MutationArchivePeopleSegmentArgs {
  id: Scalars['ID'];
}


export interface MutationClonePeopleSegmentArgs {
  id: Scalars['ID'];
}


export interface MutationEnqueueLegacyEntitiesArgs {
  input: ProcessLegacyEntitiesInput;
}


export interface MutationCreateOrUpdateKazooFieldMappingsArgs {
  input: CreateOrUpdateKazooFieldMappingsInput;
}


export interface MutationArchivePeopleNotInBatchArgs {
  input: ArchivePeopleNotInBatchInput;
}


export interface MutationPurgePulseMappingArgs {
  field: KazooField;
}


export interface MutationStagePeopleForSegmentArgs {
  input: StagePeopleForSegmentInput;
}


export interface MutationUpdateDirectoryIndexArgs {
  input: DirectoryIndexInput;
}


export interface MutationCleanDirectoryEventsArgs {
  input?: InputMaybe<CleanDirectoryEventsInput>;
}


export interface MutationSetPersonUiColumnsArgs {
  input?: InputMaybe<Array<PersonUiColumn>>;
}


export interface MutationInsertTestCdcCompanyArgs {
  input: InsertLegacyCdcYeiCompany;
}


export interface MutationPurgeUnlinkedPeopleArgs {
  ids: Array<Scalars['ID']>;
}


export interface MutationLinkPeopleIdentitiesArgs {
  ids: Array<Scalars['ID']>;
}

export interface Query {
  __typename?: 'Query';
  /** Search AI assistant documents with a text query */
  searchAIAssistantDocuments: Array<SearchAiAssistantDocumentsResult>;
  /** Gets a list of all the AI Document Uploads */
  aiDocumentUploads: AiAssistantDocumentsConnection;
  /** Gets the current AI assistant settings */
  aiAssistantSettings: AiAssistantSettings;
  /** Get a list of all the conversations */
  getConversations: Array<Conversation>;
  aiAssistantConversation: Conversation;
  getConversationMessages: Array<Message>;
  /** Get AI response rating by response type and ID */
  getAiResponseRating?: Maybe<AiResponseRating>;
  /** Returns a single person */
  person?: Maybe<Person>;
  /** executes a people search */
  people: PersonConnection;
  /** Returns an array of ids of people who are in `status` and are NOT in the set of ids provided.  This is used for bulk deactivating users. */
  peopleNotInSet?: Maybe<Array<IdResult>>;
  /** Gets any Company by identifier (Kazoo ID or workspace). */
  company?: Maybe<Company>;
  /** Gets a Legacy Cdc Yei Company */
  legacyYeiCompany?: Maybe<LegacyYeiCompany>;
  /** Gets Legacy Cdc Yei Companies */
  legacyYeiCompanies: Array<LegacyYeiCompany>;
  /** gets any arbitrary group */
  group?: Maybe<Group>;
  /** gets an array of groups */
  groups: GroupConnection;
  /** Returns a single department */
  department?: Maybe<Department>;
  departments: DepartmentConnection;
  /** Returns list of available languages  */
  locale: Array<Scalars['String']>;
  /** Returns a single location */
  location?: Maybe<Location>;
  locations: LocationConnection;
  directoryEvent?: Maybe<DirectoryEvent>;
  /** Returns events for a given business object. Note: only returns _already processed events_. Events that have yet to be broadcast are not yet considered to have happened, so won't appear here. */
  directoryEvents?: Maybe<DirectoryEventConnection>;
  country?: Maybe<Country>;
  /** Returns an array of people who lack this identity provider */
  peopleWithoutIdentityProvider: PersonConnection;
  countries: Array<Country>;
  /** Returns timezones, filtered by country. */
  timezones: Array<Timezone>;
  /** returns the options for a valid default identity provider for the current company */
  companyDefaultIdentityProviders: Array<PersonIdentityProvider>;
  activationRequest: ActivationRequest;
  /** Takes a segment id that an API or module access can use to return user segments. */
  peopleSegment: PeopleSegment;
  /** Returns the people segments that were created for the company modules filters by module or returns all module segments by default. Does NOT return all segments at a company. */
  moduleSegments?: Maybe<Array<PeopleSegment>>;
  /** Returns the list of things related to custom attributes the current user can do. */
  customAttributeCapabilities: CustomAttributeCapabilities;
  /**
   * Takes a CSV upload input and returns an object with the total row count and the Person Kazoo IDs for any people whose identifiers are found at the company in the supplied context.
   * This will extract either email or employee id from the CSV, as per the company default identifier.
   *
   * This query can optionally take in a module the persons in the CSV must have access to so the list is narrowed down.
   */
  peopleIdsInCsv: CsvUploadContents;
  /** Allows platform admins to load every company in the system, ordered by workspace. */
  companies: CompanyConnection;
  /** Returns the steps and current status for aligning Pulse attributes for the current company */
  pulseAttributeAlignmentTasks: PulseAttributeAlignmentTasksPayload;
  /** Returns a single custom attribute definition. */
  customAttribute: CustomAttribute;
  /** Returns custom attributes for your company. */
  customAttributes: CustomAttributeConnection;
  /** Returns a single Pulse mapping attribute definition. */
  fieldMapping: FieldMapping;
  /** Returns a batch that was executed against directory */
  directoryBatch?: Maybe<DirectoryBatch>;
  /** Returns an array of all KazooFields and CustomAttributes available to be mapped using createOrUpdateKazooFieldMappings mutation. */
  mappableFields: Array<MappableField>;
  /** For users who can administer other users, this query returns the columns that the current user will see on that user table. */
  personUiColumns: PersonUiColumnsResponse;
  accessCapabilities: AccessCapabilities;
  apiPing: Scalars['String'];
}


export interface QuerySearchAiAssistantDocumentsArgs {
  input: SearchAiAssistantDocumentsInput;
}


export interface QueryAiDocumentUploadsArgs {
  filter?: InputMaybe<AiAssistantDocumentFilterInput>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
}


export interface QueryAiAssistantConversationArgs {
  input: ConversationInput;
}


export interface QueryGetConversationMessagesArgs {
  input: ConversationMessagesInput;
}


export interface QueryGetAiResponseRatingArgs {
  input: GetAiResponseRatingInput;
}


export interface QueryPersonArgs {
  identifier: PersonIdentityInput;
}


export interface QueryPeopleArgs {
  filters?: InputMaybe<Array<QueryPeopleInput>>;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface QueryPeopleNotInSetArgs {
  ids: Array<Scalars['ID']>;
  status: Array<PersonStatus>;
  workspace?: InputMaybe<Scalars['String']>;
}


export interface QueryCompanyArgs {
  identifier?: InputMaybe<CompanyIdentifierInput>;
}


export interface QueryLegacyYeiCompanyArgs {
  yeiCompanyId?: InputMaybe<Scalars['ID']>;
  workspace?: InputMaybe<Scalars['String']>;
}


export interface QueryLegacyYeiCompaniesArgs {
  status?: InputMaybe<LegacyCdcYeiCompanyStatus>;
}


export interface QueryGroupArgs {
  identifier: EntityIdentifierInput;
}


export interface QueryGroupsArgs {
  filter?: InputMaybe<QueryGroupFilter>;
  sort?: InputMaybe<QueryEntitiesSortInput>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface QueryDepartmentArgs {
  identifier: EntityIdentifierInput;
}


export interface QueryDepartmentsArgs {
  filter?: InputMaybe<QueryEntitiesFilter>;
  sort?: InputMaybe<QueryEntitiesSortInput>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface QueryLocationArgs {
  identifier: EntityIdentifierInput;
}


export interface QueryLocationsArgs {
  filter?: InputMaybe<QueryEntitiesFilter>;
  sort?: InputMaybe<QueryEntitiesSortInput>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}


export interface QueryDirectoryEventArgs {
  id: Scalars['ID'];
}


export interface QueryDirectoryEventsArgs {
  filter?: InputMaybe<DirectoryEventQueryFilter>;
  first?: Scalars['Int'];
  after?: InputMaybe<Scalars['String']>;
  sortOrder: DirectoryEventSort;
}


export interface QueryCountryArgs {
  input: Scalars['String'];
}


export interface QueryPeopleWithoutIdentityProviderArgs {
  filter: QueryPeopleWithoutIdentityProviderFilterInput;
  after?: InputMaybe<Scalars['String']>;
  first?: Scalars['Int'];
  sort?: InputMaybe<Array<PersonSortInput>>;
}


export interface QueryTimezonesArgs {
  country: Scalars['String'];
}


export interface QueryActivationRequestArgs {
  id: Scalars['ID'];
}


export interface QueryPeopleSegmentArgs {
  id: Scalars['ID'];
}


export interface QueryModuleSegmentsArgs {
  filter?: InputMaybe<PeopleSegmentsFilter>;
}


export interface QueryPeopleIdsInCsvArgs {
  csvFile: Scalars['Upload'];
  restrictToModule?: InputMaybe<PeopleSegmentModule>;
}


export interface QueryCompaniesArgs {
  filter?: InputMaybe<CompaniesFilterInput>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
}


export interface QueryCustomAttributeArgs {
  id: Scalars['ID'];
}


export interface QueryCustomAttributesArgs {
  filter?: InputMaybe<CustomAttributeQueryFilter>;
  sort?: InputMaybe<Array<CustomAttributeQuerySort>>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
}


export interface QueryFieldMappingArgs {
  id: Scalars['ID'];
}


export interface QueryDirectoryBatchArgs {
  id: Scalars['ID'];
}

export interface AiAssistantDocument {
  __typename?: 'AIAssistantDocument';
  /** The id of the file. */
  id: Scalars['ID'];
  /** The original filename of the file. */
  originalFileName: Scalars['String'];
  /** The filename of the file. */
  fileName?: Maybe<Scalars['String']>;
  /** The mimetype of the file. */
  mimeType: Scalars['String'];
  /** The size of the file (defaults to KB). */
  fileSize: Scalars['Float'];
  /** The user who uploaded the file. */
  owner?: Maybe<Person>;
  /** The status of the file. */
  status: AiAssistantDocumentStatus;
  /** The category of the document. */
  category?: Maybe<AiAssistantDocumentCategory>;
  /** The permission of the document. */
  permission?: Maybe<AiAssistantDocumentPermission>;
  /** A summary of the document content. */
  summary?: Maybe<Scalars['String']>;
  /** Signed URL from GCP cloud storage, valid for urlDuration (seconds, default is 1 hr). */
  url: Scalars['String'];
  /** When the upload is set to expire (null if the file has not been activated). */
  expiresAt?: Maybe<Scalars['DateTime']>;
  /** Identifier for instigator of the update. */
  principal?: Maybe<Scalars['String']>;
  /** When the document was last updated. */
  updatedAt?: Maybe<Scalars['DateTime']>;
}


export interface AiAssistantDocumentFileSizeArgs {
  units?: InputMaybe<AiAssistantDocumentSize>;
}


export interface AiAssistantDocumentUrlArgs {
  urlDuration?: InputMaybe<Scalars['Int']>;
}

export interface Message {
  __typename?: 'Message';
  /** The unique identifier of the message. */
  id: Scalars['ID'];
  /** The role of the message. */
  role: AiAssistantConversationMessageRole;
  /** The text content of the message. */
  messageText: Scalars['String'];
  /** The conversation that the message belongs to. */
  conversationId: Scalars['String'];
  /** Optional metadata for the message to store such as toolNames etc */
  metadata?: Maybe<Scalars['JSONObject']>;
  /** The user's feedback rating for this message, if one exists. */
  aiResponseRating?: Maybe<AiResponseRating>;
}

export interface Conversation {
  __typename?: 'Conversation';
  /** The unique identifier of the conversation which is the same as the id of the conversation. */
  id: Scalars['ID'];
  /** The messages in the conversation. */
  messages: Array<Message>;
  /** The user who participated in the conversation. */
  userId: Scalars['String'];
  /** The workspace that the conversation belongs to. */
  workspace: Scalars['String'];
  /** The title of the conversation. */
  title: Scalars['String'];
  /** The date and time when the conversation was last updated. */
  updatedAt?: Maybe<Scalars['DateTime']>;
}

export interface AiResponseRating {
  __typename?: 'AiResponseRating';
  /** The unique identifier of the rating. */
  id: Scalars['ID'];
  /** Type of response being rated. */
  responseType: AiResponseType;
  /** ID of the rated response. */
  responseId: Scalars['ID'];
  /** Full text of the generated AI message that was rated. */
  genAiMessage: Scalars['String'];
  /** Timestamp when the AI message was created. */
  genAiMessageTimestamp: Scalars['DateTime'];
  /** User rating of the message (thumbs up or down). */
  userRating?: Maybe<AiRatingValue>;
  /** Optional comment from the user about the rated message. */
  userComment?: Maybe<Scalars['String']>;
  /** User identifier (UUID or stringified INT). */
  userIdentifier: Scalars['String'];
  /** Type of user identifier. */
  userIdentifierType: UserIdentifierType;
  /** Workspace identifier. */
  workspace: Scalars['String'];
  /** When the rating was created. */
  createdAt: Scalars['DateTime'];
  /** When the rating was last updated. */
  updatedAt: Scalars['DateTime'];
}

export type AiAssistantDocumentStatus =
  /** A document that has been successfully processed and is ready for use */
  | 'ACTIVE'
  /** A document that has been deleted */
  | 'DELETED'
  /** A document that failed processing */
  | 'FAILED'
  /** A document that is currently being processed by the AI assistant */
  | 'PROCESSING'
  /** A document that has been marked as purged when a user is purged from directory for later deletion */
  | 'PURGED'
  /** A document that has been disassociated from all feature entities */
  | 'REMOVED';

export type AiAssistantDocumentCategory =
  /** Awards and nominations documents */
  | 'AWARDS_AND_NOMINATIONS'
  /** Career path and progression documents */
  | 'CAREER_PATH_AND_PROGRESSION'
  /** Error message documents */
  | 'ERROR_MESSAGE'
  /** Financial data documents */
  | 'FINANCIAL_DATA'
  /** HRIS information documents */
  | 'HRIS_INFORMATION'
  /** Other documents that don't fit into specific categories */
  | 'OTHER'
  /** Performance management documents */
  | 'PERFORMANCE_MANAGEMENT'
  /** Platform activity documents */
  | 'PLATFORM_ACTIVITY'
  /** Recognition-related documents */
  | 'RECOGNITION';

export type AiAssistantDocumentPermission =
  /** Document is accessible only to admins and analysts */
  | 'ADMIN_AND_ANALYSTS'
  /** Document is accessible to everyone in the workspace */
  | 'EVERYONE'
  /** Document is accessible only to managers */
  | 'MANAGERS';

export type AiAssistantDocumentSize =
  | 'B'
  | 'KB'
  | 'MB';

export type AiAssistantConversationStyle =
  /** Business casual, professional but not too formal */
  | 'BUSINESS_CASUAL'
  /** Casual, friendly and relaxed communication style */
  | 'CASUAL'
  /** Formal, strictly business communication style */
  | 'FORMAL';

export type AiAssistantConversationTone =
  /** Direct and straightforward tone */
  | 'DIRECT'
  /** Empathetic and understanding tone */
  | 'EMPATHETIC';

export type AiAssistantVoice =
  /** Aoede voice type */
  | 'AOEDE'
  /** Charon voice type */
  | 'CHARON'
  /** Fenrir voice type */
  | 'FENRIR'
  /** Kore voice type */
  | 'KORE'
  /** Leda voice type */
  | 'LEDA'
  /** Orus voice type */
  | 'ORUS'
  /** Puck voice type */
  | 'PUCK'
  /** Zephyr voice type */
  | 'ZEPHYR';

export type AiAssistantConversationMessageRole =
  /** A message that was sent by the LLM */
  | 'MODEL'
  /** A message comes from tool calling. */
  | 'TOOL'
  /** A message that was sent by the user. */
  | 'USER';

export type AiResponseType =
  /** Work Tango Coach message */
  | 'WTC_MESSAGE'
  /** Survey summary */
  | 'SURVEY_SUMMARY'
  /** Comments summary */
  | 'COMMENTS_SUMMARY';

export type AiRatingValue =
  /** Thumbs up rating */
  | 'THUMBS_UP'
  /** Thumbs down rating */
  | 'THUMBS_DOWN';

export type UserIdentifierType =
  /** Kazoo person ID */
  | 'KAZOO_ID'
  /** Pulse user ID */
  | 'PULSE_ID';

export interface ConversationInput {
  conversationId: Scalars['String'];
}

export interface UploadAiAssistantDocumentInput {
  file: Scalars['Upload'];
}

export interface UpdateAiAssistantDocumentInput {
  id: Scalars['ID'];
  category?: InputMaybe<AiAssistantDocumentCategory>;
  permission?: InputMaybe<AiAssistantDocumentPermission>;
  summary?: InputMaybe<Scalars['String']>;
  fileName?: InputMaybe<Scalars['String']>;
}

export interface DeleteAiAssistantDocumentInput {
  id: Scalars['ID'];
}

export interface UpdateAiAssistantSettingsInput {
  /** The preferred conversation style */
  conversationStyle?: InputMaybe<AiAssistantConversationStyle>;
  /** The preferred conversation tone */
  conversationTone?: InputMaybe<AiAssistantConversationTone>;
  /** The preferred AI assistant voice */
  voice?: InputMaybe<AiAssistantVoice>;
}

export interface CreateConversationInput {
  title: Scalars['String'];
  messages: Array<MessageInput>;
}

export interface AppendMessageInput {
  conversationId: Scalars['String'];
  message: MessageInput;
}

export interface UpdateConversationTitleInput {
  conversationId: Scalars['String'];
  title: Scalars['String'];
}

export interface DeleteConversationInput {
  conversationId: Scalars['String'];
}

export interface MessageInput {
  /** If supplied, we will use this ID, otherwise, we will generate a new one. If this ID exists, this mutation will fail. */
  id?: InputMaybe<Scalars['String']>;
  role: AiAssistantConversationMessageRole;
  messageText: Scalars['String'];
  metadata?: InputMaybe<Scalars['JSONObject']>;
}

export interface CreateAiResponseRatingInput {
  /** Type of response being rated. */
  responseType: AiResponseType;
  /** ID of the rated response. */
  responseId: Scalars['ID'];
  /** Full text of the generated AI message that was rated. */
  genAiMessage: Scalars['String'];
  /** Timestamp when the AI message was created. */
  genAiMessageTimestamp: Scalars['DateTime'];
  /** User rating of the message (thumbs up or down). */
  userRating?: InputMaybe<AiRatingValue>;
  /** Optional comment from the user about the rated message. */
  userComment?: InputMaybe<Scalars['String']>;
}

export interface GetAiResponseRatingInput {
  /** Type of response being rated. */
  responseType: AiResponseType;
  /** ID of the rated response. */
  responseId: Scalars['ID'];
}

export interface DeleteWorkspaceGenAiResponseRatingsInput {
  /** The workspace identifier for which to delete all GenAI response ratings. */
  workspace: Scalars['String'];
}

export interface UploadAiAssistantDocumentPayload {
  __typename?: 'UploadAIAssistantDocumentPayload';
  document: AiAssistantDocument;
}

export interface DeleteAiAssistantDocumentPayload {
  __typename?: 'DeleteAIAssistantDocumentPayload';
  document: AiAssistantDocument;
}

export interface AiAssistantSettings {
  __typename?: 'AIAssistantSettings';
  /** The preferred conversation style */
  conversationStyle: AiAssistantConversationStyle;
  /** The preferred conversation tone */
  conversationTone: AiAssistantConversationTone;
  /** The preferred AI assistant voice */
  voice: AiAssistantVoice;
}

export interface UpdateAiAssistantSettingsPayload {
  __typename?: 'UpdateAIAssistantSettingsPayload';
  settings: AiAssistantSettings;
}

export interface CreateConversationPayload {
  __typename?: 'CreateConversationPayload';
  conversation: Conversation;
}

export interface AppendMessagePayload {
  __typename?: 'AppendMessagePayload';
  conversation: Conversation;
}

export interface UpdateConversationTitlePayload {
  __typename?: 'UpdateConversationTitlePayload';
  status: Scalars['String'];
}

export interface DeleteConversationPayload {
  __typename?: 'DeleteConversationPayload';
  status: Scalars['String'];
}

export interface DeleteWorkspaceGenAiResponseRatingsPayload {
  __typename?: 'DeleteWorkspaceGenAIResponseRatingsPayload';
  /** The job ID of the enqueued task. */
  jobId: Scalars['String'];
}

export interface SearchAiAssistantDocumentsInput {
  query: Scalars['String'];
}

export interface SearchAiAssistantDocumentsResult {
  __typename?: 'SearchAIAssistantDocumentsResult';
  chunkId: Scalars['ID'];
  documentId: Scalars['ID'];
  text: Scalars['String'];
  distance: Scalars['Float'];
  url: Scalars['String'];
  fileName: Scalars['String'];
  metadata: Scalars['JSONObject'];
}

export interface AiAssistantDocumentFilterInput {
  id?: InputMaybe<Scalars['ID']>;
  fileName?: InputMaybe<Scalars['String']>;
  categories?: InputMaybe<Array<AiAssistantDocumentCategory>>;
  status?: InputMaybe<Array<AiAssistantDocumentStatus>>;
  permission?: InputMaybe<Array<AiAssistantDocumentPermission>>;
}

export interface ConversationMessagesInput {
  conversationId: Scalars['String'];
}

export interface AiAssistantDocumentsConnection {
  __typename?: 'AIAssistantDocumentsConnection';
  pageInfo: PageInfo;
  edges: Array<AiAssistantDocumentsEdge>;
}

export interface AiAssistantDocumentsEdge {
  __typename?: 'AIAssistantDocumentsEdge';
  cursor: Scalars['String'];
  node: AiAssistantDocument;
}

export interface AccessCapabilities {
  __typename?: 'AccessCapabilities';
  /** Not used, but required by Apollo Federation v2 to be a key field. */
  id: Scalars['ID'];
  directory?: Maybe<DirectoryAccessCapabilities>;
}

export interface LinkPeopleIdentitiesResult {
  __typename?: 'LinkPeopleIdentitiesResult';
  successCount: Scalars['Int'];
  errors?: Maybe<Array<Maybe<ErrorPayload>>>;
}

export interface ErrorPayload {
  __typename?: 'ErrorPayload';
  personId: Scalars['ID'];
  message: Scalars['String'];
}

export interface PurgeUnlinkedPeopleResult {
  __typename?: 'PurgeUnlinkedPeopleResult';
  jobIds: Array<Scalars['String']>;
}

export interface CompaniesFilterInput {
  workspaces?: InputMaybe<Array<Scalars['String']>>;
  status?: InputMaybe<Array<CompanyStatus>>;
  /**
   * Timezone Identifiers like 'America/Chicago' or 'Etc/GMT+1'.
   * Must be an exact match to moment JS timezone names as we store them on the directory.company table.
   * Reference: https://momentjs.com/timezone/docs/#/data-loading/getting-zone-names/
   */
  timezones?: InputMaybe<Array<Scalars['String']>>;
}

export interface StagePeopleForSegmentInput {
  peopleIds: Array<Scalars['ID']>;
  /** For the first use, the server will return an ID. Subsequent calls should use the same ID. */
  operationId?: InputMaybe<Scalars['ID']>;
}

export interface CommitStagedSegmentOperationInput {
  operationId: Scalars['ID'];
}

export interface StagePeopleForSegmentPayload {
  __typename?: 'StagePeopleForSegmentPayload';
  operationId: Scalars['ID'];
}

export interface DirectoryAccessCapabilities {
  __typename?: 'DirectoryAccessCapabilities';
  canEditUserRoles: Scalars['Boolean'];
  canManagePrivateGroupMembership: Scalars['Boolean'];
  canSeePrivateGroups: Scalars['Boolean'];
  canCreatePrivateGroups: Scalars['Boolean'];
  canSetPersonUIColumns: Scalars['Boolean'];
  canSeeAllPhoneNumbers: Scalars['Boolean'];
  canSetPersonPhoneNumbers: Scalars['Boolean'];
}

export interface CleanDirectoryEventsInput {
  maxBatchSize?: InputMaybe<Scalars['Int']>;
}

export interface CleanDirectoryEventsPayload {
  __typename?: 'CleanDirectoryEventsPayload';
  eventsCleaned: Scalars['Int'];
  timeInMs: Scalars['Float'];
}

export interface ArchivePeopleNotInBatchPayload {
  __typename?: 'ArchivePeopleNotInBatchPayload';
  batchId: Scalars['ID'];
  count: Scalars['Int'];
}

/** represents a customer company */
export interface Company {
  __typename?: 'Company';
  id: Scalars['ID'];
  name: Scalars['String'];
  /** @deprecated Use workspace instead. */
  subdomain: Scalars['String'];
  /** Workspace */
  workspace: Scalars['String'];
  /** Only Email and EmployeeId are supported */
  defaultPersonIdentifierProvider: PersonIdentityProvider;
  /** Company Id from the legacy Kazoo YouEarnedIt application */
  yeiCompanyId?: Maybe<Scalars['String']>;
  /** Company Id from the legacy Kazoo HighGround application */
  hgCompanyId?: Maybe<Scalars['String']>;
  /** Company Id from the legacy WorkTango Pulse application */
  pulseCompanyId?: Maybe<Scalars['Int']>;
  defaultCountry?: Maybe<Country>;
  timezone: Timezone;
  profileSettings: CompanyProfileSettings;
  /** Returns all people segments defined for modules at a company. Does not return all segments. */
  moduleSegments?: Maybe<Array<PeopleSegment>>;
  /** Returns all defined custom fields for this company. */
  customAttributes: Array<CustomAttribute>;
  /** Returns all roles to which people may be assigned, depending on company configuration.  For example, If the customer hasn't bought surveys, you can't make anyone a SURVEY_ADMIN) */
  availableRoles: Array<Role>;
  /** Returns field mappings for the current company, if configured. */
  pulseFieldMapping: PulseFieldMapping;
  /** The state of this customer.  PURGED companies have all their PII anonymized.  It is a big deal. */
  status: CompanyStatus;
  /**
   * Various places in our system allow admin-supplied translations. This list of
   * locales is the full set of available locales in the system, as well as their
   * availability for this company.
   */
  customTranslationLocales: Array<CompanyCustomTranslationLocale>;
  useFullDateOfBirth: Scalars['Boolean'];
  /** The creation date of the company on the legacy YEI platform, if applicable. */
  yeiCreatedAt?: Maybe<Scalars['Date']>;
}


/** represents a customer company */
export interface CompanyAvailableRolesArgs {
  excludeUnused?: InputMaybe<Scalars['Boolean']>;
}

export interface CompanyCustomTranslationLocale {
  __typename?: 'CompanyCustomTranslationLocale';
  locale: Scalars['String'];
  name: Scalars['String'];
  available: Scalars['Boolean'];
}

export type CompanyStatus =
  | 'ACTIVE'
  | 'PURGED';

/** represents a legacy CDC YEI customer company entity */
export interface LegacyYeiCompany {
  __typename?: 'LegacyYeiCompany';
  name: Scalars['String'];
  workspace: Scalars['String'];
  legacyId?: Maybe<Scalars['String']>;
  status: Scalars['String'];
  /** The date the yei Company document was created. */
  createdAt: Scalars['Date'];
}

export interface PersonIdentityFilterInput {
  providers?: InputMaybe<Array<PersonIdentityProvider>>;
  showInactive?: Scalars['Boolean'];
}

export type StringSearchOperator =
  | 'CONTAINS'
  | 'DOES_NOT_CONTAIN'
  | 'DOES_NOT_END_WITH'
  | 'DOES_NOT_EQUAL'
  | 'DOES_NOT_START_WITH'
  | 'ENDS_WITH'
  | 'EQUALS'
  | 'IS_NULL'
  | 'STARTS_WITH';

export type CustomAttributeType =
  | 'BOOLEAN'
  | 'DATE'
  | 'NUMBER'
  | 'STRING';

export type CustomAttributeValuesCategory =
  | 'SYSTEM_ACTIVITY'
  | 'USER_CREATED';

export type KazooMappableFieldType =
  | 'DATE'
  | 'EMAIL'
  | 'NUMBER'
  | 'STRING';

export type CustomAttributeValue = CustomBooleanAttribute | CustomDateAttribute | CustomNumberAttribute | CustomStringAttribute;

export interface CustomAttribute {
  __typename?: 'CustomAttribute';
  /** Arbitrary, unique identifier */
  id: Scalars['ID'];
  /** Unique name for this value. */
  name: Scalars['String'];
  /** Immutable data type for this attribute. */
  dataType: CustomAttributeType;
  /** Category of the values a CustomAttribute can have. Currently there are two categories of Custom Attribute values. We have USER_CREATED whose values obviously the result of user input. And SYSTEM_ACTIVITY which are generated values based on activity in the platform. */
  category: CustomAttributeValuesCategory;
  /**
   * When archived, this means the Custom Attribute is no longer in use.
   * Required, unique, etc. will not be checked on person creation.
   */
  archived: Scalars['Boolean'];
  /**
   * Every active or paused person who has a value, must have a unique value.
   * Archived people can have duplicate values because we don't validate them.
   */
  unique: Scalars['Boolean'];
  /**
   * Every active or paused person must have a value for this custom attribute.
   * Active or paused people cannot be created without specifying a value.
   */
  required: Scalars['Boolean'];
  /**
   * Prevents display of this attribute on an individual basis.
   * It will still be used in survey aggregation
   * (e.g. 'calculate employee sentiment and group by gender-identity')
   * but the value is not displayed to Customer Administrators.
   */
  private: Scalars['Boolean'];
  /**
   * Controls if this attribute appears on survey reporting by default or if it needs to be chosen when creating a new report.
   * Only 5 custom attributes may be designated default.
   */
  primary: Scalars['Boolean'];
  /** Id of the attribute in the pulseAPI.  If the company does not have surveys or the attribute has not been synchronized yet, this value will be null. */
  pulseId?: Maybe<Scalars['Int']>;
  /** Localized names of this attribute */
  translations: Array<CustomAttributeTranslation>;
  /** Actions the current user can perform on this attribute. */
  permissions: CustomAttributePermissions;
  /**
   * Suggested values for this attribute. This is useful for autocomplete.
   * Returns the top `N` values, with 10 as the default. Returns a string
   * representation of the value, rather than a union or wonky input-like
   * type. This is suitable for throwing the data straight back as an input.
   * - Boolean and Date types will always return an empty list
   * - Private and unique attributes also return an empty list
   */
  suggestedValues?: Maybe<Array<Scalars['String']>>;
}


export interface CustomAttributeSuggestedValuesArgs {
  input?: InputMaybe<CustomAttributeSuggestedValuesInput>;
}

export interface CustomAttributeSuggestedValuesInput {
  first?: InputMaybe<Scalars['Int']>;
}

export interface CustomAttributeCapabilities {
  __typename?: 'CustomAttributeCapabilities';
  /** True if the current user can create custom attributes; false otherwise. */
  canCreate: Scalars['Boolean'];
  /** We allow 10 or fewer primary attributes. This will be false if the company already has 10 primary attributes, or the current user cannot create custom attributes */
  canCreatePrimaryAttribute: Scalars['Boolean'];
}

export interface CustomAttributePermissions {
  __typename?: 'CustomAttributePermissions';
  canEdit: Scalars['Boolean'];
  canSetRequired: Scalars['Boolean'];
  canSetUnique: Scalars['Boolean'];
  canSetPrivate: Scalars['Boolean'];
  canSetPublic: Scalars['Boolean'];
  canSetPrimary: Scalars['Boolean'];
  canArchive: Scalars['Boolean'];
  canSetActive: Scalars['Boolean'];
}

export interface TranslatedValueInput {
  locale: Scalars['String'];
  value: Scalars['String'];
}

export interface CreateOrUpdateCustomAttributeInput {
  /** If provided, we attempt to lookup the custom attribute and throw an error if not found. */
  id?: InputMaybe<Scalars['ID']>;
  /** Client generated id for this update.  Useful for tracking changes across systems. */
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** Canonical, internal name of this field.  Required on create.  Immutable. */
  name?: InputMaybe<Scalars['String']>;
  /** This may only be set on create.  Required on create.  Optional on update. */
  dataType?: InputMaybe<CustomAttributeType>;
  /** If there are active or paused people with duplicate values, this update will fail.  Correct the data first, then toggle unique. */
  unique?: InputMaybe<Scalars['Boolean']>;
  /** If there are active or paused people without values, this update will fail.  Correct the data first, then toggle required. */
  required?: InputMaybe<Scalars['Boolean']>;
  /**
   * Prevents display of this attribute on an individual basis.
   * It will still be used in survey aggregation
   * (e.g. 'calculate employee sentiment and group by gender-identity')
   * but the value is not displayed to Customer Administrators.
   */
  private?: InputMaybe<Scalars['Boolean']>;
  /**
   * Controls if this attribute appears on survey reporting by default or if it needs to be chosen when creating a new report.
   * Only 5 fields may be designated default
   */
  primary?: InputMaybe<Scalars['Boolean']>;
  /**
   * When archived, this means the Custom Attribute is no longer in use.
   * Required, unique, etc. will not be checked on person creation.
   *
   * Those rules enforce when un-archiving:
   * A required attribute cannot be toggled archived:false unless all active or paused people have a value.
   * A unique attribute cannot be toggled archived:false if active or paused people have duplicate values.
   */
  archived?: InputMaybe<Scalars['Boolean']>;
  /** User-supplied translated names of this attribute */
  translations?: InputMaybe<Array<TranslatedValueInput>>;
  /** Optional id from the Pulse system used when mapping fields. */
  pulseId?: InputMaybe<Scalars['Int']>;
}

export interface CustomAttributeQuerySort {
  field: CustomAttributeSortField;
  direction: SortDirection;
}

export type CustomAttributeSortField =
  | 'NAME';

export interface CustomAttributeQueryFilter {
  name?: InputMaybe<Scalars['String']>;
  archived?: InputMaybe<Scalars['Boolean']>;
  private?: InputMaybe<Scalars['Boolean']>;
  required?: InputMaybe<Scalars['Boolean']>;
  unique?: InputMaybe<Scalars['Boolean']>;
  primary?: InputMaybe<Scalars['Boolean']>;
  category?: InputMaybe<CustomAttributeValuesCategory>;
}

export interface CustomAttributeTranslation {
  __typename?: 'CustomAttributeTranslation';
  locale: Scalars['String'];
  value: Scalars['String'];
  archived?: Maybe<Scalars['Boolean']>;
}

export interface ICustomAttributeValue {
  /** When archived, this means the item is no longer valid for this person. */
  archived: Scalars['Boolean'];
  /** Contains the attribute name, type etc. */
  customAttribute: CustomAttribute;
  updatedAt: Scalars['Date'];
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: Maybe<Scalars['Date']>;
}

export interface CustomAttributeConnection {
  __typename?: 'CustomAttributeConnection';
  edges: Array<CustomAttributeEdge>;
  pageInfo: PageInfo;
}

export interface CustomAttributeEdge {
  __typename?: 'CustomAttributeEdge';
  cursor: Scalars['String'];
  node: CustomAttribute;
}

export interface CustomBooleanAttribute extends ICustomAttributeValue {
  __typename?: 'CustomBooleanAttribute';
  customAttribute: CustomAttribute;
  value?: Maybe<Scalars['Boolean']>;
  /** When archived, this means the item is no longer valid for this person. */
  archived: Scalars['Boolean'];
  updatedAt: Scalars['Date'];
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: Maybe<Scalars['Date']>;
}

export interface CustomDateAttribute extends ICustomAttributeValue {
  __typename?: 'CustomDateAttribute';
  customAttribute: CustomAttribute;
  value?: Maybe<Scalars['Date']>;
  /** When archived, this means the item is no longer valid for this person */
  archived: Scalars['Boolean'];
  updatedAt: Scalars['Date'];
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: Maybe<Scalars['Date']>;
}

export interface CustomNumberAttribute extends ICustomAttributeValue {
  __typename?: 'CustomNumberAttribute';
  customAttribute: CustomAttribute;
  value?: Maybe<Scalars['Float']>;
  /** When archived, this means the item is no longer valid for this person */
  archived: Scalars['Boolean'];
  updatedAt: Scalars['Date'];
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: Maybe<Scalars['Date']>;
}

export interface CustomStringAttribute extends ICustomAttributeValue {
  __typename?: 'CustomStringAttribute';
  customAttribute: CustomAttribute;
  value?: Maybe<Scalars['String']>;
  /** When archived, this means the item is no longer valid for this person */
  archived: Scalars['Boolean'];
  updatedAt: Scalars['Date'];
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: Maybe<Scalars['Date']>;
}

export interface StringSearch {
  operator: StringSearchOperator;
  /** Optional if StringSearchOperator is IS_NULL */
  value?: InputMaybe<Scalars['String']>;
}

export type HierarchicalEntityOperator =
  | 'IS'
  | 'NOT';

export type HierarchicalEntityFilterRelationshipType =
  | 'CHILD_OF'
  | 'DIRECT_CHILD_OF'
  | 'DIRECT_PARENT_OF'
  | 'EQUAL_TO'
  | 'INDIRECT_CHILD_OF'
  | 'INDIRECT_PARENT_OF'
  | 'PARENT_OF';

export interface HierarchicalEntityFilter {
  operator: HierarchicalEntityOperator;
  relationship: HierarchicalEntityFilterRelationshipType;
  identifier: EntityIdentifierInput;
}

export interface CompanyProfileSettings {
  __typename?: 'CompanyProfileSettings';
  canShareBirthday: Scalars['Boolean'];
  canShareAnniversary: Scalars['Boolean'];
  canShareBio: Scalars['Boolean'];
  canChangeAvatar: Scalars['Boolean'];
  canChangePreferredName: Scalars['Boolean'];
}

export interface PhoneNumber {
  __typename?: 'PhoneNumber';
  e164: Scalars['String'];
  type: PersonPhoneNumberType;
  isDefault: Scalars['Boolean'];
}

export interface DirectoryIndexes {
  __typename?: 'DirectoryIndexes';
  pointsToSend?: Maybe<Scalars['Int']>;
  pointsToSpend?: Maybe<Scalars['Int']>;
  pointRule?: Maybe<Scalars['String']>;
}

export interface PersonAssistant {
  __typename?: 'PersonAssistant';
  id: Scalars['ID'];
  assistant: Person;
  person: Person;
}

export interface LegacyYeiUser {
  __typename?: 'LegacyYeiUser';
  id: Scalars['ID'];
}

export type PrincipalType =
  | 'PERSON'
  | 'PLATFORM_ADMIN'
  | 'ROBOT'
  | 'YEI_USER';

export interface Principal {
  __typename?: 'Principal';
  id: Scalars['ID'];
  type: PrincipalType;
  person?: Maybe<Person>;
  robot?: Maybe<Scalars['String']>;
  yeiUser?: Maybe<LegacyYeiUser>;
}

export interface DirectoryPermissions {
  __typename?: 'DirectoryPermissions';
  canEdit: Scalars['Boolean'];
}

export interface CreateOrUpdateKazooFieldMappingsInput {
  clientMutationId?: InputMaybe<Scalars['String']>;
  customAttributes?: InputMaybe<Array<CreateOrUpdateCustomAttributeInput>>;
  fields?: InputMaybe<Array<CreateOrUpdateKazooFieldInput>>;
}

/** Represents how Directory fields map to Pulse */
export interface PulseFieldMapping {
  __typename?: 'PulseFieldMapping';
  customAttributes: Array<CustomAttribute>;
  fields: Array<FieldMapping>;
}

export interface FieldMapping {
  __typename?: 'FieldMapping';
  id: Scalars['ID'];
  pulseId: Scalars['Int'];
  kazooField: KazooField;
  /** Is the mapping active? */
  archived: Scalars['Boolean'];
}

export interface CreateOrUpdateKazooFieldInput {
  /** If provided, this updates the mapping.  Use with caution. */
  id?: InputMaybe<Scalars['ID']>;
  pulseId: Scalars['Int'];
  kazooField: KazooField;
  /** If provided, it archives the relationship between the pulseId and the Kazoo field. */
  archive?: InputMaybe<Scalars['Boolean']>;
}

export interface MappableKazooField {
  __typename?: 'MappableKazooField';
  /** Data type of the field. */
  type: KazooMappableFieldType;
  /** The canonical value for the field in Kazoo-Web that can be mapped in Pulse. */
  field: KazooField;
  /** Human readable version of the canonical field. */
  fieldName: Scalars['String'];
}

export interface MappableAttribute {
  __typename?: 'MappableAttribute';
  /** Data type of the field. */
  type: CustomAttributeType;
  /** The Kazoo ID of the Custom Attribute. */
  attributeId: Scalars['ID'];
  /** Human readable name of the Custom Attribute. */
  attributeName: Scalars['String'];
}

export type MappableField = MappableKazooField | MappableAttribute;

export type AvatarFormat =
  | 'CIRCLE_30_PX'
  | 'CIRCLE_60_PX'
  | 'CIRCLE_70_PX'
  | 'CIRCLE_80_PX'
  | 'CIRCLE_140_PX'
  | 'CIRCLE_160_PX'
  /** the way it was originally uploaded - uncropped even */
  | 'ORIGINAL';

export interface PersonResponsibleFor {
  __typename?: 'PersonResponsibleFor';
  departments: Array<Department>;
  locations: Array<Location>;
  groups: Array<Group>;
}


export interface PersonResponsibleForGroupsArgs {
  type?: Array<GroupType>;
}

/** Used for calling out 'today's birthdays' without Kazoo storing actual DOB. */
export interface MonthDay {
  __typename?: 'MonthDay';
  /** 2 digit month */
  month: Scalars['Int'];
  /** 2 digit day of month */
  day: Scalars['Int'];
}

export type HierarchyType =
  | 'ALL'
  | 'DIRECT'
  | 'INDIRECT';

export type NameFormat =
  /** Preferred if exists or first + last; Sam or Samuel Smith */
  | 'FULL'
  /** Used for integrations into the HG and YEI legacy APIs. */
  | 'LEGACY_FIRST_NAME'
  /** Used for integrations into the HG and YEI legacy APIs. */
  | 'LEGACY_LAST_NAME'
  /** First name preferred; Sam */
  | 'PREFERRED'
  /** e.g. S.S. */
  | 'SHORT';

/** Type for supporting external accounts.  Today, just does legacy Kazoo products and GRS. */
export interface Identity {
  __typename?: 'Identity';
  provider: PersonIdentityProvider;
  key: Scalars['String'];
  active: Scalars['Boolean'];
}

/** interface describing a group */
export interface IGroup {
  id: Scalars['ID'];
  key: Scalars['String'];
  name: Scalars['String'];
  parent?: Maybe<IGroup>;
  members: PersonConnection;
  status: DepartmentLocationGroupStatus;
  createdInBatch?: Maybe<DirectoryBatch>;
}


/** interface describing a group */
export interface IGroupMembersArgs {
  filter?: MemberFilter;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}

export interface DepartmentLocationGroupChildrenFilter {
  status?: InputMaybe<Array<DepartmentLocationGroupStatus>>;
}

export interface Location extends IGroup {
  __typename?: 'Location';
  /** unique, Kazoo-assigned id */
  id: Scalars['ID'];
  /** Optional external key used by customers for this location e.g. AUSTIN_TX */
  key: Scalars['String'];
  /** Display name of the Location e.g. 9th Street, Austin */
  name: Scalars['String'];
  status: DepartmentLocationGroupStatus;
  /** Actions the current user can perform on this location */
  permissions: DepartmentLocationGroupPermissions;
  /** @deprecated Use status instead. */
  active?: Maybe<Scalars['Boolean']>;
  /** Optional parent, e.g. 'Continental US' */
  parent?: Maybe<Location>;
  /** Chicago has neighborhoods: Wicker Park, Lincoln Park, etc. */
  children: Array<Location>;
  /** People in this location. */
  members: PersonConnection;
  /** pointer to YEI */
  legacyRrId?: Maybe<Scalars['String']>;
  /** pointer to HG */
  legacyPmId?: Maybe<Scalars['String']>;
  /** Owners of this location */
  owners: Array<Person>;
  /** these people can administer members */
  administrators: Array<Person>;
  /** Returns an array of current locations's parents with their level in hierarchy. */
  parents: Array<ParentLocation>;
  /** Returns the batch that this was created in, if it was created as part of a batch op. */
  createdInBatch?: Maybe<DirectoryBatch>;
}


export interface LocationChildrenArgs {
  filter?: InputMaybe<DepartmentLocationGroupChildrenFilter>;
}


export interface LocationMembersArgs {
  filter?: MemberFilter;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}

/** Used when we say department/members or group/members */
export interface MemberFilter {
  status?: Array<PersonStatus>;
}

export interface DepartmentLocationGroupPermissions {
  __typename?: 'DepartmentLocationGroupPermissions';
  canArchive: Scalars['Boolean'];
  canDelete: Scalars['Boolean'];
  canSetActive: Scalars['Boolean'];
}

/** represents an arbitrary collection of people */
export interface Group extends IGroup {
  __typename?: 'Group';
  type: GroupType;
  /** unique, Kazoo-assigned id */
  id: Scalars['ID'];
  /** Optional external key used by customers for this group e.g. 2020_INTERNS */
  key: Scalars['String'];
  /** Name of the group e.g. '2020 Intern class */
  name: Scalars['String'];
  status: DepartmentLocationGroupStatus;
  /** @deprecated Use status instead. */
  active?: Maybe<Scalars['Boolean']>;
  /** Optional parent, e.g. 'Interns and Former Interns' */
  parent?: Maybe<Group>;
  /** Actions the current user can perform on this group */
  permissions: DepartmentLocationGroupPermissions;
  /** Full group parent hierarchy */
  parents?: Maybe<Array<Group>>;
  /** Optional children array e.g. '2020 Engineering Interns, etc.' */
  children: Array<Group>;
  /** Array of people in this group */
  members: PersonConnection;
  /** Owners of this group */
  owners: Array<Person>;
  /** these people can administer members */
  administrators: Array<Person>;
  /** pointer to YEI */
  legacyRrId?: Maybe<Scalars['String']>;
  /** pointer to YEI group type */
  legacyRrGroupTypeId?: Maybe<Scalars['String']>;
  /** pointer to HG */
  legacyPmId?: Maybe<Scalars['String']>;
  /** Returns the batch that this was created in, if it was created as part of a batch op. */
  createdInBatch?: Maybe<DirectoryBatch>;
}


/** represents an arbitrary collection of people */
export interface GroupParentsArgs {
  sort?: SortDirection;
}


/** represents an arbitrary collection of people */
export interface GroupChildrenArgs {
  filter?: InputMaybe<DepartmentLocationGroupChildrenFilter>;
}


/** represents an arbitrary collection of people */
export interface GroupMembersArgs {
  filter?: MemberFilter;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}

export interface Department extends IGroup {
  __typename?: 'Department';
  /** globally unique, Kazoo-assigned id */
  id: Scalars['ID'];
  /** e.g. IT_HLP */
  key: Scalars['String'];
  /** e.g. IT Help Desk */
  name: Scalars['String'];
  status: DepartmentLocationGroupStatus;
  /** @deprecated Use status instead. */
  active?: Maybe<Scalars['Boolean']>;
  /** e.g. a group like Information Technology */
  parent?: Maybe<Department>;
  /** Actions the current user can perform on this department */
  permissions: DepartmentLocationGroupPermissions;
  /** teams under this department */
  children: Array<Department>;
  /** People in this group */
  members: PersonConnection;
  /** Owners of this department */
  owners: Array<Person>;
  /** These people can admin people in this department */
  administrators: Array<Person>;
  /** pointer to YEI */
  legacyRrId?: Maybe<Scalars['String']>;
  /** pointer to HG */
  legacyPmId?: Maybe<Scalars['String']>;
  /** Returns an array of current department's parents with their level in hierarchy. */
  parents: Array<ParentDepartment>;
  /** Returns the batch that this was created in, if it was created as part of a batch op. */
  createdInBatch?: Maybe<DirectoryBatch>;
}


export interface DepartmentChildrenArgs {
  filter?: InputMaybe<DepartmentLocationGroupChildrenFilter>;
}


export interface DepartmentMembersArgs {
  filter?: MemberFilter;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}

/** Represents a department's parent hierarchy entry. */
export interface ParentDepartment {
  __typename?: 'ParentDepartment';
  department: Department;
  /** Number representing how many steps above the current department this department is.  e.g. the grandparent is 2. */
  hierarchyLevel: Scalars['Int'];
}

/** Represents a location's parent hierarchy entry. */
export interface ParentLocation {
  __typename?: 'ParentLocation';
  location: Location;
  /** Number representing how many steps above the current location this location is.  e.g. the grandparent is 2. */
  hierarchyLevel: Scalars['Int'];
}

/** represents properties displayed on users profile */
export interface ProfileSettings {
  __typename?: 'ProfileSettings';
  /** Display birthday on user profile */
  showBirthday?: Maybe<Scalars['Boolean']>;
  /** Display start date on user profile */
  showAnniversary?: Maybe<Scalars['Boolean']>;
}

export interface CompanyProfileSettingsInput {
  canShareBirthday?: InputMaybe<Scalars['Boolean']>;
  canShareAnniversary?: InputMaybe<Scalars['Boolean']>;
  canShareBio?: InputMaybe<Scalars['Boolean']>;
  canChangeAvatar?: InputMaybe<Scalars['Boolean']>;
  canChangePreferredName?: InputMaybe<Scalars['Boolean']>;
}

export type CompanyIdentifierType =
  /** globally unique, kazoo-generated id */
  | 'KAZOO_ID'
  | 'LEGACY_PM_ID'
  | 'LEGACY_RR_ID'
  | 'PULSE_COMPANY_ID'
  | 'WORKSPACE';

export interface CompanyIdentifierInput {
  type: CompanyIdentifierType;
  key: Scalars['String'];
}

export interface IdResult {
  __typename?: 'IdResult';
  id: Scalars['ID'];
}

export type ActivationRequestStatus =
  | 'COMPLETE'
  | 'REQUESTED';

export interface ActivationRequest {
  __typename?: 'ActivationRequest';
  id: Scalars['ID'];
  person: Person;
  status: ActivationRequestStatus;
  createdAt: Scalars['Date'];
  updatedAt: Scalars['Date'];
}

/** Identifies a Person entity. */
export interface SegmentPersonIdentifier {
  __typename?: 'SegmentPersonIdentifier';
  provider: PersonIdentityProvider;
  key: Scalars['String'];
}

/** Identifies an entity like a Location, Group, or Department */
export interface SegmentEntityIdentifier {
  __typename?: 'SegmentEntityIdentifier';
  type: EntityIdentifierType;
  key: Scalars['String'];
}

export interface SegmentEntityHierarchyCriteria {
  __typename?: 'SegmentEntityHierarchyCriteria';
  operator: HierarchicalEntityOperator;
  relationship: HierarchicalEntityFilterRelationshipType;
  identifier: SegmentEntityIdentifier;
}

export interface SegmentPersonHierarchyCriteria {
  __typename?: 'SegmentPersonHierarchyCriteria';
  hierarchyType: HierarchyType;
  identifier: SegmentPersonIdentifier;
}

export interface SegmentStringSearchCriteria {
  __typename?: 'SegmentStringSearchCriteria';
  operator: StringSearchOperator;
  /** Optional if StringSearchOperator is IS_NULL */
  value?: Maybe<Scalars['String']>;
}

export type PeopleSegmentModule =
  | 'BEHAVIOR_BONUS'
  | 'INCENTIVES'
  | 'KW_FEEDBACK'
  | 'KW_SYNC_UPS'
  | 'KW_TALENT_REVIEW'
  | 'NEW_CHECK_INS'
  | 'NEW_GOALS'
  | 'REWARDS'
  | 'SURVEYS'
  | 'SYNC_UP';

/** Output type for the people query. Matches the input types since it will be used to filter people for module access. */
export interface QueryPeopleForSegmentOutputType {
  __typename?: 'QueryPeopleForSegmentOutputType';
  status?: Maybe<Array<PersonStatus>>;
  role?: Maybe<Array<Role>>;
  hasDirectReports?: Maybe<Scalars['Boolean']>;
  location?: Maybe<Array<SegmentEntityHierarchyCriteria>>;
  department?: Maybe<Array<SegmentEntityHierarchyCriteria>>;
  group?: Maybe<Array<SegmentEntityHierarchyCriteria>>;
  countries?: Maybe<Array<SegmentStringSearchCriteria>>;
  /** Is this person a report of this person? */
  reportsTo?: Maybe<Array<SegmentPersonHierarchyCriteria>>;
  /** Identifier of one of their direct reports */
  manages?: Maybe<Array<SegmentPersonHierarchyCriteria>>;
  /**
   * Filters the result set based on the provided person ids.
   * Passing [] for this property will cause the query to return zero people.
   * The field will be ignored if its value is either `undefined` or `null`.
   */
  peopleInSet?: Maybe<Array<Scalars['ID']>>;
  /**
   * Ensures that the people on this segment can access the specified module.
   * Failing to provide a value for this field will cause the segment computation code to ignore Module Access.
   */
  module?: Maybe<PeopleSegmentModule>;
}

/** This is a partial of QueryPeopleInput that contains the filters supported by PeopleSegments */
export interface QueryPeopleForSegmentInputType {
  status?: InputMaybe<Array<PersonStatus>>;
  role?: InputMaybe<Array<Role>>;
  hasDirectReports?: InputMaybe<Scalars['Boolean']>;
  location?: InputMaybe<Array<HierarchicalEntityFilter>>;
  department?: InputMaybe<Array<HierarchicalEntityFilter>>;
  group?: InputMaybe<Array<HierarchicalEntityFilter>>;
  countries?: InputMaybe<Array<StringSearch>>;
  /** Is this person a report of this person? */
  reportsTo?: InputMaybe<Array<SearchPersonHierarchyInput>>;
  /** Identifier of one of their direct reports */
  manages?: InputMaybe<Array<SearchPersonHierarchyInput>>;
  /**
   * Filters the result set based on the provided person ids.
   * Passing [] for this property will cause the query to return zero people.
   * The field will be ignored if its value is either `undefined` or `null`.
   */
  peopleInSet?: InputMaybe<Array<Scalars['ID']>>;
  /**
   * Ensures that the people on this segment can access the specified module.
   * Failing to provide a value for this field will cause the segment computation code to ignore Module Access.
   */
  module?: InputMaybe<PeopleSegmentModule>;
}

/** Filters return by module or returns all modules by default */
export interface PeopleSegmentsFilter {
  modules?: InputMaybe<Array<PeopleSegmentModule>>;
}

export interface ParticipantsFilter {
  peopleInSet?: InputMaybe<Array<Scalars['ID']>>;
}

export interface PeopleSegment {
  __typename?: 'PeopleSegment';
  id: Scalars['ID'];
  participants: PersonConnection;
  filters?: Maybe<Array<QueryPeopleForSegmentOutputType>>;
  module?: Maybe<PeopleSegmentModule>;
  /** Archived segments will not be updated, and they will always return an empty list of participants. */
  archived: Scalars['Boolean'];
  /**
   * The time at which a Segment will stop being refreshed when changes are made in Directory.
   * If there is no expiration date, Segments will refresh indefinitely. Please provide one when creating a segment.
   */
  expirationDate?: Maybe<Scalars['DateTime']>;
  /** Indicates whether or not a segment uses Filters to build its cache, or if people are added/removed from it directly. */
  segmentType?: Maybe<PeopleSegmentType>;
  /** Limits all users within a segment by a module */
  limitByModule?: Maybe<PeopleSegmentModule>;
}


export interface PeopleSegmentParticipantsArgs {
  filter?: InputMaybe<ParticipantsFilter>;
  sort?: InputMaybe<Array<QueryPeopleSortInput>>;
  after?: InputMaybe<Scalars['String']>;
  first?: InputMaybe<Scalars['Int']>;
}

export type PeopleSegmentType =
  | 'FILTER'
  | 'PERSON_IDS';

/** update the Person Segment by ID or create a new one if no id is passed in */
export interface CreateOrUpdatePeopleSegmentInput {
  id?: InputMaybe<Scalars['ID']>;
  clientMutationId?: InputMaybe<Scalars['String']>;
  filters?: InputMaybe<Array<QueryPeopleForSegmentInputType>>;
  /** Defines which module we're creating a Segment for. Unnecessary for editing. */
  module?: InputMaybe<PeopleSegmentModule>;
  /**
   * The time at which a Segment will stop being refreshed when changes are made in Directory.
   * If there is no expiration date, Segments will refresh indefinitely. Please provide one when creating a segment.
   */
  expirationDate?: InputMaybe<Scalars['StrictDateTimeInput']>;
  segmentType?: InputMaybe<PeopleSegmentType>;
  commitStagedSegmentOperation?: InputMaybe<CommitStagedSegmentOperationInput>;
  /** Limits all users within a segment by a module */
  limitByModule?: InputMaybe<PeopleSegmentModule>;
}

export type CsvUploadExclusionReason =
  | 'INVALID_ID'
  | 'MODULE_ACCESS_DENIED'
  /** The Id is valid but it doesn't represent someone in the company */
  | 'PERSON_NOT_FOUND';

export interface CsvUploadExclusion {
  __typename?: 'CsvUploadExclusion';
  idValue?: Maybe<Scalars['String']>;
  rowNumber: Scalars['Int'];
  person?: Maybe<Person>;
  reason: CsvUploadExclusionReason;
}

export interface CsvUploadContents {
  __typename?: 'CsvUploadContents';
  kazooIds: Array<Scalars['ID']>;
  totalRowsInCsv: Scalars['Int'];
  exclusions: Array<CsvUploadExclusion>;
}

export interface PersonSortInput {
  field: PersonSortField;
  direction: SortDirection;
}

export type PersonSortField =
  | 'EMPLOYMENT_START_DATE'
  | 'FULL_NAME'
  | 'LEGACY_FIRST_NAME'
  | 'LEGACY_LAST_NAME'
  | 'STATUS';

export interface QueryPeopleWithoutIdentityProviderFilterInput {
  provider: PersonIdentityProvider;
}

export interface Country {
  __typename?: 'Country';
  /** ISO 3166-1 numeric country code. e.g. 840, 484. */
  id: Scalars['ID'];
  /** Common name. e.g. United States, Mexico. */
  name: Scalars['String'];
  /** ISO 3166 ALPHA-2 country code. e.g. US, MX. */
  iso2: Scalars['String'];
  /** ISO 3166 ALPHA-3 country code. e.g. USA, MEX. */
  iso3: Scalars['String'];
  /** ISO 3166 name country code. e.g. United States of America (the), Mexico. */
  canonicalName: Scalars['String'];
  /** Array of common names that may also be used. */
  aliases: Array<Scalars['String']>;
}

export interface DirectoryEventEdge {
  __typename?: 'DirectoryEventEdge';
  cursor: Scalars['String'];
  node: DirectoryEvent;
}

export interface DirectoryEventConnection {
  __typename?: 'DirectoryEventConnection';
  pageInfo: PageInfo;
  edges: Array<DirectoryEventEdge>;
}

export type DirectoryEventRelatedEntityType =
  | 'ACTIVATION_REQUEST'
  | 'COMPANY'
  | 'COUNTRY'
  | 'CUSTOM_ATTRIBUTE'
  | 'CUSTOM_ATTRIBUTE_TRANSLATION'
  | 'DEPARTMENT'
  | 'EXECUTIVE_ASSISTANT'
  | 'GROUP'
  | 'IDENTITY'
  | 'KAZOO_FIELD'
  | 'LOCATION'
  | 'PEOPLE_SEGMENT'
  | 'PERSON'
  | 'PULSE_FIELD_MAPPING_SET';

export type DirectoryEventSortField =
  | 'EVENT_TYPE'
  | 'TIMESTAMP';

export interface DirectoryEventSort {
  direction?: SortDirection;
  field: DirectoryEventSortField;
}

/** Its a thing that's involved in a directory event.  Like a person, department, etc. */
export interface DirectoryEventRelatedEntity {
  type?: InputMaybe<DirectoryEventRelatedEntityType>;
  id?: InputMaybe<Scalars['String']>;
}

export interface UpdateUserProfileInput {
  clientMutationId?: InputMaybe<Scalars['String']>;
  identifier: PersonIdentityInput;
  aboutMe?: InputMaybe<Scalars['String']>;
  avatar?: InputMaybe<ImageInput>;
  locale?: InputMaybe<Scalars['String']>;
  name?: InputMaybe<NameInput>;
  settings?: InputMaybe<ProfileSettingsInput>;
}

export type AllowedPersonDefaultIdentityProvider =
  | 'EMAIL'
  | 'EMPLOYEE_ID';

export interface UpdateCompanySettingsInput {
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  clientMutationId?: InputMaybe<Scalars['String']>;
  defaultPersonIdentityProvider?: InputMaybe<AllowedPersonDefaultIdentityProvider>;
  profileSettings?: InputMaybe<CompanyProfileSettingsInput>;
  defaultCountry?: InputMaybe<Scalars['String']>;
  timezone?: InputMaybe<Scalars['String']>;
  /**
   * Various places in the system allow admins to provide custom translations when
   * entering content. Set your supported locales here. By default, only a single
   * locale (English) is available.
   *
   * Note: modifying this property does not remove or alter existing translations.
   * It only modifies the set of available locales for future translatable inputs.
   */
  customTranslationLocales?: InputMaybe<Array<CompanyCustomAttributeTranslationInput>>;
  useFullDateOfBirth?: InputMaybe<Scalars['Boolean']>;
}

export interface CreateOrUpdateCompanyInput {
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** We treat this as 'current company' if not provided */
  identifier?: InputMaybe<CompanyIdentifierInput>;
  legacyPmId?: InputMaybe<Scalars['String']>;
  legacyRrId?: InputMaybe<Scalars['String']>;
  /**
   * Company Id from the legacy WorkTango platform Pulse.
   * `null` is valid to un-set the value as long as PULSE_COMPANY_SYNCHRONIZATION feature flag is off for the company.
   */
  pulseCompanyId?: InputMaybe<Scalars['Int']>;
  workspace?: InputMaybe<Scalars['String']>;
  defaultPersonIdentityProvider?: InputMaybe<AllowedPersonDefaultIdentityProvider>;
  profileSettings?: InputMaybe<CompanyProfileSettingsInput>;
  timezone?: InputMaybe<Scalars['String']>;
  name?: InputMaybe<Scalars['String']>;
  /** Either ISO-3166-ALPHA2, ISO-3166-ALPHA2, ISO-3166-NUMERIC Number, Name, or common Alias */
  defaultCountry?: InputMaybe<Scalars['String']>;
  /**
   * Setting a company status to PURGED will anonymize PII for all people data in directory in the company.
   * It will attempt to destroy avatars as well but due to undocumented rate limits in cloudinary,
   * it appears likely that companies with people with over 6000 avatars will encounter this rate limit.
   */
  status?: InputMaybe<CompanyStatus>;
  /**
   * Various places in the system allow admins to provide custom translations when
   * entering content. Set your supported locales here. By default, only a single
   * locale (English) is available.
   *
   * Note: modifying this property does not remove or alter existing translations.
   * It only modifies the set of available locales for future translatable inputs.
   */
  customTranslationLocales?: InputMaybe<Array<CompanyCustomAttributeTranslationInput>>;
  /** If true, the date of birth will be stored.  If false, just the birthday. */
  useFullDateOfBirth?: InputMaybe<Scalars['Boolean']>;
}

export interface CompanyCustomAttributeTranslationInput {
  /** ISO 639-1 ISO 3316-1 language code e.g. en-US, es-MX */
  locale: Scalars['String'];
  available: Scalars['Boolean'];
}

export interface DirectoryEventQueryFilter {
  clientMutationId?: InputMaybe<Scalars['String']>;
  involvedEntity?: InputMaybe<DirectoryEventRelatedEntity>;
  batchId?: InputMaybe<Scalars['String']>;
  eventTypes?: InputMaybe<Array<DirectoryEventType>>;
}

/** used to define if one person is a direct or indirect supervisor or supervisee of another */
export interface SearchPersonHierarchyInput {
  hierarchyType: HierarchyType;
  identifier: PersonIdentityInput;
  /**
   * Skips over inactive managers/reports, returning their manager/reports as if they belonged to the level below/above.
   *
   * I.E. If Ella Executive manages Ariana Admin, who is Archived, when querying Ella's reports, we can skipInactive to return Ella's reports - Ariana + Ariana's reports.
   * This works down the chain, so a chain of inactive managers will always return the highest set of active people, and never inactive people.
   */
  skipInactive?: InputMaybe<Scalars['Boolean']>;
}

/** Defines the reports a person secondary manages plus defaults to those I primarily manage as a direct report if they don't have a secondary manager assigned */
export interface SearchPersonSecondaryManagerInput {
  provider: PersonIdentityProvider;
  key: Scalars['String'];
  /** Returns the primary manager in the case where the person secondary manager is null  */
  fallbackToPrimaryManager?: InputMaybe<Scalars['Boolean']>;
}

export interface CompanyEdge {
  __typename?: 'CompanyEdge';
  cursor: Scalars['String'];
  node: Company;
}

export interface CompanyConnection {
  __typename?: 'CompanyConnection';
  pageInfo: PageInfo;
  edges: Array<CompanyEdge>;
}

export interface PersonEdge {
  __typename?: 'PersonEdge';
  cursor: Scalars['String'];
  node: Person;
}

export interface PersonConnection {
  __typename?: 'PersonConnection';
  pageInfo: PageInfo;
  edges: Array<PersonEdge>;
}

export interface BatchErrorEntityIdentifier {
  __typename?: 'BatchErrorEntityIdentifier';
  /** e.g. employeeId if this is a person error */
  provider: Scalars['String'];
  /** This might be null */
  key?: Maybe<Scalars['String']>;
}

export interface DirectoryBatchPersonError extends IDirectoryBatchError {
  __typename?: 'DirectoryBatchPersonError';
  id: Scalars['ID'];
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** This points to the entity the identity is for. */
  identifier?: Maybe<BatchErrorEntityIdentifier>;
  /** If the batch came from a file, this would be the row id. */
  batchSequence?: Maybe<Scalars['Int']>;
  /** If the person existed before the attempted change, they appear here. */
  person?: Maybe<Person>;
}

export interface DirectoryBatchDepartmentError extends IDirectoryBatchError {
  __typename?: 'DirectoryBatchDepartmentError';
  id: Scalars['ID'];
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** This points to the entity the identity is for. */
  identifier?: Maybe<BatchErrorEntityIdentifier>;
  /** If the batch came from a file, this would be the row id. */
  batchSequence?: Maybe<Scalars['Int']>;
  /** If the department existed before the attempted change, it appears here. */
  department?: Maybe<Department>;
}

export interface DirectoryBatchLocationError extends IDirectoryBatchError {
  __typename?: 'DirectoryBatchLocationError';
  id: Scalars['ID'];
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** This points to the entity the identity is for. */
  identifier?: Maybe<BatchErrorEntityIdentifier>;
  /** If the batch came from a file, this would be the row id. */
  batchSequence?: Maybe<Scalars['Int']>;
  /** If the location existed before the attempted change, it appears here. */
  location?: Maybe<Location>;
}

export interface DirectoryBatchGroupError extends IDirectoryBatchError {
  __typename?: 'DirectoryBatchGroupError';
  id: Scalars['ID'];
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** This points to the entity the identity is for. */
  identifier?: Maybe<BatchErrorEntityIdentifier>;
  /** If the batch came from a file, this would be the row id. */
  batchSequence?: Maybe<Scalars['Int']>;
  /** If the group existed before the attempted change, it appears here. */
  group?: Maybe<Group>;
}

export interface IDirectoryBatchError {
  id: Scalars['ID'];
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** This points to the entity the identity is for. */
  identifier?: Maybe<BatchErrorEntityIdentifier>;
  /** If the batch came from a file, this would be the row id. */
  batchSequence?: Maybe<Scalars['Int']>;
}

export interface DirectoryBatchPersonErrorEdge {
  __typename?: 'DirectoryBatchPersonErrorEdge';
  cursor: Scalars['String'];
  node?: Maybe<DirectoryBatchPersonError>;
}

export interface DirectoryBatchPersonErrorConnection {
  __typename?: 'DirectoryBatchPersonErrorConnection';
  pageInfo: PageInfo;
  edges: Array<DirectoryBatchPersonErrorEdge>;
}

export interface DirectoryBatchDepartmentErrorEdge {
  __typename?: 'DirectoryBatchDepartmentErrorEdge';
  cursor: Scalars['String'];
  node?: Maybe<DirectoryBatchDepartmentError>;
}

export interface DirectoryBatchDepartmentErrorConnection {
  __typename?: 'DirectoryBatchDepartmentErrorConnection';
  pageInfo: PageInfo;
  edges: Array<DirectoryBatchDepartmentErrorEdge>;
}

export interface DirectoryBatchLocationErrorEdge {
  __typename?: 'DirectoryBatchLocationErrorEdge';
  cursor: Scalars['String'];
  node?: Maybe<DirectoryBatchLocationError>;
}

export interface DirectoryBatchLocationErrorConnection {
  __typename?: 'DirectoryBatchLocationErrorConnection';
  pageInfo: PageInfo;
  edges: Array<DirectoryBatchLocationErrorEdge>;
}

export interface DirectoryBatchGroupErrorEdge {
  __typename?: 'DirectoryBatchGroupErrorEdge';
  cursor: Scalars['String'];
  node?: Maybe<DirectoryBatchGroupError>;
}

export interface DirectoryBatchGroupErrorConnection {
  __typename?: 'DirectoryBatchGroupErrorConnection';
  pageInfo: PageInfo;
  edges: Array<DirectoryBatchGroupErrorEdge>;
}

export interface Timezone {
  __typename?: 'Timezone';
  name: Scalars['String'];
  offset: Scalars['Float'];
}

export interface DepartmentEdge {
  __typename?: 'DepartmentEdge';
  cursor: Scalars['String'];
  node: Department;
}

export interface DepartmentConnection {
  __typename?: 'DepartmentConnection';
  pageInfo: PageInfo;
  edges: Array<DepartmentEdge>;
}

export interface LocationEdge {
  __typename?: 'LocationEdge';
  cursor: Scalars['String'];
  node: Location;
}

export interface LocationConnection {
  __typename?: 'LocationConnection';
  pageInfo: PageInfo;
  edges: Array<LocationEdge>;
}

export interface GroupEdge {
  __typename?: 'GroupEdge';
  cursor: Scalars['String'];
  node: Group;
}

export interface GroupConnection {
  __typename?: 'GroupConnection';
  pageInfo: PageInfo;
  edges: Array<GroupEdge>;
}

export type QueryPersonHierarchySortField =
  | 'BIRTHDAY'
  | 'COUNTRY_CODE'
  | 'DEPARTMENT_NAME'
  | 'EMPLOYMENT_START_DATE'
  | 'FULL_NAME'
  | 'HIERARCHY'
  | 'LEGACY_FIRST_NAME'
  | 'LEGACY_LAST_NAME'
  | 'LOCATION_NAME'
  | 'POINTS_TO_SEND'
  | 'POINTS_TO_SPEND'
  | 'POINT_RULE'
  | 'PREFERRED_NAME'
  | 'SHORT_NAME'
  | 'TITLE';

export interface QueryPersonHierarchySortInput {
  field: QueryPersonHierarchySortField;
  direction: SortDirection;
}

export interface QueryPeopleInput {
  /** searches across all names, titles */
  nameOrTitle?: InputMaybe<StringSearch>;
  aboutMe?: InputMaybe<StringSearch>;
  locale?: InputMaybe<StringSearch>;
  country?: InputMaybe<StringSearch>;
  countries?: InputMaybe<Array<StringSearch>>;
  avatarUrl?: InputMaybe<StringSearch>;
  title?: InputMaybe<StringSearch>;
  legacyFirstName?: InputMaybe<StringSearch>;
  legacyLastName?: InputMaybe<StringSearch>;
  preferredName?: InputMaybe<StringSearch>;
  email?: InputMaybe<StringSearch>;
  employeeId?: InputMaybe<StringSearch>;
  shortName?: InputMaybe<StringSearch>;
  fullName?: InputMaybe<StringSearch>;
  status?: InputMaybe<Array<PersonStatus>>;
  pointRule?: InputMaybe<Array<Scalars['ID']>>;
  role?: InputMaybe<Array<Role>>;
  inRole?: InputMaybe<Array<Role>>;
  notInRole?: InputMaybe<Array<Role>>;
  hasDirectReports?: InputMaybe<Scalars['Boolean']>;
  location?: InputMaybe<Array<HierarchicalEntityFilter>>;
  department?: InputMaybe<Array<HierarchicalEntityFilter>>;
  group?: InputMaybe<Array<HierarchicalEntityFilter>>;
  /**
   * Filters by employment start date. Privacy-aware for non-admin contexts:
   * - If company.profileCanShareAnniversary is false, this filter is ignored for non-admins.
   * - People who have set showAnniversary to false are excluded from results for non-admins.
   * - Admins must set includePrivateBirthdayAndAnniversary to true to bypass these restrictions.
   */
  employmentStartDate?: InputMaybe<Array<DateFilter>>;
  /**
   * Deprecated. Use employmentStartDate instead.
   * Privacy-aware: same rules as employmentStartDate apply.
   */
  workAnniversary?: InputMaybe<Array<MonthDayFilter>>;
  /**
   * Filters by birthday (month and day). Privacy-aware for non-admin contexts:
   * - If company.profileCanShareBirthday is false, this filter is ignored for non-admins.
   * - People who have set showBirthday to false are excluded from results for non-admins.
   * - Admins must set includePrivateBirthdayAndAnniversary to true to bypass these restrictions.
   * Note: dateOfBirth is not always set depending on company configuration, so we should filter on birthday.
   * See: useFullDateOfBirth under Company and UpdateCompanySettingsInput.
   */
  birthday?: InputMaybe<Array<MonthDayFilter>>;
  /**
   * When true, allows admin contexts to bypass privacy restrictions for birthday and anniversary filters.
   * This includes people who have hidden their birthday/anniversary and ignores company-level settings.
   * Has no effect for non-admin contexts.
   */
  includePrivateBirthdayAndAnniversary?: InputMaybe<Scalars['Boolean']>;
  /** SearchPersonHierarchyInputs of possible managers. Used to find People who report to a Person or Persons. */
  reportsTo?: InputMaybe<Array<SearchPersonHierarchyInput>>;
  /** PersonIdentityInput of possible secondary managers. Used to find People whose secondary manager is a Person or Persons. */
  reportsToSecondaryManager?: InputMaybe<Array<SearchPersonSecondaryManagerInput>>;
  /** Identifiers of one of their direct reports. When provided, the query will return the managers of the People indicated. */
  manages?: InputMaybe<Array<SearchPersonHierarchyInput>>;
  /** Identifiers of one of their secondary reports. When provided, the query will return the Secondary Managers of the People indicated. */
  secondaryManages?: InputMaybe<Array<QuerySecondaryManagersOfInput>>;
  /** If true, returns only people the current user can edit */
  forEdit?: InputMaybe<Scalars['Boolean']>;
  /**
   * Filters the result set based on the provided person ids.
   * Passing [] for this property will cause the query to return zero people.
   * The field will be ignored if its value is either `undefined` or `null`.
   */
  peopleInSet?: InputMaybe<Array<Scalars['ID']>>;
  module?: InputMaybe<PeopleSegmentModule>;
  segmentId?: InputMaybe<Scalars['ID']>;
  personIdentity?: InputMaybe<Array<PersonIdentityInput>>;
  assistedBy?: InputMaybe<Array<InputMaybe<PersonIdentityInput>>>;
  assists?: InputMaybe<Array<InputMaybe<PersonIdentityInput>>>;
}

export interface QuerySecondaryManagersOfInput {
  /** Person for whom you'd like to query their secondary manager. */
  targetPerson: PersonIdentityInput;
  /** If true, will return the next highest active person in the managerial hierarchy for the targetPerson if they have no active secondary manager. */
  skipInactive?: InputMaybe<Scalars['Boolean']>;
}

export interface QueryEntitiesFilter {
  /** searches across all entities' fields */
  name?: InputMaybe<StringSearch>;
  /** Deprecated. Use status, instead. */
  active?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<Array<DepartmentLocationGroupStatus>>;
  key?: InputMaybe<StringSearch>;
  hierarchy?: InputMaybe<Array<HierarchicalEntityFilter>>;
  entityIdentifier?: InputMaybe<Array<EntityIdentifierInput>>;
}

export interface QueryGroupFilter {
  /** searches across Group entity fields */
  name?: InputMaybe<StringSearch>;
  /** Deprecated. Use status, instead. */
  active?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<Array<DepartmentLocationGroupStatus>>;
  key?: InputMaybe<StringSearch>;
  hierarchy?: InputMaybe<Array<HierarchicalEntityFilter>>;
  /** Filters the groups by type.  Only administrators and analysts may request PRIVATE groups. */
  type?: InputMaybe<Array<GroupType>>;
  entityIdentifier?: InputMaybe<Array<EntityIdentifierInput>>;
}

export type QueryEntitiesSortField =
  | 'ACTIVE'
  | 'HIERARCHY'
  | 'KEY'
  | 'NAME';

export interface QueryEntitiesSortInput {
  field: QueryEntitiesSortField;
  direction: SortDirection;
}

export interface QueryPersonHierarchyInput {
  /** searches across all names, titles */
  nameOrTitle?: InputMaybe<StringSearch>;
  aboutMe?: InputMaybe<StringSearch>;
  locale?: InputMaybe<StringSearch>;
  country?: InputMaybe<StringSearch>;
  countries?: InputMaybe<Array<StringSearch>>;
  avatarUrl?: InputMaybe<StringSearch>;
  title?: InputMaybe<StringSearch>;
  legacyFirstName?: InputMaybe<StringSearch>;
  legacyLastName?: InputMaybe<StringSearch>;
  preferredName?: InputMaybe<StringSearch>;
  email?: InputMaybe<StringSearch>;
  employeeId?: InputMaybe<StringSearch>;
  shortName?: InputMaybe<StringSearch>;
  fullName?: InputMaybe<StringSearch>;
  status?: InputMaybe<Array<PersonStatus>>;
  role?: InputMaybe<Array<Role>>;
  inRole?: InputMaybe<Array<Role>>;
  notInRole?: InputMaybe<Array<Role>>;
  pointRule?: InputMaybe<Array<Scalars['ID']>>;
  hasDirectReports?: InputMaybe<Scalars['Boolean']>;
  location?: InputMaybe<Array<HierarchicalEntityFilter>>;
  department?: InputMaybe<Array<HierarchicalEntityFilter>>;
  group?: InputMaybe<Array<HierarchicalEntityFilter>>;
  /**
   * Filters by employment start date. Privacy-aware for non-admin contexts:
   * - If company.profileCanShareAnniversary is false, this filter is ignored for non-admins.
   * - People who have set showAnniversary to false are excluded from results for non-admins.
   * - Admins must set includePrivateBirthdayAndAnniversary to true to bypass these restrictions.
   */
  employmentStartDate?: InputMaybe<Array<DateFilter>>;
  /**
   * Deprecated. Use employmentStartDate instead.
   * Privacy-aware: same rules as employmentStartDate apply.
   */
  workAnniversary?: InputMaybe<Array<MonthDayFilter>>;
  /**
   * Filters by birthday (month and day). Privacy-aware for non-admin contexts:
   * - If company.profileCanShareBirthday is false, this filter is ignored for non-admins.
   * - People who have set showBirthday to false are excluded from results for non-admins.
   * - Admins must set includePrivateBirthdayAndAnniversary to true to bypass these restrictions.
   */
  birthday?: InputMaybe<Array<MonthDayFilter>>;
  /**
   * When true, allows admin contexts to bypass privacy restrictions for birthday and anniversary filters.
   * This includes people who have hidden their birthday/anniversary and ignores company-level settings.
   * Has no effect for non-admin contexts.
   */
  includePrivateBirthdayAndAnniversary?: InputMaybe<Scalars['Boolean']>;
  hierarchyType: HierarchyType;
  /**
   * Filters the result set based on the provided person ids.
   * Passing [] for this property will cause the query to return zero people.
   * The field will be ignored if its value is either `undefined` or `null`.
   */
  peopleInSet?: InputMaybe<Array<Scalars['ID']>>;
  module?: InputMaybe<PeopleSegmentModule>;
  segmentId?: InputMaybe<Scalars['ID']>;
  /**
   * Skips over inactive managers/reports, returning their manager/reports as if they belonged to the level below/above.
   *
   * I.E. If Ella Executive manages Ariana Admin, who is Archived, when querying Ella's reports, we can skipInactive to return Ella's reports - Ariana + Ariana's reports.
   * This works down the chain, so a chain of inactive managers will always return the highest set of active people, and never inactive people.
   */
  skipInactive?: InputMaybe<Scalars['Boolean']>;
}

export interface UpdateActivationRequestInput {
  id: Scalars['ID'];
  status: ActivationRequestStatus;
}

export interface StagedAvatarPayload {
  __typename?: 'StagedAvatarPayload';
  id: Scalars['ID'];
  /** Represents the raw upload to cloudinary. */
  raw: Scalars['String'];
  /** The same as the raw, but with cloudinary's avatar URL params added */
  avatar: Scalars['String'];
}

export type LegacyEntityType =
  | 'YEI_COMPANY'
  | 'YEI_GROUP'
  | 'YEI_GROUP_ADMINS'
  | 'YEI_GROUP_TYPE'
  | 'YEI_USER';

export interface ProcessLegacyEntitiesInput {
  /** YEI_COMPANY, etc. */
  type: LegacyEntityType;
  /** If provided, only entities with this id will be included. */
  id?: InputMaybe<Array<Scalars['String']>>;
  /** If provided, only entities created, updated, or deleted since this date will be included. */
  since?: InputMaybe<Scalars['Date']>;
}

export interface ProcessLegacyEntitiesPayload {
  __typename?: 'ProcessLegacyEntitiesPayload';
  jobId: Scalars['String'];
  enqueuedAt: Scalars['Date'];
}

export interface IPayload {
  id: Scalars['ID'];
  clientMutationId?: Maybe<Scalars['String']>;
  timestamp: Scalars['String'];
  events: Array<DirectoryEvent>;
  warnings: Array<DirectoryWarning>;
}

export interface CreateOrUpdateOperationPayload extends IPayload {
  __typename?: 'CreateOrUpdateOperationPayload';
  id: Scalars['ID'];
  clientMutationId?: Maybe<Scalars['String']>;
  timestamp: Scalars['String'];
  events: Array<DirectoryEvent>;
  relatesToEntityType: DirectoryEventRelatedEntityType;
  relatesToEntityId?: Maybe<Scalars['ID']>;
  warnings: Array<DirectoryWarning>;
}

export interface ClonePeopleSegmentPayload extends IPayload {
  __typename?: 'ClonePeopleSegmentPayload';
  id: Scalars['ID'];
  clientMutationId?: Maybe<Scalars['String']>;
  timestamp: Scalars['String'];
  events: Array<DirectoryEvent>;
  relatesToEntityType: DirectoryEventRelatedEntityType;
  relatesToEntityId?: Maybe<Scalars['ID']>;
  warnings: Array<DirectoryWarning>;
  segment: PeopleSegment;
}

export type DirectoryEventPeopleSegmentRole =
  | 'SUBJECT';

export type DirectoryEventActionRole =
  | 'ACTION';

export type DirectoryEventGroupRole =
  | 'ADMINISTRATOR'
  | 'GROUP'
  | 'OLD_ADMINISTRATOR'
  | 'OLD_PARENT'
  | 'PARENT'
  | 'SUBJECT';

export type DirectoryEventIdentityRole =
  | 'IDENTITY';

export type DirectoryEventCompanyRole =
  | 'SUBJECT';

export type DirectoryEventFieldMappingRole =
  | 'SUBJECT';

export type DirectoryEventCustomAttributeRole =
  | 'SUBJECT';

export type DirectoryEventPersonRole =
  | 'ADMINISTRATOR'
  | 'MANAGER'
  | 'OLD_ADMINISTRATOR'
  | 'OLD_MANAGER'
  | 'OLD_OWNER'
  | 'OLD_SECONDARY_MANAGER'
  | 'OWNER'
  | 'SECONDARY_MANAGER'
  | 'SUBJECT';

export type DirectoryEventDepartmentRole =
  | 'DEPARTMENT'
  | 'OLD_DEPARTMENT'
  | 'OLD_PARENT'
  | 'PARENT'
  | 'SUBJECT';

export type DirectoryEventLocationRole =
  | 'LOCATION'
  | 'OLD_LOCATION'
  | 'OLD_PARENT'
  | 'PARENT'
  | 'SUBJECT';

export interface DirectoryEventDepartment {
  __typename?: 'DirectoryEventDepartment';
  role?: Maybe<DirectoryEventDepartmentRole>;
  department?: Maybe<Department>;
}

export interface DirectoryEventCompany {
  __typename?: 'DirectoryEventCompany';
  role?: Maybe<DirectoryEventCompanyRole>;
  company?: Maybe<Company>;
}

export interface DirectoryEventPerson {
  __typename?: 'DirectoryEventPerson';
  role?: Maybe<DirectoryEventPersonRole>;
  person?: Maybe<Person>;
}

export interface DirectoryEventIdentity {
  __typename?: 'DirectoryEventIdentity';
  role?: Maybe<DirectoryEventIdentityRole>;
  identity?: Maybe<Identity>;
}

export interface DirectoryEventGroup {
  __typename?: 'DirectoryEventGroup';
  role?: Maybe<DirectoryEventGroupRole>;
  group?: Maybe<Group>;
}

export interface DirectoryEventLocation {
  __typename?: 'DirectoryEventLocation';
  role?: Maybe<DirectoryEventLocationRole>;
  location?: Maybe<Location>;
}

export interface DirectoryEventCustomAttribute {
  __typename?: 'DirectoryEventCustomAttribute';
  role?: Maybe<DirectoryEventCustomAttributeRole>;
  customAttribute?: Maybe<CustomAttribute>;
}

export interface DirectoryEventFieldMapping {
  __typename?: 'DirectoryEventFieldMapping';
  role?: Maybe<DirectoryEventFieldMappingRole>;
  fieldMapping?: Maybe<FieldMapping>;
}

export interface DirectoryEventAction {
  __typename?: 'DirectoryEventAction';
  role?: Maybe<DirectoryEventActionRole>;
  action?: Maybe<ActivationRequest>;
}

export interface DirectoryEventPeopleSegment {
  __typename?: 'DirectoryEventPeopleSegment';
  role?: Maybe<DirectoryEventPeopleSegmentRole>;
  peopleSegment?: Maybe<PeopleSegment>;
}

export type DirectoryEventType =
  | 'ASSISTANT_DETAILS_CHANGED'
  | 'COMPANY_CREATED'
  | 'COMPANY_DEFAULT_COUNTRY_CHANGED'
  | 'COMPANY_DEFAULT_IDENTITY_PROVIDER_CHANGED'
  | 'COMPANY_LEGACY_PM_ID_CHANGED'
  | 'COMPANY_LEGACY_RR_ID_CHANGED'
  | 'COMPANY_NAME_CHANGED'
  | 'COMPANY_PROFILE_CAN_CHANGE_AVATAR_CHANGED'
  | 'COMPANY_PROFILE_CAN_CHANGE_PREFERRED_NAME_CHANGED'
  | 'COMPANY_PROFILE_CAN_SHARE_ANNIVERSARY_CHANGED'
  | 'COMPANY_PROFILE_CAN_SHARE_BIO_CHANGED'
  | 'COMPANY_PROFILE_CAN_SHARE_BIRTHDAY_CHANGED'
  | 'COMPANY_PULSE_COMPANY_ID_CHANGED'
  | 'COMPANY_PURGED'
  | 'COMPANY_TIMEZONE_CHANGED'
  | 'COMPANY_USE_FULL_DATE_OF_BIRTH_CHANGED'
  | 'COMPANY_WORKSPACE_CHANGED'
  | 'CUSTOM_ATTRIBUTE_ARCHIVED_CHANGED'
  | 'CUSTOM_ATTRIBUTE_CREATED'
  | 'CUSTOM_ATTRIBUTE_DATA_TYPE_CHANGED'
  | 'CUSTOM_ATTRIBUTE_DELETED'
  | 'CUSTOM_ATTRIBUTE_DISPLAY_NAME_CHANGED'
  | 'CUSTOM_ATTRIBUTE_NAME_CHANGED'
  | 'CUSTOM_ATTRIBUTE_PRIMARY_CHANGED'
  | 'CUSTOM_ATTRIBUTE_PRIVATE_CHANGED'
  | 'CUSTOM_ATTRIBUTE_PULSE_ID_CHANGED'
  | 'CUSTOM_ATTRIBUTE_REQUIRED_CHANGED'
  | 'CUSTOM_ATTRIBUTE_TRANSLATION_ADDED'
  | 'CUSTOM_ATTRIBUTE_TRANSLATION_ARCHIVED'
  | 'CUSTOM_ATTRIBUTE_TRANSLATION_CHANGED'
  | 'CUSTOM_ATTRIBUTE_TRANSLATION_REMOVED'
  | 'CUSTOM_ATTRIBUTE_UNIQUE_CHANGED'
  | 'DEPARTMENT_ACTIVATED'
  | 'DEPARTMENT_ADMINISTRATOR_ADDED'
  | 'DEPARTMENT_ADMINISTRATOR_REMOVED'
  | 'DEPARTMENT_ARCHIVED'
  | 'DEPARTMENT_CREATED'
  | 'DEPARTMENT_DELETED'
  | 'DEPARTMENT_KEY_CHANGED'
  | 'DEPARTMENT_LEGACY_PM_ID_CHANGED'
  | 'DEPARTMENT_LEGACY_RR_ID_CHANGED'
  | 'DEPARTMENT_NAME_CHANGED'
  | 'DEPARTMENT_OWNER_ADDED'
  | 'DEPARTMENT_OWNER_REMOVED'
  | 'DEPARTMENT_PARENT_ADDED'
  | 'DEPARTMENT_PARENT_CHANGED'
  | 'DEPARTMENT_PARENT_REMOVED'
  | 'GROUP_ACTIVATED'
  | 'GROUP_ADMINISTRATOR_ADDED'
  | 'GROUP_ADMINISTRATOR_REMOVED'
  | 'GROUP_ARCHIVED'
  | 'GROUP_CREATED'
  | 'GROUP_DELETED'
  | 'GROUP_KEY_CHANGED'
  | 'GROUP_LEGACY_PM_ID_CHANGED'
  | 'GROUP_LEGACY_RR_GROUP_TYPE_ID_CHANGED'
  | 'GROUP_LEGACY_RR_ID_CHANGED'
  | 'GROUP_NAME_CHANGED'
  | 'GROUP_OWNER_ADDED'
  | 'GROUP_OWNER_REMOVED'
  | 'GROUP_PARENT_ADDED'
  | 'GROUP_PARENT_CHANGED'
  | 'GROUP_PARENT_REMOVED'
  | 'GROUP_TYPE_CHANGED'
  | 'LOCATION_ACTIVATED'
  | 'LOCATION_ADMINISTRATOR_ADDED'
  | 'LOCATION_ADMINISTRATOR_REMOVED'
  | 'LOCATION_ARCHIVED'
  | 'LOCATION_CREATED'
  | 'LOCATION_DELETED'
  | 'LOCATION_KEY_CHANGED'
  | 'LOCATION_LEGACY_PM_ID_CHANGED'
  | 'LOCATION_LEGACY_RR_ID_CHANGED'
  | 'LOCATION_NAME_CHANGED'
  | 'LOCATION_OWNER_ADDED'
  | 'LOCATION_OWNER_REMOVED'
  | 'LOCATION_PARENT_ADDED'
  | 'LOCATION_PARENT_CHANGED'
  | 'LOCATION_PARENT_REMOVED'
  | 'PEOPLE_SEGMENT_ARCHIVED'
  | 'PEOPLE_SEGMENT_CHANGED'
  | 'PEOPLE_SEGMENT_CREATED'
  | 'PEOPLE_SEGMENT_REFRESHED'
  | 'PERSON_ABOUT_ME_CHANGED'
  | 'PERSON_ACTIVATED'
  | 'PERSON_ACTIVATION_REQUESTED'
  | 'PERSON_ANNIVERSARY_CHANGED'
  | 'PERSON_ARCHIVED'
  /** Person was archived because they were not in a batch operation.  Typical for bulk file operations of 'full file' imports. */
  | 'PERSON_AUTO_ARCHIVED'
  | 'PERSON_AVATAR_CREATED'
  | 'PERSON_AVATAR_REMOVED'
  | 'PERSON_BIRTHDAY_CHANGED'
  | 'PERSON_COUNTRY_CHANGED'
  | 'PERSON_CREATED'
  | 'PERSON_CUSTOM_ATTRIBUTE_CHANGED'
  | 'PERSON_CUSTOM_ATTRIBUTE_CREATED'
  | 'PERSON_CUSTOM_ATTRIBUTE_REMOVED'
  | 'PERSON_DATE_OF_BIRTH_CHANGED'
  | 'PERSON_DEPARTMENT_ADDED'
  | 'PERSON_DEPARTMENT_CHANGED'
  | 'PERSON_DEPARTMENT_REMOVED'
  | 'PERSON_EMAIL_CHANGED'
  | 'PERSON_EMPLOYMENT_START_DATE_CHANGED'
  | 'PERSON_EXEMPT_FROM_AUTO_ARCHIVE_CHANGED'
  | 'PERSON_FIELD_MAPPING_ARCHIVED_CHANGED'
  | 'PERSON_FIELD_MAPPING_KAZOO_FIELD_CHANGED'
  | 'PERSON_FIELD_MAPPING_PULSE_ID_CHANGED'
  | 'PERSON_FULL_NAME_CHANGED'
  | 'PERSON_GROUP_ADDED'
  | 'PERSON_GROUP_REMOVED'
  | 'PERSON_IDENTITY_CREATED'
  | 'PERSON_IDENTITY_REMOVED'
  | 'PERSON_LEGACY_FIRST_NAME_CHANGED'
  | 'PERSON_LEGACY_LAST_NAME_CHANGED'
  | 'PERSON_LOCALE_CHANGED'
  | 'PERSON_LOCATION_ADDED'
  | 'PERSON_LOCATION_CHANGED'
  | 'PERSON_LOCATION_REMOVED'
  | 'PERSON_MANAGER_ADDED'
  | 'PERSON_MANAGER_CHANGED'
  | 'PERSON_MANAGER_REMOVED'
  | 'PERSON_PAUSED'
  | 'PERSON_PHONE_NUMBERS_CHANGED'
  | 'PERSON_PREFERRED_NAME_CHANGED'
  | 'PERSON_PURGED'
  | 'PERSON_REACTIVATED'
  | 'PERSON_ROLE_ADDED'
  | 'PERSON_ROLE_REMOVED'
  | 'PERSON_SECONDARY_MANAGER_CHANGED'
  | 'PERSON_SHORT_NAME_CHANGED'
  | 'PERSON_SHOW_ANNIVERSARY_CHANGED'
  | 'PERSON_SHOW_BIRTHDAY_CHANGED'
  | 'PERSON_TITLE_CHANGED';

export type DirectoryEventSourceOfTruth =
  | 'KAZOO'
  | 'LEGACY';

/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEvent {
  __typename?: 'DirectoryEvent';
  id: Scalars['ID'];
  workspace: Scalars['String'];
  /** Returns an arbitrary UUID that groups all changes from a single request together. */
  clientMutationId: Scalars['ID'];
  timestamp?: Maybe<Scalars['String']>;
  before?: Maybe<Scalars['String']>;
  after?: Maybe<Scalars['String']>;
  type?: Maybe<DirectoryEventType>;
  /** At the time of this event, is Kazoo or Legacy the source of truth for U&H info? */
  sourceOfTruth: DirectoryEventSourceOfTruth;
  companies?: Maybe<Array<DirectoryEventCompany>>;
  people?: Maybe<Array<DirectoryEventPerson>>;
  departments?: Maybe<Array<DirectoryEventDepartment>>;
  groups?: Maybe<Array<DirectoryEventGroup>>;
  locations?: Maybe<Array<DirectoryEventLocation>>;
  identities?: Maybe<Array<DirectoryEventIdentity>>;
  actions?: Maybe<Array<DirectoryEventAction>>;
  peopleSegments?: Maybe<Array<DirectoryEventPeopleSegment>>;
  customAttributes?: Maybe<Array<DirectoryEventCustomAttribute>>;
  fieldMappings?: Maybe<Array<DirectoryEventFieldMapping>>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventCompaniesArgs {
  role?: InputMaybe<DirectoryEventCompanyRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventPeopleArgs {
  role?: InputMaybe<DirectoryEventPersonRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventDepartmentsArgs {
  role?: InputMaybe<DirectoryEventDepartmentRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventGroupsArgs {
  role?: InputMaybe<DirectoryEventGroupRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventLocationsArgs {
  role?: InputMaybe<DirectoryEventLocationRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventIdentitiesArgs {
  role?: InputMaybe<DirectoryEventIdentityRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventActionsArgs {
  role?: InputMaybe<DirectoryEventActionRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventPeopleSegmentsArgs {
  role?: InputMaybe<DirectoryEventPeopleSegmentRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventCustomAttributesArgs {
  role?: InputMaybe<DirectoryEventCustomAttributeRole>;
}


/** minimal implementation of event, suitable for asking 'what happened?' without detail. */
export interface DirectoryEventFieldMappingsArgs {
  role?: InputMaybe<DirectoryEventFieldMappingRole>;
}

/** Represents a non-fatal warning such as skipping a bad manager assignment. */
export interface DirectoryWarning {
  __typename?: 'DirectoryWarning';
  /** A localized translation value. */
  message: Scalars['String'];
  /** A key that internationalization can use. */
  translationKey: Scalars['String'];
  /** A map of values that internationalization can use. */
  translationValues: Array<TranslationValue>;
  /** The type of entity involved, e.g. PERSON */
  relatedEntityType: DirectoryEventRelatedEntityType;
  /** If the entity is available, contains their ID.  */
  relatedEntityId?: Maybe<Scalars['ID']>;
}

/** Steps listed in order of expected completion. */
export type PulseAttributeAlignmentTaskName =
  | 'LINK_COMPANY'
  | 'ALIGN_ATTRIBUTES'
  | 'VERIFY_ALIGNMENT'
  | 'FINALIZE_ATTRIBUTES';

export type PulseAttributeAlignmentTaskStatus =
  /** A step you already completed */
  | 'COMPLETED'
  /** The current step you're on */
  | 'CURRENT'
  /** A step that needs attention because of errors or failures */
  | 'ERROR'
  /** A step that needs to be completed in the future */
  | 'FUTURE';

export interface PulseAttributeAlignmentTask {
  __typename?: 'PulseAttributeAlignmentTask';
  name: PulseAttributeAlignmentTaskName;
  status: PulseAttributeAlignmentTaskStatus;
  disabled: Scalars['Boolean'];
  /** Issues that need to be addressed before you can finalize attribute alignment */
  issues: Array<Scalars['String']>;
}

export type PulseAttributeAlignmentStatus =
  | 'COMPLETE'
  | 'PENDING';

export interface PulseAttributeAlignmentTasksPayload {
  __typename?: 'PulseAttributeAlignmentTasksPayload';
  status: PulseAttributeAlignmentStatus;
  /** The current step the company is on in attribute alignment. May or may not correspond to the UI, since users can navigate the steps in the UI independently of the backend. Once they save their progress, however, this will reflect the current step in the linking process. */
  currentTask: PulseAttributeAlignmentTask;
  /** All necessary tasks in the linking process */
  tasks: Array<PulseAttributeAlignmentTask>;
}

export type DirectoryBatchErrorFilter =
  | 'ALL'
  | 'CREATED_WITH_ERRORS'
  | 'NOT_CREATED'
  | 'NOT_UPDATED'
  | 'UPDATED_WITH_ERRORS';

export interface DirectoryBatchPersonOperationEdge {
  __typename?: 'DirectoryBatchPersonOperationEdge';
  cursor: Scalars['String'];
  node: DirectoryBatchPersonOperation;
}

export interface DirectoryBatchOperationPersonConnection {
  __typename?: 'DirectoryBatchOperationPersonConnection';
  edges: Array<DirectoryBatchPersonOperationEdge>;
  pageInfo: PageInfo;
}

export interface DirectoryBatchDepartmentOperationEdge {
  __typename?: 'DirectoryBatchDepartmentOperationEdge';
  cursor: Scalars['String'];
  node: DirectoryBatchDepartmentOperation;
}

export interface DirectoryBatchOperationDepartmentConnection {
  __typename?: 'DirectoryBatchOperationDepartmentConnection';
  edges: Array<DirectoryBatchDepartmentOperationEdge>;
  pageInfo: PageInfo;
}

export interface DirectoryBatchLocationOperationEdge {
  __typename?: 'DirectoryBatchLocationOperationEdge';
  cursor: Scalars['String'];
  node: DirectoryBatchLocationOperation;
}

export interface DirectoryBatchOperationLocationConnection {
  __typename?: 'DirectoryBatchOperationLocationConnection';
  edges: Array<DirectoryBatchLocationOperationEdge>;
  pageInfo: PageInfo;
}

export interface DirectoryBatchGroupOperationEdge {
  __typename?: 'DirectoryBatchGroupOperationEdge';
  cursor: Scalars['String'];
  node: DirectoryBatchGroupOperation;
}

export interface DirectoryBatchOperationGroupConnection {
  __typename?: 'DirectoryBatchOperationGroupConnection';
  edges: Array<DirectoryBatchGroupOperationEdge>;
  pageInfo: PageInfo;
}

export interface DirectoryWarningEdge {
  __typename?: 'DirectoryWarningEdge';
  cursor: Scalars['String'];
  node: DirectoryWarning;
}

export interface DirectoryWarningConnection {
  __typename?: 'DirectoryWarningConnection';
  edges: Array<DirectoryWarningEdge>;
  pageInfo: PageInfo;
}

export interface DirectoryBatchPersonOperation {
  __typename?: 'DirectoryBatchPersonOperation';
  id: Scalars['ID'];
  personId: Scalars['ID'];
  batchId: Scalars['ID'];
  person: Person;
  events: DirectoryEventConnection;
  warnings: DirectoryWarningConnection;
}


export interface DirectoryBatchPersonOperationEventsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}


export interface DirectoryBatchPersonOperationWarningsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}

export interface DirectoryBatchDepartmentOperation {
  __typename?: 'DirectoryBatchDepartmentOperation';
  id: Scalars['ID'];
  departmentId: Scalars['ID'];
  batchId: Scalars['ID'];
  department: Department;
  events: DirectoryEventConnection;
  warnings: DirectoryWarningConnection;
}


export interface DirectoryBatchDepartmentOperationEventsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}


export interface DirectoryBatchDepartmentOperationWarningsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}

export interface DirectoryBatchLocationOperation {
  __typename?: 'DirectoryBatchLocationOperation';
  id: Scalars['ID'];
  locationId: Scalars['ID'];
  batchId: Scalars['ID'];
  location: Location;
  events: DirectoryEventConnection;
  warnings: DirectoryWarningConnection;
}


export interface DirectoryBatchLocationOperationEventsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}


export interface DirectoryBatchLocationOperationWarningsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}

export interface DirectoryBatchGroupOperation {
  __typename?: 'DirectoryBatchGroupOperation';
  id: Scalars['ID'];
  groupId: Scalars['ID'];
  batchId: Scalars['ID'];
  group: Group;
  events: DirectoryEventConnection;
  warnings: DirectoryWarningConnection;
}


export interface DirectoryBatchGroupOperationEventsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}


export interface DirectoryBatchGroupOperationWarningsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}

export type DirectoryBatchOperationSortField =
  | 'BATCH_SEQUENCE'
  | 'NAME';

export interface DirectoryBatchOperationSort {
  direction: SortDirection;
  field: DirectoryBatchOperationSortField;
}

export interface DirectoryBatch {
  __typename?: 'DirectoryBatch';
  id: Scalars['ID'];
  /** Returns true if the batch has any events waiting to be published.  Counts of people, departments, etc. will be off until all events fully publish. */
  hasPendingEvents: Scalars['Boolean'];
  autoArchivedPeople: DirectoryBatchOperationPersonConnection;
  erroredPeople: DirectoryBatchPersonErrorConnection;
  createdPeople: DirectoryBatchOperationPersonConnection;
  updatedPeople: DirectoryBatchOperationPersonConnection;
  unchangedPeople: DirectoryBatchOperationPersonConnection;
  erroredDepartments: DirectoryBatchDepartmentErrorConnection;
  createdDepartments: DirectoryBatchOperationDepartmentConnection;
  updatedDepartments: DirectoryBatchOperationDepartmentConnection;
  unchangedDepartments: DirectoryBatchOperationDepartmentConnection;
  erroredLocations: DirectoryBatchLocationErrorConnection;
  createdLocations: DirectoryBatchOperationLocationConnection;
  updatedLocations: DirectoryBatchOperationLocationConnection;
  unchangedLocations: DirectoryBatchOperationLocationConnection;
  erroredGroups: DirectoryBatchGroupErrorConnection;
  createdGroups: DirectoryBatchOperationGroupConnection;
  updatedGroups: DirectoryBatchOperationGroupConnection;
  unchangedGroups: DirectoryBatchOperationGroupConnection;
}


export interface DirectoryBatchAutoArchivedPeopleArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sortDirection?: InputMaybe<SortDirection>;
}


export interface DirectoryBatchErroredPeopleArgs {
  filter?: InputMaybe<DirectoryBatchErrorFilter>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchCreatedPeopleArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUpdatedPeopleArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUnchangedPeopleArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchErroredDepartmentsArgs {
  filter?: InputMaybe<DirectoryBatchErrorFilter>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchCreatedDepartmentsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUpdatedDepartmentsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUnchangedDepartmentsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchErroredLocationsArgs {
  filter?: InputMaybe<DirectoryBatchErrorFilter>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchCreatedLocationsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUpdatedLocationsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUnchangedLocationsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchErroredGroupsArgs {
  filter?: InputMaybe<DirectoryBatchErrorFilter>;
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchCreatedGroupsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUpdatedGroupsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}


export interface DirectoryBatchUnchangedGroupsArgs {
  first?: InputMaybe<Scalars['Int']>;
  last?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  before?: InputMaybe<Scalars['String']>;
  sort?: InputMaybe<DirectoryBatchOperationSort>;
}

export interface DirectoryIndexInput {
  identifier: PersonIdentityInput;
  indexType: DirectoryIndexType;
  /** This field is required when indexType = 'POINT_RULE' */
  pointRuleName?: InputMaybe<Scalars['String']>;
  /** This field is required when indexType = 'POINT_RULE' */
  pointRuleId?: InputMaybe<Scalars['String']>;
  /** This field is required when indexType = 'POINT_VALUES' */
  pointsToSend?: InputMaybe<Scalars['Int']>;
  /** This field is required when indexType = 'POINT_VALUES' */
  pointsToSpend?: InputMaybe<Scalars['Int']>;
}

export type DirectoryIndexType =
  | 'POINT_RULE'
  | 'POINT_VALUES';

export interface UpdateDirectoryIndexPayload {
  __typename?: 'UpdateDirectoryIndexPayload';
  indexType: DirectoryIndexType;
  pointRuleName?: Maybe<Scalars['String']>;
  pointsToSend?: Maybe<Scalars['Int']>;
  pointsToSpend?: Maybe<Scalars['Int']>;
  pointRuleId?: Maybe<Scalars['String']>;
}

export type PersonUiColumn =
  | 'BIO'
  | 'DEPARTMENT'
  | 'DIRECT_REPORTS_COUNT'
  | 'EMAIL'
  | 'EMPLOYEE_ID'
  | 'EXEMPT_FROM_AUTO_ARCHIVE'
  | 'LOCATION'
  | 'MANAGER_ID'
  | 'MANAGER_NAME'
  | 'PERSONAL_PHONE_NUMBER'
  | 'POINTS_TO_SEND'
  | 'POINTS_TO_SPEND'
  | 'POINT_RULE'
  | 'PREFERRED_NAME'
  | 'ROLES'
  | 'SECONDARY_MANAGER_ID'
  | 'SECONDARY_MANAGER_NAME'
  | 'STATUS'
  | 'TITLE'
  | 'WORK_PHONE_NUMBER';

export interface PersonUiColumnsResponse {
  __typename?: 'PersonUIColumnsResponse';
  /** The columns stored for a given user. If no previous record a default list is provided */
  selectedColumns: Array<PersonUiColumn>;
  /** The maximum amount of selections available */
  maxAllowable: Scalars['Int'];
  /** All the valid options (based on the modules the user/company have enabled) that can be provided in setPersonUiColumns mutation */
  selectableColumns: Array<PersonUiColumn>;
}

/** Input for creating a LegacyCdcYeiCompany entity. Workspace is derived from context. */
export interface InsertLegacyCdcYeiCompany {
  name: Scalars['String'];
  status: Scalars['String'];
  legacyId: Scalars['String'];
  createdAt?: InputMaybe<Scalars['Date']>;
}

export interface LegacyCdcYeiCompany {
  __typename?: 'LegacyCdcYeiCompany';
  id: Scalars['ID'];
  /** The Mongo ID of the company */
  legacyId: Scalars['String'];
  name: Scalars['String'];
  workspace: Scalars['String'];
  /** A string and not an enum because this value comes from YEI. */
  status: Scalars['String'];
  createdAt: Scalars['Date'];
}

export type LegacyCdcYeiCompanyStatus =
  | 'ACTIVE'
  | 'CANCELLED'
  | 'DELETED'
  | 'DEMO'
  | 'PRELAUNCH'
  | 'SUSPENDED'
  | 'TEMPLATE'
  | 'TRIAL';

export interface EnqueueActivationRequestForWorkspacePayload {
  __typename?: 'EnqueueActivationRequestForWorkspacePayload';
  jobId: Scalars['String'];
}

export interface NotificationSetting {
  __typename?: 'NotificationSetting';
  /** Key (which is unique) copied into the ID column for cache invalidation on the UI. */
  id: Scalars['ID'];
  /** Unique key identifying this notification setting */
  key: Scalars['String'];
  /** A localized translation value. */
  nameTranslation: Scalars['String'];
  /** An indicator of how to render these notification settings in grouped sections in the UI. */
  section: NotificationSettingUiSection;
  /** true: enabled. false: disabled. undefined: unset (use the API's default) */
  bell?: Maybe<Scalars['Boolean']>;
  /** true: enabled. false: disabled. undefined: unset (use the API's default) */
  actionItem?: Maybe<Scalars['Boolean']>;
  /** true: enabled. false: disabled. undefined: unset (use the API's default) */
  email?: Maybe<Scalars['Boolean']>;
}

export type NotificationSettingUiSection =
  | 'MAIN'
  | 'MANAGER_ENABLEMENT';

/** Represents some rich text content, which can be rendered in one of several formats. JSON is the native format; other formats are derived from it and may be lossy. */
export interface RichTextContent {
  __typename?: 'RichTextContent';
  /** The canonical representation of the rich text content, in ProseMirror JSON format. */
  json: Scalars['RichTextDocument'];
  /** The HTML representation of the rich text content, supporting a limited set of basic HTML formatting tags. Conversion to and from ProseMirror JSON may not be 1-to-1. */
  html: Scalars['String'];
  /** The plaintext representation of the rich text content. Any rich text formatting will be lost. */
  plaintext: Scalars['String'];
}

/** Represents a user's input for some rich text content. User input can be provided in one of several formats and will be sanitized and converted to a ProseMirror document if necessary. JSON inputs which do not conform to the ProseMirror schema will be rejected. */
export interface RichTextContentInput {
  json?: InputMaybe<Scalars['RichTextDocument']>;
  html?: InputMaybe<Scalars['String']>;
  plaintext?: InputMaybe<Scalars['String']>;
}

export interface PageInfo {
  __typename?: 'PageInfo';
  totalCount: Scalars['Int'];
  hasNextPage: Scalars['Boolean'];
  hasPreviousPage: Scalars['Boolean'];
  startCursor?: Maybe<Scalars['String']>;
  endCursor?: Maybe<Scalars['String']>;
}

export type SortDirection =
  | 'ASC'
  | 'DESC';

export interface Node {
  /** A globally unique identifier. */
  id: Scalars['ID'];
}

/** Used for calling out 'today's birthdays' without Kazoo storing actual DOB. */
export interface MonthDayInput {
  /** 2 digit month */
  month: Scalars['Int'];
  /** 2 digit day of month */
  day: Scalars['Int'];
  nullify?: InputMaybe<Scalars['Boolean']>;
}

export type DateFilterOperator =
  | 'DATE_EQUALS'
  | 'GREATER_THAN'
  | 'GREATER_THAN_OR_EQUAL_TO'
  | 'IS_NULL'
  | 'LESS_THAN'
  | 'LESS_THAN_OR_EQUAL_TO'
  /** For finding a date that matches the month and day of the value, but not the year. IE all anniversaries today regardless of year. */
  | 'MATCH_MONTH_AND_DAY_ANY_YEAR'
  | 'MATCH_MONTH_AND_DAY_GREATER_THAN_OR_EQUAL_ANY_YEAR'
  | 'MATCH_MONTH_AND_DAY_LESS_THAN_OR_EQUAL_ANY_YEAR';

export interface MonthDayFilter {
  operator: DateFilterOperator;
  value?: InputMaybe<MonthDayInput>;
}

export interface DateFilter {
  operator: DateFilterOperator;
  value?: InputMaybe<Scalars['Date']>;
}

export interface DateTimeFilter {
  operator: DateTimeFilterOperator;
  value?: InputMaybe<Scalars['DateTime']>;
}

export type DateTimeFilterOperator =
  | 'GREATER_THAN'
  | 'GREATER_THAN_OR_EQUAL_TO'
  | 'LESS_THAN'
  | 'LESS_THAN_OR_EQUAL_TO';

export interface HighGroundFeatureFlags {
  __typename?: 'HighGroundFeatureFlags';
  accessYEIRecognition?: Maybe<Scalars['Boolean']>;
  adhocGoal?: Maybe<Scalars['Boolean']>;
  adminInitiateFeedback?: Maybe<Scalars['Boolean']>;
  alertMissingPoint?: Maybe<Scalars['Boolean']>;
  allowCustomHRISFieldFiltering?: Maybe<Scalars['Boolean']>;
  allowSurveyKiosk?: Maybe<Scalars['Boolean']>;
  anonymousFeedback?: Maybe<Scalars['Boolean']>;
  answerLibrary?: Maybe<Scalars['Boolean']>;
  awaitingCommunication?: Maybe<Scalars['Boolean']>;
  brandedEmail?: Maybe<Scalars['Boolean']>;
  carryForwardGoals?: Maybe<Scalars['Boolean']>;
  certificateTemplates?: Maybe<Scalars['Boolean']>;
  colAdjustment?: Maybe<Scalars['Boolean']>;
  continuousFeedback?: Maybe<Scalars['Boolean']>;
  customProfanityFilter?: Maybe<Scalars['Boolean']>;
  customRole?: Maybe<Scalars['Boolean']>;
  defaultEverydayRecognition?: Maybe<Scalars['Boolean']>;
  disableFeatureByRole?: Maybe<Scalars['Boolean']>;
  disableMotivate?: Maybe<Scalars['Boolean']>;
  disableTracks?: Maybe<Scalars['Boolean']>;
  dontPersistCookies?: Maybe<Scalars['Boolean']>;
  emailFeedbackLink?: Maybe<Scalars['Boolean']>;
  enableAddPoints?: Maybe<Scalars['Boolean']>;
  enableBenchmarkSurvey?: Maybe<Scalars['Boolean']>;
  enableCheckInCalibration?: Maybe<Scalars['Boolean']>;
  enableCoaching?: Maybe<Scalars['Boolean']>;
  enableConversationGuide?: Maybe<Scalars['Boolean']>;
  enableDisplay?: Maybe<Scalars['Boolean']>;
  enableFeedback?: Maybe<Scalars['Boolean']>;
  enableGoals?: Maybe<Scalars['Boolean']>;
  enableLanguages?: Maybe<Scalars['Boolean']>;
  enableLocation?: Maybe<Scalars['Boolean']>;
  enableNineBox?: Maybe<Scalars['Boolean']>;
  enableOptOutPublicRec?: Maybe<Scalars['Boolean']>;
  enablePerform?: Maybe<Scalars['Boolean']>;
  enablePilotMembers?: Maybe<Scalars['Boolean']>;
  enablePoints?: Maybe<Scalars['Boolean']>;
  enablePolling?: Maybe<Scalars['Boolean']>;
  enablePulseSurvey?: Maybe<Scalars['Boolean']>;
  enableTeamTab?: Maybe<Scalars['Boolean']>;
  enableUserLanguage?: Maybe<Scalars['Boolean']>;
  enableVisibilityToAllSurveyData?: Maybe<Scalars['Boolean']>;
  feedback360?: Maybe<Scalars['Boolean']>;
  feedbackCheckin?: Maybe<Scalars['Boolean']>;
  forSalesDemo?: Maybe<Scalars['Boolean']>;
  giveFeedback?: Maybe<Scalars['Boolean']>;
  gmailPlugin?: Maybe<Scalars['Boolean']>;
  goalActivityWithActivity?: Maybe<Scalars['Boolean']>;
  goalCycleAdminHideDepartmentGoals?: Maybe<Scalars['Boolean']>;
  goalLibrary?: Maybe<Scalars['Boolean']>;
  goalWeighting?: Maybe<Scalars['Boolean']>;
  googleOAuth?: Maybe<Scalars['Boolean']>;
  grsInternalStoreFront?: Maybe<Scalars['Boolean']>;
  grsStorefront?: Maybe<Scalars['Boolean']>;
  hideAchievementLevelsDisplay?: Maybe<Scalars['Boolean']>;
  hideHelpLink?: Maybe<Scalars['Boolean']>;
  hidePasswordLogins?: Maybe<Scalars['Boolean']>;
  hideRecognitionByDepartment?: Maybe<Scalars['Boolean']>;
  hideRecognitionByLocation?: Maybe<Scalars['Boolean']>;
  hideSeeAllNotification?: Maybe<Scalars['Boolean']>;
  hideSelectAllWhenGivingRecognition?: Maybe<Scalars['Boolean']>;
  hideTermsOfUse?: Maybe<Scalars['Boolean']>;
  lamCustomReports?: Maybe<Scalars['Boolean']>;
  managerCheckInAnswerTypes?: Maybe<Scalars['Boolean']>;
  managerOnlySectionCheckin?: Maybe<Scalars['Boolean']>;
  managersSeePrivateBadge?: Maybe<Scalars['Boolean']>;
  managerTeamFeedback?: Maybe<Scalars['Boolean']>;
  managerTeamTabLearning?: Maybe<Scalars['Boolean']>;
  maskAnonymousReviewUser?: Maybe<Scalars['Boolean']>;
  mobileAccess?: Maybe<Scalars['Boolean']>;
  mobileAllowCompanyGoalMod?: Maybe<Scalars['Boolean']>;
  mobileAllowTeamGoalMod?: Maybe<Scalars['Boolean']>;
  mobileEmailSSOOverride?: Maybe<Scalars['Boolean']>;
  mobileSSOLogin?: Maybe<Scalars['Boolean']>;
  multiManager?: Maybe<Scalars['Boolean']>;
  notifyApproverGoalUpdates?: Maybe<Scalars['Boolean']>;
  openClosedGoal?: Maybe<Scalars['Boolean']>;
  outlookAddin?: Maybe<Scalars['Boolean']>;
  payrollAwardReport?: Maybe<Scalars['Boolean']>;
  payrollRedeemReport?: Maybe<Scalars['Boolean']>;
  performGoal?: Maybe<Scalars['Boolean']>;
  population?: Maybe<Scalars['Boolean']>;
  preventProfileInfoEditing?: Maybe<Scalars['Boolean']>;
  previewsEmbed?: Maybe<Scalars['Boolean']>;
  profanityFilter?: Maybe<Scalars['Boolean']>;
  publicAPI?: Maybe<Scalars['Boolean']>;
  publicRecFreeformComments?: Maybe<Scalars['Boolean']>;
  recognition2?: Maybe<Scalars['Boolean']>;
  recurringGoalCycle?: Maybe<Scalars['Boolean']>;
  relevancyFilter?: Maybe<Scalars['Boolean']>;
  reqFeedbackAboutOthers?: Maybe<Scalars['Boolean']>;
  requestFeedback?: Maybe<Scalars['Boolean']>;
  requireEmployeeID?: Maybe<Scalars['Boolean']>;
  restrictAvatarSetting?: Maybe<Scalars['Boolean']>;
  restrictChatWidget?: Maybe<Scalars['Boolean']>;
  restrictToSingleSession?: Maybe<Scalars['Boolean']>;
  rulesEngine?: Maybe<Scalars['Boolean']>;
  selectRecapTime?: Maybe<Scalars['Boolean']>;
  sendEmailsFromKazooDomain?: Maybe<Scalars['Boolean']>;
  sendRealEmails?: Maybe<Scalars['Boolean']>;
  sharedGoalsTab?: Maybe<Scalars['Boolean']>;
  shareLink?: Maybe<Scalars['Boolean']>;
  showPublicRecognitions?: Maybe<Scalars['Boolean']>;
  skipGoalApproval?: Maybe<Scalars['Boolean']>;
  spendCreditTransfer?: Maybe<Scalars['Boolean']>;
  spotBonus?: Maybe<Scalars['Boolean']>;
  suggestRewardIdea?: Maybe<Scalars['Boolean']>;
  syncUp?: Maybe<Scalars['Boolean']>;
  talentInsights?: Maybe<Scalars['Boolean']>;
  teamAnalytics?: Maybe<Scalars['Boolean']>;
  trackObjectiveWeight?: Maybe<Scalars['Boolean']>;
  turnOffTeam?: Maybe<Scalars['Boolean']>;
  unlimitedGiveBank?: Maybe<Scalars['Boolean']>;
  uploadGoalCycleParticipants?: Maybe<Scalars['Boolean']>;
  userNotificationPreference?: Maybe<Scalars['Boolean']>;
  workInProgress?: Maybe<Scalars['Boolean']>;
  yammerIntegration?: Maybe<Scalars['Boolean']>;
  hideLegacyAdminAnalytics?: Maybe<Scalars['Boolean']>;
}

export type HgMemberPermission =
  | 'AccessToAdminCustomLamReport'
  | 'AccessToManagerCustomLamReport'
  | 'AccessToPayrollRewardsReport'
  | 'AchievementRecognition'
  | 'AddGiftToNewRecognition'
  | 'AddGiftToOldRecognition'
  | 'AddPointsInRecognition'
  | 'AddRecognitionComment'
  | 'AdditionalBenchmarkCohortTypeReport'
  | 'AdhocGoal'
  | 'AdhocTeam'
  | 'AdminCompanyDashboard'
  | 'AdminFeedbackDashboard'
  | 'AdminGoalsDashboard'
  | 'AdminLevelProfileAccess'
  | 'AdminPointsDashboard'
  | 'AdminRecognitionDashboard'
  | 'AdminReports'
  | 'AdminTrackReportStatus'
  | 'AllImportantNotifications'
  | 'AllowAvatarUpload'
  | 'AllowChatWidget'
  | 'AllowProfileInfoEditing'
  | 'AllowSelectAllWhenGivingRecognition'
  | 'AllowSurveyKiosk'
  | 'AnonymousFeedback'
  | 'AnswerLibrary'
  | 'ApproveGoal'
  | 'AssignTrack'
  | 'AutomaticallySubmitEmployeeCheckIn'
  | 'BenchmarkSurvey'
  | 'COLAdjustment'
  | 'CanBeCreditAdmin'
  | 'CanBePointAdmin'
  | 'CanSeeRecognitionEmail'
  | 'CheckInCalibration'
  | 'CompanyAudit'
  | 'ContinuousFeedback'
  | 'CreateManagerOnlySectionCheckIn'
  | 'CreateTrack'
  | 'CreateTrackAddCredits'
  | 'CreateTrackAddPoints'
  | 'CreateTrackMoreOptions'
  | 'CreditTransactions'
  | 'CustomizedRecognition'
  | 'DefaultEverydayRecognition'
  | 'DeleteCoachingComment'
  | 'DeleteGoalComment'
  | 'DeleteRecognition'
  | 'DeleteRecognitionComment'
  | 'DonateToCharities'
  | 'DontPersistCookies'
  | 'EditRecognitionComment'
  | 'EditRecognitionMessage'
  | 'EmailFeedbackLink'
  | 'EnableConversationGuide'
  | 'EnableLanguages'
  | 'EnableOptOutPublicRec'
  | 'EnableUserLanguage'
  | 'EverydayRecognition'
  | 'ExportGroupData'
  | 'ExportMemberData'
  | 'ExpressPigeonSuppressedList'
  | 'Feedback360'
  | 'FeedbackCheckin'
  | 'ForSalesDemo'
  | 'GRSInternalStoreFront'
  | 'GRSStorefront'
  | 'GiveFeedback'
  | 'GivePointGift'
  | 'GiveRecognition'
  | 'GiveRecognitionToDepartment'
  | 'GiveRecognitionToLocation'
  | 'GmailPlugin'
  | 'Goal'
  | 'GoalCycleAdminHideDepartmentGoals'
  | 'GoalWeighting'
  | 'GoogleOAuth'
  | 'GroupCreditManagement'
  | 'GroupMemberEdit'
  | 'GroupMemberExport'
  | 'GroupMemberOffBoard'
  | 'GroupMemberOnboard'
  | 'GroupMemberTransferManager'
  | 'GroupSettingManagement'
  | 'GroupTerminologyManagement'
  | 'HGAdminReports'
  | 'HGManageTemplates'
  | 'HideAchievementLevelsDisplay'
  | 'HideHelpLink'
  | 'HidePasswordLogins'
  | 'HideRecognition'
  | 'HideTermsOfUse'
  | 'ImpersonateGlobal'
  | 'ImpersonateeShortList'
  | 'LamAdminSpotBonusReport'
  | 'LamManagerSpotBonusReport'
  | 'LikeGoalComment'
  | 'LikeRecognition'
  | 'LikeRecognitionComment'
  | 'ManageAPI'
  | 'ManageAchievementRecognition'
  | 'ManageAuthentication'
  | 'ManageBenchmarkSurvey'
  | 'ManageClientApi'
  | 'ManageCompanyNews'
  | 'ManageDepartment'
  | 'ManageDepartmentViewOnly'
  | 'ManageDisplay'
  | 'ManageEverydayRecognition'
  | 'ManageFeedback'
  | 'ManageGoalCycle'
  | 'ManageGoalLibrary'
  | 'ManageLocation'
  | 'ManageMilestoneRecognition'
  | 'ManagePointCycle'
  | 'ManagePointEconomy'
  | 'ManagePolls'
  | 'ManagePopulation'
  | 'ManageProductItem'
  | 'ManageProductOrder'
  | 'ManageProfanity'
  | 'ManagePulseSurvey'
  | 'ManageRecognitionSettings'
  | 'ManageRules'
  | 'ManageSlackIntegration'
  | 'ManageSpotBonus'
  | 'ManageSystemRecognition'
  | 'ManageTalentInsight'
  | 'ManageTrack'
  | 'ManageValuesRecognition'
  | 'ManagerCheckInAnswerTypes'
  | 'ManagerTeamFeedback'
  | 'ManagerTeamLearning'
  | 'MemberCredit'
  | 'MemberPoint'
  | 'MergeAccount'
  | 'MobileAllowCompanyGoalMod'
  | 'MobileAllowTeamGoalMod'
  | 'MonthlyInvoice'
  | 'MultiManager'
  | 'NotifyWhenBadPublicRecognition'
  | 'OpenClosedGoal'
  | 'OutlookAddin'
  | 'PasswordNeverExpires'
  | 'PaymentProfile'
  | 'PerformCardLibrary'
  | 'PerformCycle'
  | 'PerformGoal'
  | 'PerformNineBox'
  | 'PointStore'
  | 'Polls'
  | 'PopulationReporting'
  | 'PreviewsEmbed'
  | 'ProfileCoaching'
  | 'ProfileFeedback'
  | 'ProfilePerform'
  | 'ProvisionAssets'
  | 'ProvisionBilling'
  | 'ProvisionCompany'
  | 'ProvisionDemo'
  | 'ProvisionMetrics'
  | 'ProvisionSystem'
  | 'ProvisionTemplates'
  | 'PulseSurvey'
  | 'PurchaseCredits'
  | 'PurchaseGiftCards'
  | 'ReceiveCreditsInRecognition'
  | 'ReceiveGiftInRecognition'
  | 'ReceivePointsInBenchmarkSurvey'
  | 'ReceivePointsInPulseSurvey'
  | 'ReceivePointsInRecognition'
  | 'RecognizeMeLink'
  | 'RecurringGoalCycle'
  | 'RelevancyFilter'
  | 'ReportAnalytics'
  | 'ReqFeedbackAboutOthers'
  | 'RequestFeedback'
  | 'RequireEmployeeID'
  | 'RestrictReportsByLocation'
  | 'RestrictSurveyResultByLocation'
  | 'RestrictToSingleSession'
  | 'SeeAllCycles'
  | 'SeeAllFeedback'
  | 'SeeLocation'
  | 'SelectRecapTime'
  | 'SelfNotificationEmail'
  | 'SelfPreference'
  | 'SellMyOwnItemForPoints'
  | 'SendCreditsInRecognition'
  | 'SendPointsInRecognition'
  | 'SetPointAdmin'
  | 'ShareGoals'
  | 'ShareLink'
  | 'ShowPointsInPublicFeed'
  | 'SkipGoalApproval'
  | 'SpotBonus'
  | 'SuggestRewardIdea'
  | 'SwitchEnvironment'
  | 'SwitchEnvironmentHG'
  | 'SwitchEnvironmentQA'
  | 'SwitchEnvironmentSales'
  | 'SyncUp'
  | 'TeamAction'
  | 'TeamActionDemo'
  | 'TeamAnalyticsDownload'
  | 'TeamAnalyticsReport'
  | 'TeamCheckin'
  | 'TeamCoaching'
  | 'TeamGoals'
  | 'TeamManagement'
  | 'TeamPerform'
  | 'TeamRecognize'
  | 'TeamTabManagement'
  | 'TeamTalent'
  | 'TrackLibrary'
  | 'TrackObjectiveWeight'
  | 'Tracks'
  | 'TransferCredits'
  | 'TransferPoints'
  | 'TransferSpendCredits'
  | 'TrophyRoom'
  | 'UnlimitedGiveBank'
  | 'UploadGoalCycleParticipants'
  | 'UserNotificationPreference'
  | 'ValuesRecognition'
  | 'ViewAllCoachingNotes'
  | 'WishList'
  | 'YammerIntegration';

export type KazooModule =
  | 'BEHAVIOR_BONUS'
  | 'INCENTIVES'
  | 'KW_FEEDBACK'
  | 'KW_SYNC_UPS'
  | 'KW_TALENT_REVIEW'
  | 'LEGACY_AWARDS'
  | 'NEW_CHECK_INS'
  | 'NEW_GOALS'
  | 'REWARDS'
  | 'SURVEYS'
  | 'SYNC_UP';

export type KazooIcon =
  | 'ADD_USER'
  | 'ADMIN'
  | 'ANNIVERSARY'
  | 'ANNIVERSARY_CAL'
  | 'ARROW_LEFT'
  | 'ARROW_RIGHT'
  | 'BACK'
  | 'BELL'
  | 'BIRTHDAY'
  | 'BIRTHDAY_CAKE'
  | 'CALENDAR'
  | 'CARET_DN'
  | 'CARET_DOWN'
  | 'CARET_LEFT'
  | 'CARET_RIGHT'
  | 'CARET_UP'
  | 'CHECK'
  | 'CHECKMARK'
  | 'CHECK_IN'
  | 'CHECK_SEAL'
  | 'CLOCK'
  | 'CLOSE'
  | 'CLOUD_DOWNLOAD'
  | 'COMMENT'
  | 'COMPANY_LINKS'
  | 'DATEPICKER_NAV'
  | 'DOT'
  | 'DOWNLOAD'
  | 'DOWN_ARROW'
  | 'DRAG'
  | 'EARN'
  | 'EMAIL'
  | 'EXPIRED'
  | 'EYE'
  | 'FEEDBACK'
  | 'FILTER'
  | 'FILTER_MENU'
  | 'FIND'
  | 'FLAG'
  | 'GOALS'
  | 'GOAL_COUNT'
  | 'GOAL_PERCENT'
  | 'GOAL_TASK'
  | 'HAMBURGER'
  | 'HAND_EXPANDED'
  | 'HELP'
  | 'HIGH_FIVE'
  | 'HIGH_FIVE_HOLLOW'
  | 'HOME'
  | 'HORIZONTAL_LINE'
  | 'HOURGLASS'
  | 'IMAGE_FILE'
  | 'INCENTIVES'
  | 'INFO'
  | 'INSIGHTS'
  | 'LINK'
  | 'LINK_ARROW'
  | 'LINK_FEATURE'
  | 'LOCK'
  | 'MEATBALL_MENU'
  | 'NOMINATION'
  | 'NOTIFICATION'
  | 'OPEN_CARET'
  | 'OPEN_CARET_DOWN'
  | 'OPEN_CARET_LEFT'
  | 'OPEN_CARET_UP'
  | 'PENCIL'
  | 'PEOPLE'
  | 'PIN'
  | 'PLATFORM_LOGO'
  | 'PLUS'
  | 'PROGRESS_CIRCLE'
  | 'PUSH_PIN'
  | 'RATING'
  | 'RECOGNITION'
  | 'REMOVE'
  | 'REWARDS'
  | 'SEARCH'
  | 'SEND_RECOGNITION'
  | 'SHARE_LINK'
  | 'SKILL'
  | 'SMILEY'
  | 'SURVEY'
  | 'SURVEYS'
  | 'SYNCS'
  | 'TALENT_REVIEW'
  | 'TALENT_REVIEW_INSIGHTS'
  | 'TASK_COMPLETED'
  | 'TEAMS'
  | 'TEXT_BOLD'
  | 'TEXT_BULLETLIST'
  | 'TEXT_INPUT'
  | 'TEXT_ITALIC'
  | 'TEXT_NUMBERLIST'
  | 'TEXT_UNDERLINE'
  | 'TOGGLE'
  | 'TRASH'
  | 'TREND_DOWN'
  | 'TREND_UP'
  | 'UP_ARROW'
  | 'UP_DOWN_CARET'
  | 'VERTICAL_LINE'
  | 'WARNING'
  | 'WARNING_NO_OUTLINE';

export interface TranslationLinkInput {
  /** URL you'd like the split of the translation to link to */
  url: Scalars['String'];
  /** The split point in the translation value EG: for <0>Sent Recognition to</0> <1>{{ recipient }}</1>, the split would be 1. */
  translationSubstitutionIndex: Scalars['Int'];
}

export interface TranslationVariableInput {
  /** The variable name defined in content.json or common.json for a specific translation. */
  key: Scalars['String'];
  /** The value to be rendered in the translation. EG: Janet, Q4 Check-In, etc. */
  value: Scalars['String'];
  /** Optionally may provide a UUID. Useful for linking to something on the frontend. */
  translationLink?: InputMaybe<TranslationLinkInput>;
}

export type TranslationIdentifierTypes =
  | 'PERSON';

export type FieldOnEntityForTranslation =
  | 'PERSON_FULL_NAME';

export interface DynamicTranslationVariableInput {
  /** The name of the variable in the translation. */
  key: Scalars['String'];
  /** The entity type we want to query */
  identifierType: TranslationIdentifierTypes;
  /** The ID of the entity to query. */
  identifierId: Scalars['ID'];
  /** The field on that entity to be used as a translation variable. */
  fieldOnIdentifiedEntity: FieldOnEntityForTranslation;
  /** Optionally may provide a URL. Useful for linking to something on the frontend. */
  translationLink?: InputMaybe<TranslationLinkInput>;
}

/** Used to provide a translation key and and variables which can be used in translation function. */
export interface TranslatableObjectInput {
  /** Translation key. Should map to to known translation in content.json or common.json. If you provide any other string value it will render untranslated. */
  key: Scalars['String'];
  /** JSON object consisting of variables defined for a given translation. */
  variables?: InputMaybe<Array<TranslationVariableInput>>;
  dynamicVariables?: InputMaybe<Array<DynamicTranslationVariableInput>>;
}

export interface TranslationLink {
  __typename?: 'TranslationLink';
  /** URL you'd like the split of the translation to link to */
  url: Scalars['String'];
  /** The split point in the translation value EG: for <0>Sent Recognition to</0> <1>{{ recipient }}</1>, the split would be 1. */
  translationSubstitutionIndex: Scalars['Int'];
}

export interface TranslationVariable {
  __typename?: 'TranslationVariable';
  /** The variable name defined in content.json or common.json for a specific translation. */
  key: Scalars['String'];
  /** The value to be rendered in the translation. EG: Janet, Q4 Check-In, etc. */
  value: Scalars['String'];
  /** Optionally may provide a URL. Useful for linking to something on the frontend. */
  translationLink?: Maybe<TranslationLink>;
}

/** Returns a translation key and variables needed to translate. */
export interface TranslatableObject {
  __typename?: 'TranslatableObject';
  key: Scalars['String'];
  variables?: Maybe<Array<TranslationVariable>>;
  translatedValue?: Maybe<Scalars['String']>;
}

/** Represents an element that can be substituted into a translation. */
export interface TranslationValue {
  __typename?: 'TranslationValue';
  key: Scalars['String'];
  value?: Maybe<Scalars['String']>;
}

export interface TranslatableError {
  __typename?: 'TranslatableError';
  message: Scalars['String'];
  translationKey: Scalars['String'];
  translationValues?: Maybe<Array<TranslationValue>>;
}

export type Role =
  | 'ADMIN'
  | 'ANALYST'
  | 'FINANCE'
  | 'FULFILLER'
  | 'PLATFORM_ADMIN'
  /** Can approve or reject rewards redemptions. */
  | 'REWARDS_MODERATOR'
  /** Deprecated. Use REWARDS_MODERATOR. */
  | 'REWARDS_MODERATORS'
  | 'SURVEY_ADMIN'
  /** Role that grants users UI access to Pulse app. Will also write back a pre-defined set of permissions within the Pulse app so that that WTW user can access certain features in Pulse. */
  | 'SURVEY_CUSTOM'
  /**
   * Sets a Full Report Reader in S&I.
   * Has access to view detailed reports for the Engagement survey type, including employee-level data, across all hierarchies.
   * This role can also filter reports using all attributes.
   */
  | 'SURVEY_FULL_REPORT_READER'
  /**
   * Sets a People Leader role in S&I.
   * Can manage and analyze engagement surveys, including viewing detailed reports filtered by various attributes, but their data access is limited to employees within their own hierarchy.
   * This role can also view and manage comments to understand employee sentiment.
   */
  | 'SURVEY_PEOPLE_LEADER'
  /**
   * Role that grants Pulse-only users access to the WorkTango AI Assistant admin
   * functionality.
   *
   * Some KW_USERS People who do not have this role will be treated as if they do if they have the WORKTANGO_COACH_ADMIN role in Pulse.
   * This allows SURVEY_CUSTOM permissions to define in the pulse app if a user can admin WorkTango Coach.
   */
  | 'WORKTANGO_COACH_ADMIN'
  /**
   * Role that grants users access to the WorkTango coach functionality.
   *
   * Some KW_USERS People who do not have this role will be treated as if they do if they have the WORKTANGO_COACH_USER role in Pulse.
   * This allows SURVEY_CUSTOM permissions to define in the pulse app if a user can use WorkTango Coach.
   */
  | 'WORKTANGO_COACH_USER';

export type PersonIdentityProvider =
  /** This is only supported for legacy CSV parsers that call imports.  Directory does not actually support default.  DO NOT USE. */
  | 'DEFAULT'
  /** Email.  Only unique within a company. */
  | 'EMAIL'
  /** EmployeeID, badge number or other value that is only unique within a company. */
  | 'EMPLOYEE_ID'
  /** GRS member id */
  | 'GRS_MEMBER_ID'
  /** globally unique identifier. Kazoo-assigned. */
  | 'KAZOO_ID'
  /** Legacy Highground userId */
  | 'LEGACY_HIGHGROUND_ID'
  /** Legacy Highground memberId */
  | 'LEGACY_HIGHGROUND_MEMBER_ID'
  /** Legacy Highground username */
  | 'LEGACY_HIGHGROUND_USERNAME'
  /** Employee Id from the legacy WorkTango platform Pulse */
  | 'LEGACY_PULSE_EMPLOYEE_ID'
  /** User Id from the legacy WorkTango platform Pulse */
  | 'LEGACY_PULSE_USER_ID'
  /** Legacy YouEarnedIt userId */
  | 'LEGACY_YEI_ID'
  /** Legacy YouEarnedIt username */
  | 'LEGACY_YEI_USERNAME'
  /** Kazoo Username */
  | 'USERNAME'
  /** WorkOS user id */
  | 'WORKOS_USER_ID';

export type QueryPeopleSortField =
  | 'BIRTHDAY'
  | 'DEPARTMENT_NAME'
  | 'EMPLOYMENT_START_DATE'
  | 'EXEMPT_FROM_AUTO_ARCHIVE'
  | 'FULL_NAME'
  | 'LEGACY_FIRST_NAME'
  | 'LEGACY_LAST_NAME'
  | 'LOCATION_NAME'
  | 'POINTS_TO_SEND'
  | 'POINTS_TO_SPEND'
  | 'POINT_RULE'
  | 'STATUS'
  | 'TITLE';

export interface QueryPeopleSortInput {
  field: QueryPeopleSortField;
  direction: SortDirection;
}

/** Used to identify a person in input operations */
export interface PersonIdentityInput {
  /** provider */
  provider: PersonIdentityProvider;
  /** identifier of their account */
  key: Scalars['String'];
}

/** Nullable to support delete operations. e.g.: Update my manager to null. */
export interface NullablePersonIdentityInput {
  provider: PersonIdentityProvider;
  key?: InputMaybe<Scalars['String']>;
}

/** Used to identify Departments, Locations, and Groups. */
export type EntityIdentifierType =
  /** client-provided key */
  | 'EXTERNAL'
  /** globally unique, kazoo-generated id */
  | 'KAZOO_ID'
  /** hg */
  | 'LEGACY_HIGHGROUND_ID'
  /** YEI */
  | 'LEGACY_YEI_ID';

/** Identifies an entity like a Location, Group, or Department.  Nullable for use in delete operations like 'set my department to null'. */
export interface NullableEntityIdentifierInput {
  type: EntityIdentifierType;
  key?: InputMaybe<Scalars['String']>;
}

/** Identifies an entity like a Location, Group, or Department. */
export interface EntityIdentifierInput {
  type: EntityIdentifierType;
  key: Scalars['String'];
}

/** creates or updates a person record, typically from HRIS import. */
export interface CreateOrUpdatePersonInput {
  /** client generated id for this update.  Ensures this update succeeds once and only once. */
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  /**
   * Identifies the user to be created or updated.
   * Providing a null value for this field will create a new Person, though you _must_
   * provide at least one identity that matches the company identity provider in the
   * `identitiesToAdd` field.
   */
  identifier?: InputMaybe<PersonIdentityInput>;
  /** array of provider/key pairs to add */
  identitiesToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** array of provider strings to remove */
  identitiesToRemove?: InputMaybe<Array<PersonIdentityProvider>>;
  /** Most people have a manager. */
  manager?: InputMaybe<NullablePersonIdentityInput>;
  /** Overwrites the existing list of groups with this list.  Empty if [].  No op for null.  Use in place of groupsToAdd/groupsToRemove */
  groups?: InputMaybe<Array<EntityIdentifierInput>>;
  /** These are all group memberships that are not department, title, or location, e.g. 2019 Interns or Team Bravo. */
  groupsToAdd?: InputMaybe<Array<EntityIdentifierInput>>;
  /** These are all group memberships that are not department, title, or location, e.g. 2019 Interns or Team Bravo. */
  groupsToRemove?: InputMaybe<Array<EntityIdentifierInput>>;
  /** Add this person to these security roles */
  rolesToAdd?: InputMaybe<Array<Role>>;
  /** Remove this person from these security roles */
  rolesToRemove?: InputMaybe<Array<Role>>;
  /** Set the roles on this person to these.  Invalid with either rolesToAdd or rolesToRemove. */
  roles?: InputMaybe<Array<Role>>;
  /** e.g. IT_HLP.  If key is null, we remove them from the department. */
  department?: InputMaybe<NullableEntityIdentifierInput>;
  /** This can be as granular as desired. E.g. US, or Chicago, or 363 W Erie.  If key is null, we remove them from the location. */
  location?: InputMaybe<NullableEntityIdentifierInput>;
  /** e.g. Customer Service Representative II. */
  title?: InputMaybe<Scalars['String']>;
  /** Person's name. See NameInput for details. */
  name?: InputMaybe<NameInput>;
  /** Supports firstName and lastName. */
  legacyNameInput?: InputMaybe<LegacyNameInput>;
  /** person's country code. e.g. US, CA, MX, etc. */
  country?: InputMaybe<Scalars['String']>;
  /** If provided, and null, we set the current value to default. */
  avatar?: InputMaybe<ImageInput>;
  /** Employee bio, statement of purpose, shocking facts, pets, etc. */
  aboutMe?: InputMaybe<Scalars['String']>;
  /** ISO 639-1 ISO 3316-1 language code e.g. en-US, es-MX */
  locale?: InputMaybe<Scalars['String']>;
  /** ISO-8601 date only (e.g. YYYY-MM-DDTHH:MM:SSZ). Used for tracking anniversaries. */
  employmentStartDate?: InputMaybe<Scalars['StrictDateTimeInput']>;
  /** month and year only */
  birthday?: InputMaybe<MonthDayInput>;
  /** ISO-8601 date only (e.g. YYYY-MM-DDTHH:MM:SSZ). Updating DOB will also update birthday. */
  dateOfBirth?: InputMaybe<Scalars['StrictDateTimeInput']>;
  /** month and year only */
  workAnniversary?: InputMaybe<MonthDayInput>;
  /**
   * Active or archived.  If null, a no-op
   * Changing the status of someone to ARCHIVE does not delete any of their relationships with any other table/entity
   */
  status?: InputMaybe<PersonStatus>;
  /** person's email */
  email?: InputMaybe<Scalars['String']>;
  /** showBirthday, showAnniversary belong to on user profile */
  profileSettings?: InputMaybe<ProfileSettingsInput>;
  /** When true, this person is exempt from being auto-archived through directory ingestion/import operations. */
  exemptFromAutoArchive?: InputMaybe<Scalars['Boolean']>;
  /** Use this field to request directory to perform tasks after the User has been created or Updated. Refer the documentation on each enum values for more details. */
  followupTasks?: InputMaybe<Array<InputMaybe<CrudPersonFollowupTasks>>>;
  /** Person that has access to conditionally review the modules of the users they 'Coach' or 'Manage' */
  secondaryManager?: InputMaybe<NullablePersonIdentityInput>;
  /** If provided, overwrites the existing custom attributes with this list.  To remove an attribute, set 'archiveMissing' to true and only pass the attributes you intend to keep.  Or pass "" for the value. */
  customAttributes?: InputMaybe<CustomAttributeValuesInput>;
  options?: InputMaybe<CreateOrUpdatePersonOptionsInput>;
  /** The people that this person assists. Assistants can take certain actions on behalf of the person they assist. */
  assists?: InputMaybe<Array<PersonIdentityInput>>;
  /** Phone numbers for the person. If not provided, the person's existing phone numbers will be used. If empty array, all phone numbers will be removed. */
  phoneNumbers?: InputMaybe<Array<PhoneNumberInput>>;
}

export interface PhoneNumberInput {
  type: PersonPhoneNumberType;
  /** The raw phone number string, e.g. +12345678901 */
  raw: Scalars['String'];
  /** Whether this is the default phone number for the person */
  isDefault: Scalars['Boolean'];
}

export interface CreateOrUpdatePersonOptionsInput {
  /** If true, we do not create a person.  Used in scenarios where we do bulk operations and want to ONLY update. */
  onlyCreateIfStatusIn?: InputMaybe<Array<PersonStatus>>;
  /** Skips adding or changing the manager if the new manager does not exist. */
  skipManagerIfNotFound?: InputMaybe<Scalars['Boolean']>;
  /** Skips adding or changing the secondary manager if the new manager does not exist. */
  skipSecondaryManagerIfNotFound?: InputMaybe<Scalars['Boolean']>;
  /** converts bad email input like ali ce@acme.com to alice@acme.com */
  closeUpSpacesInEmail?: InputMaybe<Scalars['Boolean']>;
  /** If true, it creates/updates the person without the avatar if the avatar service is unavailable. */
  warnOnAvatarProblems?: InputMaybe<Scalars['Boolean']>;
  /** If true, it creates/updates the person without the phone numbers if the phone number service is not a valid E.164 number. */
  skipInvalidPhoneNumbers?: InputMaybe<Scalars['Boolean']>;
}

export interface CreateOrUpdateDepartmentInput {
  /** client generated id for this update.  Ensures this update succeeds once and only once. */
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  /** attempts an insert operation if not provided */
  identifier: EntityIdentifierInput;
  name?: InputMaybe<Scalars['String']>;
  key?: InputMaybe<Scalars['String']>;
  parent?: InputMaybe<NullableEntityIdentifierInput>;
  active?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<DepartmentLocationGroupStatus>;
  /** Overwrites the existing list of administrators with this list.  Empty if [].  No op for null. */
  administrators?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these administrators. */
  administratorsToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these administrators. */
  administratorsToRemove?: InputMaybe<Array<PersonIdentityInput>>;
  /** Overwrites the existing list of owners with this list.  Empty if [].  No op for null. */
  owners?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these owners. */
  ownersToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these owners. */
  ownersToRemove?: InputMaybe<Array<PersonIdentityInput>>;
  legacyRrId?: InputMaybe<Scalars['String']>;
  legacyPmId?: InputMaybe<Scalars['String']>;
}

export interface CreateOrUpdateLocationInput {
  /** client generated id for this update.  Ensures this update succeeds once and only once. */
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  /** attempts an insert operation if not provided */
  identifier: EntityIdentifierInput;
  name?: InputMaybe<Scalars['String']>;
  key?: InputMaybe<Scalars['String']>;
  parent?: InputMaybe<NullableEntityIdentifierInput>;
  active?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<DepartmentLocationGroupStatus>;
  legacyRrId?: InputMaybe<Scalars['String']>;
  legacyPmId?: InputMaybe<Scalars['String']>;
  /** Overwrites the existing list of administrators with this list.  Empty if [].  No op for null. */
  administrators?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these administrators. */
  administratorsToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these administrators. */
  administratorsToRemove?: InputMaybe<Array<PersonIdentityInput>>;
  /** Overwrites the existing list of owners with this list.  Empty if [].  No op for null. */
  owners?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these owners. */
  ownersToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these owners. */
  ownersToRemove?: InputMaybe<Array<PersonIdentityInput>>;
}

export interface CreateOrUpdateGroupInput {
  /** client generated id for this update.  Ensures this update succeeds once and only once. */
  clientMutationId?: InputMaybe<Scalars['String']>;
  /** Optional id for correlating bulk operations.  If provided, these are aggregated on the Batch entity. */
  batchId?: InputMaybe<Scalars['String']>;
  /** Optional ordinal value for bulk opertions.  Useful for sorting the results of batch operations. */
  batchSequence?: InputMaybe<Scalars['Int']>;
  /** attempts an insert operation if not provided */
  identifier: EntityIdentifierInput;
  /** legacy platform identifier */
  legacyRrId?: InputMaybe<Scalars['String']>;
  /** YEI group type identifier */
  legacyRrGroupTypeId?: InputMaybe<Scalars['String']>;
  legacyPmId?: InputMaybe<Scalars['String']>;
  name?: InputMaybe<Scalars['String']>;
  /** Group creation defaults to type AFFINITY. Any change to GroupType cascades to the Group's children. One may not change a child Group's GroupType directly. */
  type?: InputMaybe<GroupType>;
  key?: InputMaybe<Scalars['String']>;
  parent?: InputMaybe<NullableEntityIdentifierInput>;
  active?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<DepartmentLocationGroupStatus>;
  /** Overwrites the existing list of administrators with this list.  Empty if [].  No op for null. */
  administrators?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these administrators. */
  administratorsToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these administrators. */
  administratorsToRemove?: InputMaybe<Array<PersonIdentityInput>>;
  /** Overwrites the existing list of owners with this list.  Empty if [].  No op for null. */
  owners?: InputMaybe<Array<PersonIdentityInput>>;
  /** Adds these owners. */
  ownersToAdd?: InputMaybe<Array<PersonIdentityInput>>;
  /** Removes these owners. */
  ownersToRemove?: InputMaybe<Array<PersonIdentityInput>>;
}

export type GroupType =
  /** e.g. Intern Class of 2014, front-end developers */
  | 'AFFINITY'
  /** Does not appear for non-admins.  Typically used for things like CostCenter that is meaningless for end users. */
  | 'PRIVATE';

/** Allows us to attach custom attributes to a person */
export interface CustomAttributeValuesInput {
  archiveMissing?: InputMaybe<Scalars['Boolean']>;
  values: Array<CustomAttributeValueInput>;
}

/** name and value of a custom attribute */
export interface CustomAttributeValueInput {
  /** Canonical name of this custom field.  If it doesn't exist, we throw a UserInputError. */
  name: Scalars['String'];
  /**
   * We pass the value in as a string and parse it at runtime.
   * Passing invalid input, e.g. 'foo' for an number field will throw UserInputError.
   * Passing null removes the custom field from the Person.
   */
  value?: InputMaybe<Scalars['String']>;
  /**
   * We do not make DB updates that are no-ops, but for tracking the system activity feature,
   * product would like us to track when we last successfully fetched and attempted to update
   * system attributes, regardless of if the actual data was a no-op.
   */
  syncedFromWarehouseAt?: InputMaybe<Scalars['Date']>;
}

export type CrudPersonFollowupTasks =
  /** Sends email notification once user is activated whether or not they are new. */
  | 'REQUEST_ACCOUNT_ACTIVATION'
  /** Sends email notification once user is activated but only for newly created people. */
  | 'REQUEST_ACCOUNT_ACTIVATION_IF_NEW';

export interface ProfileSettingsInput {
  /** Display birthday on user profile */
  showBirthday?: InputMaybe<Scalars['Boolean']>;
  /** Display start date on user profile */
  showAnniversary?: InputMaybe<Scalars['Boolean']>;
}

export type PersonStatus =
  /** They are an active Kazoo user. */
  | 'ACTIVE'
  /** They have been deleted. */
  | 'ARCHIVED'
  /** They cannot login or be a participant, but their points remain. */
  | 'PAUSED'
  /** records anonymized/deleted for GDPR-type scenarios */
  | 'PURGED';

export type DepartmentLocationGroupStatus =
  | 'ACTIVE'
  /** The department, location, or group has been deleted, but can be resurrected */
  | 'ARCHIVED'
  /** Records deleted and no longer recoverable by users */
  | 'DELETED';

export type ImageInputType =
  | 'BYTES_BASE_64'
  | 'NULLIFY'
  | 'URL';

export interface ImageInput {
  type?: InputMaybe<ImageInputType>;
  payload: Scalars['String'];
  /** Should the software automatically center the user's face? */
  autoFocus?: InputMaybe<Scalars['Boolean']>;
  /** When true, the main Person updates will happen as normal but the avatar upload will happen asynchronously as a task. Only supports URL avatars. For use in batches. */
  performAsync?: InputMaybe<Scalars['Boolean']>;
}

/** Setting any of these to null ignores the input.  Setting to empty string clears it. */
export interface NameInput {
  preferredName?: InputMaybe<Scalars['String']>;
  fullName?: InputMaybe<Scalars['String']>;
  shortName?: InputMaybe<Scalars['String']>;
}

/** Support legacy name concepts. */
export interface LegacyNameInput {
  firstName?: InputMaybe<Scalars['String']>;
  lastName?: InputMaybe<Scalars['String']>;
}

/** These are used when mapping Kazoo Person fields to Pulse. */
export type KazooField =
  | 'COUNTRY'
  | 'DATE_OF_BIRTH'
  | 'DEPARTMENT'
  | 'EMAIL'
  | 'EMPLOYEE_ID'
  | 'EMPLOYMENT_START_DATE'
  | 'FIRST_NAME'
  | 'JOB_TITLE'
  | 'LAST_NAME'
  | 'LOCATION'
  | 'MANAGER'
  | 'PARENT_DEPARTMENT'
  | 'PARENT_LOCATION'
  | 'PERSONAL_PHONE_NUMBER'
  | 'PREFERRED_NAME'
  | 'WORK_PHONE_NUMBER';

export interface ArchivePeopleNotInBatchInput {
  batchId: Scalars['String'];
}

export type PersonPhoneNumberType =
  | 'PERSONAL'
  | 'WORK';

/** Only the fields passed through will be updated in the database. */
export interface CreateOrUpdateGoalInput {
  /** ID of the goal to update. */
  id?: InputMaybe<Scalars['ID']>;
  /** User supplied unique key. Immutable */
  externalKey?: InputMaybe<Scalars['String']>;
  /** If provided, associates this update with a batch. */
  batchId?: InputMaybe<Scalars['ID']>;
  name?: InputMaybe<Scalars['String']>;
  /** There aren't huge differences in the goal data depending on the type, so it's perfectly fine to change the goal's type on the fly. */
  type?: InputMaybe<GoalType>;
  /** Updates existing measurable results attached to the goal. */
  measurableResults?: InputMaybe<Array<UpdateMeasurableResultFromGoalInput>>;
  riskStatus?: InputMaybe<GoalRiskStatus>;
  description?: InputMaybe<Scalars['String']>;
  dueDate?: InputMaybe<Scalars['Date']>;
  startDate?: InputMaybe<Scalars['Date']>;
  /** Defaults to PUBLIC */
  privacy?: InputMaybe<GoalPrivacy>;
  /** ID of the goal this goal aligns to. */
  parentGoalId?: InputMaybe<Scalars['ID']>;
  /** External key of the goal that this goal aligns to.  If parentGoalId is provided, this is ignored. */
  parentGoalExternalKey?: InputMaybe<Scalars['String']>;
  archived?: InputMaybe<Scalars['Boolean']>;
  status?: InputMaybe<GoalStatus>;
  /** Reason why the Goal will be closed */
  closeReason?: InputMaybe<Scalars['String']>;
  /** If the Goal will be closed, is it completed? */
  completed?: InputMaybe<Scalars['Boolean']>;
  /** ID of the department to which the Goal will be linked */
  departmentId?: InputMaybe<Scalars['ID']>;
  /** Identifier of the of the department using directory-style inputs.  If departmentId is provided, this is ignored. */
  departmentIdentifier?: InputMaybe<EntityIdentifierInput>;
  /** IDs of the collaborators of the Goal. If this is an empty array, that indicates remove all collaborators. Undefined means no op. */
  collaboratorsIds?: InputMaybe<Array<Scalars['ID']>>;
  /** Identifiers of the of the collaborators using directory-style inputs. If this is an empty array, that indicates remove all collaborators. Undefined means no op. If collaboratorIds is provided, this is ignored. */
  collaboratorsIdentifiers?: InputMaybe<Array<PersonIdentityInput>>;
  /** Owner ID, only updates on Orphaned Goals */
  ownerId?: InputMaybe<Scalars['ID']>;
  /** Identifier of the owner using directory-stlye inputs.  If ownerId is provided, this is ignored. */
  ownerIdentifier?: InputMaybe<PersonIdentityInput>;
  /** ID of category this Goal aligns to. */
  categoryId?: InputMaybe<Scalars['String']>;
  /** Name of the category that this goal aligns to.  If categoryId is provided, this is ignored. */
  categoryName?: InputMaybe<Scalars['String']>;
  /** optional comment */
  comment?: InputMaybe<Scalars['String']>;
}

export interface UpdateMeasurableResultFromGoalInput {
  id?: InputMaybe<Scalars['ID']>;
  target?: InputMaybe<Scalars['Int']>;
  progress?: InputMaybe<Scalars['Int']>;
  type?: InputMaybe<MeasurableResultType>;
  name?: InputMaybe<Scalars['String']>;
  description?: InputMaybe<Scalars['String']>;
  dueDate?: InputMaybe<Scalars['Date']>;
}

export type MeasurableResultType =
  | 'BOOLEAN'
  | 'NUMERIC'
  | 'PERCENT';

export type GoalType =
  | 'COMPANY'
  | 'DEPARTMENT'
  | 'INDIVIDUAL';

export type GoalStatus =
  | 'AWAITING_APPROVAL'
  | 'AWAITING_CLOSURE'
  | 'CLOSED'
  | 'DRAFT'
  | 'IN_PROGRESS'
  | 'OVERDUE';

export type GoalRiskStatus =
  | 'AT_RISK'
  | 'BEHIND'
  | 'ON_TRACK';

export type GoalPrivacy =
  | 'PRIVATE'
  | 'PUBLIC';

export interface AssignPointRuleInput {
  /**
   * Optional identifier for grouping this operation into a batch.
   *
   * If provided, we will look up the person and if they were created in the same batch, we will apply the point rule (if the point rule is to be applied on new person input).
   */
  batchId?: InputMaybe<Scalars['String']>;
  /** The identifier of the point rule. */
  pointRuleIdentifier: PointRuleIdentifier;
  /** The id of the person. */
  personIdentifier: PersonIdentityInput;
  personOptions?: InputMaybe<PersonPointOperationOptions>;
}

export interface PersonPointOperationOptions {
  /** If the person cannot be found, we suppress the error.  Used in 'do not create inactive people' scenarios. */
  suppressErrorForPersonNotFound?: InputMaybe<Scalars['Boolean']>;
  /** We only ever apply point rules on assignment if we are also creating the person. At this time, its only possible to create and assign a point rule at the same time via batches. The default here is false, and batches will specify true. */
  applyPointRuleOnAssignment?: InputMaybe<Scalars['Boolean']>;
}

export type PointRuleIdentifierType =
  | 'KAZOO_ID'
  /** Legacy YEI ID is to be used only during migrating a company from YEI to KW. */
  | 'LEGACY_YEI_ID'
  | 'NAME';

export interface PointRuleIdentifier {
  type: PointRuleIdentifierType;
  /** If null, we remove the point rule from the person. */
  key?: InputMaybe<Scalars['String']>;
}

export type PointBalanceAccount =
  | 'GIVING'
  | 'REDEMPTION';

export interface PointBalanceInput {
  /** Optional identifier for grouping this operation into a batch. */
  batchId?: InputMaybe<Scalars['String']>;
  /** The owner of the point balance to adjust. */
  personIdentifier: PersonIdentityInput;
  /** A globally unique client key that guarantees the points are adjusted only once. */
  idempotencyKey: Scalars['ID'];
  /** Which user account should be adjusted? */
  account: PointBalanceAccount;
  /** The positive or negative number of points to transact. Only use if absolutely necessary. */
  points: Scalars['Int'];
  /** If true, the operation will be executed synchronously. */
  synchronouslyApplyAdjustment?: InputMaybe<Scalars['Boolean']>;
  /**
   * An event identifier related to the adjustment for audit purposes.
   *
   * Example: `Incentive:Claimed:123`
   */
  eventId: Scalars['String'];
  personOptions?: InputMaybe<PersonPointOperationOptions>;
}

export type PointRuleApplicationReason =
  | 'ADMINISTRATIVE_OVERRIDE'
  | 'PERIODIC_REFRESH'
  | 'PERSON_CREATED';

export interface RefreshPointsInput {
  personId: Scalars['ID'];
  /** If not provided, it executes the built in point rules for the company */
  pointRuleId?: InputMaybe<Scalars['ID']>;
  idempotencyKey: Scalars['String'];
  batchId: Scalars['ID'];
  pointRefreshRunId: Scalars['ID'];
  /** If true, the operation will not actually execute. */
  dryRun?: InputMaybe<Scalars['Boolean']>;
}

export interface RecognitionIdentifierInput {
  id: Scalars['String'];
}

export interface RecipientsSearchOptionsInput {
  namePartial: Scalars['String'];
}

export interface ConfigureRecognitionGiphySettingsInput {
  enabled: Scalars['Boolean'];
  rating?: InputMaybe<GiphyContentRating>;
  defaultSearchTerm?: InputMaybe<Scalars['String']>;
}

export interface CreateOrUpdateRecognitionInput {
  /** The ID of the Recognition for updating. Can be a KW Recognition ID or YEI Recognition ID */
  id?: InputMaybe<Scalars['ID']>;
  /** For robots to send Recognition on behalf of a user. Request will fail for non-robots */
  senderIdentifier?: InputMaybe<RecognitionSenderInput>;
  /** The content of the Recognition. Legacy, only supports plain text. Use richTextBody for rich text content (which allows you to specify the content in any format). */
  body?: InputMaybe<Scalars['String']>;
  /** The content of the Recognition. */
  richTextBody?: InputMaybe<RichTextContentInput>;
  /**
   * If the company is KW_USERS or KW_USERS_READ_ONLY, recipients MUST have be a list of KAZOO_ID identity providers. Otherwise this means
   * they are a YEI-only company and their identity providers must be LEGACY_YEI_ID. When `source` is `UPLOAD`, recipients may also use
   * `EMAIL` or `EMPLOYEE_ID` identity providers; the mutation will resolve them to `KAZOO_ID` before saving.
   */
  recipients?: InputMaybe<Array<RecipientInput>>;
  /** Core Value is provided as its actual text value rather than ID. It will be looked up by workspace + name */
  coreValueName?: InputMaybe<Scalars['String']>;
  /** Skills are sent as a list of their string names. */
  skills?: InputMaybe<Array<Scalars['String']>>;
  /** Indicates the privacy of the Recognition. */
  public?: Scalars['Boolean'];
  /** Request will fail for companies which force zero-point recognitions */
  points?: InputMaybe<PointsInput>;
  /**
   * Unique ID that prevents a Recognition from being processed more than once. When in doubt, use a UUID."
   * Required for create operations and will be disregarded on edit operations.
   */
  idempotencyKey?: InputMaybe<Scalars['String']>;
  /** ID of the batch to which this recognition belongs. This is used for bulk recognitions. */
  batchId?: InputMaybe<Scalars['String']>;
  /** The type of recognition to send */
  recognitionType?: InputMaybe<RecognitionType>;
  /** The source of the recognition */
  source?: InputMaybe<RecognitionSource>;
  /** Whether the user accepted the AI writer's recommendation */
  acceptedAIRecommendation?: InputMaybe<Scalars['Boolean']>;
  /** ImageUpload IDs that were uploaded in association with this Recognition. An empty array will remove all images. */
  images?: InputMaybe<Array<Scalars['ID']>>;
  background?: InputMaybe<RecognitionBackground>;
}

export interface RecognitionSenderInput {
  provider: RecognitionSenderIdentityProvider;
  key?: InputMaybe<Scalars['String']>;
}

export interface RecipientInput {
  type: RecipientType;
  identifier: RecipientIdentifierInput;
}

export interface RecipientIdentifierInput {
  key: Scalars['String'];
  provider: RecognitionIdentityProvider;
}

export interface PointsInput {
  type: PointsType;
  amount: Scalars['Int'];
  tokenId?: InputMaybe<Scalars['String']>;
  nonTaxable?: InputMaybe<Scalars['Boolean']>;
}

export interface PointsPayload {
  __typename?: 'PointsPayload';
  type: PointsType;
  amount: Scalars['Int'];
  /** For SPECIAL_CATALOG_TOKEN type, the token ID to be used for the recognition */
  tokenId?: Maybe<Scalars['String']>;
  nonTaxable: Scalars['Boolean'];
}

export type RecipientType =
  | 'PERSON';

export type PointsType =
  | 'POINTS'
  | 'SPECIAL_CATALOG_TOKENS';

export type GiphyContentRating =
  | 'G'
  | 'PG'
  | 'PG13';

export type RecognitionIdentityProvider =
  | 'KAZOO_ID'
  | 'LEGACY_YEI_ID'
  | 'EMAIL'
  | 'EMPLOYEE_ID';

export type RecognitionPrivacy =
  | 'PRIVATE'
  | 'PUBLIC';

export type RecognitionRole =
  | 'RECIPIENT'
  | 'SENDER';

export type RecognitionType =
  /** A bulk recognition sent to multiple recipients by an admin */
  | 'BULK_RECOGNITION'
  /** An automated birthday or work anniversary recognition sent by the system */
  | 'MILESTONE_RECOGNITION'
  /** A standard peer-to-peer recognition */
  | 'PEER_TO_PEER_RECOGNITION'
  /** An ad-hoc special recognition sent by an admin on behalf of the company */
  | 'SPECIAL_RECOGNITION';

export type RecognitionSenderIdentityProvider =
  | 'KAZOO_ID'
  | 'LEGACY_YEI_ID'
  | 'SYSTEM';

export type RecognitionSource =
  | 'ANDROID'
  | 'IOS'
  | 'SLACK'
  | 'WEB_BULK_RECOGNITION'
  | 'WEB_DASHBOARD'
  | 'WEB_OTHER'
  | 'WEB_PROFILE'
  | 'UPLOAD';

export interface RecognitionEvent {
  __typename?: 'RecognitionEvent';
  /** The ID of the Recognition as it lives in the database */
  aggregateId: Scalars['ID'];
  aggregateType: Scalars['String'];
  type: Scalars['String'];
  timestamp: Scalars['DateTime'];
}

export type RecognitionBackground =
  | 'BALLOONS'
  | 'CHAMPAGNE'
  | 'FEATHER'
  | 'FIREWORKS'
  | 'LEAVES'
  | 'NEON'
  | 'PRIMARY_BRANDING'
  | 'SECONDARY_BRANDING'
  | 'SIDING'
  | 'SPRINKLES'
  | 'STARS'
  | 'SUNSET'
  | 'TEDDY_BEAR'
  | 'WAVES'
  | 'WINTER_TREES'
  | 'CHALK_BURST'
  | 'FIREWORKS_SMALL'
  | 'GOLD_STARS'
  | 'LAZER_PRISM'
  | 'CONFETTI';

export interface MigrateIncentivesEntityInput {
  /** The type of the legacy entity to migrate */
  type: MigratableIncentivesEntity;
  /** The MongoDB ObjectID of the legacy entity */
  legacyId: Scalars['ID'];
  /** The ID of the IncentivesMigrationBatch that this migration belongs to */
  batchId: Scalars['ID'];
  /** If true, the provided legacy data will not be persisted. */
  dryRun?: Scalars['Boolean'];
}

export type MigratableIncentivesEntity =
  | 'ITEM'
  | 'ITEM_ORDER';

export interface CreateWorkOsUserFromKwPersonInput {
  personId: Scalars['ID'];
  batchId?: InputMaybe<Scalars['String']>;
}

export type AppendMessageToConversationMutationVariables = Exact<{
  input: AppendMessageInput;
}>;


export type AppendMessageToConversationMutation = { __typename?: 'Mutation', appendMessage: { __typename?: 'AppendMessagePayload', conversation: { __typename?: 'Conversation', id: string, title: string, userId: string, workspace: string, updatedAt?: any | undefined } } };

export type CreateOrUpdateAiResponseRatingMutationVariables = Exact<{
  input: CreateAiResponseRatingInput;
}>;


export type CreateOrUpdateAiResponseRatingMutation = { __typename?: 'Mutation', createOrUpdateAiResponseRating: { __typename?: 'AiResponseRating', id: string, responseType: AiResponseType, responseId: string, userRating?: AiRatingValue | undefined, userComment?: string | undefined, createdAt: any, updatedAt: any } };

export type DeleteAiDocumentMutationVariables = Exact<{
  input: DeleteAiAssistantDocumentInput;
}>;


export type DeleteAiDocumentMutation = { __typename?: 'Mutation', deleteAIAssistantDocument: { __typename?: 'DeleteAIAssistantDocumentPayload', document: { __typename?: 'AIAssistantDocument', id: string } } };

export type GetAConversationQueryVariables = Exact<{
  input: ConversationInput;
}>;


export type GetAConversationQuery = { __typename?: 'Query', aiAssistantConversation: { __typename?: 'Conversation', id: string, title: string, updatedAt?: any | undefined, messages: Array<{ __typename?: 'Message', id: string, messageText: string, conversationId: string, role: AiAssistantConversationMessageRole, metadata?: any | undefined, aiResponseRating?: { __typename?: 'AiResponseRating', id: string, userRating?: AiRatingValue | undefined, userComment?: string | undefined } | undefined }> } };

export type GetAiDocumentsQueryVariables = Exact<{
  first?: InputMaybe<Scalars['Int']>;
  after?: InputMaybe<Scalars['String']>;
  filter?: InputMaybe<AiAssistantDocumentFilterInput>;
}>;


export type GetAiDocumentsQuery = { __typename?: 'Query', aiDocumentUploads: { __typename?: 'AIAssistantDocumentsConnection', pageInfo: { __typename?: 'PageInfo', totalCount: number, endCursor?: string | undefined }, edges: Array<{ __typename?: 'AIAssistantDocumentsEdge', cursor: string, node: { __typename?: 'AIAssistantDocument', id: string, originalFileName: string, fileName?: string | undefined, fileSize: number, status: AiAssistantDocumentStatus, permission?: AiAssistantDocumentPermission | undefined, category?: AiAssistantDocumentCategory | undefined, summary?: string | undefined, updatedAt?: any | undefined } }> } };

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


export type GetAiSettingsQuery = { __typename?: 'Query', aiAssistantSettings: { __typename?: 'AIAssistantSettings', conversationStyle: AiAssistantConversationStyle, conversationTone: AiAssistantConversationTone, voice: AiAssistantVoice } };

export type GetAiResponseRatingQueryVariables = Exact<{
  input: GetAiResponseRatingInput;
}>;


export type GetAiResponseRatingQuery = { __typename?: 'Query', getAiResponseRating?: { __typename?: 'AiResponseRating', id: string, userRating?: AiRatingValue | undefined, userComment?: string | undefined } | undefined };

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


export type GetAllConversationsQuery = { __typename?: 'Query', getConversations: Array<{ __typename?: 'Conversation', id: string, title: string, updatedAt?: any | undefined }> };

export type UpdateAiDocumentMutationVariables = Exact<{
  input: UpdateAiAssistantDocumentInput;
}>;


export type UpdateAiDocumentMutation = { __typename?: 'Mutation', updateAIAssistantDocument: { __typename?: 'UploadAIAssistantDocumentPayload', document: { __typename?: 'AIAssistantDocument', id: string } } };

export type UpdateAiSettingsMutationVariables = Exact<{
  input: UpdateAiAssistantSettingsInput;
}>;


export type UpdateAiSettingsMutation = { __typename?: 'Mutation', updateAIAssistantSettings: { __typename?: 'UpdateAIAssistantSettingsPayload', settings: { __typename?: 'AIAssistantSettings', conversationStyle: AiAssistantConversationStyle, conversationTone: AiAssistantConversationTone, voice: AiAssistantVoice } } };

export type UpdateConversationTitleMutationVariables = Exact<{
  input: UpdateConversationTitleInput;
}>;


export type UpdateConversationTitleMutation = { __typename?: 'Mutation', updateConversationTitle: { __typename?: 'UpdateConversationTitlePayload', status: string } };

export type UploadAiDocumentMutationVariables = Exact<{
  input: UploadAiAssistantDocumentInput;
}>;


export type UploadAiDocumentMutation = { __typename?: 'Mutation', uploadAIAssistantDocument: { __typename?: 'UploadAIAssistantDocumentPayload', document: { __typename?: 'AIAssistantDocument', id: string, fileName?: string | undefined, mimeType: string, fileSize: number, status: AiAssistantDocumentStatus, url: string } } };


export const AppendMessageToConversationDocument = gql`
    mutation AppendMessageToConversation($input: AppendMessageInput!) {
  appendMessage(input: $input) {
    conversation {
      id
      title
      userId
      workspace
      updatedAt
    }
  }
}
    `;
export type AppendMessageToConversationMutationFn = ApolloReactCommon.MutationFunction<AppendMessageToConversationMutation, AppendMessageToConversationMutationVariables>;

/**
 * __useAppendMessageToConversationMutation__
 *
 * To run a mutation, you first call `useAppendMessageToConversationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAppendMessageToConversationMutation` 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 [appendMessageToConversationMutation, { data, loading, error }] = useAppendMessageToConversationMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useAppendMessageToConversationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<AppendMessageToConversationMutation, AppendMessageToConversationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<AppendMessageToConversationMutation, AppendMessageToConversationMutationVariables>(AppendMessageToConversationDocument, options);
      }
export type AppendMessageToConversationMutationHookResult = ReturnType<typeof useAppendMessageToConversationMutation>;
export type AppendMessageToConversationMutationResult = ApolloReactCommon.MutationResult<AppendMessageToConversationMutation>;
export type AppendMessageToConversationMutationOptions = ApolloReactCommon.BaseMutationOptions<AppendMessageToConversationMutation, AppendMessageToConversationMutationVariables>;
export const CreateOrUpdateAiResponseRatingDocument = gql`
    mutation CreateOrUpdateAiResponseRating($input: CreateAiResponseRatingInput!) {
  createOrUpdateAiResponseRating(input: $input) {
    id
    responseType
    responseId
    userRating
    userComment
    createdAt
    updatedAt
  }
}
    `;
export type CreateOrUpdateAiResponseRatingMutationFn = ApolloReactCommon.MutationFunction<CreateOrUpdateAiResponseRatingMutation, CreateOrUpdateAiResponseRatingMutationVariables>;

/**
 * __useCreateOrUpdateAiResponseRatingMutation__
 *
 * To run a mutation, you first call `useCreateOrUpdateAiResponseRatingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateOrUpdateAiResponseRatingMutation` 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 [createOrUpdateAiResponseRatingMutation, { data, loading, error }] = useCreateOrUpdateAiResponseRatingMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateOrUpdateAiResponseRatingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateOrUpdateAiResponseRatingMutation, CreateOrUpdateAiResponseRatingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<CreateOrUpdateAiResponseRatingMutation, CreateOrUpdateAiResponseRatingMutationVariables>(CreateOrUpdateAiResponseRatingDocument, options);
      }
export type CreateOrUpdateAiResponseRatingMutationHookResult = ReturnType<typeof useCreateOrUpdateAiResponseRatingMutation>;
export type CreateOrUpdateAiResponseRatingMutationResult = ApolloReactCommon.MutationResult<CreateOrUpdateAiResponseRatingMutation>;
export type CreateOrUpdateAiResponseRatingMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateOrUpdateAiResponseRatingMutation, CreateOrUpdateAiResponseRatingMutationVariables>;
export const DeleteAiDocumentDocument = gql`
    mutation DeleteAIDocument($input: DeleteAIAssistantDocumentInput!) {
  deleteAIAssistantDocument(input: $input) {
    document {
      id
    }
  }
}
    `;
export type DeleteAiDocumentMutationFn = ApolloReactCommon.MutationFunction<DeleteAiDocumentMutation, DeleteAiDocumentMutationVariables>;

/**
 * __useDeleteAiDocumentMutation__
 *
 * To run a mutation, you first call `useDeleteAiDocumentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteAiDocumentMutation` 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 [deleteAiDocumentMutation, { data, loading, error }] = useDeleteAiDocumentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useDeleteAiDocumentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteAiDocumentMutation, DeleteAiDocumentMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<DeleteAiDocumentMutation, DeleteAiDocumentMutationVariables>(DeleteAiDocumentDocument, options);
      }
export type DeleteAiDocumentMutationHookResult = ReturnType<typeof useDeleteAiDocumentMutation>;
export type DeleteAiDocumentMutationResult = ApolloReactCommon.MutationResult<DeleteAiDocumentMutation>;
export type DeleteAiDocumentMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteAiDocumentMutation, DeleteAiDocumentMutationVariables>;
export const GetAConversationDocument = gql`
    query GetAConversation($input: ConversationInput!) {
  aiAssistantConversation(input: $input) {
    id
    title
    updatedAt
    messages {
      id
      messageText
      conversationId
      role
      metadata
      aiResponseRating {
        id
        userRating
        userComment
      }
    }
  }
}
    `;

/**
 * __useGetAConversationQuery__
 *
 * To run a query within a React component, call `useGetAConversationQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAConversationQuery` 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 } = useGetAConversationQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useGetAConversationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<GetAConversationQuery, GetAConversationQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<GetAConversationQuery, GetAConversationQueryVariables>(GetAConversationDocument, options);
      }
export function useGetAConversationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetAConversationQuery, GetAConversationQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<GetAConversationQuery, GetAConversationQueryVariables>(GetAConversationDocument, options);
        }
export type GetAConversationQueryHookResult = ReturnType<typeof useGetAConversationQuery>;
export type GetAConversationLazyQueryHookResult = ReturnType<typeof useGetAConversationLazyQuery>;
export type GetAConversationQueryResult = ApolloReactCommon.QueryResult<GetAConversationQuery, GetAConversationQueryVariables>;
export const GetAiDocumentsDocument = gql`
    query GetAIDocuments($first: Int, $after: String, $filter: AIAssistantDocumentFilterInput) {
  aiDocumentUploads(first: $first, after: $after, filter: $filter) {
    pageInfo {
      totalCount
      endCursor
    }
    edges {
      cursor
      node {
        id
        originalFileName
        fileName
        fileSize
        status
        permission
        category
        summary
        updatedAt
      }
    }
  }
}
    `;

/**
 * __useGetAiDocumentsQuery__
 *
 * To run a query within a React component, call `useGetAiDocumentsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAiDocumentsQuery` 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 } = useGetAiDocumentsQuery({
 *   variables: {
 *      first: // value for 'first'
 *      after: // value for 'after'
 *      filter: // value for 'filter'
 *   },
 * });
 */
export function useGetAiDocumentsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetAiDocumentsQuery, GetAiDocumentsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<GetAiDocumentsQuery, GetAiDocumentsQueryVariables>(GetAiDocumentsDocument, options);
      }
export function useGetAiDocumentsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetAiDocumentsQuery, GetAiDocumentsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<GetAiDocumentsQuery, GetAiDocumentsQueryVariables>(GetAiDocumentsDocument, options);
        }
export type GetAiDocumentsQueryHookResult = ReturnType<typeof useGetAiDocumentsQuery>;
export type GetAiDocumentsLazyQueryHookResult = ReturnType<typeof useGetAiDocumentsLazyQuery>;
export type GetAiDocumentsQueryResult = ApolloReactCommon.QueryResult<GetAiDocumentsQuery, GetAiDocumentsQueryVariables>;
export const GetAiSettingsDocument = gql`
    query GetAISettings {
  aiAssistantSettings {
    conversationStyle
    conversationTone
    voice
  }
}
    `;

/**
 * __useGetAiSettingsQuery__
 *
 * To run a query within a React component, call `useGetAiSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAiSettingsQuery` 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 } = useGetAiSettingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetAiSettingsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetAiSettingsQuery, GetAiSettingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<GetAiSettingsQuery, GetAiSettingsQueryVariables>(GetAiSettingsDocument, options);
      }
export function useGetAiSettingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetAiSettingsQuery, GetAiSettingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<GetAiSettingsQuery, GetAiSettingsQueryVariables>(GetAiSettingsDocument, options);
        }
export type GetAiSettingsQueryHookResult = ReturnType<typeof useGetAiSettingsQuery>;
export type GetAiSettingsLazyQueryHookResult = ReturnType<typeof useGetAiSettingsLazyQuery>;
export type GetAiSettingsQueryResult = ApolloReactCommon.QueryResult<GetAiSettingsQuery, GetAiSettingsQueryVariables>;
export const GetAiResponseRatingDocument = gql`
    query GetAiResponseRating($input: GetAiResponseRatingInput!) {
  getAiResponseRating(input: $input) {
    id
    userRating
    userComment
  }
}
    `;

/**
 * __useGetAiResponseRatingQuery__
 *
 * To run a query within a React component, call `useGetAiResponseRatingQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAiResponseRatingQuery` 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 } = useGetAiResponseRatingQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useGetAiResponseRatingQuery(baseOptions: ApolloReactHooks.QueryHookOptions<GetAiResponseRatingQuery, GetAiResponseRatingQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<GetAiResponseRatingQuery, GetAiResponseRatingQueryVariables>(GetAiResponseRatingDocument, options);
      }
export function useGetAiResponseRatingLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetAiResponseRatingQuery, GetAiResponseRatingQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<GetAiResponseRatingQuery, GetAiResponseRatingQueryVariables>(GetAiResponseRatingDocument, options);
        }
export type GetAiResponseRatingQueryHookResult = ReturnType<typeof useGetAiResponseRatingQuery>;
export type GetAiResponseRatingLazyQueryHookResult = ReturnType<typeof useGetAiResponseRatingLazyQuery>;
export type GetAiResponseRatingQueryResult = ApolloReactCommon.QueryResult<GetAiResponseRatingQuery, GetAiResponseRatingQueryVariables>;
export const GetAllConversationsDocument = gql`
    query GetAllConversations {
  getConversations {
    id
    title
    updatedAt
  }
}
    `;

/**
 * __useGetAllConversationsQuery__
 *
 * To run a query within a React component, call `useGetAllConversationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAllConversationsQuery` 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 } = useGetAllConversationsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetAllConversationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetAllConversationsQuery, GetAllConversationsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<GetAllConversationsQuery, GetAllConversationsQueryVariables>(GetAllConversationsDocument, options);
      }
export function useGetAllConversationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetAllConversationsQuery, GetAllConversationsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<GetAllConversationsQuery, GetAllConversationsQueryVariables>(GetAllConversationsDocument, options);
        }
export type GetAllConversationsQueryHookResult = ReturnType<typeof useGetAllConversationsQuery>;
export type GetAllConversationsLazyQueryHookResult = ReturnType<typeof useGetAllConversationsLazyQuery>;
export type GetAllConversationsQueryResult = ApolloReactCommon.QueryResult<GetAllConversationsQuery, GetAllConversationsQueryVariables>;
export const UpdateAiDocumentDocument = gql`
    mutation UpdateAIDocument($input: UpdateAIAssistantDocumentInput!) {
  updateAIAssistantDocument(input: $input) {
    document {
      id
    }
  }
}
    `;
export type UpdateAiDocumentMutationFn = ApolloReactCommon.MutationFunction<UpdateAiDocumentMutation, UpdateAiDocumentMutationVariables>;

/**
 * __useUpdateAiDocumentMutation__
 *
 * To run a mutation, you first call `useUpdateAiDocumentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateAiDocumentMutation` 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 [updateAiDocumentMutation, { data, loading, error }] = useUpdateAiDocumentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateAiDocumentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateAiDocumentMutation, UpdateAiDocumentMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<UpdateAiDocumentMutation, UpdateAiDocumentMutationVariables>(UpdateAiDocumentDocument, options);
      }
export type UpdateAiDocumentMutationHookResult = ReturnType<typeof useUpdateAiDocumentMutation>;
export type UpdateAiDocumentMutationResult = ApolloReactCommon.MutationResult<UpdateAiDocumentMutation>;
export type UpdateAiDocumentMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateAiDocumentMutation, UpdateAiDocumentMutationVariables>;
export const UpdateAiSettingsDocument = gql`
    mutation UpdateAISettings($input: UpdateAIAssistantSettingsInput!) {
  updateAIAssistantSettings(input: $input) {
    settings {
      conversationStyle
      conversationTone
      voice
    }
  }
}
    `;
export type UpdateAiSettingsMutationFn = ApolloReactCommon.MutationFunction<UpdateAiSettingsMutation, UpdateAiSettingsMutationVariables>;

/**
 * __useUpdateAiSettingsMutation__
 *
 * To run a mutation, you first call `useUpdateAiSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateAiSettingsMutation` 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 [updateAiSettingsMutation, { data, loading, error }] = useUpdateAiSettingsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateAiSettingsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateAiSettingsMutation, UpdateAiSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<UpdateAiSettingsMutation, UpdateAiSettingsMutationVariables>(UpdateAiSettingsDocument, options);
      }
export type UpdateAiSettingsMutationHookResult = ReturnType<typeof useUpdateAiSettingsMutation>;
export type UpdateAiSettingsMutationResult = ApolloReactCommon.MutationResult<UpdateAiSettingsMutation>;
export type UpdateAiSettingsMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateAiSettingsMutation, UpdateAiSettingsMutationVariables>;
export const UpdateConversationTitleDocument = gql`
    mutation UpdateConversationTitle($input: UpdateConversationTitleInput!) {
  updateConversationTitle(input: $input) {
    status
  }
}
    `;
export type UpdateConversationTitleMutationFn = ApolloReactCommon.MutationFunction<UpdateConversationTitleMutation, UpdateConversationTitleMutationVariables>;

/**
 * __useUpdateConversationTitleMutation__
 *
 * To run a mutation, you first call `useUpdateConversationTitleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateConversationTitleMutation` 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 [updateConversationTitleMutation, { data, loading, error }] = useUpdateConversationTitleMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateConversationTitleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateConversationTitleMutation, UpdateConversationTitleMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<UpdateConversationTitleMutation, UpdateConversationTitleMutationVariables>(UpdateConversationTitleDocument, options);
      }
export type UpdateConversationTitleMutationHookResult = ReturnType<typeof useUpdateConversationTitleMutation>;
export type UpdateConversationTitleMutationResult = ApolloReactCommon.MutationResult<UpdateConversationTitleMutation>;
export type UpdateConversationTitleMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateConversationTitleMutation, UpdateConversationTitleMutationVariables>;
export const UploadAiDocumentDocument = gql`
    mutation UploadAIDocument($input: UploadAIAssistantDocumentInput!) {
  uploadAIAssistantDocument(input: $input) {
    document {
      id
      fileName
      mimeType
      fileSize
      status
      url
    }
  }
}
    `;
export type UploadAiDocumentMutationFn = ApolloReactCommon.MutationFunction<UploadAiDocumentMutation, UploadAiDocumentMutationVariables>;

/**
 * __useUploadAiDocumentMutation__
 *
 * To run a mutation, you first call `useUploadAiDocumentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUploadAiDocumentMutation` 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 [uploadAiDocumentMutation, { data, loading, error }] = useUploadAiDocumentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUploadAiDocumentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UploadAiDocumentMutation, UploadAiDocumentMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useMutation<UploadAiDocumentMutation, UploadAiDocumentMutationVariables>(UploadAiDocumentDocument, options);
      }
export type UploadAiDocumentMutationHookResult = ReturnType<typeof useUploadAiDocumentMutation>;
export type UploadAiDocumentMutationResult = ApolloReactCommon.MutationResult<UploadAiDocumentMutation>;
export type UploadAiDocumentMutationOptions = ApolloReactCommon.BaseMutationOptions<UploadAiDocumentMutation, UploadAiDocumentMutationVariables>;