$ curl https://onboarding-api.greenhouse.io/graphql \
  -X POST \
  -u your_access_key:your_secret_key \
  -d '{"query":"{\n  rateLimit {\n    limit\n  }\n}"}' \
  -H "Content-Type: application/json"

...

> GET /graphql HTTP/1.1
> Host: onboarding-api.greenhouse.io
> Authorization: Basic eW91cl9hY2Nlc3Nfa2V5OnlvdXJfdmFsdWU=

# When the rate limit is reached, ensuing requests will result 
# in the following response (until the next time period begins):
{
  "errors": [
    {
      "message": "Rate limit reached.",
      "limit": 100,
      "remaining": 0,
      "resetAt": "2018-01-01T01:00:00Z"
    }
  ]
}

# To request the current rate limit information:
{
  rateLimit {
    resetAt
    limit
    remaining
  }
}

# rateLimit response:
{
  "data": { 
    "rateLimit": {
      "resetAt": "2018-09-12T18:00:00Z",
      "limit": 100,
      "remaining": 99
    }
  }
}

# Say we had the following query:
{
  employee(id: 25) {
    email
  }
}

# To request the complexity score of this query, simply 
# include complexityInfo as such:
{
  employee(id: 25) {
    email
  }
  complexityInfo {
    score
    maximum
  }
}

# The response:
{
  "data": {
    "employee": {
      "email": "email_address@example.com"
    },
    "complexityInfo": {
      "score": 1,
      "maximum": 2500
    }
  }
}

# If we wanted to retrieve the email address of the employee 
# with ID 25, the GraphQL query would look like this:

{
  employee(id: 25) {
    email
  }
}

# We then pack this query into a JSON object as a string

{
    "query": "{\n  employee(id: 25) {\n    email\n  }\n}"
}

# Here's what the final cURL request would look like

curl 'https://onboarding-api.greenhouse.io/graphql' \
  -X POST \
  -u your_access_key:your_secret_key \
  -d '{"query":"{\n  employee(id: 25) {\n    email\n  }\n}"}' \
  -H 'content-type: application/json'

# and here's what the response would look like

{"data":{"employee":{"email":"employee_25_email@example.com"}}}

{
  employees(first: 2, after: "NQ==") { # Please fetch the next 2 records, starting after the "NQ==" cursor
    pageInfo {
      endCursor
      hasNextPage
    }
    edges {
      node {
        email
      }
    }
  }
}

# Returns:

{
  "data": {
    "employees": {
      "pageInfo": {
        "endCursor": "MTA=",
        "hasNextPage": true
      },
      "edges": [
        {
          "node": {
            "email": "kima@example.com"
          }
        },
        {
          "node": {
            "email": "omar@example.com"
          }
        }
      ]
    }
  }
}

{
  employee(id: 100000000) {
    email
  }
}

{
  "data": {
    "employee": null
  },
  "errors": [
    {
      "message": "Unable to find Employee with id 100000000",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": [
        "employee"
      ],
      "errorCode": "NotFound"
    }
  ]
}

# the basic structure of the complexityInfo query
{
  complexityInfo {
    score
    maximum
  }
}

# Example of retriving complexity information from the employee query
{
  employee(id: 20) {
     email
     lastName
  }
  complexityInfo {
    score
    maximum
  }
}

{
  contactRelationships
}

# Request all country information for North America
{
  countries(countryCodes: ["USA", "CAN", "MEX"]) {
    countryCode
    name
    states {
      name
      stateCode
      country {
        name
      }
    }
  }
}

# Request all country information for all countries
{
  countries {
    countryCode
    name
    states {
      name
      stateCode
      country {
        name
      }
    }
  }
}

# Request custom field information for a custom field
{
  customField(id: "system.pronouns") {
    id
    name
    fieldType
    multipleChoiceOptions
    customFieldGroup {
      id
      name
    }
    teamCategory {
      id
      name
    }
    createdAt
    updatedAt
  }
}

# Request the first 5 custom fields after the cursor "NQ=="
{
  customFields(first: 5, after: "NQ==") {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
    }
  }
}

# Request the first 5 custom fields before the cursor "MTA="
{
  customFields(first: 5, before: "MTA=") {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
      cursor
    }
  }
}

# Request the first 10 custom fields with the field type 'text'
{
  customFields(first: 10, fieldTypes: [TEXT]) {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
      cursor
    }
  }
}

# Request the first 10 customFields in the list
{
  customFields(first: 10) {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
      cursor
    }
  }
}

# Request the last 10 customFields in the list
{
  customFields(last: 10) {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
      cursor
    }
  }
}

# Request custom fields with permanent field ids "department" and "location"
{
  customFields(first: 2, ids: ["department", "location"]) {
    edges {
      node {
        name
        id
        teamCategory {
          id
          name
        }
        fieldType
        customFieldGroup {
          id
          name
        }
        multipleChoiceOptions
      }
      cursor
    }
  }
}

{
  department(id: 1) {
    id
    name
    externalId
  }
}

# Request for the first 5 departments after cursor "NQ=="
{
  departments(first: 5, after: "NQ==") {
    edges {
      node {
       id
       name
       externalId
      }
      cursor
    }
  }
}

# Request for the first 5 departments before cursor "NQ=="
{
  departments(first: 5, before: "NQ==") {
    edges {
      node {
       id
       name
       externalId
      }
      cursor
    }
  }
}

# Request for first 10 departments in the list
{
  departments(first: 10) {
    edges {
      node {
       id
       name
       externalId
      }
      cursor
    }
  }
}

# Request for the last 10 departments in the list
{
  departments(last: 10) {
    edges {
      node {
       id
       name
       externalId
      }
      cursor
    }
  }
}

# Request for an employee
{
  employee(id: 5) {
    about
    createdAt
    dateOfBirth
    dateOfTermination
    department {
      id
      name
      externalId
    }
    documents {
      id
      file {
        fileUrl
        fileName
        fileSize
      }
    }
    email
    employmentStatus
    firstName
    greenhouseRecruitingData {
      applicationId
    }
    hrManager {
      id
      email
    }
    id
    lastName
    location {
      id
      name
      address
      externalId
    }
    manager {
      id
      email
    }
    middleName
    otherCriteria {
      id
      name
    }
    personalEmail
    phoneNumber
    preferredFirstName
    preferredLastName
    profileImage {
      fileUrl
      fileName
      fileSize
    }
    requiredFieldsCompletedAt
    startDate
    suffix
    title
    updatedAt
    workCountryCode
  }
}

# Request an employee but limit their customFieldValues to those of specific customFields.
# The customFieldIds argument can be used when you are interested in only getting a specific
# customFieldValues for the employee.
{
  employee(id: 20) {
    customFieldValues(customFieldIds: ["emergency_contact", "favorite_food"]) {
      customField {
        id
        fieldType
      }
      value
    }
  }
}

# Request an employee and limit their signatureRequests to those that are waiting on a signature or being processed
{
  employee(id: 20) {
    signatureRequests(statuses: [WAITING_FOR_SIGNATURE, BEING_PROCESSED]) {
      counterSigner {
        id
        email
      }
      file {
        fileUrl
      }
      status
      signatureRequestTemplate {
        publicName
        counterSigner {
          id
          email
        }
      }
    }
  }
}

# Request an employee, limit their signatureRequests to those that are completed an request the formFields
{
  employee(id: 20) {
    signatureRequests(statuses: [COMPLETED]) {
      formFields(fieldNames: ["first_name", "last_name"])
    }
  }
}

# Request employees after the cursor "NQ=="
{
  employees(first: 25, after: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
      cursor
    }
  }
}

# Request employees before the cursor "MTM="
{
  employees(first: 25, before: "MTM=") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      nodes {
        id
        email
      }
      cursor
    }
  }
}

# Request only those employees that were createed before 12-13-2021 and after 10-01-2021. For each employee that
# fits that criteria, return their id and work email
{
  employees(first: 25, createdAt: {after: "2021-10-01T00:00:00+00:00", before: "2021-12-31T00:00:00+00:00" }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have a value (ANY value) set for the "favorite_food" Custom Field. For these employees, return
# ALL of their customFieldValues.
{
  employees(first: 25, customFieldValues: [{id: "favorite_food"}]) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
      }
    }
  }
}

# Request only those employees that have "Hot Dogs" or "Chicken Nuggets" set for their "favorite_food" Custom Field.
# Because the "favorite_food" Custom Field is of type text, we provide the "textValues" argument (as opposed to
# dateValues or idValues)
{
  employees(
    first: 25,
    customFieldValues: [{id: "favorite_food", textValues: ["Hot Dogs", "Chicken Nuggets"]}]
  ) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        customFieldValues {
          customField {
            id
          }
          value
        }
      }
    }
  }
}

# Request only those employees that have a value set for their "favorite_food" Custom Field and "Blue" for their
# "favorite_color" Custom Field. For each of these employees, return their ID and work email address.
{
  employees(
    first: 25,
    customFieldValues: [{id: "favorite_food"}, {id: "favorite_color", textValues: ["Blue"]}]
  ) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request employees that have a value set for the "favorite_food" Custom Field. Return each employee's ID and
# customFieldValues, but only return the customFieldValue for the "favorite_food" customField.
{
  employees(
    first: 25,
    customFieldValues: [{ id: "favorite_food" }]
  ) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        customFieldValues(customFieldIds: ["favorite_food"]) {
          customField {
            id
          }
          value
        }
      }
    }
  }
}

# Request employees that have a date value between "2017-04-13" and "2018-04-13" (exclusive) for the
# "1_year_anniversary" Custom Field. For each of these employees, return their ID and
# the value for the "1_year_anniversary" Custom Field (and only the value for this Custom Field).
{
  employees(
    first: 25,
    customFieldValues: [{ id: "1_year_anniversary", dateValue: { after: "2017-04-13", before: "2018-04-13" } }]
  ) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        customFieldValues(customFieldIds: ["1_year_anniversary"]) {
          customField {
            id
          }
          value
        }
      }
    }
  }
}

# Request employees that have Employee 35 or Employee 40 set as the value for the "mentor" Custom Field. For each of
# these employees, return their id, work email address, and "about me" text.
{
  employees(
    first: 25,
    customFieldValues: [{id: "mentor", idValues: [35, 40]}]
  ) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
        about
      }
    }
  }
}

# Request only those employees that have a dateOfBirth between 1989-12-31 and 2000-01-01.
# These dates are exclusive (e.g. someone who was born on 1989-12-31 or 2000-01-01 would not be included.
{
  employees(first: 25, dateOfBirthFilter: { dateFilter: { after: "1989-12-31", before: "2000-01-01" } }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
        startDate
      }
    }
  }
}

# Request only those employees that have a department set (department is not null). For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, departmentFilter: { anyValue: true }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that lack a department (department is null). For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, departmentFilter: { noValue: true }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that are in specific departments. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, departmentFilter: { departmentIds: [1, 3] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have specific emails. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, emailFilter: { emails: ["john.doe@example.com"] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have specific employment statuses. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, employmentStatusFilter: { employmentStatuses: ["Full-time", "Part-time"] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request the first 10 employees in the list, For each employee return their id and work email
{
  employees(first: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have a specific hr manager or managers. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, hrManagerFilter: { hrManagerIds: [1, 2] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request the last 10 employees in the list, For each employee return their id and work email
{
  employees(last: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that are in a specific location or locations. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, locationFilter: { locationIds: [1, 2] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have a specific manager or managers. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, managerFilter: { managerIds: [1, 2] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have a specific personal email or emails. For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, personalEmailFilter: { personalEmails: ["john.doe@example.com", "jon.doe2@example.com"] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that have a startDate between 2017-03-25 and 2018-03-25.
# These dates are exclusive (e.g. someone who started on 2017-03-25 or 2018-03-25 would not be included.
{
  employees(first: 25, startDateFilter: { dateFilter: { after: "2017-03-25", before: "2018-03-25" } }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
        startDate
      }
    }
  }
}

# Request only those employees that have title "Account Manager". For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, titleFilter: { titles: ["Account Manager"] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees in a specific country or countries (using workCountryCode). For each employee that fits the criteria,
# return their id and work email
{
  employees(first: 25, workCountryCodeFilter: { workCountryCodes: ["USA", "CAN"] }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

# Request only those employees that were updated before 12-13-2021 and after 10-01-2021. For each employee that
# fits that criteria, return their id and work email
{
  employees(first: 25, updatedAt: {after: "2021-10-01T00:00:00+00:00", before: "2021-12-31T00:00:00+00:00" }) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        email
      }
    }
  }
}

{
  employmentStatuses
}

{
  location(id: 1) {
    id
    name
    address
    externalId
  }
}

# Request for first 10 locations after cursor "NQ=="
{
  locations(first: 10, after: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        address
        externalId
      }
      cursor
    }
  }
}

# Request for first 10 locations before cursor "NQ=="
{
  locations(first: 10, before: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        address
        externalId
      }
      cursor
    }
  }
}

# Request for first 10 locations in the list
{
  locations(first: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        address
        externalId
      }
      cursor
    }
  }
}

# Request for last 10 locations in the list
{
  locations(last: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        address
        externalId
      }
      cursor
    }
  }
}

# Request for first 10 other criteria after cursor "NQ=="
{
  otherCriteria(first: 10, after: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        createdAt
        updatedAt
      }
      cursor
    }
  }
}

# Request for first 10 other criteria before cursor "NQ=="
{
  otherCriteria(first: 10, before: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        createdAt
        updatedAt
      }
      cursor
    }
  }
}

# Request for first 10 other criteria in the list
{
  otherCriteria(first: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        createdAt
        updatedAt
      }
      cursor
    }
  }
}

# Request for last 10 other criteria in the list
{
  otherCriteria(last: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        createdAt
        updatedAt
      }
      cursor
    }
  }
}

{
  otherCriterion(id: 1) {
    id
    name
    createdAt
    updatedAt
  }
}

{
  rateLimit {
    cost
    limit
    remaining
    resetAt
  }
}

{
  team(id: 1) {
    id
    name
    description
    email
    location
    name
    teamCategory {
      id
      name
    }
  }
}

# Request for first 5 team categories after cursor "NQ=="
{
  teamCategories(first: 5, after: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
      }
      cursor
    }
  }
}

# Request for first 5 team categories before cursor "NQ=="
{
  teamCategories(first: 5, before: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
      }
      cursor
    }
  }
}

# Request for first 5 team categories in the list
{
  teamCategories(first: 5) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
      }
      cursor
    }
  }
}

# Request for last 5 team categories in the list
{
  teamCategories(last: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
      }
      cursor
    }
  }
}

{
  teamCategory(id: 1) {
    id
    name
  }
}

# Request for first 10 teams after cursor "NQ=="
{
  teams(first: 10, after: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        description
        email
        location
        name
        teamCategory {
          id
          name
        }
      }
      cursor
    }
  }
}

# Request for first 10 teams before cursor "NQ=="
{
  teams(first: 10, before: "NQ==") {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        description
        email
        location
        name
        teamCategory {
          id
          name
        }
      }
      cursor
    }
  }
}

# Request for first 10 teams in the list
{
  teams(first: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        description
        email
        location
        name
        teamCategory {
          id
          name
        }
      }
      cursor
    }
  }
}

# Request for last 10 teams in the list
{
  teams(last: 10) {
    pageInfo {
      hasNextPage
      endCursor
    }
    edges {
      node {
        id
        name
        description
        email
        location
        name
        teamCategory {
          id
          name
        }
      }
      cursor
    }
  }
}

# Create a Department
mutation {
  addDepartment(
    addDepartmentInput: {
      name: "Engineering"
      externalId: "123"
    }
  ) {
    department {
      id
      name
      externalId
    }
  }
}

# Create a Location
mutation {
  addLocation(
    addLocationInput: {
      name: "Denver, CO"
      address: "1801 Broadway, 13th Floor, Denver, CO 80202"
      externalId: "123"
    }
  ) {
    location {
      id
      name
      address
      externalId
    }
  }
}

# Create a PendingHire with required information as well as a value for a text Custom Field (long text, confirmable,
# and multiple_choice Custom Fields also take Strings as the "value").
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email: "joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        { customFieldId: "favorite_food", value: "Egg McMuffins" }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues(customFieldIds: ["favorite_food"]) {
      customField { id }
      value
    }
  }
}

# Create a PendingHire with required information as well as a value for a Multiple Select Custom Field. These Custom
# Fields require a JSON Array-formatted string (including escaped quotes) for the "value". Also of note, each of the
# elements in the array must be a valid option for the given Custom Field.
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email: "joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        { customFieldId: "required_equipment", value: "[\"Ergonomic Keyboard\", \"Standing Desk\"]" }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues(customFieldIds: ["required_equipment"]) {
      customField { id }
      value
    }
  }
}

# Create a PendingHire with required information as well as a value for a Team Custom Field. These Custom Fields
# require an ID for the "value."
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email: "joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        { customFieldId: "primary_social_club", value: 14 }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues {
      customField { id }
      value
    }
  }
}

# Create a PendingHire with required information as well as a value for an Address Custom Field. These Custom
# Fields require a JSON Object-formatted string (including escaped quotes) for the "value".
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email:"joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        {
          customFieldId: "address",
          value: "{\"address_line_1\":\"123 Test Street\",\"address_line_2\":\"Apartment 1\",\"city\":\"Pawnee\", \"state\":\"IN\", \"zipcode\":\"12345\",\"country\":\"USA\"}"
        }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues(customFieldIds: ["address"]) {
      customField { id }
      value
    }
  }
}

# Create a PendingHire with required information as well as a value for a Contact Custom Field. These Custom
# Fields require a JSON Object-formatted string (including escaped quotes) for the "value".
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email:"joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        {
          customFieldId: "emergency_contact",
          value: "{\"first_name\": \"Joe\", \"last_name\": \"Schmoe\", \"email\":\"jschmoe@aol.com\", \"phone\": \"123.456.7890\", \"relationship\": \"Other\"}" }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues(customFieldIds: ["emergency_contact"]) {
      customField { id }
      value
    }
  }
}

# Create a PendingHire with required information as well as a value for a Date Custom Field. These Custom Fields
# require a String formatted as such: YYYY-MM-DD.
mutation {
  addPendingHire(
    pendingHireInfo: {
      firstName: "Joe"
      lastName: "Schmoe"
      email:"joe123@example.com"
      workCountryCode: "USA"
      customFieldValues: [
        { customFieldId: "fully_vested", value: "2019-12-12" }
      ]
    }
  ) {
    firstName
    lastName
    email
    workCountryCode
    customFieldValues(customFieldIds: ["fully_vested"]) {
      customField { id }
      value
    }
  }
}

# Delete a department by the department id
mutation {
  deleteDepartment(deleteDepartmentInput: {id: 1}) {
    deletedDepartmentId
  }
}

# Delete a location by the location id
mutation {
  deleteLocation(deleteLocationInput: {id: 1}) {
    deletedLocationId
  }
}

# Update a department's name. Must provide the id of an existing department
mutation {
  updateDepartment(
    updateDepartmentInput: {
      id: 1
      name: "Data Science"
      externalId: "123"
    }
  ) {
    department {
      id
      name
      externalId
    }
  }
}

# Update an employee's work email address, date of birth, and department. Return these fields to confirm the change.
mutation {
  updateEmployeeProfile(
    id: 25,
    employeeUpdates: {
      email: "new_email_address@example.com"
      dateOfBirth: "1985-04-07"
      department: 1
    }
  ) {
    email
    dateOfBirth
    department {
      id
    }
  }
}

# Update/create the value for a text, long text, confirmable, or multiple_choice Custom Field. For Custom Fields of
# these types, provide a string for the value. Here we update the "favorite_food" Custom Field Value (a text Custom
# Field) to "Egg McMuffins". We ask for the employee's customFieldValues, but we limit them to those that
# belong to the "favorite_food" Custom Field. E.g. we filter out the irrelevant customFieldValues.
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        { customFieldId: "favorite_food", value: "Egg McMuffins" }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["favorite_food"]) {
      customField {
        id
      }
      value
    }
  }
}

# Update/create the value for a Multiple Select Custom Field. For these Custom Fields, "value" must be a string
# representing a JSON Array (including escaped quotation marks).  Also of note, each of the values of this array must
# be one of the pre-defined values for the given Custom Field.  Here, we set the "required_equipment" Custom Field Value
# to contain "Ergonomic Keyboard" and "Standing Desk". We then request the updated Employee's value for this Custom Field
# to confirm the change.
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        { customFieldId: "required_equipment", value: "[\"Ergonomic Keyboard\", \"Standing Desk\"]" }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["required_equipment"]) {
      customField {
        id
        fieldType
      }
      value
    }
  }
}

# Update/create the value for a Team Custom Field. For Custom Fields of type "Team" we provide an ID as the
# value.  This value represents the ID of the new Team.  Here we change the this employees "primary_social_club" to be
# Team 14.  These Team IDs can be found by utilizing the team query.
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        { customFieldId: "primary_social_club", value: 14 }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["primary_social_club"]) {
      customField {
        id
        fieldType
      }
      value
    }
  }
}

# Update/create the value for an Address Custom Field. These Custom Fields require a String value.  This String value
# must be a JSON Object (with quotes escaped accordingly).
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        {
          customFieldId: "address",
          value: "{\"address_line_1\":\"123 Test Street\",\"address_line_2\":\"Apartment 1\",\"city\":\"Pawnee\", \"state\":\"IN\", \"zipcode\":\"12345\",\"country\":\"USA\"}"
        }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["address"]) {
      customField {
        id
      }
      value
    }
  }
}

# Update/create the value for a Contact Custom Field. These Custom Fields require a String value. This String value
# must be a JSON Object (with quotes escaped accordingly).
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        {
          customFieldId: "emergency_contact",
          value: "{\"first_name\": \"Joe\", \"last_name\": \"Schmoe\", \"email\":\"jschmoe@aol.com\", \"phone\": \"123.456.7890\", \"relationship\": \"Other\"}" }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["emergency_contact"]) {
      customField {
        id
        fieldType
      }
      value
    }
  }
}

# Update/create the value for a date Custom Field. These Custom Fields require a String formatted as such: YYYY-MM-DD
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      customFieldValues: [
        { customFieldId: "fully_vested", value: "2019-12-12" }
      ]
    }
  ) {
    customFieldValues(customFieldIds: ["fully_vested"]) {
      customField {
        id
        fieldType
      }
      value
    }
  }
}

# Terminate an employee. Both employment status and date of termination are required.
# Date of termination can be in the past for immediate termination or in the future.
mutation {
  updateEmployeeProfile(
    id: 20,
    employeeUpdates: {
      employmentStatus: "Terminated"
      customFieldValues: {
        customFieldId: "system.date_of_termination"
        value: "2020-01-01"
      }
    }
  ) {
    id
    employmentStatus
    dateOfTermination
  }
}

# Update a location. Must provide the id of an existing location.
mutation {
  updateLocation(
    updateLocationInput: {
      id: 22
      name: "San Francisco, CA"
      address: "575 Market Street, Suite #1750, San Francisco, CA 94105"
      externalId: "123"
    }
  ) {
    location {
      id
      name
      address
      externaId
    }
  }
}